mkl_lapack.f90

!*******************************************************************************
!                              INTEL CONFIDENTIAL
!   Copyright(C) 2005-2007 Intel Corporation. All Rights Reserved.
!   The source code contained  or  described herein and all documents related to
!   the source code ("Material") are owned by Intel Corporation or its suppliers
!   or licensors.  Title to the  Material remains with  Intel Corporation or its
!   suppliers and licensors. The Material contains trade secrets and proprietary
!   and  confidential  information of  Intel or its suppliers and licensors. The
!   Material  is  protected  by  worldwide  copyright  and trade secret laws and
!   treaty  provisions. No part of the Material may be used, copied, reproduced,
!   modified, published, uploaded, posted, transmitted, distributed or disclosed
!   in any way without Intel's prior express written permission.
!   No license  under any  patent, copyright, trade secret or other intellectual
!   property right is granted to or conferred upon you by disclosure or delivery
!   of the Materials,  either expressly, by implication, inducement, estoppel or
!   otherwise.  Any  license  under  such  intellectual property  rights must be
!   express and approved by Intel in writing.
!
!*******************************************************************************
!  Content:
!      Intel(R) Math Kernel Library (MKL) F95 interface for LAPACK routines
!*******************************************************************************
! This file was generated automatically!
!*******************************************************************************

MODULE MKL95_PRECISION
    INTEGER, PARAMETER :: SP = KIND(1.0E0)
    INTEGER, PARAMETER :: DP = KIND(1.0D0)
END MODULE MKL95_PRECISION

MODULE MKL95_LAPACK
INTERFACE GETRF
    PURE SUBROUTINE SGETRF_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGETRF(M,N,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGETRF_MKL95
    PURE SUBROUTINE DGETRF_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGETRF(M,N,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGETRF_MKL95
    PURE SUBROUTINE CGETRF_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGETRF(M,N,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGETRF_MKL95
    PURE SUBROUTINE ZGETRF_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGETRF(M,N,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGETRF_MKL95
END INTERFACE GETRF
INTERFACE GBTRF
    PURE SUBROUTINE SGBTRF_MKL95(A,KL,M,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGBTRF(M,N,KL,KU,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGBTRF_MKL95
    PURE SUBROUTINE DGBTRF_MKL95(A,KL,M,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGBTRF(M,N,KL,KU,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGBTRF_MKL95
    PURE SUBROUTINE CGBTRF_MKL95(A,KL,M,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGBTRF(M,N,KL,KU,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGBTRF_MKL95
    PURE SUBROUTINE ZGBTRF_MKL95(A,KL,M,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGBTRF(M,N,KL,KU,A,LDA,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGBTRF_MKL95
END INTERFACE GBTRF
INTERFACE GTTRF
    PURE SUBROUTINE SGTTRF_MKL95(DL,D,DU,DU2,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGTTRF(N,DL,D,DU,DU2,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: DL(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: DU(:)
        REAL(WP), INTENT(OUT) :: DU2(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGTTRF_MKL95
    PURE SUBROUTINE DGTTRF_MKL95(DL,D,DU,DU2,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGTTRF(N,DL,D,DU,DU2,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: DL(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: DU(:)
        REAL(WP), INTENT(OUT) :: DU2(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGTTRF_MKL95
    PURE SUBROUTINE CGTTRF_MKL95(DL,D,DU,DU2,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGTTRF(N,DL,D,DU,DU2,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: DL(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: DU(:)
        COMPLEX(WP), INTENT(OUT) :: DU2(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGTTRF_MKL95
    PURE SUBROUTINE ZGTTRF_MKL95(DL,D,DU,DU2,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGTTRF(N,DL,D,DU,DU2,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: DL(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: DU(:)
        COMPLEX(WP), INTENT(OUT) :: DU2(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGTTRF_MKL95
END INTERFACE GTTRF
INTERFACE POTRF
    PURE SUBROUTINE SPOTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPOTRF(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE SPOTRF_MKL95
    PURE SUBROUTINE DPOTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPOTRF(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE DPOTRF_MKL95
    PURE SUBROUTINE CPOTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPOTRF(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE CPOTRF_MKL95
    PURE SUBROUTINE ZPOTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPOTRF(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE ZPOTRF_MKL95
END INTERFACE POTRF
INTERFACE PPTRF
    PURE SUBROUTINE SPPTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPTRF(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE SPPTRF_MKL95
    PURE SUBROUTINE DPPTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPTRF(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE DPPTRF_MKL95
    PURE SUBROUTINE CPPTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPTRF(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE CPPTRF_MKL95
    PURE SUBROUTINE ZPPTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPTRF(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE ZPPTRF_MKL95
END INTERFACE PPTRF
INTERFACE PBTRF
    PURE SUBROUTINE SPBTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBTRF(UPLO,N,KD,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE SPBTRF_MKL95
    PURE SUBROUTINE DPBTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBTRF(UPLO,N,KD,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE DPBTRF_MKL95
    PURE SUBROUTINE CPBTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBTRF(UPLO,N,KD,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE CPBTRF_MKL95
    PURE SUBROUTINE ZPBTRF_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBTRF(UPLO,N,KD,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE ZPBTRF_MKL95
END INTERFACE PBTRF
INTERFACE PTTRF
    PURE SUBROUTINE SPTTRF_MKL95(D,E,INFO)
        ! MKL Fortran77 call:
        ! SPTTRF(N,D,E,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
    END SUBROUTINE SPTTRF_MKL95
    PURE SUBROUTINE DPTTRF_MKL95(D,E,INFO)
        ! MKL Fortran77 call:
        ! DPTTRF(N,D,E,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
    END SUBROUTINE DPTTRF_MKL95
    PURE SUBROUTINE CPTTRF_MKL95(D,E,INFO)
        ! MKL Fortran77 call:
        ! CPTTRF(N,D,E,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: E(:)
    END SUBROUTINE CPTTRF_MKL95
    PURE SUBROUTINE ZPTTRF_MKL95(D,E,INFO)
        ! MKL Fortran77 call:
        ! ZPTTRF(N,D,E,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: E(:)
    END SUBROUTINE ZPTTRF_MKL95
END INTERFACE PTTRF
INTERFACE SYTRF
    PURE SUBROUTINE SSYTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SSYTRF(UPLO,N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSYTRF_MKL95
    PURE SUBROUTINE DSYTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DSYTRF(UPLO,N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSYTRF_MKL95
    PURE SUBROUTINE CSYTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CSYTRF(UPLO,N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSYTRF_MKL95
    PURE SUBROUTINE ZSYTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZSYTRF(UPLO,N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSYTRF_MKL95
END INTERFACE SYTRF
INTERFACE HETRF
    PURE SUBROUTINE CHETRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CHETRF(UPLO,N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHETRF_MKL95
    PURE SUBROUTINE ZHETRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZHETRF(UPLO,N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHETRF_MKL95
END INTERFACE HETRF
INTERFACE SPTRF
    PURE SUBROUTINE SSPTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SSPTRF(UPLO,N,A,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSPTRF_MKL95
    PURE SUBROUTINE DSPTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DSPTRF(UPLO,N,A,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSPTRF_MKL95
    PURE SUBROUTINE CSPTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CSPTRF(UPLO,N,A,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSPTRF_MKL95
    PURE SUBROUTINE ZSPTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZSPTRF(UPLO,N,A,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSPTRF_MKL95
END INTERFACE SPTRF
INTERFACE HPTRF
    PURE SUBROUTINE CHPTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CHPTRF(UPLO,N,A,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHPTRF_MKL95
    PURE SUBROUTINE ZHPTRF_MKL95(A,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZHPTRF(UPLO,N,A,IPIV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHPTRF_MKL95
END INTERFACE HPTRF
INTERFACE GETRS
    PURE SUBROUTINE SGETRS_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SGETRS_MKL95
    PURE SUBROUTINE SGETRS1_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SGETRS1_MKL95
    PURE SUBROUTINE DGETRS_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DGETRS_MKL95
    PURE SUBROUTINE DGETRS1_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DGETRS1_MKL95
    PURE SUBROUTINE CGETRS_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CGETRS_MKL95
    PURE SUBROUTINE CGETRS1_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CGETRS1_MKL95
    PURE SUBROUTINE ZGETRS_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZGETRS_MKL95
    PURE SUBROUTINE ZGETRS1_MKL95(A,IPIV,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGETRS(TRANS,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZGETRS1_MKL95
END INTERFACE GETRS
INTERFACE GBTRS
    PURE SUBROUTINE SGBTRS_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SGBTRS_MKL95
    PURE SUBROUTINE SGBTRS1_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SGBTRS1_MKL95
    PURE SUBROUTINE DGBTRS_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DGBTRS_MKL95
    PURE SUBROUTINE DGBTRS1_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DGBTRS1_MKL95
    PURE SUBROUTINE CGBTRS_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CGBTRS_MKL95
    PURE SUBROUTINE CGBTRS1_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CGBTRS1_MKL95
    PURE SUBROUTINE ZGBTRS_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZGBTRS_MKL95
    PURE SUBROUTINE ZGBTRS1_MKL95(A,B,IPIV,KL,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGBTRS(TRANS,N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZGBTRS1_MKL95
END INTERFACE GBTRS
INTERFACE GTTRS
    PURE SUBROUTINE SGTTRS_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SGTTRS_MKL95
    PURE SUBROUTINE SGTTRS1_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SGTTRS1_MKL95
    PURE SUBROUTINE DGTTRS_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DGTTRS_MKL95
    PURE SUBROUTINE DGTTRS1_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DGTTRS1_MKL95
    PURE SUBROUTINE CGTTRS_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CGTTRS_MKL95
    PURE SUBROUTINE CGTTRS1_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CGTTRS1_MKL95
    PURE SUBROUTINE ZGTTRS_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZGTTRS_MKL95
    PURE SUBROUTINE ZGTTRS1_MKL95(DL,D,DU,DU2,B,IPIV,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGTTRS(TRANS,N,NRHS,DL,D,DU,DU2,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZGTTRS1_MKL95
END INTERFACE GTTRS
INTERFACE POTRS
    PURE SUBROUTINE SPOTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPOTRS_MKL95
    PURE SUBROUTINE SPOTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPOTRS1_MKL95
    PURE SUBROUTINE DPOTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPOTRS_MKL95
    PURE SUBROUTINE DPOTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPOTRS1_MKL95
    PURE SUBROUTINE CPOTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPOTRS_MKL95
    PURE SUBROUTINE CPOTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPOTRS1_MKL95
    PURE SUBROUTINE ZPOTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPOTRS_MKL95
    PURE SUBROUTINE ZPOTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPOTRS(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPOTRS1_MKL95
END INTERFACE POTRS
INTERFACE PPTRS
    PURE SUBROUTINE SPPTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPPTRS_MKL95
    PURE SUBROUTINE SPPTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPPTRS1_MKL95
    PURE SUBROUTINE DPPTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPPTRS_MKL95
    PURE SUBROUTINE DPPTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPPTRS1_MKL95
    PURE SUBROUTINE CPPTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPPTRS_MKL95
    PURE SUBROUTINE CPPTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPPTRS1_MKL95
    PURE SUBROUTINE ZPPTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPPTRS_MKL95
    PURE SUBROUTINE ZPPTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPTRS(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPPTRS1_MKL95
END INTERFACE PPTRS
INTERFACE PBTRS
    PURE SUBROUTINE SPBTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPBTRS_MKL95
    PURE SUBROUTINE SPBTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPBTRS1_MKL95
    PURE SUBROUTINE DPBTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPBTRS_MKL95
    PURE SUBROUTINE DPBTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPBTRS1_MKL95
    PURE SUBROUTINE CPBTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPBTRS_MKL95
    PURE SUBROUTINE CPBTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPBTRS1_MKL95
    PURE SUBROUTINE ZPBTRS_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPBTRS_MKL95
    PURE SUBROUTINE ZPBTRS1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBTRS(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPBTRS1_MKL95
END INTERFACE PBTRS
INTERFACE PTTRS
    PURE SUBROUTINE SPTTRS_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! SPTTRS(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPTTRS_MKL95
    PURE SUBROUTINE SPTTRS1_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! SPTTRS(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPTTRS1_MKL95
    PURE SUBROUTINE DPTTRS_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! DPTTRS(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPTTRS_MKL95
    PURE SUBROUTINE DPTTRS1_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! DPTTRS(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPTTRS1_MKL95
    PURE SUBROUTINE CPTTRS_MKL95(D,E,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPTTRS(UPLO,N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPTTRS_MKL95
    PURE SUBROUTINE CPTTRS1_MKL95(D,E,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPTTRS(UPLO,N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPTTRS1_MKL95
    PURE SUBROUTINE ZPTTRS_MKL95(D,E,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPTTRS(UPLO,N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPTTRS_MKL95
    PURE SUBROUTINE ZPTTRS1_MKL95(D,E,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPTTRS(UPLO,N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPTTRS1_MKL95
END INTERFACE PTTRS
INTERFACE SYTRS
    PURE SUBROUTINE SSYTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSYTRS_MKL95
    PURE SUBROUTINE SSYTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSYTRS1_MKL95
    PURE SUBROUTINE DSYTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSYTRS_MKL95
    PURE SUBROUTINE DSYTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSYTRS1_MKL95
    PURE SUBROUTINE CSYTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSYTRS_MKL95
    PURE SUBROUTINE CSYTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSYTRS1_MKL95
    PURE SUBROUTINE ZSYTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSYTRS_MKL95
    PURE SUBROUTINE ZSYTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSYTRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSYTRS1_MKL95
END INTERFACE SYTRS
INTERFACE HETRS
    PURE SUBROUTINE CHETRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHETRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHETRS_MKL95
    PURE SUBROUTINE CHETRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHETRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHETRS1_MKL95
    PURE SUBROUTINE ZHETRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHETRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHETRS_MKL95
    PURE SUBROUTINE ZHETRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHETRS(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHETRS1_MKL95
END INTERFACE HETRS
INTERFACE SPTRS
    PURE SUBROUTINE SSPTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSPTRS_MKL95
    PURE SUBROUTINE SSPTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSPTRS1_MKL95
    PURE SUBROUTINE DSPTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSPTRS_MKL95
    PURE SUBROUTINE DSPTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSPTRS1_MKL95
    PURE SUBROUTINE CSPTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSPTRS_MKL95
    PURE SUBROUTINE CSPTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSPTRS1_MKL95
    PURE SUBROUTINE ZSPTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSPTRS_MKL95
    PURE SUBROUTINE ZSPTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSPTRS1_MKL95
END INTERFACE SPTRS
INTERFACE HPTRS
    PURE SUBROUTINE CHPTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHPTRS_MKL95
    PURE SUBROUTINE CHPTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHPTRS1_MKL95
    PURE SUBROUTINE ZHPTRS_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHPTRS_MKL95
    PURE SUBROUTINE ZHPTRS1_MKL95(A,B,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHPTRS(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHPTRS1_MKL95
END INTERFACE HPTRS
INTERFACE TRTRS
    PURE SUBROUTINE STRTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE STRTRS_MKL95
    PURE SUBROUTINE STRTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE STRTRS1_MKL95
    PURE SUBROUTINE DTRTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DTRTRS_MKL95
    PURE SUBROUTINE DTRTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DTRTRS1_MKL95
    PURE SUBROUTINE CTRTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CTRTRS_MKL95
    PURE SUBROUTINE CTRTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CTRTRS1_MKL95
    PURE SUBROUTINE ZTRTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZTRTRS_MKL95
    PURE SUBROUTINE ZTRTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTRTRS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZTRTRS1_MKL95
END INTERFACE TRTRS
INTERFACE TPTRS
    PURE SUBROUTINE STPTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE STPTRS_MKL95
    PURE SUBROUTINE STPTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE STPTRS1_MKL95
    PURE SUBROUTINE DTPTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DTPTRS_MKL95
    PURE SUBROUTINE DTPTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DTPTRS1_MKL95
    PURE SUBROUTINE CTPTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CTPTRS_MKL95
    PURE SUBROUTINE CTPTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CTPTRS1_MKL95
    PURE SUBROUTINE ZTPTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZTPTRS_MKL95
    PURE SUBROUTINE ZTPTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTPTRS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZTPTRS1_MKL95
END INTERFACE TPTRS
INTERFACE TBTRS
    PURE SUBROUTINE STBTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE STBTRS_MKL95
    PURE SUBROUTINE STBTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE STBTRS1_MKL95
    PURE SUBROUTINE DTBTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DTBTRS_MKL95
    PURE SUBROUTINE DTBTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DTBTRS1_MKL95
    PURE SUBROUTINE CTBTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CTBTRS_MKL95
    PURE SUBROUTINE CTBTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CTBTRS1_MKL95
    PURE SUBROUTINE ZTBTRS_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZTBTRS_MKL95
    PURE SUBROUTINE ZTBTRS1_MKL95(A,B,UPLO,TRANS,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTBTRS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZTBTRS1_MKL95
END INTERFACE TBTRS
INTERFACE GECON
    PURE SUBROUTINE SGECON_MKL95(A,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! SGECON(NORM,N,A,LDA,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE SGECON_MKL95
    PURE SUBROUTINE DGECON_MKL95(A,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! DGECON(NORM,N,A,LDA,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE DGECON_MKL95
    PURE SUBROUTINE CGECON_MKL95(A,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! CGECON(NORM,N,A,LDA,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE CGECON_MKL95
    PURE SUBROUTINE ZGECON_MKL95(A,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! ZGECON(NORM,N,A,LDA,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE ZGECON_MKL95
END INTERFACE GECON
INTERFACE GBCON
    PURE SUBROUTINE SGBCON_MKL95(A,IPIV,ANORM,RCOND,KL,NORM,INFO)
        ! MKL Fortran77 call:
        ! SGBCON(NORM,N,KL,KU,A,LDA,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SGBCON_MKL95
    PURE SUBROUTINE DGBCON_MKL95(A,IPIV,ANORM,RCOND,KL,NORM,INFO)
        ! MKL Fortran77 call:
        ! DGBCON(NORM,N,KL,KU,A,LDA,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DGBCON_MKL95
    PURE SUBROUTINE CGBCON_MKL95(A,IPIV,ANORM,RCOND,KL,NORM,INFO)
        ! MKL Fortran77 call:
        ! CGBCON(NORM,N,KL,KU,A,LDA,IPIV,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CGBCON_MKL95
    PURE SUBROUTINE ZGBCON_MKL95(A,IPIV,ANORM,RCOND,KL,NORM,INFO)
        ! MKL Fortran77 call:
        ! ZGBCON(NORM,N,KL,KU,A,LDA,IPIV,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZGBCON_MKL95
END INTERFACE GBCON
INTERFACE GTCON
    PURE SUBROUTINE SGTCON_MKL95(DL,D,DU,DU2,IPIV,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! SGTCON(NORM,N,DL,D,DU,DU2,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SGTCON_MKL95
    PURE SUBROUTINE DGTCON_MKL95(DL,D,DU,DU2,IPIV,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! DGTCON(NORM,N,DL,D,DU,DU2,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DGTCON_MKL95
    PURE SUBROUTINE CGTCON_MKL95(DL,D,DU,DU2,IPIV,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! CGTCON(NORM,N,DL,D,DU,DU2,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CGTCON_MKL95
    PURE SUBROUTINE ZGTCON_MKL95(DL,D,DU,DU2,IPIV,ANORM,RCOND,NORM,INFO)
        ! MKL Fortran77 call:
        ! ZGTCON(NORM,N,DL,D,DU,DU2,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZGTCON_MKL95
END INTERFACE GTCON
INTERFACE POCON
    PURE SUBROUTINE SPOCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPOCON(UPLO,N,A,LDA,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE SPOCON_MKL95
    PURE SUBROUTINE DPOCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPOCON(UPLO,N,A,LDA,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE DPOCON_MKL95
    PURE SUBROUTINE CPOCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPOCON(UPLO,N,A,LDA,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE CPOCON_MKL95
    PURE SUBROUTINE ZPOCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPOCON(UPLO,N,A,LDA,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE ZPOCON_MKL95
END INTERFACE POCON
INTERFACE PPCON
    PURE SUBROUTINE SPPCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPCON(UPLO,N,A,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
    END SUBROUTINE SPPCON_MKL95
    PURE SUBROUTINE DPPCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPCON(UPLO,N,A,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
    END SUBROUTINE DPPCON_MKL95
    PURE SUBROUTINE CPPCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPCON(UPLO,N,A,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
    END SUBROUTINE CPPCON_MKL95
    PURE SUBROUTINE ZPPCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPCON(UPLO,N,A,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
    END SUBROUTINE ZPPCON_MKL95
END INTERFACE PPCON
INTERFACE PBCON
    PURE SUBROUTINE SPBCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBCON(UPLO,N,KD,A,LDA,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE SPBCON_MKL95
    PURE SUBROUTINE DPBCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBCON(UPLO,N,KD,A,LDA,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE DPBCON_MKL95
    PURE SUBROUTINE CPBCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBCON(UPLO,N,KD,A,LDA,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE CPBCON_MKL95
    PURE SUBROUTINE ZPBCON_MKL95(A,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBCON(UPLO,N,KD,A,LDA,ANORM,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE ZPBCON_MKL95
END INTERFACE PBCON
INTERFACE PTCON
    PURE SUBROUTINE SPTCON_MKL95(D,E,ANORM,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SPTCON(N,D,E,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
    END SUBROUTINE SPTCON_MKL95
    PURE SUBROUTINE DPTCON_MKL95(D,E,ANORM,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DPTCON(N,D,E,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
    END SUBROUTINE DPTCON_MKL95
    PURE SUBROUTINE CPTCON_MKL95(D,E,ANORM,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CPTCON(N,D,E,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
    END SUBROUTINE CPTCON_MKL95
    PURE SUBROUTINE ZPTCON_MKL95(D,E,ANORM,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZPTCON(N,D,E,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
    END SUBROUTINE ZPTCON_MKL95
END INTERFACE PTCON
INTERFACE SYCON
    PURE SUBROUTINE SSYCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYCON(UPLO,N,A,LDA,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSYCON_MKL95
    PURE SUBROUTINE DSYCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYCON(UPLO,N,A,LDA,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSYCON_MKL95
    PURE SUBROUTINE CSYCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSYCON(UPLO,N,A,LDA,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSYCON_MKL95
    PURE SUBROUTINE ZSYCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSYCON(UPLO,N,A,LDA,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSYCON_MKL95
END INTERFACE SYCON
INTERFACE HECON
    PURE SUBROUTINE CHECON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHECON(UPLO,N,A,LDA,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHECON_MKL95
    PURE SUBROUTINE ZHECON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHECON(UPLO,N,A,LDA,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHECON_MKL95
END INTERFACE HECON
INTERFACE SPCON
    PURE SUBROUTINE SSPCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSPCON(UPLO,N,A,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSPCON_MKL95
    PURE SUBROUTINE DSPCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSPCON(UPLO,N,A,IPIV,ANORM,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSPCON_MKL95
    PURE SUBROUTINE CSPCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSPCON(UPLO,N,A,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSPCON_MKL95
    PURE SUBROUTINE ZSPCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSPCON(UPLO,N,A,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSPCON_MKL95
END INTERFACE SPCON
INTERFACE HPCON
    PURE SUBROUTINE CHPCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHPCON(UPLO,N,A,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHPCON_MKL95
    PURE SUBROUTINE ZHPCON_MKL95(A,IPIV,ANORM,RCOND,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHPCON(UPLO,N,A,IPIV,ANORM,RCOND,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: ANORM
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHPCON_MKL95
END INTERFACE HPCON
INTERFACE TRCON
    PURE SUBROUTINE STRCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! STRCON(NORM,UPLO,DIAG,N,A,LDA,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE STRCON_MKL95
    PURE SUBROUTINE DTRCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! DTRCON(NORM,UPLO,DIAG,N,A,LDA,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE DTRCON_MKL95
    PURE SUBROUTINE CTRCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! CTRCON(NORM,UPLO,DIAG,N,A,LDA,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE CTRCON_MKL95
    PURE SUBROUTINE ZTRCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! ZTRCON(NORM,UPLO,DIAG,N,A,LDA,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE ZTRCON_MKL95
END INTERFACE TRCON
INTERFACE TPCON
    PURE SUBROUTINE STPCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! STPCON(NORM,UPLO,DIAG,N,A,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
    END SUBROUTINE STPCON_MKL95
    PURE SUBROUTINE DTPCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! DTPCON(NORM,UPLO,DIAG,N,A,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
    END SUBROUTINE DTPCON_MKL95
    PURE SUBROUTINE CTPCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! CTPCON(NORM,UPLO,DIAG,N,A,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
    END SUBROUTINE CTPCON_MKL95
    PURE SUBROUTINE ZTPCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! ZTPCON(NORM,UPLO,DIAG,N,A,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
    END SUBROUTINE ZTPCON_MKL95
END INTERFACE TPCON
INTERFACE TBCON
    PURE SUBROUTINE STBCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! STBCON(NORM,UPLO,DIAG,N,KD,A,LDA,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE STBCON_MKL95
    PURE SUBROUTINE DTBCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! DTBCON(NORM,UPLO,DIAG,N,KD,A,LDA,RCOND,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE DTBCON_MKL95
    PURE SUBROUTINE CTBCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! CTBCON(NORM,UPLO,DIAG,N,KD,A,LDA,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE CTBCON_MKL95
    PURE SUBROUTINE ZTBCON_MKL95(A,RCOND,UPLO,DIAG,NORM,INFO)
        ! MKL Fortran77 call:
        ! ZTBCON(NORM,UPLO,DIAG,N,KD,A,LDA,RCOND,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: RCOND
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: NORM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
    END SUBROUTINE ZTBCON_MKL95
END INTERFACE TBCON
INTERFACE GERFS
    PURE SUBROUTINE SGERFS_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SGERFS_MKL95
    PURE SUBROUTINE SGERFS1_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SGERFS1_MKL95
    PURE SUBROUTINE DGERFS_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DGERFS_MKL95
    PURE SUBROUTINE DGERFS1_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DGERFS1_MKL95
    PURE SUBROUTINE CGERFS_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CGERFS_MKL95
    PURE SUBROUTINE CGERFS1_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CGERFS1_MKL95
    PURE SUBROUTINE ZGERFS_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZGERFS_MKL95
    PURE SUBROUTINE ZGERFS1_MKL95(A,AF,IPIV,B,X,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZGERFS(TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZGERFS1_MKL95
END INTERFACE GERFS
INTERFACE GBRFS
    PURE SUBROUTINE SGBRFS_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SGBRFS_MKL95
    PURE SUBROUTINE SGBRFS1_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SGBRFS1_MKL95
    PURE SUBROUTINE DGBRFS_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DGBRFS_MKL95
    PURE SUBROUTINE DGBRFS1_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DGBRFS1_MKL95
    PURE SUBROUTINE CGBRFS_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CGBRFS_MKL95
    PURE SUBROUTINE CGBRFS1_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CGBRFS1_MKL95
    PURE SUBROUTINE ZGBRFS_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZGBRFS_MKL95
    PURE SUBROUTINE ZGBRFS1_MKL95(A,AF,IPIV,B,X,KL,TRANS,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZGBRFS(TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZGBRFS1_MKL95
END INTERFACE GBRFS
INTERFACE GTRFS
    PURE SUBROUTINE SGTRFS_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS, &
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DLF(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: DUF(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SGTRFS_MKL95
    PURE SUBROUTINE SGTRFS1_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS,&
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DLF(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: DUF(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SGTRFS1_MKL95
    PURE SUBROUTINE DGTRFS_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS, &
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DLF(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: DUF(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DGTRFS_MKL95
    PURE SUBROUTINE DGTRFS1_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS,&
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: DLF(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: DUF(:)
        REAL(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DGTRFS1_MKL95
    PURE SUBROUTINE CGTRFS_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS, &
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DLF(:)
        COMPLEX(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: DUF(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CGTRFS_MKL95
    PURE SUBROUTINE CGTRFS1_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS,&
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DLF(:)
        COMPLEX(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: DUF(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CGTRFS1_MKL95
    PURE SUBROUTINE ZGTRFS_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS, &
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DLF(:)
        COMPLEX(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: DUF(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZGTRFS_MKL95
    PURE SUBROUTINE ZGTRFS1_MKL95(DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,X,TRANS,&
     &                                                   FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZGTRFS(TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,LDX,
        !   FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: DLF(:)
        COMPLEX(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: DUF(:)
        COMPLEX(WP), INTENT(IN) :: DU2(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZGTRFS1_MKL95
END INTERFACE GTRFS
INTERFACE PORFS
    PURE SUBROUTINE SPORFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPORFS_MKL95
    PURE SUBROUTINE SPORFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SPORFS1_MKL95
    PURE SUBROUTINE DPORFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPORFS_MKL95
    PURE SUBROUTINE DPORFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DPORFS1_MKL95
    PURE SUBROUTINE CPORFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPORFS_MKL95
    PURE SUBROUTINE CPORFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CPORFS1_MKL95
    PURE SUBROUTINE ZPORFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPORFS_MKL95
    PURE SUBROUTINE ZPORFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPORFS(UPLO,N,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZPORFS1_MKL95
END INTERFACE PORFS
INTERFACE PPRFS
    PURE SUBROUTINE SPPRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPPRFS_MKL95
    PURE SUBROUTINE SPPRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SPPRFS1_MKL95
    PURE SUBROUTINE DPPRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPPRFS_MKL95
    PURE SUBROUTINE DPPRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DPPRFS1_MKL95
    PURE SUBROUTINE CPPRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPPRFS_MKL95
    PURE SUBROUTINE CPPRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CPPRFS1_MKL95
    PURE SUBROUTINE ZPPRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPPRFS_MKL95
    PURE SUBROUTINE ZPPRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPPRFS(UPLO,N,NRHS,A,AF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZPPRFS1_MKL95
END INTERFACE PPRFS
INTERFACE PBRFS
    PURE SUBROUTINE SPBRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPBRFS_MKL95
    PURE SUBROUTINE SPBRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SPBRFS1_MKL95
    PURE SUBROUTINE DPBRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPBRFS_MKL95
    PURE SUBROUTINE DPBRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DPBRFS1_MKL95
    PURE SUBROUTINE CPBRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPBRFS_MKL95
    PURE SUBROUTINE CPBRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CPBRFS1_MKL95
    PURE SUBROUTINE ZPBRFS_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPBRFS_MKL95
    PURE SUBROUTINE ZPBRFS1_MKL95(A,AF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPBRFS(UPLO,N,KD,NRHS,A,LDA,AF,LDAF,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZPBRFS1_MKL95
END INTERFACE PBRFS
INTERFACE PTRFS
    PURE SUBROUTINE SPTRFS_MKL95(D,DF,E,EF,B,X,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPTRFS(N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: EF(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPTRFS_MKL95
    PURE SUBROUTINE SPTRFS1_MKL95(D,DF,E,EF,B,X,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SPTRFS(N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: EF(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SPTRFS1_MKL95
    PURE SUBROUTINE DPTRFS_MKL95(D,DF,E,EF,B,X,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPTRFS(N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: EF(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPTRFS_MKL95
    PURE SUBROUTINE DPTRFS1_MKL95(D,DF,E,EF,B,X,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DPTRFS(N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: EF(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DPTRFS1_MKL95
    PURE SUBROUTINE CPTRFS_MKL95(D,DF,E,EF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPTRFS(UPLO,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: EF(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPTRFS_MKL95
    PURE SUBROUTINE CPTRFS1_MKL95(D,DF,E,EF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CPTRFS(UPLO,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: EF(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CPTRFS1_MKL95
    PURE SUBROUTINE ZPTRFS_MKL95(D,DF,E,EF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPTRFS(UPLO,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: EF(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPTRFS_MKL95
    PURE SUBROUTINE ZPTRFS1_MKL95(D,DF,E,EF,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZPTRFS(UPLO,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DF(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: EF(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZPTRFS1_MKL95
END INTERFACE PTRFS
INTERFACE SYRFS
    PURE SUBROUTINE SSYRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SSYRFS_MKL95
    PURE SUBROUTINE SSYRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SSYRFS1_MKL95
    PURE SUBROUTINE DSYRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DSYRFS_MKL95
    PURE SUBROUTINE DSYRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DSYRFS1_MKL95
    PURE SUBROUTINE CSYRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CSYRFS_MKL95
    PURE SUBROUTINE CSYRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CSYRFS1_MKL95
    PURE SUBROUTINE ZSYRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZSYRFS_MKL95
    PURE SUBROUTINE ZSYRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZSYRFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZSYRFS1_MKL95
END INTERFACE SYRFS
INTERFACE HERFS
    PURE SUBROUTINE CHERFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CHERFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CHERFS_MKL95
    PURE SUBROUTINE CHERFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CHERFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CHERFS1_MKL95
    PURE SUBROUTINE ZHERFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZHERFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZHERFS_MKL95
    PURE SUBROUTINE ZHERFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZHERFS(UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: AF(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZHERFS1_MKL95
END INTERFACE HERFS
INTERFACE SPRFS
    PURE SUBROUTINE SSPRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SSPRFS_MKL95
    PURE SUBROUTINE SSPRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! SSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE SSPRFS1_MKL95
    PURE SUBROUTINE DSPRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DSPRFS_MKL95
    PURE SUBROUTINE DSPRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE DSPRFS1_MKL95
    PURE SUBROUTINE CSPRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CSPRFS_MKL95
    PURE SUBROUTINE CSPRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CSPRFS1_MKL95
    PURE SUBROUTINE ZSPRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZSPRFS_MKL95
    PURE SUBROUTINE ZSPRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZSPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZSPRFS1_MKL95
END INTERFACE SPRFS
INTERFACE HPRFS
    PURE SUBROUTINE CHPRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CHPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CHPRFS_MKL95
    PURE SUBROUTINE CHPRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CHPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE CHPRFS1_MKL95
    PURE SUBROUTINE ZHPRFS_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZHPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZHPRFS_MKL95
    PURE SUBROUTINE ZHPRFS1_MKL95(A,AF,IPIV,B,X,UPLO,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZHPRFS(UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,FERR,BERR,WORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: AF(:)
        INTEGER, INTENT(IN) :: IPIV(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(INOUT) :: X(:)
    END SUBROUTINE ZHPRFS1_MKL95
END INTERFACE HPRFS
INTERFACE TRRFS
    PURE SUBROUTINE STRRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! STRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE STRRFS_MKL95
    PURE SUBROUTINE STRRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! STRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(IN) :: X(:)
    END SUBROUTINE STRRFS1_MKL95
    PURE SUBROUTINE DTRRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DTRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DTRRFS_MKL95
    PURE SUBROUTINE DTRRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DTRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(IN) :: X(:)
    END SUBROUTINE DTRRFS1_MKL95
    PURE SUBROUTINE CTRRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CTRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CTRRFS_MKL95
    PURE SUBROUTINE CTRRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CTRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(IN) :: X(:)
    END SUBROUTINE CTRRFS1_MKL95
    PURE SUBROUTINE ZTRRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZTRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZTRRFS_MKL95
    PURE SUBROUTINE ZTRRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZTRRFS(UPLO,TRANS,DIAG,N,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(IN) :: X(:)
    END SUBROUTINE ZTRRFS1_MKL95
END INTERFACE TRRFS
INTERFACE TPRFS
    PURE SUBROUTINE STPRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! STPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE STPRFS_MKL95
    PURE SUBROUTINE STPRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! STPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(IN) :: X(:)
    END SUBROUTINE STPRFS1_MKL95
    PURE SUBROUTINE DTPRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DTPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DTPRFS_MKL95
    PURE SUBROUTINE DTPRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DTPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(IN) :: X(:)
    END SUBROUTINE DTPRFS1_MKL95
    PURE SUBROUTINE CTPRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CTPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CTPRFS_MKL95
    PURE SUBROUTINE CTPRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CTPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(IN) :: X(:)
    END SUBROUTINE CTPRFS1_MKL95
    PURE SUBROUTINE ZTPRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZTPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZTPRFS_MKL95
    PURE SUBROUTINE ZTPRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZTPRFS(UPLO,TRANS,DIAG,N,NRHS,A,B,LDB,X,LDX,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(IN) :: X(:)
    END SUBROUTINE ZTPRFS1_MKL95
END INTERFACE TPRFS
INTERFACE TBRFS
    PURE SUBROUTINE STBRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! STBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE STBRFS_MKL95
    PURE SUBROUTINE STBRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! STBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(IN) :: X(:)
    END SUBROUTINE STBRFS1_MKL95
    PURE SUBROUTINE DTBRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DTBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DTBRFS_MKL95
    PURE SUBROUTINE DTBRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! DTBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(IN) :: X(:)
    END SUBROUTINE DTBRFS1_MKL95
    PURE SUBROUTINE CTBRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CTBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CTBRFS_MKL95
    PURE SUBROUTINE CTBRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! CTBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(IN) :: X(:)
    END SUBROUTINE CTBRFS1_MKL95
    PURE SUBROUTINE ZTBRFS_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZTBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(IN) :: X(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZTBRFS_MKL95
    PURE SUBROUTINE ZTBRFS1_MKL95(A,B,X,UPLO,TRANS,DIAG,FERR,BERR,INFO)
        ! MKL Fortran77 call:
        ! ZTBRFS(UPLO,TRANS,DIAG,N,KD,NRHS,A,LDA,B,LDB,X,LDX,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(IN) :: X(:)
    END SUBROUTINE ZTBRFS1_MKL95
END INTERFACE TBRFS
INTERFACE GETRI
    PURE SUBROUTINE SGETRI_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGETRI(N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SGETRI_MKL95
    PURE SUBROUTINE DGETRI_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGETRI(N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DGETRI_MKL95
    PURE SUBROUTINE CGETRI_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGETRI(N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CGETRI_MKL95
    PURE SUBROUTINE ZGETRI_MKL95(A,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGETRI(N,A,LDA,IPIV,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZGETRI_MKL95
END INTERFACE GETRI
INTERFACE POTRI
    PURE SUBROUTINE SPOTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPOTRI(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE SPOTRI_MKL95
    PURE SUBROUTINE DPOTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPOTRI(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE DPOTRI_MKL95
    PURE SUBROUTINE CPOTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPOTRI(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE CPOTRI_MKL95
    PURE SUBROUTINE ZPOTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPOTRI(UPLO,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE ZPOTRI_MKL95
END INTERFACE POTRI
INTERFACE PPTRI
    PURE SUBROUTINE SPPTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPTRI(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE SPPTRI_MKL95
    PURE SUBROUTINE DPPTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPTRI(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE DPPTRI_MKL95
    PURE SUBROUTINE CPPTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPTRI(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE CPPTRI_MKL95
    PURE SUBROUTINE ZPPTRI_MKL95(A,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPTRI(UPLO,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE ZPPTRI_MKL95
END INTERFACE PPTRI
INTERFACE SYTRI
    PURE SUBROUTINE SSYTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYTRI(UPLO,N,A,LDA,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSYTRI_MKL95
    PURE SUBROUTINE DSYTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYTRI(UPLO,N,A,LDA,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSYTRI_MKL95
    PURE SUBROUTINE CSYTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSYTRI(UPLO,N,A,LDA,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSYTRI_MKL95
    PURE SUBROUTINE ZSYTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSYTRI(UPLO,N,A,LDA,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSYTRI_MKL95
END INTERFACE SYTRI
INTERFACE HETRI
    PURE SUBROUTINE CHETRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHETRI(UPLO,N,A,LDA,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHETRI_MKL95
    PURE SUBROUTINE ZHETRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHETRI(UPLO,N,A,LDA,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHETRI_MKL95
END INTERFACE HETRI
INTERFACE SPTRI
    PURE SUBROUTINE SSPTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSPTRI(UPLO,N,A,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE SSPTRI_MKL95
    PURE SUBROUTINE DSPTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSPTRI(UPLO,N,A,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE DSPTRI_MKL95
    PURE SUBROUTINE CSPTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CSPTRI(UPLO,N,A,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CSPTRI_MKL95
    PURE SUBROUTINE ZSPTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZSPTRI(UPLO,N,A,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZSPTRI_MKL95
END INTERFACE SPTRI
INTERFACE HPTRI
    PURE SUBROUTINE CHPTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHPTRI(UPLO,N,A,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE CHPTRI_MKL95
    PURE SUBROUTINE ZHPTRI_MKL95(A,IPIV,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHPTRI(UPLO,N,A,IPIV,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        INTEGER, INTENT(IN) :: IPIV(:)
    END SUBROUTINE ZHPTRI_MKL95
END INTERFACE HPTRI
INTERFACE TRTRI
    PURE SUBROUTINE STRTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STRTRI(UPLO,DIAG,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE STRTRI_MKL95
    PURE SUBROUTINE DTRTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTRTRI(UPLO,DIAG,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE DTRTRI_MKL95
    PURE SUBROUTINE CTRTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTRTRI(UPLO,DIAG,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE CTRTRI_MKL95
    PURE SUBROUTINE ZTRTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTRTRI(UPLO,DIAG,N,A,LDA,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
    END SUBROUTINE ZTRTRI_MKL95
END INTERFACE TRTRI
INTERFACE TPTRI
    PURE SUBROUTINE STPTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! STPTRI(UPLO,DIAG,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE STPTRI_MKL95
    PURE SUBROUTINE DTPTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! DTPTRI(UPLO,DIAG,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE DTPTRI_MKL95
    PURE SUBROUTINE CTPTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! CTPTRI(UPLO,DIAG,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE CTPTRI_MKL95
    PURE SUBROUTINE ZTPTRI_MKL95(A,UPLO,DIAG,INFO)
        ! MKL Fortran77 call:
        ! ZTPTRI(UPLO,DIAG,N,A,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: DIAG
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
    END SUBROUTINE ZTPTRI_MKL95
END INTERFACE TPTRI
INTERFACE GEEQU
    PURE SUBROUTINE SGEEQU_MKL95(A,R,C,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! SGEEQU(M,N,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE SGEEQU_MKL95
    PURE SUBROUTINE DGEEQU_MKL95(A,R,C,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! DGEEQU(M,N,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE DGEEQU_MKL95
    PURE SUBROUTINE CGEEQU_MKL95(A,R,C,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! CGEEQU(M,N,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE CGEEQU_MKL95
    PURE SUBROUTINE ZGEEQU_MKL95(A,R,C,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! ZGEEQU(M,N,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE ZGEEQU_MKL95
END INTERFACE GEEQU
INTERFACE GBEQU
    PURE SUBROUTINE SGBEQU_MKL95(A,R,C,KL,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! SGBEQU(M,N,KL,KU,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE SGBEQU_MKL95
    PURE SUBROUTINE DGBEQU_MKL95(A,R,C,KL,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! DGBEQU(M,N,KL,KU,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE DGBEQU_MKL95
    PURE SUBROUTINE CGBEQU_MKL95(A,R,C,KL,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! CGBEQU(M,N,KL,KU,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE CGBEQU_MKL95
    PURE SUBROUTINE ZGBEQU_MKL95(A,R,C,KL,ROWCND,COLCND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! ZGBEQU(M,N,KL,KU,A,LDA,R,C,ROWCND,COLCND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        REAL(WP), INTENT(OUT), OPTIONAL :: ROWCND
        REAL(WP), INTENT(OUT), OPTIONAL :: COLCND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: R(:)
        REAL(WP), INTENT(OUT) :: C(:)
    END SUBROUTINE ZGBEQU_MKL95
END INTERFACE GBEQU
INTERFACE POEQU
    PURE SUBROUTINE SPOEQU_MKL95(A,S,SCOND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! SPOEQU(N,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE SPOEQU_MKL95
    PURE SUBROUTINE DPOEQU_MKL95(A,S,SCOND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! DPOEQU(N,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE DPOEQU_MKL95
    PURE SUBROUTINE CPOEQU_MKL95(A,S,SCOND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! CPOEQU(N,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE CPOEQU_MKL95
    PURE SUBROUTINE ZPOEQU_MKL95(A,S,SCOND,AMAX,INFO)
        ! MKL Fortran77 call:
        ! ZPOEQU(N,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE ZPOEQU_MKL95
END INTERFACE POEQU
INTERFACE PPEQU
    PURE SUBROUTINE SPPEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPEQU(UPLO,N,A,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE SPPEQU_MKL95
    PURE SUBROUTINE DPPEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPEQU(UPLO,N,A,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE DPPEQU_MKL95
    PURE SUBROUTINE CPPEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPEQU(UPLO,N,A,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE CPPEQU_MKL95
    PURE SUBROUTINE ZPPEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPEQU(UPLO,N,A,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE ZPPEQU_MKL95
END INTERFACE PPEQU
INTERFACE PBEQU
    PURE SUBROUTINE SPBEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBEQU(UPLO,N,KD,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE SPBEQU_MKL95
    PURE SUBROUTINE DPBEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBEQU(UPLO,N,KD,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE DPBEQU_MKL95
    PURE SUBROUTINE CPBEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBEQU(UPLO,N,KD,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE CPBEQU_MKL95
    PURE SUBROUTINE ZPBEQU_MKL95(A,S,SCOND,AMAX,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBEQU(UPLO,N,KD,A,LDA,S,SCOND,AMAX,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT), OPTIONAL :: SCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: AMAX
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
    END SUBROUTINE ZPBEQU_MKL95
END INTERFACE PBEQU
INTERFACE GESV
    PURE SUBROUTINE SGESV_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGESV_MKL95
    PURE SUBROUTINE SGESV1_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGESV1_MKL95
    PURE SUBROUTINE DGESV_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGESV_MKL95
    PURE SUBROUTINE DGESV1_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGESV1_MKL95
    PURE SUBROUTINE CGESV_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGESV_MKL95
    PURE SUBROUTINE CGESV1_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGESV1_MKL95
    PURE SUBROUTINE ZGESV_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGESV_MKL95
    PURE SUBROUTINE ZGESV1_MKL95(A,B,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGESV(N,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGESV1_MKL95
END INTERFACE GESV
INTERFACE GESVX
    PURE SUBROUTINE SGESVX_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,    &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! SGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SGESVX_MKL95
    PURE SUBROUTINE SGESVX1_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,   &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! SGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE SGESVX1_MKL95
    PURE SUBROUTINE DGESVX_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,    &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! DGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DGESVX_MKL95
    PURE SUBROUTINE DGESVX1_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,   &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! DGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE DGESVX1_MKL95
    PURE SUBROUTINE CGESVX_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,    &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! CGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CGESVX_MKL95
    PURE SUBROUTINE CGESVX1_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,   &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! CGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE CGESVX1_MKL95
    PURE SUBROUTINE ZGESVX_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,    &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! ZGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZGESVX_MKL95
    PURE SUBROUTINE ZGESVX1_MKL95(A,B,X,AF,IPIV,FACT,TRANS,EQUED,R,C,   &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! ZGESVX(FACT,TRANS,N,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE ZGESVX1_MKL95
END INTERFACE GESVX
INTERFACE GBSV
    PURE SUBROUTINE SGBSV_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGBSV_MKL95
    PURE SUBROUTINE SGBSV1_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGBSV1_MKL95
    PURE SUBROUTINE DGBSV_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGBSV_MKL95
    PURE SUBROUTINE DGBSV1_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGBSV1_MKL95
    PURE SUBROUTINE CGBSV_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGBSV_MKL95
    PURE SUBROUTINE CGBSV1_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGBSV1_MKL95
    PURE SUBROUTINE ZGBSV_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGBSV_MKL95
    PURE SUBROUTINE ZGBSV1_MKL95(A,B,KL,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZGBSV(N,KL,KU,NRHS,A,LDA,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGBSV1_MKL95
END INTERFACE GBSV
INTERFACE GBSVX
    PURE SUBROUTINE SGBSVX_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C, &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! SGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SGBSVX_MKL95
    PURE SUBROUTINE SGBSVX1_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C,&
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! SGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE SGBSVX1_MKL95
    PURE SUBROUTINE DGBSVX_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C, &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! DGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DGBSVX_MKL95
    PURE SUBROUTINE DGBSVX1_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C,&
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! DGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE DGBSVX1_MKL95
    PURE SUBROUTINE CGBSVX_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C, &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! CGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CGBSVX_MKL95
    PURE SUBROUTINE CGBSVX1_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C,&
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! CGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE CGBSVX1_MKL95
    PURE SUBROUTINE ZGBSVX_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C, &
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! ZGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZGBSVX_MKL95
    PURE SUBROUTINE ZGBSVX1_MKL95(A,B,X,KL,AF,IPIV,FACT,TRANS,EQUED,R,C,&
     &                                      FERR,BERR,RCOND,RPVGRW,INFO)
        ! MKL Fortran77 call:
        ! ZGBSVX(FACT,TRANS,N,KL,KU,NRHS,A,LDA,AF,LDAF,IPIV,EQUED,R,C,B,
        !   LDB,X,LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        REAL(WP), INTENT(OUT), OPTIONAL :: RPVGRW
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: R(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:)
    END SUBROUTINE ZGBSVX1_MKL95
END INTERFACE GBSVX
INTERFACE GTSV
    PURE SUBROUTINE SGTSV_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! SGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: DL(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: DU(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SGTSV_MKL95
    PURE SUBROUTINE SGTSV1_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! SGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: DL(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: DU(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SGTSV1_MKL95
    PURE SUBROUTINE DGTSV_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! DGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: DL(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: DU(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DGTSV_MKL95
    PURE SUBROUTINE DGTSV1_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! DGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: DL(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: DU(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DGTSV1_MKL95
    PURE SUBROUTINE CGTSV_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! CGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: DL(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: DU(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CGTSV_MKL95
    PURE SUBROUTINE CGTSV1_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! CGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: DL(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: DU(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CGTSV1_MKL95
    PURE SUBROUTINE ZGTSV_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! ZGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: DL(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: DU(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZGTSV_MKL95
    PURE SUBROUTINE ZGTSV1_MKL95(DL,D,DU,B,INFO)
        ! MKL Fortran77 call:
        ! ZGTSV(N,NRHS,DL,D,DU,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: DL(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: DU(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZGTSV1_MKL95
END INTERFACE GTSV
INTERFACE GTSVX
    PURE SUBROUTINE SGTSVX_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT,  &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SGTSVX_MKL95
    PURE SUBROUTINE SGTSVX1_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT, &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SGTSVX1_MKL95
    PURE SUBROUTINE DGTSVX_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT,  &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DGTSVX_MKL95
    PURE SUBROUTINE DGTSVX1_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT, &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: DL(:)
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: DU(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DGTSVX1_MKL95
    PURE SUBROUTINE CGTSVX_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT,  &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CGTSVX_MKL95
    PURE SUBROUTINE CGTSVX1_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT, &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CGTSVX1_MKL95
    PURE SUBROUTINE ZGTSVX_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT,  &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZGTSVX_MKL95
    PURE SUBROUTINE ZGTSVX1_MKL95(DL,D,DU,B,X,DLF,DF,DUF,DU2,IPIV,FACT, &
     &                                       TRANS,FERR,BERR,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGTSVX(FACT,TRANS,N,NRHS,DL,D,DU,DLF,DF,DUF,DU2,IPIV,B,LDB,X,
        !   LDX,RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: DL(:)
        COMPLEX(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: DU(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DLF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DUF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: DU2(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZGTSVX1_MKL95
END INTERFACE GTSVX
INTERFACE POSV
    PURE SUBROUTINE SPOSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPOSV_MKL95
    PURE SUBROUTINE SPOSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPOSV1_MKL95
    PURE SUBROUTINE DPOSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPOSV_MKL95
    PURE SUBROUTINE DPOSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPOSV1_MKL95
    PURE SUBROUTINE CPOSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPOSV_MKL95
    PURE SUBROUTINE CPOSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPOSV1_MKL95
    PURE SUBROUTINE ZPOSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPOSV_MKL95
    PURE SUBROUTINE ZPOSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPOSV(UPLO,N,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPOSV1_MKL95
END INTERFACE POSV
INTERFACE POSVX
    PURE SUBROUTINE SPOSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPOSVX_MKL95
    PURE SUBROUTINE SPOSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE SPOSVX1_MKL95
    PURE SUBROUTINE DPOSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPOSVX_MKL95
    PURE SUBROUTINE DPOSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE DPOSVX1_MKL95
    PURE SUBROUTINE CPOSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPOSVX_MKL95
    PURE SUBROUTINE CPOSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE CPOSVX1_MKL95
    PURE SUBROUTINE ZPOSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPOSVX_MKL95
    PURE SUBROUTINE ZPOSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZPOSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE ZPOSVX1_MKL95
END INTERFACE POSVX
INTERFACE PPSV
    PURE SUBROUTINE SPPSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPPSV_MKL95
    PURE SUBROUTINE SPPSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPPSV1_MKL95
    PURE SUBROUTINE DPPSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPPSV_MKL95
    PURE SUBROUTINE DPPSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPPSV1_MKL95
    PURE SUBROUTINE CPPSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPPSV_MKL95
    PURE SUBROUTINE CPPSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPPSV1_MKL95
    PURE SUBROUTINE ZPPSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPPSV_MKL95
    PURE SUBROUTINE ZPPSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPPSV(UPLO,N,NRHS,A,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPPSV1_MKL95
END INTERFACE PPSV
INTERFACE PPSVX
    PURE SUBROUTINE SPPSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPPSVX_MKL95
    PURE SUBROUTINE SPPSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE SPPSVX1_MKL95
    PURE SUBROUTINE DPPSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPPSVX_MKL95
    PURE SUBROUTINE DPPSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE DPPSVX1_MKL95
    PURE SUBROUTINE CPPSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPPSVX_MKL95
    PURE SUBROUTINE CPPSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE CPPSVX1_MKL95
    PURE SUBROUTINE ZPPSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPPSVX_MKL95
    PURE SUBROUTINE ZPPSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZPPSVX(FACT,UPLO,N,NRHS,A,AF,EQUED,S,B,LDB,X,LDX,RCOND,FERR,
        !   BERR,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE ZPPSVX1_MKL95
END INTERFACE PPSVX
INTERFACE PBSV
    PURE SUBROUTINE SPBSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPBSV_MKL95
    PURE SUBROUTINE SPBSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPBSV1_MKL95
    PURE SUBROUTINE DPBSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPBSV_MKL95
    PURE SUBROUTINE DPBSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPBSV1_MKL95
    PURE SUBROUTINE CPBSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPBSV_MKL95
    PURE SUBROUTINE CPBSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPBSV1_MKL95
    PURE SUBROUTINE ZPBSV_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPBSV_MKL95
    PURE SUBROUTINE ZPBSV1_MKL95(A,B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBSV(UPLO,N,KD,NRHS,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPBSV1_MKL95
END INTERFACE PBSV
INTERFACE PBSVX
    PURE SUBROUTINE SPBSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPBSVX_MKL95
    PURE SUBROUTINE SPBSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE SPBSVX1_MKL95
    PURE SUBROUTINE DPBSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPBSVX_MKL95
    PURE SUBROUTINE DPBSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE DPBSVX1_MKL95
    PURE SUBROUTINE CPBSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPBSVX_MKL95
    PURE SUBROUTINE CPBSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE CPBSVX1_MKL95
    PURE SUBROUTINE ZPBSVX_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR,  &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPBSVX_MKL95
    PURE SUBROUTINE ZPBSVX1_MKL95(A,B,X,UPLO,AF,FACT,EQUED,S,FERR,BERR, &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZPBSVX(FACT,UPLO,N,KD,NRHS,A,LDA,AF,LDAF,EQUED,S,B,LDB,X,LDX,
        !   RCOND,FERR,BERR,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        CHARACTER(LEN=1), INTENT(INOUT), OPTIONAL :: EQUED
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE ZPBSVX1_MKL95
END INTERFACE PBSVX
INTERFACE PTSV
    PURE SUBROUTINE SPTSV_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! SPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPTSV_MKL95
    PURE SUBROUTINE SPTSV1_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! SPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SPTSV1_MKL95
    PURE SUBROUTINE DPTSV_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! DPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPTSV_MKL95
    PURE SUBROUTINE DPTSV1_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! DPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DPTSV1_MKL95
    PURE SUBROUTINE CPTSV_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! CPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPTSV_MKL95
    PURE SUBROUTINE CPTSV1_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! CPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CPTSV1_MKL95
    PURE SUBROUTINE ZPTSV_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! ZPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPTSV_MKL95
    PURE SUBROUTINE ZPTSV1_MKL95(D,E,B,INFO)
        ! MKL Fortran77 call:
        ! ZPTSV(N,NRHS,D,E,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZPTSV1_MKL95
END INTERFACE PTSV
INTERFACE PTSVX
    PURE SUBROUTINE SPTSVX_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,    &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SPTSVX_MKL95
    PURE SUBROUTINE SPTSVX1_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
    END SUBROUTINE SPTSVX1_MKL95
    PURE SUBROUTINE DPTSVX_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,    &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DPTSVX_MKL95
    PURE SUBROUTINE DPTSVX1_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
    END SUBROUTINE DPTSVX1_MKL95
    PURE SUBROUTINE CPTSVX_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,    &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! CPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CPTSVX_MKL95
    PURE SUBROUTINE CPTSVX1_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! CPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
    END SUBROUTINE CPTSVX1_MKL95
    PURE SUBROUTINE ZPTSVX_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,    &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! ZPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZPTSVX_MKL95
    PURE SUBROUTINE ZPTSVX1_MKL95(D,E,B,X,DF,EF,FACT,FERR,BERR,RCOND,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! ZPTSVX(FACT,N,NRHS,D,E,DF,EF,B,LDB,X,LDX,RCOND,FERR,BERR,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        COMPLEX(WP), INTENT(IN) :: E(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: DF(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: EF(:)
    END SUBROUTINE ZPTSVX1_MKL95
END INTERFACE PTSVX
INTERFACE SYSV
    PURE SUBROUTINE SSYSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSYSV_MKL95
    PURE SUBROUTINE SSYSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSYSV1_MKL95
    PURE SUBROUTINE DSYSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSYSV_MKL95
    PURE SUBROUTINE DSYSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSYSV1_MKL95
    PURE SUBROUTINE CSYSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSYSV_MKL95
    PURE SUBROUTINE CSYSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSYSV1_MKL95
    PURE SUBROUTINE ZSYSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSYSV_MKL95
    PURE SUBROUTINE ZSYSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZSYSV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSYSV1_MKL95
END INTERFACE SYSV
INTERFACE SYSVX
    PURE SUBROUTINE SSYSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SSYSVX_MKL95
    PURE SUBROUTINE SSYSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSYSVX1_MKL95
    PURE SUBROUTINE DSYSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DSYSVX_MKL95
    PURE SUBROUTINE DSYSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSYSVX1_MKL95
    PURE SUBROUTINE CSYSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CSYSVX_MKL95
    PURE SUBROUTINE CSYSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSYSVX1_MKL95
    PURE SUBROUTINE ZSYSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZSYSVX_MKL95
    PURE SUBROUTINE ZSYSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZSYSVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSYSVX1_MKL95
END INTERFACE SYSVX
INTERFACE HESVX
    PURE SUBROUTINE CHESVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CHESVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CHESVX_MKL95
    PURE SUBROUTINE CHESVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CHESVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHESVX1_MKL95
    PURE SUBROUTINE ZHESVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZHESVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZHESVX_MKL95
    PURE SUBROUTINE ZHESVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZHESVX(FACT,UPLO,N,NRHS,A,LDA,AF,LDAF,IPIV,B,LDB,X,LDX,RCOND,
        !   FERR,BERR,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHESVX1_MKL95
END INTERFACE HESVX
INTERFACE HESV
    PURE SUBROUTINE CHESV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CHESV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHESV_MKL95
    PURE SUBROUTINE CHESV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CHESV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHESV1_MKL95
    PURE SUBROUTINE ZHESV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZHESV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHESV_MKL95
    PURE SUBROUTINE ZHESV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZHESV(UPLO,N,NRHS,A,LDA,IPIV,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHESV1_MKL95
END INTERFACE HESV
INTERFACE SPSV
    PURE SUBROUTINE SSPSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSPSV_MKL95
    PURE SUBROUTINE SSPSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! SSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSPSV1_MKL95
    PURE SUBROUTINE DSPSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSPSV_MKL95
    PURE SUBROUTINE DSPSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! DSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSPSV1_MKL95
    PURE SUBROUTINE CSPSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSPSV_MKL95
    PURE SUBROUTINE CSPSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSPSV1_MKL95
    PURE SUBROUTINE ZSPSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSPSV_MKL95
    PURE SUBROUTINE ZSPSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZSPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSPSV1_MKL95
END INTERFACE SPSV
INTERFACE SPSVX
    PURE SUBROUTINE SSPSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE SSPSVX_MKL95
    PURE SUBROUTINE SSPSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! SSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE SSPSVX1_MKL95
    PURE SUBROUTINE DSPSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT) :: X(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE DSPSVX_MKL95
    PURE SUBROUTINE DSPSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! DSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: B(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE DSPSVX1_MKL95
    PURE SUBROUTINE CSPSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CSPSVX_MKL95
    PURE SUBROUTINE CSPSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CSPSVX1_MKL95
    PURE SUBROUTINE ZSPSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZSPSVX_MKL95
    PURE SUBROUTINE ZSPSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZSPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZSPSVX1_MKL95
END INTERFACE SPSVX
INTERFACE HPSVX
    PURE SUBROUTINE CHPSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CHPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE CHPSVX_MKL95
    PURE SUBROUTINE CHPSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! CHPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHPSVX1_MKL95
    PURE SUBROUTINE ZHPSVX_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,     &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZHPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: X(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: FERR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BERR(:)
    END SUBROUTINE ZHPSVX_MKL95
    PURE SUBROUTINE ZHPSVX1_MKL95(A,B,X,UPLO,AF,IPIV,FACT,FERR,BERR,    &
     &                                                       RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZHPSVX(FACT,UPLO,N,NRHS,A,AF,IPIV,B,LDB,X,LDX,RCOND,FERR,BERR,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: FACT
        REAL(WP), INTENT(OUT), OPTIONAL :: FERR
        REAL(WP), INTENT(OUT), OPTIONAL :: BERR
        REAL(WP), INTENT(OUT), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: AF(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHPSVX1_MKL95
END INTERFACE HPSVX
INTERFACE HPSV
    PURE SUBROUTINE CHPSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CHPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHPSV_MKL95
    PURE SUBROUTINE CHPSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! CHPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE CHPSV1_MKL95
    PURE SUBROUTINE ZHPSV_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZHPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHPSV_MKL95
    PURE SUBROUTINE ZHPSV1_MKL95(A,B,UPLO,IPIV,INFO)
        ! MKL Fortran77 call:
        ! ZHPSV(UPLO,N,NRHS,A,IPIV,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IPIV(:)
    END SUBROUTINE ZHPSV1_MKL95
END INTERFACE HPSV
INTERFACE GEQRF
    PURE SUBROUTINE SGEQRF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SGEQRF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE SGEQRF_MKL95
    PURE SUBROUTINE DGEQRF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DGEQRF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DGEQRF_MKL95
    PURE SUBROUTINE CGEQRF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CGEQRF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CGEQRF_MKL95
    PURE SUBROUTINE ZGEQRF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZGEQRF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZGEQRF_MKL95
END INTERFACE GEQRF
INTERFACE GEQPF
    PURE SUBROUTINE SGEQPF_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! SGEQPF(M,N,A,LDA,JPVT,TAU,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE SGEQPF_MKL95
    PURE SUBROUTINE DGEQPF_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! DGEQPF(M,N,A,LDA,JPVT,TAU,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DGEQPF_MKL95
    PURE SUBROUTINE CGEQPF_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! CGEQPF(M,N,A,LDA,JPVT,TAU,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CGEQPF_MKL95
    PURE SUBROUTINE ZGEQPF_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZGEQPF(M,N,A,LDA,JPVT,TAU,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZGEQPF_MKL95
END INTERFACE GEQPF
INTERFACE GEQP3
    PURE SUBROUTINE SGEQP3_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! SGEQP3(M,N,A,LDA,JPVT,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE SGEQP3_MKL95
    PURE SUBROUTINE DGEQP3_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! DGEQP3(M,N,A,LDA,JPVT,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DGEQP3_MKL95
    PURE SUBROUTINE CGEQP3_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! CGEQP3(M,N,A,LDA,JPVT,TAU,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CGEQP3_MKL95
    PURE SUBROUTINE ZGEQP3_MKL95(A,JPVT,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZGEQP3(M,N,A,LDA,JPVT,TAU,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        INTEGER, INTENT(INOUT) :: JPVT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZGEQP3_MKL95
END INTERFACE GEQP3
INTERFACE ORGQR
    PURE SUBROUTINE SORGQR_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SORGQR(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE SORGQR_MKL95
    PURE SUBROUTINE DORGQR_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DORGQR(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE DORGQR_MKL95
END INTERFACE ORGQR
INTERFACE ORMQR
    PURE SUBROUTINE SORMQR_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMQR(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMQR_MKL95
    PURE SUBROUTINE DORMQR_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMQR(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMQR_MKL95
END INTERFACE ORMQR
INTERFACE UNGQR
    PURE SUBROUTINE CUNGQR_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CUNGQR(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE CUNGQR_MKL95
    PURE SUBROUTINE ZUNGQR_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZUNGQR(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE ZUNGQR_MKL95
END INTERFACE UNGQR
INTERFACE UNMQR
    PURE SUBROUTINE CUNMQR_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMQR(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMQR_MKL95
    PURE SUBROUTINE ZUNMQR_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMQR(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMQR_MKL95
END INTERFACE UNMQR
INTERFACE GELQF
    PURE SUBROUTINE SGELQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SGELQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE SGELQF_MKL95
    PURE SUBROUTINE DGELQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DGELQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DGELQF_MKL95
    PURE SUBROUTINE CGELQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CGELQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CGELQF_MKL95
    PURE SUBROUTINE ZGELQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZGELQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZGELQF_MKL95
END INTERFACE GELQF
INTERFACE ORGLQ
    PURE SUBROUTINE SORGLQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SORGLQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE SORGLQ_MKL95
    PURE SUBROUTINE DORGLQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DORGLQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE DORGLQ_MKL95
END INTERFACE ORGLQ
INTERFACE ORMLQ
    PURE SUBROUTINE SORMLQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMLQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMLQ_MKL95
    PURE SUBROUTINE DORMLQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMLQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMLQ_MKL95
END INTERFACE ORMLQ
INTERFACE UNGLQ
    PURE SUBROUTINE CUNGLQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CUNGLQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE CUNGLQ_MKL95
    PURE SUBROUTINE ZUNGLQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZUNGLQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE ZUNGLQ_MKL95
END INTERFACE UNGLQ
INTERFACE UNMLQ
    PURE SUBROUTINE CUNMLQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMLQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMLQ_MKL95
    PURE SUBROUTINE ZUNMLQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMLQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMLQ_MKL95
END INTERFACE UNMLQ
INTERFACE GEQLF
    PURE SUBROUTINE SGEQLF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SGEQLF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE SGEQLF_MKL95
    PURE SUBROUTINE DGEQLF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DGEQLF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DGEQLF_MKL95
    PURE SUBROUTINE CGEQLF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CGEQLF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CGEQLF_MKL95
    PURE SUBROUTINE ZGEQLF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZGEQLF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZGEQLF_MKL95
END INTERFACE GEQLF
INTERFACE ORGQL
    PURE SUBROUTINE SORGQL_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SORGQL(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE SORGQL_MKL95
    PURE SUBROUTINE DORGQL_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DORGQL(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE DORGQL_MKL95
END INTERFACE ORGQL
INTERFACE UNGQL
    PURE SUBROUTINE CUNGQL_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CUNGQL(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE CUNGQL_MKL95
    PURE SUBROUTINE ZUNGQL_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZUNGQL(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE ZUNGQL_MKL95
END INTERFACE UNGQL
INTERFACE ORMQL
    PURE SUBROUTINE SORMQL_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMQL(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMQL_MKL95
    PURE SUBROUTINE DORMQL_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMQL(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMQL_MKL95
END INTERFACE ORMQL
INTERFACE UNMQL
    PURE SUBROUTINE CUNMQL_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMQL(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMQL_MKL95
    PURE SUBROUTINE ZUNMQL_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMQL(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMQL_MKL95
END INTERFACE UNMQL
INTERFACE GERQF
    PURE SUBROUTINE SGERQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SGERQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE SGERQF_MKL95
    PURE SUBROUTINE DGERQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DGERQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DGERQF_MKL95
    PURE SUBROUTINE CGERQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CGERQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CGERQF_MKL95
    PURE SUBROUTINE ZGERQF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZGERQF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZGERQF_MKL95
END INTERFACE GERQF
INTERFACE ORGRQ
    PURE SUBROUTINE SORGRQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! SORGRQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE SORGRQ_MKL95
    PURE SUBROUTINE DORGRQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DORGRQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE DORGRQ_MKL95
END INTERFACE ORGRQ
INTERFACE UNGRQ
    PURE SUBROUTINE CUNGRQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CUNGRQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE CUNGRQ_MKL95
    PURE SUBROUTINE ZUNGRQ_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZUNGRQ(M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE ZUNGRQ_MKL95
END INTERFACE UNGRQ
INTERFACE ORMRQ
    PURE SUBROUTINE SORMRQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMRQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMRQ_MKL95
    PURE SUBROUTINE DORMRQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMRQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMRQ_MKL95
END INTERFACE ORMRQ
INTERFACE UNMRQ
    PURE SUBROUTINE CUNMRQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMRQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMRQ_MKL95
    PURE SUBROUTINE ZUNMRQ_MKL95(A,TAU,C,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMRQ(SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMRQ_MKL95
END INTERFACE UNMRQ
INTERFACE TZRZF
    PURE SUBROUTINE STZRZF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! STZRZF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE STZRZF_MKL95
    PURE SUBROUTINE DTZRZF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! DTZRZF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DTZRZF_MKL95
    PURE SUBROUTINE CTZRZF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! CTZRZF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CTZRZF_MKL95
    PURE SUBROUTINE ZTZRZF_MKL95(A,TAU,INFO)
        ! MKL Fortran77 call:
        ! ZTZRZF(M,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZTZRZF_MKL95
END INTERFACE TZRZF
INTERFACE ORMRZ
    PURE SUBROUTINE SORMRZ_MKL95(A,TAU,C,L,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMRZ(SIDE,TRANS,M,N,K,L,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMRZ_MKL95
    PURE SUBROUTINE DORMRZ_MKL95(A,TAU,C,L,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMRZ(SIDE,TRANS,M,N,K,L,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMRZ_MKL95
END INTERFACE ORMRZ
INTERFACE UNMRZ
    PURE SUBROUTINE CUNMRZ_MKL95(A,TAU,C,L,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMRZ(SIDE,TRANS,M,N,K,L,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMRZ_MKL95
    PURE SUBROUTINE ZUNMRZ_MKL95(A,TAU,C,L,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMRZ(SIDE,TRANS,M,N,K,L,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMRZ_MKL95
END INTERFACE UNMRZ
INTERFACE GGQRF
    PURE SUBROUTINE SGGQRF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! SGGQRF(N,M,P,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE SGGQRF_MKL95
    PURE SUBROUTINE DGGQRF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! DGGQRF(N,M,P,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE DGGQRF_MKL95
    PURE SUBROUTINE CGGQRF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! CGGQRF(N,M,P,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE CGGQRF_MKL95
    PURE SUBROUTINE ZGGQRF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! ZGGQRF(N,M,P,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE ZGGQRF_MKL95
END INTERFACE GGQRF
INTERFACE GGRQF
    PURE SUBROUTINE SGGRQF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! SGGRQF(M,P,N,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE SGGRQF_MKL95
    PURE SUBROUTINE DGGRQF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! DGGRQF(M,P,N,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE DGGRQF_MKL95
    PURE SUBROUTINE CGGRQF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! CGGRQF(M,P,N,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE CGGRQF_MKL95
    PURE SUBROUTINE ZGGRQF_MKL95(A,B,TAUA,TAUB,INFO)
        ! MKL Fortran77 call:
        ! ZGGRQF(M,P,N,A,LDA,TAUA,B,LDB,TAUB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUB(:)
    END SUBROUTINE ZGGRQF_MKL95
END INTERFACE GGRQF
INTERFACE GEBRD
    PURE SUBROUTINE SGEBRD_MKL95(A,D,E,TAUQ,TAUP,INFO)
        ! MKL Fortran77 call:
        ! SGEBRD(M,N,A,LDA,D,E,TAUQ,TAUP,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUQ(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUP(:)
    END SUBROUTINE SGEBRD_MKL95
    PURE SUBROUTINE DGEBRD_MKL95(A,D,E,TAUQ,TAUP,INFO)
        ! MKL Fortran77 call:
        ! DGEBRD(M,N,A,LDA,D,E,TAUQ,TAUP,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUQ(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUP(:)
    END SUBROUTINE DGEBRD_MKL95
    PURE SUBROUTINE CGEBRD_MKL95(A,D,E,TAUQ,TAUP,INFO)
        ! MKL Fortran77 call:
        ! CGEBRD(M,N,A,LDA,D,E,TAUQ,TAUP,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUQ(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUP(:)
    END SUBROUTINE CGEBRD_MKL95
    PURE SUBROUTINE ZGEBRD_MKL95(A,D,E,TAUQ,TAUP,INFO)
        ! MKL Fortran77 call:
        ! ZGEBRD(M,N,A,LDA,D,E,TAUQ,TAUP,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUQ(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAUP(:)
    END SUBROUTINE ZGEBRD_MKL95
END INTERFACE GEBRD
INTERFACE GBBRD
    PURE SUBROUTINE SGBBRD_MKL95(A,C,D,E,Q,PT,KL,M,INFO)
        ! MKL Fortran77 call:
        ! SGBBRD(VECT,M,N,NCC,KL,KU,A,LDA,D,E,Q,LDQ,PT,LDPT,C,LDC,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: PT(:,:)
    END SUBROUTINE SGBBRD_MKL95
    PURE SUBROUTINE DGBBRD_MKL95(A,C,D,E,Q,PT,KL,M,INFO)
        ! MKL Fortran77 call:
        ! DGBBRD(VECT,M,N,NCC,KL,KU,A,LDA,D,E,Q,LDQ,PT,LDPT,C,LDC,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: PT(:,:)
    END SUBROUTINE DGBBRD_MKL95
    PURE SUBROUTINE CGBBRD_MKL95(A,C,D,E,Q,PT,KL,M,INFO)
        ! MKL Fortran77 call:
        ! CGBBRD(VECT,M,N,NCC,KL,KU,A,LDA,D,E,Q,LDQ,PT,LDPT,C,LDC,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: PT(:,:)
    END SUBROUTINE CGBBRD_MKL95
    PURE SUBROUTINE ZGBBRD_MKL95(A,C,D,E,Q,PT,KL,M,INFO)
        ! MKL Fortran77 call:
        ! ZGBBRD(VECT,M,N,NCC,KL,KU,A,LDA,D,E,Q,LDQ,PT,LDPT,C,LDC,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: KL
        INTEGER, INTENT(IN), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: D(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: E(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: PT(:,:)
    END SUBROUTINE ZGBBRD_MKL95
END INTERFACE GBBRD
INTERFACE ORGBR
    PURE SUBROUTINE SORGBR_MKL95(A,TAU,VECT,INFO)
        ! MKL Fortran77 call:
        ! SORGBR(VECT,M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE SORGBR_MKL95
    PURE SUBROUTINE DORGBR_MKL95(A,TAU,VECT,INFO)
        ! MKL Fortran77 call:
        ! DORGBR(VECT,M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE DORGBR_MKL95
END INTERFACE ORGBR
INTERFACE ORMBR
    PURE SUBROUTINE SORMBR_MKL95(A,TAU,C,VECT,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMBR(VECT,SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMBR_MKL95
    PURE SUBROUTINE DORMBR_MKL95(A,TAU,C,VECT,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMBR(VECT,SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMBR_MKL95
END INTERFACE ORMBR
INTERFACE UNGBR
    PURE SUBROUTINE CUNGBR_MKL95(A,TAU,VECT,INFO)
        ! MKL Fortran77 call:
        ! CUNGBR(VECT,M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE CUNGBR_MKL95
    PURE SUBROUTINE ZUNGBR_MKL95(A,TAU,VECT,INFO)
        ! MKL Fortran77 call:
        ! ZUNGBR(VECT,M,N,K,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE ZUNGBR_MKL95
END INTERFACE UNGBR
INTERFACE UNMBR
    PURE SUBROUTINE CUNMBR_MKL95(A,TAU,C,VECT,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMBR(VECT,SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMBR_MKL95
    PURE SUBROUTINE ZUNMBR_MKL95(A,TAU,C,VECT,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMBR(VECT,SIDE,TRANS,M,N,K,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMBR_MKL95
END INTERFACE UNMBR
INTERFACE RBDSQR
    PURE SUBROUTINE SBDSQR_MKL95(D,E,VT,U,C,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SBDSQR(UPLO,N,NCVT,NRU,NCC,D,E,VT,LDVT,U,LDU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
    END SUBROUTINE SBDSQR_MKL95
    PURE SUBROUTINE DBDSQR_MKL95(D,E,VT,U,C,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DBDSQR(UPLO,N,NCVT,NRU,NCC,D,E,VT,LDVT,U,LDU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
    END SUBROUTINE DBDSQR_MKL95
END INTERFACE RBDSQR
INTERFACE BDSQR
    PURE SUBROUTINE CBDSQR_MKL95(D,E,VT,U,C,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CBDSQR(UPLO,N,NCVT,NRU,NCC,D,E,VT,LDVT,U,LDU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VT(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
    END SUBROUTINE CBDSQR_MKL95
    PURE SUBROUTINE ZBDSQR_MKL95(D,E,VT,U,C,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZBDSQR(UPLO,N,NCVT,NRU,NCC,D,E,VT,LDVT,U,LDU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VT(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: C(:,:)
    END SUBROUTINE ZBDSQR_MKL95
END INTERFACE BDSQR
INTERFACE BDSDC
    PURE SUBROUTINE SBDSDC_MKL95(D,E,U,VT,Q,IQ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SBDSDC(UPLO,COMPQ,N,D,E,U,LDU,VT,LDVT,Q,IQ,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IQ(:)
    END SUBROUTINE SBDSDC_MKL95
    PURE SUBROUTINE DBDSDC_MKL95(D,E,U,VT,Q,IQ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DBDSDC(UPLO,COMPQ,N,D,E,U,LDU,VT,LDVT,Q,IQ,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IQ(:)
    END SUBROUTINE DBDSDC_MKL95
END INTERFACE BDSDC
INTERFACE SYTRD
    PURE SUBROUTINE SSYTRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYTRD(UPLO,N,A,LDA,D,E,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE SSYTRD_MKL95
    PURE SUBROUTINE DSYTRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYTRD(UPLO,N,A,LDA,D,E,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE DSYTRD_MKL95
END INTERFACE SYTRD
INTERFACE ORGTR
    PURE SUBROUTINE SORGTR_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SORGTR(UPLO,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE SORGTR_MKL95
    PURE SUBROUTINE DORGTR_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DORGTR(UPLO,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE DORGTR_MKL95
END INTERFACE ORGTR
INTERFACE ORMTR
    PURE SUBROUTINE SORMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMTR(SIDE,UPLO,TRANS,M,N,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMTR_MKL95
    PURE SUBROUTINE DORMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMTR(SIDE,UPLO,TRANS,M,N,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMTR_MKL95
END INTERFACE ORMTR
INTERFACE HETRD
    PURE SUBROUTINE CHETRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHETRD(UPLO,N,A,LDA,D,E,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE CHETRD_MKL95
    PURE SUBROUTINE ZHETRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHETRD(UPLO,N,A,LDA,D,E,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE ZHETRD_MKL95
END INTERFACE HETRD
INTERFACE UNGTR
    PURE SUBROUTINE CUNGTR_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CUNGTR(UPLO,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE CUNGTR_MKL95
    PURE SUBROUTINE ZUNGTR_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZUNGTR(UPLO,N,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE ZUNGTR_MKL95
END INTERFACE UNGTR
INTERFACE UNMTR
    PURE SUBROUTINE CUNMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMTR(SIDE,UPLO,TRANS,M,N,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMTR_MKL95
    PURE SUBROUTINE ZUNMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMTR(SIDE,UPLO,TRANS,M,N,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMTR_MKL95
END INTERFACE UNMTR
INTERFACE SPTRD
    PURE SUBROUTINE SSPTRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSPTRD(UPLO,N,A,D,E,TAU,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE SSPTRD_MKL95
    PURE SUBROUTINE DSPTRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSPTRD(UPLO,N,A,D,E,TAU,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE DSPTRD_MKL95
END INTERFACE SPTRD
INTERFACE OPGTR
    PURE SUBROUTINE SOPGTR_MKL95(A,TAU,Q,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SOPGTR(UPLO,N,A,TAU,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(OUT) :: Q(:,:)
    END SUBROUTINE SOPGTR_MKL95
    PURE SUBROUTINE DOPGTR_MKL95(A,TAU,Q,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DOPGTR(UPLO,N,A,TAU,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(OUT) :: Q(:,:)
    END SUBROUTINE DOPGTR_MKL95
END INTERFACE OPGTR
INTERFACE OPMTR
    PURE SUBROUTINE SOPMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SOPMTR(SIDE,UPLO,TRANS,M,N,A,TAU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SOPMTR_MKL95
    PURE SUBROUTINE DOPMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DOPMTR(SIDE,UPLO,TRANS,M,N,A,TAU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DOPMTR_MKL95
END INTERFACE OPMTR
INTERFACE HPTRD
    PURE SUBROUTINE CHPTRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHPTRD(UPLO,N,A,D,E,TAU,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE CHPTRD_MKL95
    PURE SUBROUTINE ZHPTRD_MKL95(A,TAU,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHPTRD(UPLO,N,A,D,E,TAU,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(OUT) :: TAU(:)
    END SUBROUTINE ZHPTRD_MKL95
END INTERFACE HPTRD
INTERFACE UPGTR
    PURE SUBROUTINE CUPGTR_MKL95(A,TAU,Q,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CUPGTR(UPLO,N,A,TAU,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(OUT) :: Q(:,:)
    END SUBROUTINE CUPGTR_MKL95
    PURE SUBROUTINE ZUPGTR_MKL95(A,TAU,Q,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZUPGTR(UPLO,N,A,TAU,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(OUT) :: Q(:,:)
    END SUBROUTINE ZUPGTR_MKL95
END INTERFACE UPGTR
INTERFACE UPMTR
    PURE SUBROUTINE CUPMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUPMTR(SIDE,UPLO,TRANS,M,N,A,TAU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUPMTR_MKL95
    PURE SUBROUTINE ZUPMTR_MKL95(A,TAU,C,SIDE,UPLO,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUPMTR(SIDE,UPLO,TRANS,M,N,A,TAU,C,LDC,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUPMTR_MKL95
END INTERFACE UPMTR
INTERFACE SBTRD
    PURE SUBROUTINE SSBTRD_MKL95(A,Q,VECT,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSBTRD(VECT,UPLO,N,KD,A,LDA,D,E,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE SSBTRD_MKL95
    PURE SUBROUTINE DSBTRD_MKL95(A,Q,VECT,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSBTRD(VECT,UPLO,N,KD,A,LDA,D,E,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE DSBTRD_MKL95
END INTERFACE SBTRD
INTERFACE HBTRD
    PURE SUBROUTINE CHBTRD_MKL95(A,Q,VECT,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHBTRD(VECT,UPLO,N,KD,A,LDA,D,E,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE CHBTRD_MKL95
    PURE SUBROUTINE ZHBTRD_MKL95(A,Q,VECT,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHBTRD(VECT,UPLO,N,KD,A,LDA,D,E,Q,LDQ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: VECT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE ZHBTRD_MKL95
END INTERFACE HBTRD
INTERFACE STERF
    PURE SUBROUTINE SSTERF_MKL95(D,E,INFO)
        ! MKL Fortran77 call:
        ! SSTERF(N,D,E,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
    END SUBROUTINE SSTERF_MKL95
    PURE SUBROUTINE DSTERF_MKL95(D,E,INFO)
        ! MKL Fortran77 call:
        ! DSTERF(N,D,E,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
    END SUBROUTINE DSTERF_MKL95
END INTERFACE STERF
INTERFACE RSTEQR
    PURE SUBROUTINE SSTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! SSTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSTEQR_MKL95
    PURE SUBROUTINE DSTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! DSTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSTEQR_MKL95
END INTERFACE RSTEQR
INTERFACE STEQR
    PURE SUBROUTINE CSTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! CSTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CSTEQR_MKL95
    PURE SUBROUTINE ZSTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! ZSTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZSTEQR_MKL95
END INTERFACE STEQR
INTERFACE RSTEDC
    PURE SUBROUTINE SSTEDC_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! SSTEDC(COMPZ,N,D,E,Z,LDZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSTEDC_MKL95
    PURE SUBROUTINE DSTEDC_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! DSTEDC(COMPZ,N,D,E,Z,LDZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSTEDC_MKL95
END INTERFACE RSTEDC
INTERFACE STEDC
    PURE SUBROUTINE CSTEDC_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! CSTEDC(COMPZ,N,D,E,Z,LDZ,WORK,LWORK,RWORK,LRWORK,IWORK,LIWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CSTEDC_MKL95
    PURE SUBROUTINE ZSTEDC_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! ZSTEDC(COMPZ,N,D,E,Z,LDZ,WORK,LWORK,RWORK,LRWORK,IWORK,LIWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZSTEDC_MKL95
END INTERFACE STEDC
INTERFACE RSTEGR
    PURE SUBROUTINE SSTEGR_MKL95(D,E,W,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SSTEGR(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,ISUPPZ,
        !   WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE SSTEGR_MKL95
    PURE SUBROUTINE DSTEGR_MKL95(D,E,W,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DSTEGR(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,ISUPPZ,
        !   WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE DSTEGR_MKL95
END INTERFACE RSTEGR
INTERFACE STEGR
    PURE SUBROUTINE CSTEGR_MKL95(D,E,W,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! CSTEGR(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,ISUPPZ,
        !   WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE CSTEGR_MKL95
    PURE SUBROUTINE ZSTEGR_MKL95(D,E,W,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! ZSTEGR(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,ISUPPZ,
        !   WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE ZSTEGR_MKL95
END INTERFACE STEGR
INTERFACE RPTEQR
    PURE SUBROUTINE SPTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! SPTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SPTEQR_MKL95
    PURE SUBROUTINE DPTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! DPTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DPTEQR_MKL95
END INTERFACE RPTEQR
INTERFACE PTEQR
    PURE SUBROUTINE CPTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! CPTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CPTEQR_MKL95
    PURE SUBROUTINE ZPTEQR_MKL95(D,E,Z,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! ZPTEQR(COMPZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZPTEQR_MKL95
END INTERFACE PTEQR
INTERFACE STEBZ
    PURE SUBROUTINE SSTEBZ_MKL95(D,E,M,NSPLIT,W,IBLOCK,ISPLIT,ORDER,VL, &
     &                                             VU,IL,IU,ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! SSTEBZ(RANGE,ORDER,N,VL,VU,IL,IU,ABSTOL,D,E,M,NSPLIT,W,IBLOCK,
        !   ISPLIT,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT) :: M
        INTEGER, INTENT(OUT) :: NSPLIT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: ORDER
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        INTEGER, INTENT(OUT) :: IBLOCK(:)
        INTEGER, INTENT(OUT) :: ISPLIT(:)
    END SUBROUTINE SSTEBZ_MKL95
    PURE SUBROUTINE DSTEBZ_MKL95(D,E,M,NSPLIT,W,IBLOCK,ISPLIT,ORDER,VL, &
     &                                             VU,IL,IU,ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! DSTEBZ(RANGE,ORDER,N,VL,VU,IL,IU,ABSTOL,D,E,M,NSPLIT,W,IBLOCK,
        !   ISPLIT,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT) :: M
        INTEGER, INTENT(OUT) :: NSPLIT
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: ORDER
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        INTEGER, INTENT(OUT) :: IBLOCK(:)
        INTEGER, INTENT(OUT) :: ISPLIT(:)
    END SUBROUTINE DSTEBZ_MKL95
END INTERFACE STEBZ
INTERFACE STEIN
    PURE SUBROUTINE SSTEIN_MKL95(D,E,W,IBLOCK,ISPLIT,Z,IFAILV,INFO)
        ! MKL Fortran77 call:
        ! SSTEIN(N,D,E,M,W,IBLOCK,ISPLIT,Z,LDZ,WORK,IWORK,IFAILV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: W(:)
        INTEGER, INTENT(IN) :: IBLOCK(:)
        INTEGER, INTENT(IN) :: ISPLIT(:)
        REAL(WP), INTENT(OUT) :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILV(:)
    END SUBROUTINE SSTEIN_MKL95
    PURE SUBROUTINE DSTEIN_MKL95(D,E,W,IBLOCK,ISPLIT,Z,IFAILV,INFO)
        ! MKL Fortran77 call:
        ! DSTEIN(N,D,E,M,W,IBLOCK,ISPLIT,Z,LDZ,WORK,IWORK,IFAILV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: W(:)
        INTEGER, INTENT(IN) :: IBLOCK(:)
        INTEGER, INTENT(IN) :: ISPLIT(:)
        REAL(WP), INTENT(OUT) :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILV(:)
    END SUBROUTINE DSTEIN_MKL95
    PURE SUBROUTINE CSTEIN_MKL95(D,E,W,IBLOCK,ISPLIT,Z,IFAILV,INFO)
        ! MKL Fortran77 call:
        ! CSTEIN(N,D,E,M,W,IBLOCK,ISPLIT,Z,LDZ,WORK,IWORK,IFAILV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: W(:)
        INTEGER, INTENT(IN) :: IBLOCK(:)
        INTEGER, INTENT(IN) :: ISPLIT(:)
        COMPLEX(WP), INTENT(OUT) :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILV(:)
    END SUBROUTINE CSTEIN_MKL95
    PURE SUBROUTINE ZSTEIN_MKL95(D,E,W,IBLOCK,ISPLIT,Z,IFAILV,INFO)
        ! MKL Fortran77 call:
        ! ZSTEIN(N,D,E,M,W,IBLOCK,ISPLIT,Z,LDZ,WORK,IWORK,IFAILV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(IN) :: E(:)
        REAL(WP), INTENT(IN) :: W(:)
        INTEGER, INTENT(IN) :: IBLOCK(:)
        INTEGER, INTENT(IN) :: ISPLIT(:)
        COMPLEX(WP), INTENT(OUT) :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILV(:)
    END SUBROUTINE ZSTEIN_MKL95
END INTERFACE STEIN
INTERFACE DISNA
    PURE SUBROUTINE SDISNA_MKL95(D,SEP,JOB,MINMN,INFO)
        ! MKL Fortran77 call:
        ! SDISNA(JOB,M,N,D,SEP,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: MINMN
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(OUT) :: SEP(:)
    END SUBROUTINE SDISNA_MKL95
    PURE SUBROUTINE DDISNA_MKL95(D,SEP,JOB,MINMN,INFO)
        ! MKL Fortran77 call:
        ! DDISNA(JOB,M,N,D,SEP,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: MINMN
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: D(:)
        REAL(WP), INTENT(OUT) :: SEP(:)
    END SUBROUTINE DDISNA_MKL95
END INTERFACE DISNA
INTERFACE SYGST
    PURE SUBROUTINE SSYGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYGST(ITYPE,UPLO,N,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
    END SUBROUTINE SSYGST_MKL95
    PURE SUBROUTINE DSYGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYGST(ITYPE,UPLO,N,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
    END SUBROUTINE DSYGST_MKL95
END INTERFACE SYGST
INTERFACE HEGST
    PURE SUBROUTINE CHEGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHEGST(ITYPE,UPLO,N,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
    END SUBROUTINE CHEGST_MKL95
    PURE SUBROUTINE ZHEGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHEGST(ITYPE,UPLO,N,A,LDA,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
    END SUBROUTINE ZHEGST_MKL95
END INTERFACE HEGST
INTERFACE SPGST
    PURE SUBROUTINE SSPGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSPGST(ITYPE,UPLO,N,A,B,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(IN) :: B(:)
    END SUBROUTINE SSPGST_MKL95
    PURE SUBROUTINE DSPGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSPGST(ITYPE,UPLO,N,A,B,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(IN) :: B(:)
    END SUBROUTINE DSPGST_MKL95
END INTERFACE SPGST
INTERFACE HPGST
    PURE SUBROUTINE CHPGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHPGST(ITYPE,UPLO,N,A,B,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
    END SUBROUTINE CHPGST_MKL95
    PURE SUBROUTINE ZHPGST_MKL95(A,B,ITYPE,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHPGST(ITYPE,UPLO,N,A,B,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(IN) :: B(:)
    END SUBROUTINE ZHPGST_MKL95
END INTERFACE HPGST
INTERFACE SBGST
    PURE SUBROUTINE SSBGST_MKL95(A,B,X,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSBGST(VECT,UPLO,N,KA,KB,A,LDA,B,LDB,X,LDX,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: X(:,:)
    END SUBROUTINE SSBGST_MKL95
    PURE SUBROUTINE DSBGST_MKL95(A,B,X,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSBGST(VECT,UPLO,N,KA,KB,A,LDA,B,LDB,X,LDX,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: X(:,:)
    END SUBROUTINE DSBGST_MKL95
END INTERFACE SBGST
INTERFACE HBGST
    PURE SUBROUTINE CHBGST_MKL95(A,B,X,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHBGST(VECT,UPLO,N,KA,KB,A,LDA,B,LDB,X,LDX,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: X(:,:)
    END SUBROUTINE CHBGST_MKL95
    PURE SUBROUTINE ZHBGST_MKL95(A,B,X,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHBGST(VECT,UPLO,N,KA,KB,A,LDA,B,LDB,X,LDX,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: X(:,:)
    END SUBROUTINE ZHBGST_MKL95
END INTERFACE HBGST
INTERFACE PBSTF
    PURE SUBROUTINE SPBSTF_MKL95(B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SPBSTF(UPLO,N,KB,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SPBSTF_MKL95
    PURE SUBROUTINE DPBSTF_MKL95(B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DPBSTF(UPLO,N,KB,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DPBSTF_MKL95
    PURE SUBROUTINE CPBSTF_MKL95(B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CPBSTF(UPLO,N,KB,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CPBSTF_MKL95
    PURE SUBROUTINE ZPBSTF_MKL95(B,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZPBSTF(UPLO,N,KB,B,LDB,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZPBSTF_MKL95
END INTERFACE PBSTF
INTERFACE GEHRD
    PURE SUBROUTINE SGEHRD_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! SGEHRD(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE SGEHRD_MKL95
    PURE SUBROUTINE DGEHRD_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! DGEHRD(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE DGEHRD_MKL95
    PURE SUBROUTINE CGEHRD_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! CGEHRD(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE CGEHRD_MKL95
    PURE SUBROUTINE ZGEHRD_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! ZGEHRD(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: TAU(:)
    END SUBROUTINE ZGEHRD_MKL95
END INTERFACE GEHRD
INTERFACE ORGHR
    PURE SUBROUTINE SORGHR_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! SORGHR(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE SORGHR_MKL95
    PURE SUBROUTINE DORGHR_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! DORGHR(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE DORGHR_MKL95
END INTERFACE ORGHR
INTERFACE ORMHR
    PURE SUBROUTINE SORMHR_MKL95(A,TAU,C,ILO,IHI,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SORMHR(SIDE,TRANS,M,N,ILO,IHI,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE SORMHR_MKL95
    PURE SUBROUTINE DORMHR_MKL95(A,TAU,C,ILO,IHI,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DORMHR(SIDE,TRANS,M,N,ILO,IHI,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: TAU(:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DORMHR_MKL95
END INTERFACE ORMHR
INTERFACE UNGHR
    PURE SUBROUTINE CUNGHR_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! CUNGHR(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE CUNGHR_MKL95
    PURE SUBROUTINE ZUNGHR_MKL95(A,TAU,ILO,IHI,INFO)
        ! MKL Fortran77 call:
        ! ZUNGHR(N,ILO,IHI,A,LDA,TAU,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
    END SUBROUTINE ZUNGHR_MKL95
END INTERFACE UNGHR
INTERFACE UNMHR
    PURE SUBROUTINE CUNMHR_MKL95(A,TAU,C,ILO,IHI,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CUNMHR(SIDE,TRANS,M,N,ILO,IHI,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CUNMHR_MKL95
    PURE SUBROUTINE ZUNMHR_MKL95(A,TAU,C,ILO,IHI,SIDE,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZUNMHR(SIDE,TRANS,M,N,ILO,IHI,A,LDA,TAU,C,LDC,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: TAU(:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZUNMHR_MKL95
END INTERFACE UNMHR
INTERFACE GEBAL
    PURE SUBROUTINE SGEBAL_MKL95(A,SCALE,ILO,IHI,JOB,INFO)
        ! MKL Fortran77 call:
        ! SGEBAL(JOB,N,A,LDA,ILO,IHI,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
    END SUBROUTINE SGEBAL_MKL95
    PURE SUBROUTINE DGEBAL_MKL95(A,SCALE,ILO,IHI,JOB,INFO)
        ! MKL Fortran77 call:
        ! DGEBAL(JOB,N,A,LDA,ILO,IHI,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
    END SUBROUTINE DGEBAL_MKL95
    PURE SUBROUTINE CGEBAL_MKL95(A,SCALE,ILO,IHI,JOB,INFO)
        ! MKL Fortran77 call:
        ! CGEBAL(JOB,N,A,LDA,ILO,IHI,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
    END SUBROUTINE CGEBAL_MKL95
    PURE SUBROUTINE ZGEBAL_MKL95(A,SCALE,ILO,IHI,JOB,INFO)
        ! MKL Fortran77 call:
        ! ZGEBAL(JOB,N,A,LDA,ILO,IHI,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
    END SUBROUTINE ZGEBAL_MKL95
END INTERFACE GEBAL
INTERFACE GEBAK
    PURE SUBROUTINE SGEBAK_MKL95(V,SCALE,ILO,IHI,JOB,SIDE,INFO)
        ! MKL Fortran77 call:
        ! SGEBAK(JOB,SIDE,N,ILO,IHI,SCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: V(:,:)
        REAL(WP), INTENT(IN) :: SCALE(:)
    END SUBROUTINE SGEBAK_MKL95
    PURE SUBROUTINE DGEBAK_MKL95(V,SCALE,ILO,IHI,JOB,SIDE,INFO)
        ! MKL Fortran77 call:
        ! DGEBAK(JOB,SIDE,N,ILO,IHI,SCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: V(:,:)
        REAL(WP), INTENT(IN) :: SCALE(:)
    END SUBROUTINE DGEBAK_MKL95
    PURE SUBROUTINE CGEBAK_MKL95(V,SCALE,ILO,IHI,JOB,SIDE,INFO)
        ! MKL Fortran77 call:
        ! CGEBAK(JOB,SIDE,N,ILO,IHI,SCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: V(:,:)
        REAL(WP), INTENT(IN) :: SCALE(:)
    END SUBROUTINE CGEBAK_MKL95
    PURE SUBROUTINE ZGEBAK_MKL95(V,SCALE,ILO,IHI,JOB,SIDE,INFO)
        ! MKL Fortran77 call:
        ! ZGEBAK(JOB,SIDE,N,ILO,IHI,SCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: SIDE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: V(:,:)
        REAL(WP), INTENT(IN) :: SCALE(:)
    END SUBROUTINE ZGEBAK_MKL95
END INTERFACE GEBAK
INTERFACE HSEQR
    PURE SUBROUTINE SHSEQR_MKL95(H,WR,WI,ILO,IHI,Z,JOB,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! SHSEQR(JOB,COMPZ,N,ILO,IHI,H,LDH,WR,WI,Z,LDZ,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: H(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SHSEQR_MKL95
    PURE SUBROUTINE DHSEQR_MKL95(H,WR,WI,ILO,IHI,Z,JOB,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! DHSEQR(JOB,COMPZ,N,ILO,IHI,H,LDH,WR,WI,Z,LDZ,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: H(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DHSEQR_MKL95
    PURE SUBROUTINE CHSEQR_MKL95(H,W,ILO,IHI,Z,JOB,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! CHSEQR(JOB,COMPZ,N,ILO,IHI,H,LDH,W,Z,LDZ,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: H(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHSEQR_MKL95
    PURE SUBROUTINE ZHSEQR_MKL95(H,W,ILO,IHI,Z,JOB,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! ZHSEQR(JOB,COMPZ,N,ILO,IHI,H,LDH,W,Z,LDZ,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: H(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHSEQR_MKL95
END INTERFACE HSEQR
INTERFACE HSEIN
    PURE SUBROUTINE SHSEIN_MKL95(H,WR,WI,SELECT,VL,VR,IFAILL,IFAILR,    &
     &                                              INITV,EIGSRC,M,INFO)
        ! MKL Fortran77 call:
        ! SHSEIN(JOB,EIGSRC,INITV,SELECT,N,H,LDH,WR,WI,VL,LDVL,VR,LDVR,
        !   MM,M,WORK,IFAILL,IFAILR,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: INITV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: EIGSRC
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: H(:,:)
        REAL(WP), INTENT(INOUT) :: WR(:)
        REAL(WP), INTENT(IN) :: WI(:)
        LOGICAL, INTENT(INOUT) :: SELECT(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILL(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILR(:)
    END SUBROUTINE SHSEIN_MKL95
    PURE SUBROUTINE DHSEIN_MKL95(H,WR,WI,SELECT,VL,VR,IFAILL,IFAILR,    &
     &                                              INITV,EIGSRC,M,INFO)
        ! MKL Fortran77 call:
        ! DHSEIN(JOB,EIGSRC,INITV,SELECT,N,H,LDH,WR,WI,VL,LDVL,VR,LDVR,
        !   MM,M,WORK,IFAILL,IFAILR,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: INITV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: EIGSRC
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: H(:,:)
        REAL(WP), INTENT(INOUT) :: WR(:)
        REAL(WP), INTENT(IN) :: WI(:)
        LOGICAL, INTENT(INOUT) :: SELECT(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILL(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILR(:)
    END SUBROUTINE DHSEIN_MKL95
    PURE SUBROUTINE CHSEIN_MKL95(H,W,SELECT,VL,VR,IFAILL,IFAILR,INITV,  &
     &                                                    EIGSRC,M,INFO)
        ! MKL Fortran77 call:
        ! CHSEIN(JOB,EIGSRC,INITV,SELECT,N,H,LDH,W,VL,LDVL,VR,LDVR,MM,M,
        !   WORK,RWORK,IFAILL,IFAILR,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: INITV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: EIGSRC
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: H(:,:)
        COMPLEX(WP), INTENT(INOUT) :: W(:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILL(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILR(:)
    END SUBROUTINE CHSEIN_MKL95
    PURE SUBROUTINE ZHSEIN_MKL95(H,W,SELECT,VL,VR,IFAILL,IFAILR,INITV,  &
     &                                                    EIGSRC,M,INFO)
        ! MKL Fortran77 call:
        ! ZHSEIN(JOB,EIGSRC,INITV,SELECT,N,H,LDH,W,VL,LDVL,VR,LDVR,MM,M,
        !   WORK,RWORK,IFAILL,IFAILR,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: INITV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: EIGSRC
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: H(:,:)
        COMPLEX(WP), INTENT(INOUT) :: W(:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILL(:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAILR(:)
    END SUBROUTINE ZHSEIN_MKL95
END INTERFACE HSEIN
INTERFACE TREVC
    PURE SUBROUTINE STREVC_MKL95(T,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! STREVC(SIDE,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,MM,M,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: T(:,:)
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE STREVC_MKL95
    PURE SUBROUTINE DTREVC_MKL95(T,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! DTREVC(SIDE,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,MM,M,WORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: T(:,:)
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE DTREVC_MKL95
    PURE SUBROUTINE CTREVC_MKL95(T,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! CTREVC(SIDE,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,MM,M,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE CTREVC_MKL95
    PURE SUBROUTINE ZTREVC_MKL95(T,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! ZTREVC(SIDE,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,MM,M,WORK,
        !   RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE ZTREVC_MKL95
END INTERFACE TREVC
INTERFACE TRSNA
    PURE SUBROUTINE STRSNA_MKL95(T,S,SEP,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! STRSNA(JOB,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,S,SEP,MM,M,
        !   WORK,LDWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: T(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SEP(:)
        ! VL: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE STRSNA_MKL95
    PURE SUBROUTINE DTRSNA_MKL95(T,S,SEP,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! DTRSNA(JOB,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,S,SEP,MM,M,
        !   WORK,LDWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: T(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SEP(:)
        ! VL: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE DTRSNA_MKL95
    PURE SUBROUTINE CTRSNA_MKL95(T,S,SEP,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! CTRSNA(JOB,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,S,SEP,MM,M,
        !   WORK,LDWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: T(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SEP(:)
        ! VL: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE CTRSNA_MKL95
    PURE SUBROUTINE ZTRSNA_MKL95(T,S,SEP,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! ZTRSNA(JOB,HOWMNY,SELECT,N,T,LDT,VL,LDVL,VR,LDVR,S,SEP,MM,M,
        !   WORK,LDWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: T(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SEP(:)
        ! VL: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE ZTRSNA_MKL95
END INTERFACE TRSNA
INTERFACE TREXC
    PURE SUBROUTINE STREXC_MKL95(T,IFST,ILST,Q,INFO)
        ! MKL Fortran77 call:
        ! STREXC(COMPQ,N,T,LDT,Q,LDQ,IFST,ILST,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(INOUT) :: IFST
        INTEGER, INTENT(INOUT) :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: T(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE STREXC_MKL95
    PURE SUBROUTINE DTREXC_MKL95(T,IFST,ILST,Q,INFO)
        ! MKL Fortran77 call:
        ! DTREXC(COMPQ,N,T,LDT,Q,LDQ,IFST,ILST,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(INOUT) :: IFST
        INTEGER, INTENT(INOUT) :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: T(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE DTREXC_MKL95
    PURE SUBROUTINE CTREXC_MKL95(T,IFST,ILST,Q,INFO)
        ! MKL Fortran77 call:
        ! CTREXC(COMPQ,N,T,LDT,Q,LDQ,IFST,ILST,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN) :: IFST
        INTEGER, INTENT(IN) :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE CTREXC_MKL95
    PURE SUBROUTINE ZTREXC_MKL95(T,IFST,ILST,Q,INFO)
        ! MKL Fortran77 call:
        ! ZTREXC(COMPQ,N,T,LDT,Q,LDQ,IFST,ILST,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN) :: IFST
        INTEGER, INTENT(IN) :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE ZTREXC_MKL95
END INTERFACE TREXC
INTERFACE TRSEN
    PURE SUBROUTINE STRSEN_MKL95(T,SELECT,WR,WI,M,S,SEP,Q,INFO)
        ! MKL Fortran77 call:
        ! STRSEN(JOB,COMPQ,SELECT,N,T,LDT,Q,LDQ,WR,WI,M,S,SEP,WORK,
        !   LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(OUT), OPTIONAL :: S
        REAL(WP), INTENT(OUT), OPTIONAL :: SEP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: T(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: WR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: WI(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE STRSEN_MKL95
    PURE SUBROUTINE DTRSEN_MKL95(T,SELECT,WR,WI,M,S,SEP,Q,INFO)
        ! MKL Fortran77 call:
        ! DTRSEN(JOB,COMPQ,SELECT,N,T,LDT,Q,LDQ,WR,WI,M,S,SEP,WORK,
        !   LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(OUT), OPTIONAL :: S
        REAL(WP), INTENT(OUT), OPTIONAL :: SEP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: T(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: WR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: WI(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE DTRSEN_MKL95
    PURE SUBROUTINE CTRSEN_MKL95(T,SELECT,W,M,S,SEP,Q,INFO)
        ! MKL Fortran77 call:
        ! CTRSEN(JOB,COMPQ,SELECT,N,T,LDT,Q,LDQ,W,M,S,SEP,WORK,LWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(OUT), OPTIONAL :: S
        REAL(WP), INTENT(OUT), OPTIONAL :: SEP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: W(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE CTRSEN_MKL95
    PURE SUBROUTINE ZTRSEN_MKL95(T,SELECT,W,M,S,SEP,Q,INFO)
        ! MKL Fortran77 call:
        ! ZTRSEN(JOB,COMPQ,SELECT,N,T,LDT,Q,LDQ,W,M,S,SEP,WORK,LWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(OUT), OPTIONAL :: S
        REAL(WP), INTENT(OUT), OPTIONAL :: SEP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: W(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE ZTRSEN_MKL95
END INTERFACE TRSEN
INTERFACE TRSYL
    PURE SUBROUTINE STRSYL_MKL95(A,B,C,SCALE,TRANA,TRANB,ISGN,INFO)
        ! MKL Fortran77 call:
        ! STRSYL(TRANA,TRANB,ISGN,M,N,A,LDA,B,LDB,C,LDC,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: SCALE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANA
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANB
        INTEGER, INTENT(IN), OPTIONAL :: ISGN
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE STRSYL_MKL95
    PURE SUBROUTINE DTRSYL_MKL95(A,B,C,SCALE,TRANA,TRANB,ISGN,INFO)
        ! MKL Fortran77 call:
        ! DTRSYL(TRANA,TRANB,ISGN,M,N,A,LDA,B,LDB,C,LDC,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: SCALE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANA
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANB
        INTEGER, INTENT(IN), OPTIONAL :: ISGN
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE DTRSYL_MKL95
    PURE SUBROUTINE CTRSYL_MKL95(A,B,C,SCALE,TRANA,TRANB,ISGN,INFO)
        ! MKL Fortran77 call:
        ! CTRSYL(TRANA,TRANB,ISGN,M,N,A,LDA,B,LDB,C,LDC,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(OUT) :: SCALE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANA
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANB
        INTEGER, INTENT(IN), OPTIONAL :: ISGN
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE CTRSYL_MKL95
    PURE SUBROUTINE ZTRSYL_MKL95(A,B,C,SCALE,TRANA,TRANB,ISGN,INFO)
        ! MKL Fortran77 call:
        ! ZTRSYL(TRANA,TRANB,ISGN,M,N,A,LDA,B,LDB,C,LDC,SCALE,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(OUT) :: SCALE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANA
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANB
        INTEGER, INTENT(IN), OPTIONAL :: ISGN
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
    END SUBROUTINE ZTRSYL_MKL95
END INTERFACE TRSYL
INTERFACE GGHRD
    PURE SUBROUTINE SGGHRD_MKL95(A,B,ILO,IHI,Q,Z,COMPQ,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! SGGHRD(COMPQ,COMPZ,N,ILO,IHI,A,LDA,B,LDB,Q,LDQ,Z,LDZ,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SGGHRD_MKL95
    PURE SUBROUTINE DGGHRD_MKL95(A,B,ILO,IHI,Q,Z,COMPQ,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! DGGHRD(COMPQ,COMPZ,N,ILO,IHI,A,LDA,B,LDB,Q,LDQ,Z,LDZ,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DGGHRD_MKL95
    PURE SUBROUTINE CGGHRD_MKL95(A,B,ILO,IHI,Q,Z,COMPQ,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! CGGHRD(COMPQ,COMPZ,N,ILO,IHI,A,LDA,B,LDB,Q,LDQ,Z,LDZ,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CGGHRD_MKL95
    PURE SUBROUTINE ZGGHRD_MKL95(A,B,ILO,IHI,Q,Z,COMPQ,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! ZGGHRD(COMPQ,COMPZ,N,ILO,IHI,A,LDA,B,LDB,Q,LDQ,Z,LDZ,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZGGHRD_MKL95
END INTERFACE GGHRD
INTERFACE GGBAL
    PURE SUBROUTINE SGGBAL_MKL95(A,B,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! SGGBAL(JOB,N,A,LDA,B,LDB,ILO,IHI,LSCALE,RSCALE,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE SGGBAL_MKL95
    PURE SUBROUTINE DGGBAL_MKL95(A,B,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! DGGBAL(JOB,N,A,LDA,B,LDB,ILO,IHI,LSCALE,RSCALE,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE DGGBAL_MKL95
    PURE SUBROUTINE CGGBAL_MKL95(A,B,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! CGGBAL(JOB,N,A,LDA,B,LDB,ILO,IHI,LSCALE,RSCALE,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE CGGBAL_MKL95
    PURE SUBROUTINE ZGGBAL_MKL95(A,B,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! ZGGBAL(JOB,N,A,LDA,B,LDB,ILO,IHI,LSCALE,RSCALE,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE ZGGBAL_MKL95
END INTERFACE GGBAL
INTERFACE GGBAK
    PURE SUBROUTINE SGGBAK_MKL95(V,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! SGGBAK(JOB,SIDE,N,ILO,IHI,LSCALE,RSCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: V(:,:)
        ! LSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: LSCALE(:)
        ! RSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE SGGBAK_MKL95
    PURE SUBROUTINE DGGBAK_MKL95(V,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! DGGBAK(JOB,SIDE,N,ILO,IHI,LSCALE,RSCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: V(:,:)
        ! LSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: LSCALE(:)
        ! RSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE DGGBAK_MKL95
    PURE SUBROUTINE CGGBAK_MKL95(V,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! CGGBAK(JOB,SIDE,N,ILO,IHI,LSCALE,RSCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: V(:,:)
        ! LSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: LSCALE(:)
        ! RSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE CGGBAK_MKL95
    PURE SUBROUTINE ZGGBAK_MKL95(V,ILO,IHI,LSCALE,RSCALE,JOB,INFO)
        ! MKL Fortran77 call:
        ! ZGGBAK(JOB,SIDE,N,ILO,IHI,LSCALE,RSCALE,M,V,LDV,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: V(:,:)
        ! LSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: LSCALE(:)
        ! RSCALE: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: RSCALE(:)
    END SUBROUTINE ZGGBAK_MKL95
END INTERFACE GGBAK
INTERFACE HGEQZ
    PURE SUBROUTINE SHGEQZ_MKL95(H,T,ILO,IHI,ALPHAR,ALPHAI,BETA,Q,Z,JOB,&
     &                                                 COMPQ,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! SHGEQZ(JOB,COMPQ,COMPZ,N,ILO,IHI,H,LDH,T,LDT,ALPHAR,ALPHAI,
        !   BETA,Q,LDQ,Z,LDZ,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: H(:,:)
        REAL(WP), INTENT(INOUT) :: T(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SHGEQZ_MKL95
    PURE SUBROUTINE DHGEQZ_MKL95(H,T,ILO,IHI,ALPHAR,ALPHAI,BETA,Q,Z,JOB,&
     &                                                 COMPQ,COMPZ,INFO)
        ! MKL Fortran77 call:
        ! DHGEQZ(JOB,COMPQ,COMPZ,N,ILO,IHI,H,LDH,T,LDT,ALPHAR,ALPHAI,
        !   BETA,Q,LDQ,Z,LDZ,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: H(:,:)
        REAL(WP), INTENT(INOUT) :: T(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DHGEQZ_MKL95
    PURE SUBROUTINE CHGEQZ_MKL95(H,T,ILO,IHI,ALPHA,BETA,Q,Z,JOB,COMPQ,  &
     &                                                       COMPZ,INFO)
        ! MKL Fortran77 call:
        ! CHGEQZ(JOB,COMPQ,COMPZ,N,ILO,IHI,H,LDH,T,LDT,ALPHA,BETA,Q,LDQ,
        !   Z,LDZ,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: H(:,:)
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHGEQZ_MKL95
    PURE SUBROUTINE ZHGEQZ_MKL95(H,T,ILO,IHI,ALPHA,BETA,Q,Z,JOB,COMPQ,  &
     &                                                       COMPZ,INFO)
        ! MKL Fortran77 call:
        ! ZHGEQZ(JOB,COMPQ,COMPZ,N,ILO,IHI,H,LDH,T,LDT,ALPHA,BETA,Q,LDQ,
        !   Z,LDZ,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ILO
        INTEGER, INTENT(IN), OPTIONAL :: IHI
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPQ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: COMPZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: H(:,:)
        COMPLEX(WP), INTENT(INOUT) :: T(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHGEQZ_MKL95
END INTERFACE HGEQZ
INTERFACE TGEVC
    PURE SUBROUTINE STGEVC_MKL95(S,P,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! STGEVC(SIDE,HOWMNY,SELECT,N,S,LDS,P,LDP,VL,LDVL,VR,LDVR,MM,M,
        !   WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: S(:,:)
        REAL(WP), INTENT(IN) :: P(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE STGEVC_MKL95
    PURE SUBROUTINE DTGEVC_MKL95(S,P,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! DTGEVC(SIDE,HOWMNY,SELECT,N,S,LDS,P,LDP,VL,LDVL,VR,LDVR,MM,M,
        !   WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: S(:,:)
        REAL(WP), INTENT(IN) :: P(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE DTGEVC_MKL95
    PURE SUBROUTINE CTGEVC_MKL95(S,P,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! CTGEVC(SIDE,HOWMNY,SELECT,N,S,LDS,P,LDP,VL,LDVL,VR,LDVR,MM,M,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: S(:,:)
        COMPLEX(WP), INTENT(IN) :: P(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE CTGEVC_MKL95
    PURE SUBROUTINE ZTGEVC_MKL95(S,P,HOWMNY,SELECT,VL,VR,M,INFO)
        ! MKL Fortran77 call:
        ! ZTGEVC(SIDE,HOWMNY,SELECT,N,S,LDS,P,LDP,VL,LDVL,VR,LDVR,MM,M,
        !   WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: HOWMNY
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: S(:,:)
        COMPLEX(WP), INTENT(IN) :: P(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE ZTGEVC_MKL95
END INTERFACE TGEVC
INTERFACE TGEXC
    PURE SUBROUTINE STGEXC_MKL95(A,B,IFST,ILST,Z,Q,INFO)
        ! MKL Fortran77 call:
        ! STGEXC(WANTQ,WANTZ,N,A,LDA,B,LDB,Q,LDQ,Z,LDZ,IFST,ILST,WORK,
        !   LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(INOUT), OPTIONAL :: IFST
        INTEGER, INTENT(INOUT), OPTIONAL :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE STGEXC_MKL95
    PURE SUBROUTINE DTGEXC_MKL95(A,B,IFST,ILST,Z,Q,INFO)
        ! MKL Fortran77 call:
        ! DTGEXC(WANTQ,WANTZ,N,A,LDA,B,LDB,Q,LDQ,Z,LDZ,IFST,ILST,WORK,
        !   LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(INOUT), OPTIONAL :: IFST
        INTEGER, INTENT(INOUT), OPTIONAL :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE DTGEXC_MKL95
    PURE SUBROUTINE CTGEXC_MKL95(A,B,IFST,ILST,Z,Q,INFO)
        ! MKL Fortran77 call:
        ! CTGEXC(WANTQ,WANTZ,N,A,LDA,B,LDB,Q,LDQ,Z,LDZ,IFST,ILST,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(INOUT), OPTIONAL :: IFST
        INTEGER, INTENT(INOUT), OPTIONAL :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE CTGEXC_MKL95
    PURE SUBROUTINE ZTGEXC_MKL95(A,B,IFST,ILST,Z,Q,INFO)
        ! MKL Fortran77 call:
        ! ZTGEXC(WANTQ,WANTZ,N,A,LDA,B,LDB,Q,LDQ,Z,LDZ,IFST,ILST,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(INOUT), OPTIONAL :: IFST
        INTEGER, INTENT(INOUT), OPTIONAL :: ILST
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE ZTGEXC_MKL95
END INTERFACE TGEXC
INTERFACE TGSEN
    PURE SUBROUTINE STGSEN_MKL95(A,B,SELECT,ALPHAR,ALPHAI,BETA,IJOB,Q,Z,&
     &                                                 PL,PR,DIF,M,INFO)
        ! MKL Fortran77 call:
        ! STGSEN(IJOB,WANTQ,WANTZ,SELECT,N,A,LDA,B,LDB,ALPHAR,ALPHAI,
        !   BETA,Q,LDQ,Z,LDZ,M,PL,PR,DIF,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        REAL(WP), INTENT(OUT), OPTIONAL :: PL
        REAL(WP), INTENT(OUT), OPTIONAL :: PR
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(2)
    END SUBROUTINE STGSEN_MKL95
    PURE SUBROUTINE DTGSEN_MKL95(A,B,SELECT,ALPHAR,ALPHAI,BETA,IJOB,Q,Z,&
     &                                                 PL,PR,DIF,M,INFO)
        ! MKL Fortran77 call:
        ! DTGSEN(IJOB,WANTQ,WANTZ,SELECT,N,A,LDA,B,LDB,ALPHAR,ALPHAI,
        !   BETA,Q,LDQ,Z,LDZ,M,PL,PR,DIF,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        REAL(WP), INTENT(OUT), OPTIONAL :: PL
        REAL(WP), INTENT(OUT), OPTIONAL :: PR
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAR(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHAI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(2)
    END SUBROUTINE DTGSEN_MKL95
    PURE SUBROUTINE CTGSEN_MKL95(A,B,SELECT,ALPHA,BETA,IJOB,Q,Z,PL,PR,  &
     &                                                       DIF,M,INFO)
        ! MKL Fortran77 call:
        ! CTGSEN(IJOB,WANTQ,WANTZ,SELECT,N,A,LDA,B,LDB,ALPHA,BETA,Q,LDQ,
        !   Z,LDZ,M,PL,PR,DIF,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        REAL(WP), INTENT(OUT), OPTIONAL :: PL
        REAL(WP), INTENT(OUT), OPTIONAL :: PR
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(2)
    END SUBROUTINE CTGSEN_MKL95
    PURE SUBROUTINE ZTGSEN_MKL95(A,B,SELECT,ALPHA,BETA,IJOB,Q,Z,PL,PR,  &
     &                                                       DIF,M,INFO)
        ! MKL Fortran77 call:
        ! ZTGSEN(IJOB,WANTQ,WANTZ,SELECT,N,A,LDA,B,LDB,ALPHA,BETA,Q,LDQ,
        !   Z,LDZ,M,PL,PR,DIF,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        REAL(WP), INTENT(OUT), OPTIONAL :: PL
        REAL(WP), INTENT(OUT), OPTIONAL :: PR
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        LOGICAL, INTENT(IN) :: SELECT(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Z(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(2)
    END SUBROUTINE ZTGSEN_MKL95
END INTERFACE TGSEN
INTERFACE TGSYL
    PURE SUBROUTINE STGSYL_MKL95(A,B,C,D,E,F,IJOB,TRANS,SCALE,DIF,INFO)
        ! MKL Fortran77 call:
        ! STGSYL(TRANS,IJOB,M,N,A,LDA,B,LDB,C,LDC,D,LDD,E,LDE,F,LDF,
        !   SCALE,DIF,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: SCALE
        REAL(WP), INTENT(OUT), OPTIONAL :: DIF
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
        REAL(WP), INTENT(IN) :: D(:,:)
        REAL(WP), INTENT(IN) :: E(:,:)
        REAL(WP), INTENT(INOUT) :: F(:,:)
    END SUBROUTINE STGSYL_MKL95
    PURE SUBROUTINE DTGSYL_MKL95(A,B,C,D,E,F,IJOB,TRANS,SCALE,DIF,INFO)
        ! MKL Fortran77 call:
        ! DTGSYL(TRANS,IJOB,M,N,A,LDA,B,LDB,C,LDC,D,LDD,E,LDE,F,LDF,
        !   SCALE,DIF,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: SCALE
        REAL(WP), INTENT(OUT), OPTIONAL :: DIF
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: C(:,:)
        REAL(WP), INTENT(IN) :: D(:,:)
        REAL(WP), INTENT(IN) :: E(:,:)
        REAL(WP), INTENT(INOUT) :: F(:,:)
    END SUBROUTINE DTGSYL_MKL95
    PURE SUBROUTINE CTGSYL_MKL95(A,B,C,D,E,F,IJOB,TRANS,SCALE,DIF,INFO)
        ! MKL Fortran77 call:
        ! CTGSYL(TRANS,IJOB,M,N,A,LDA,B,LDB,C,LDC,D,LDD,E,LDE,F,LDF,
        !   SCALE,DIF,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: SCALE
        REAL(WP), INTENT(OUT), OPTIONAL :: DIF
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
        COMPLEX(WP), INTENT(IN) :: D(:,:)
        COMPLEX(WP), INTENT(IN) :: E(:,:)
        COMPLEX(WP), INTENT(INOUT) :: F(:,:)
    END SUBROUTINE CTGSYL_MKL95
    PURE SUBROUTINE ZTGSYL_MKL95(A,B,C,D,E,F,IJOB,TRANS,SCALE,DIF,INFO)
        ! MKL Fortran77 call:
        ! ZTGSYL(TRANS,IJOB,M,N,A,LDA,B,LDB,C,LDC,D,LDD,E,LDE,F,LDF,
        !   SCALE,DIF,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: IJOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        REAL(WP), INTENT(OUT), OPTIONAL :: SCALE
        REAL(WP), INTENT(OUT), OPTIONAL :: DIF
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: C(:,:)
        COMPLEX(WP), INTENT(IN) :: D(:,:)
        COMPLEX(WP), INTENT(IN) :: E(:,:)
        COMPLEX(WP), INTENT(INOUT) :: F(:,:)
    END SUBROUTINE ZTGSYL_MKL95
END INTERFACE TGSYL
INTERFACE TGSNA
    PURE SUBROUTINE STGSNA_MKL95(A,B,S,DIF,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! STGSNA(JOB,HOWMNY,SELECT,N,A,LDA,B,LDB,VL,LDVL,VR,LDVR,S,DIF,
        !   MM,M,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(:)
        ! VL: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE STGSNA_MKL95
    PURE SUBROUTINE DTGSNA_MKL95(A,B,S,DIF,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! DTGSNA(JOB,HOWMNY,SELECT,N,A,LDA,B,LDB,VL,LDVL,VR,LDVR,S,DIF,
        !   MM,M,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(IN) :: A(:,:)
        REAL(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(:)
        ! VL: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE DTGSNA_MKL95
    PURE SUBROUTINE CTGSNA_MKL95(A,B,S,DIF,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! CTGSNA(JOB,HOWMNY,SELECT,N,A,LDA,B,LDB,VL,LDVL,VR,LDVR,S,DIF,
        !   MM,M,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(:)
        ! VL: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE CTGSNA_MKL95
    PURE SUBROUTINE ZTGSNA_MKL95(A,B,S,DIF,VL,VR,SELECT,M,INFO)
        ! MKL Fortran77 call:
        ! ZTGSNA(JOB,HOWMNY,SELECT,N,A,LDA,B,LDB,VL,LDVL,VR,LDVR,S,DIF,
        !   MM,M,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: M
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(IN) :: A(:,:)
        COMPLEX(WP), INTENT(IN) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: DIF(:)
        ! VL: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VL(:,:)
        ! VR: INOUT intent instead of IN because PURE.
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: VR(:,:)
        ! SELECT: INOUT intent instead of IN because PURE.
        LOGICAL, INTENT(INOUT), OPTIONAL, TARGET :: SELECT(:)
    END SUBROUTINE ZTGSNA_MKL95
END INTERFACE TGSNA
INTERFACE GGSVP
    PURE SUBROUTINE SGGSVP_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,INFO)
        ! MKL Fortran77 call:
        ! SGGSVP(JOBU,JOBV,JOBQ,M,P,N,A,LDA,B,LDB,TOLA,TOLB,K,L,U,LDU,V,
        !   LDV,Q,LDQ,IWORK,TAU,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE SGGSVP_MKL95
    PURE SUBROUTINE DGGSVP_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,INFO)
        ! MKL Fortran77 call:
        ! DGGSVP(JOBU,JOBV,JOBQ,M,P,N,A,LDA,B,LDB,TOLA,TOLB,K,L,U,LDU,V,
        !   LDV,Q,LDQ,IWORK,TAU,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE DGGSVP_MKL95
    PURE SUBROUTINE CGGSVP_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,INFO)
        ! MKL Fortran77 call:
        ! CGGSVP(JOBU,JOBV,JOBQ,M,P,N,A,LDA,B,LDB,TOLA,TOLB,K,L,U,LDU,V,
        !   LDV,Q,LDQ,IWORK,RWORK,TAU,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE CGGSVP_MKL95
    PURE SUBROUTINE ZGGSVP_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,INFO)
        ! MKL Fortran77 call:
        ! ZGGSVP(JOBU,JOBV,JOBQ,M,P,N,A,LDA,B,LDB,TOLA,TOLB,K,L,U,LDU,V,
        !   LDV,Q,LDQ,IWORK,RWORK,TAU,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE ZGGSVP_MKL95
END INTERFACE GGSVP
INTERFACE TGSJA
    PURE SUBROUTINE STGSJA_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,JOBU,JOBV,JOBQ,&
     &                                           ALPHA,BETA,NCYCLE,INFO)
        ! MKL Fortran77 call:
        ! STGSJA(JOBU,JOBV,JOBQ,M,P,N,K,L,A,LDA,B,LDB,TOLA,TOLB,ALPHA,
        !   BETA,U,LDU,V,LDV,Q,LDQ,WORK,NCYCLE,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(IN) :: K
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBU
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBQ
        INTEGER, INTENT(OUT), OPTIONAL :: NCYCLE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: V(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
    END SUBROUTINE STGSJA_MKL95
    PURE SUBROUTINE DTGSJA_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,JOBU,JOBV,JOBQ,&
     &                                           ALPHA,BETA,NCYCLE,INFO)
        ! MKL Fortran77 call:
        ! DTGSJA(JOBU,JOBV,JOBQ,M,P,N,K,L,A,LDA,B,LDB,TOLA,TOLB,ALPHA,
        !   BETA,U,LDU,V,LDV,Q,LDQ,WORK,NCYCLE,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(IN) :: K
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBU
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBQ
        INTEGER, INTENT(OUT), OPTIONAL :: NCYCLE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: V(:,:)
        REAL(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
    END SUBROUTINE DTGSJA_MKL95
    PURE SUBROUTINE CTGSJA_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,JOBU,JOBV,JOBQ,&
     &                                           ALPHA,BETA,NCYCLE,INFO)
        ! MKL Fortran77 call:
        ! CTGSJA(JOBU,JOBV,JOBQ,M,P,N,K,L,A,LDA,B,LDB,TOLA,TOLB,ALPHA,
        !   BETA,U,LDU,V,LDV,Q,LDQ,WORK,NCYCLE,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(IN) :: K
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBU
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBQ
        INTEGER, INTENT(OUT), OPTIONAL :: NCYCLE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: V(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
    END SUBROUTINE CTGSJA_MKL95
    PURE SUBROUTINE ZTGSJA_MKL95(A,B,TOLA,TOLB,K,L,U,V,Q,JOBU,JOBV,JOBQ,&
     &                                           ALPHA,BETA,NCYCLE,INFO)
        ! MKL Fortran77 call:
        ! ZTGSJA(JOBU,JOBV,JOBQ,M,P,N,K,L,A,LDA,B,LDB,TOLA,TOLB,ALPHA,
        !   BETA,U,LDU,V,LDV,Q,LDQ,WORK,NCYCLE,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN) :: TOLA
        REAL(WP), INTENT(IN) :: TOLB
        INTEGER, INTENT(IN) :: K
        INTEGER, INTENT(IN) :: L
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBU
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBV
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBQ
        INTEGER, INTENT(OUT), OPTIONAL :: NCYCLE
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: V(:,:)
        COMPLEX(WP), INTENT(INOUT), OPTIONAL, TARGET :: Q(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: ALPHA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: BETA(:)
    END SUBROUTINE ZTGSJA_MKL95
END INTERFACE TGSJA
INTERFACE GELS
    PURE SUBROUTINE SGELS_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE SGELS_MKL95
    PURE SUBROUTINE SGELS1_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! SGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE SGELS1_MKL95
    PURE SUBROUTINE DGELS_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE DGELS_MKL95
    PURE SUBROUTINE DGELS1_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! DGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE DGELS1_MKL95
    PURE SUBROUTINE CGELS_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE CGELS_MKL95
    PURE SUBROUTINE CGELS1_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! CGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE CGELS1_MKL95
    PURE SUBROUTINE ZGELS_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
    END SUBROUTINE ZGELS_MKL95
    PURE SUBROUTINE ZGELS1_MKL95(A,B,TRANS,INFO)
        ! MKL Fortran77 call:
        ! ZGELS(TRANS,M,N,NRHS,A,LDA,B,LDB,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: TRANS
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
    END SUBROUTINE ZGELS1_MKL95
END INTERFACE GELS
INTERFACE GELSY
    PURE SUBROUTINE SGELSY_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE SGELSY_MKL95
    PURE SUBROUTINE SGELSY1_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE SGELSY1_MKL95
    PURE SUBROUTINE DGELSY_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE DGELSY_MKL95
    PURE SUBROUTINE DGELSY1_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE DGELSY1_MKL95
    PURE SUBROUTINE CGELSY_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE CGELSY_MKL95
    PURE SUBROUTINE CGELSY1_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE CGELSY1_MKL95
    PURE SUBROUTINE ZGELSY_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE ZGELSY_MKL95
    PURE SUBROUTINE ZGELSY1_MKL95(A,B,RANK,JPVT,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGELSY(M,N,NRHS,A,LDA,B,LDB,JPVT,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        INTEGER, INTENT(INOUT), OPTIONAL, TARGET :: JPVT(:)
    END SUBROUTINE ZGELSY1_MKL95
END INTERFACE GELSY
INTERFACE GELSS
    PURE SUBROUTINE SGELSS_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE SGELSS_MKL95
    PURE SUBROUTINE SGELSS1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE SGELSS1_MKL95
    PURE SUBROUTINE DGELSS_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE DGELSS_MKL95
    PURE SUBROUTINE DGELSS1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE DGELSS1_MKL95
    PURE SUBROUTINE CGELSS_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE CGELSS_MKL95
    PURE SUBROUTINE CGELSS1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE CGELSS1_MKL95
    PURE SUBROUTINE ZGELSS_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE ZGELSS_MKL95
    PURE SUBROUTINE ZGELSS1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGELSS(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE ZGELSS1_MKL95
END INTERFACE GELSS
INTERFACE GELSD
    PURE SUBROUTINE SGELSD_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE SGELSD_MKL95
    PURE SUBROUTINE SGELSD1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! SGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE SGELSD1_MKL95
    PURE SUBROUTINE DGELSD_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE DGELSD_MKL95
    PURE SUBROUTINE DGELSD1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! DGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE DGELSD1_MKL95
    PURE SUBROUTINE CGELSD_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE CGELSD_MKL95
    PURE SUBROUTINE CGELSD1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! CGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE CGELSD1_MKL95
    PURE SUBROUTINE ZGELSD_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE ZGELSD_MKL95
    PURE SUBROUTINE ZGELSD1_MKL95(A,B,RANK,S,RCOND,INFO)
        ! MKL Fortran77 call:
        ! ZGELSD(M,N,NRHS,A,LDA,B,LDB,S,RCOND,RANK,WORK,LWORK,RWORK,
        !   IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: RANK
        REAL(WP), INTENT(IN), OPTIONAL :: RCOND
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: S(:)
    END SUBROUTINE ZGELSD1_MKL95
END INTERFACE GELSD
INTERFACE GGLSE
    PURE SUBROUTINE SGGLSE_MKL95(A,B,C,D,X,INFO)
        ! MKL Fortran77 call:
        ! SGGLSE(M,N,P,A,LDA,B,LDB,C,D,X,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: C(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(OUT) :: X(:)
    END SUBROUTINE SGGLSE_MKL95
    PURE SUBROUTINE DGGLSE_MKL95(A,B,C,D,X,INFO)
        ! MKL Fortran77 call:
        ! DGGLSE(M,N,P,A,LDA,B,LDB,C,D,X,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: C(:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(OUT) :: X(:)
    END SUBROUTINE DGGLSE_MKL95
    PURE SUBROUTINE CGGLSE_MKL95(A,B,C,D,X,INFO)
        ! MKL Fortran77 call:
        ! CGGLSE(M,N,P,A,LDA,B,LDB,C,D,X,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: C(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
    END SUBROUTINE CGGLSE_MKL95
    PURE SUBROUTINE ZGGLSE_MKL95(A,B,C,D,X,INFO)
        ! MKL Fortran77 call:
        ! ZGGLSE(M,N,P,A,LDA,B,LDB,C,D,X,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: C(:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
    END SUBROUTINE ZGGLSE_MKL95
END INTERFACE GGLSE
INTERFACE GGGLM
    PURE SUBROUTINE SGGGLM_MKL95(A,B,D,X,Y,INFO)
        ! MKL Fortran77 call:
        ! SGGGLM(N,M,P,A,LDA,B,LDB,D,X,Y,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(OUT) :: Y(:)
    END SUBROUTINE SGGGLM_MKL95
    PURE SUBROUTINE DGGGLM_MKL95(A,B,D,X,Y,INFO)
        ! MKL Fortran77 call:
        ! DGGGLM(N,M,P,A,LDA,B,LDB,D,X,Y,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(OUT) :: X(:)
        REAL(WP), INTENT(OUT) :: Y(:)
    END SUBROUTINE DGGGLM_MKL95
    PURE SUBROUTINE CGGGLM_MKL95(A,B,D,X,Y,INFO)
        ! MKL Fortran77 call:
        ! CGGGLM(N,M,P,A,LDA,B,LDB,D,X,Y,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(OUT) :: Y(:)
    END SUBROUTINE CGGGLM_MKL95
    PURE SUBROUTINE ZGGGLM_MKL95(A,B,D,X,Y,INFO)
        ! MKL Fortran77 call:
        ! ZGGGLM(N,M,P,A,LDA,B,LDB,D,X,Y,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(INOUT) :: D(:)
        COMPLEX(WP), INTENT(OUT) :: X(:)
        COMPLEX(WP), INTENT(OUT) :: Y(:)
    END SUBROUTINE ZGGGLM_MKL95
END INTERFACE GGGLM
INTERFACE SYEV
    PURE SUBROUTINE SSYEV_MKL95(A,W,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYEV(JOBZ,UPLO,N,A,LDA,W,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE SSYEV_MKL95
    PURE SUBROUTINE DSYEV_MKL95(A,W,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYEV(JOBZ,UPLO,N,A,LDA,W,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE DSYEV_MKL95
END INTERFACE SYEV
INTERFACE HEEV
    PURE SUBROUTINE CHEEV_MKL95(A,W,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHEEV(JOBZ,UPLO,N,A,LDA,W,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE CHEEV_MKL95
    PURE SUBROUTINE ZHEEV_MKL95(A,W,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHEEV(JOBZ,UPLO,N,A,LDA,W,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE ZHEEV_MKL95
END INTERFACE HEEV
INTERFACE SYEVD
    PURE SUBROUTINE SSYEVD_MKL95(A,W,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYEVD(JOBZ,UPLO,N,A,LDA,W,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE SSYEVD_MKL95
    PURE SUBROUTINE DSYEVD_MKL95(A,W,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYEVD(JOBZ,UPLO,N,A,LDA,W,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE DSYEVD_MKL95
END INTERFACE SYEVD
INTERFACE HEEVD
    PURE SUBROUTINE CHEEVD_MKL95(A,W,JOB,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHEEVD(JOB,UPLO,N,A,LDA,W,WORK,LWORK,RWORK,LRWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE CHEEVD_MKL95
    PURE SUBROUTINE ZHEEVD_MKL95(A,W,JOB,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHEEVD(JOB,UPLO,N,A,LDA,W,WORK,LWORK,RWORK,LRWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE ZHEEVD_MKL95
END INTERFACE HEEVD
INTERFACE SYEVX
    PURE SUBROUTINE SSYEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SSYEVX(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   WORK,LWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE SSYEVX_MKL95
    PURE SUBROUTINE DSYEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DSYEVX(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   WORK,LWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE DSYEVX_MKL95
END INTERFACE SYEVX
INTERFACE HEEVX
    PURE SUBROUTINE CHEEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! CHEEVX(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   WORK,LWORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE CHEEVX_MKL95
    PURE SUBROUTINE ZHEEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! ZHEEVX(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   WORK,LWORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE ZHEEVX_MKL95
END INTERFACE HEEVX
INTERFACE SYEVR
    PURE SUBROUTINE SSYEVR_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,&
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SSYEVR(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   ISUPPZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE SSYEVR_MKL95
    PURE SUBROUTINE DSYEVR_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,&
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DSYEVR(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   ISUPPZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE DSYEVR_MKL95
END INTERFACE SYEVR
INTERFACE HEEVR
    PURE SUBROUTINE CHEEVR_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,&
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! CHEEVR(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   ISUPPZ,WORK,LWORK,RWORK,LRWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE CHEEVR_MKL95
    PURE SUBROUTINE ZHEEVR_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,&
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! ZHEEVR(JOBZ,RANGE,UPLO,N,A,LDA,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,
        !   ISUPPZ,WORK,LWORK,RWORK,LRWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE ZHEEVR_MKL95
END INTERFACE HEEVR
INTERFACE SPEV
    PURE SUBROUTINE SSPEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSPEV(JOBZ,UPLO,N,A,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSPEV_MKL95
    PURE SUBROUTINE DSPEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSPEV(JOBZ,UPLO,N,A,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSPEV_MKL95
END INTERFACE SPEV
INTERFACE HPEV
    PURE SUBROUTINE CHPEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHPEV(JOBZ,UPLO,N,A,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHPEV_MKL95
    PURE SUBROUTINE ZHPEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHPEV(JOBZ,UPLO,N,A,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHPEV_MKL95
END INTERFACE HPEV
INTERFACE SPEVD
    PURE SUBROUTINE SSPEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSPEVD(JOBZ,UPLO,N,A,W,Z,LDZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSPEVD_MKL95
    PURE SUBROUTINE DSPEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSPEVD(JOBZ,UPLO,N,A,W,Z,LDZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSPEVD_MKL95
END INTERFACE SPEVD
INTERFACE HPEVD
    PURE SUBROUTINE CHPEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHPEVD(JOB,UPLO,N,A,W,Z,LDZ,WORK,LWORK,RWORK,LRWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHPEVD_MKL95
    PURE SUBROUTINE ZHPEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHPEVD(JOB,UPLO,N,A,W,Z,LDZ,WORK,LWORK,RWORK,LRWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHPEVD_MKL95
END INTERFACE HPEVD
INTERFACE SPEVX
    PURE SUBROUTINE SSPEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SSPEVX(JOBZ,RANGE,UPLO,N,A,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,WORK,
        !   IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE SSPEVX_MKL95
    PURE SUBROUTINE DSPEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DSPEVX(JOBZ,RANGE,UPLO,N,A,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,WORK,
        !   IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE DSPEVX_MKL95
END INTERFACE SPEVX
INTERFACE HPEVX
    PURE SUBROUTINE CHPEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! CHPEVX(JOBZ,RANGE,UPLO,N,A,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,WORK,
        !   RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE CHPEVX_MKL95
    PURE SUBROUTINE ZHPEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL, &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! ZHPEVX(JOBZ,RANGE,UPLO,N,A,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,WORK,
        !   RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE ZHPEVX_MKL95
END INTERFACE HPEVX
INTERFACE SBEV
    PURE SUBROUTINE SSBEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSBEV(JOBZ,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSBEV_MKL95
    PURE SUBROUTINE DSBEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSBEV(JOBZ,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSBEV_MKL95
END INTERFACE SBEV
INTERFACE HBEV
    PURE SUBROUTINE CHBEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHBEV(JOBZ,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHBEV_MKL95
    PURE SUBROUTINE ZHBEV_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHBEV(JOBZ,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHBEV_MKL95
END INTERFACE HBEV
INTERFACE SBEVD
    PURE SUBROUTINE SSBEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSBEVD(JOBZ,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,LWORK,IWORK,LIWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSBEVD_MKL95
    PURE SUBROUTINE DSBEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSBEVD(JOBZ,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,LWORK,IWORK,LIWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSBEVD_MKL95
END INTERFACE SBEVD
INTERFACE HBEVD
    PURE SUBROUTINE CHBEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHBEVD(JOB,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,LWORK,RWORK,LRWORK,
        !   IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHBEVD_MKL95
    PURE SUBROUTINE ZHBEVD_MKL95(A,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHBEVD(JOB,UPLO,N,KD,A,LDA,W,Z,LDZ,WORK,LWORK,RWORK,LRWORK,
        !   IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHBEVD_MKL95
END INTERFACE HBEVD
INTERFACE SBEVX
    PURE SUBROUTINE SSBEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,      &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! SSBEVX(JOBZ,RANGE,UPLO,N,KD,A,LDA,Q,LDQ,VL,VU,IL,IU,ABSTOL,M,
        !   W,Z,LDZ,WORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE SSBEVX_MKL95
    PURE SUBROUTINE DSBEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,      &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! DSBEVX(JOBZ,RANGE,UPLO,N,KD,A,LDA,Q,LDQ,VL,VU,IL,IU,ABSTOL,M,
        !   W,Z,LDZ,WORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE DSBEVX_MKL95
END INTERFACE SBEVX
INTERFACE HBEVX
    PURE SUBROUTINE CHBEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,      &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! CHBEVX(JOBZ,RANGE,UPLO,N,KD,A,LDA,Q,LDQ,VL,VU,IL,IU,ABSTOL,M,
        !   W,Z,LDZ,WORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE CHBEVX_MKL95
    PURE SUBROUTINE ZHBEVX_MKL95(A,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,      &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! ZHBEVX(JOBZ,RANGE,UPLO,N,KD,A,LDA,Q,LDQ,VL,VU,IL,IU,ABSTOL,M,
        !   W,Z,LDZ,WORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE ZHBEVX_MKL95
END INTERFACE HBEVX
INTERFACE STEV
    PURE SUBROUTINE SSTEV_MKL95(D,E,Z,INFO)
        ! MKL Fortran77 call:
        ! SSTEV(JOBZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSTEV_MKL95
    PURE SUBROUTINE DSTEV_MKL95(D,E,Z,INFO)
        ! MKL Fortran77 call:
        ! DSTEV(JOBZ,N,D,E,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSTEV_MKL95
END INTERFACE STEV
INTERFACE STEVD
    PURE SUBROUTINE SSTEVD_MKL95(D,E,Z,INFO)
        ! MKL Fortran77 call:
        ! SSTEVD(JOBZ,N,D,E,Z,LDZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSTEVD_MKL95
    PURE SUBROUTINE DSTEVD_MKL95(D,E,Z,INFO)
        ! MKL Fortran77 call:
        ! DSTEVD(JOBZ,N,D,E,Z,LDZ,WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSTEVD_MKL95
END INTERFACE STEVD
INTERFACE STEVX
    PURE SUBROUTINE SSTEVX_MKL95(D,E,W,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL,    &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SSTEVX(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,WORK,
        !   IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE SSTEVX_MKL95
    PURE SUBROUTINE DSTEVX_MKL95(D,E,W,Z,VL,VU,IL,IU,M,IFAIL,ABSTOL,    &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DSTEVX(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,WORK,
        !   IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE DSTEVX_MKL95
END INTERFACE STEVX
INTERFACE STEVR
    PURE SUBROUTINE SSTEVR_MKL95(D,E,W,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SSTEVR(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,ISUPPZ,
        !   WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE SSTEVR_MKL95
    PURE SUBROUTINE DSTEVR_MKL95(D,E,W,Z,VL,VU,IL,IU,M,ISUPPZ,ABSTOL,   &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DSTEVR(JOBZ,RANGE,N,D,E,VL,VU,IL,IU,ABSTOL,M,W,Z,LDZ,ISUPPZ,
        !   WORK,LWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: D(:)
        REAL(WP), INTENT(INOUT) :: E(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: ISUPPZ(:)
    END SUBROUTINE DSTEVR_MKL95
END INTERFACE STEVR
INTERFACE GEES
    PURE SUBROUTINE SGEES_MKL95(A,WR,WI,VS,SELECT,SDIM,INFO)
        ! MKL Fortran77 call:
        ! SGEES(JOBVS,SORT,SELECT,N,A,LDA,SDIM,WR,WI,VS,LDVS,WORK,LWORK,
        !   BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(WR,WI)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: WR,WI
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE SGEES_MKL95
    PURE SUBROUTINE DGEES_MKL95(A,WR,WI,VS,SELECT,SDIM,INFO)
        ! MKL Fortran77 call:
        ! DGEES(JOBVS,SORT,SELECT,N,A,LDA,SDIM,WR,WI,VS,LDVS,WORK,LWORK,
        !   BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(WR,WI)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: WR,WI
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE DGEES_MKL95
    PURE SUBROUTINE CGEES_MKL95(A,W,VS,SELECT,SDIM,INFO)
        ! MKL Fortran77 call:
        ! CGEES(JOBVS,SORT,SELECT,N,A,LDA,SDIM,W,VS,LDVS,WORK,LWORK,
        !   RWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(W)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: W
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE CGEES_MKL95
    PURE SUBROUTINE ZGEES_MKL95(A,W,VS,SELECT,SDIM,INFO)
        ! MKL Fortran77 call:
        ! ZGEES(JOBVS,SORT,SELECT,N,A,LDA,SDIM,W,VS,LDVS,WORK,LWORK,
        !   RWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(W)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: W
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE ZGEES_MKL95
END INTERFACE GEES
INTERFACE GEESX
    PURE SUBROUTINE SGEESX_MKL95(A,WR,WI,VS,SELECT,SDIM,RCONDE,RCONDV,  &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! SGEESX(JOBVS,SORT,SELECT,SENSE,N,A,LDA,SDIM,WR,WI,VS,LDVS,
        !   RCONDE,RCONDV,WORK,LWORK,IWORK,LIWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDE
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDV
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(WR,WI)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: WR,WI
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE SGEESX_MKL95
    PURE SUBROUTINE DGEESX_MKL95(A,WR,WI,VS,SELECT,SDIM,RCONDE,RCONDV,  &
     &                                                             INFO)
        ! MKL Fortran77 call:
        ! DGEESX(JOBVS,SORT,SELECT,SENSE,N,A,LDA,SDIM,WR,WI,VS,LDVS,
        !   RCONDE,RCONDV,WORK,LWORK,IWORK,LIWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDE
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDV
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(WR,WI)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: WR,WI
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE DGEESX_MKL95
    PURE SUBROUTINE CGEESX_MKL95(A,W,VS,SELECT,SDIM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! CGEESX(JOBVS,SORT,SELECT,SENSE,N,A,LDA,SDIM,W,VS,LDVS,RCONDE,
        !   RCONDV,WORK,LWORK,RWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDE
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDV
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(W)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: W
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE CGEESX_MKL95
    PURE SUBROUTINE ZGEESX_MKL95(A,W,VS,SELECT,SDIM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! ZGEESX(JOBVS,SORT,SELECT,SENSE,N,A,LDA,SDIM,W,VS,LDVS,RCONDE,
        !   RCONDV,WORK,LWORK,RWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDE
        REAL(WP), INTENT(OUT), OPTIONAL :: RCONDV
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VS(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(W)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: W
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE ZGEESX_MKL95
END INTERFACE GEESX
INTERFACE GEEV
    PURE SUBROUTINE SGEEV_MKL95(A,WR,WI,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! SGEEV(JOBVL,JOBVR,N,A,LDA,WR,WI,VL,LDVL,VR,LDVR,WORK,LWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE SGEEV_MKL95
    PURE SUBROUTINE DGEEV_MKL95(A,WR,WI,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! DGEEV(JOBVL,JOBVR,N,A,LDA,WR,WI,VL,LDVL,VR,LDVR,WORK,LWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE DGEEV_MKL95
    PURE SUBROUTINE CGEEV_MKL95(A,W,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! CGEEV(JOBVL,JOBVR,N,A,LDA,W,VL,LDVL,VR,LDVR,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE CGEEV_MKL95
    PURE SUBROUTINE ZGEEV_MKL95(A,W,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! ZGEEV(JOBVL,JOBVR,N,A,LDA,W,VL,LDVL,VR,LDVR,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE ZGEEV_MKL95
END INTERFACE GEEV
INTERFACE GEEVX
    PURE SUBROUTINE SGEEVX_MKL95(A,WR,WI,VL,VR,BALANC,ILO,IHI,SCALE,    &
     &                                         ABNRM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! SGEEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,WR,WI,VL,LDVL,VR,LDVR,
        !   ILO,IHI,SCALE,ABNRM,RCONDE,RCONDV,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE SGEEVX_MKL95
    PURE SUBROUTINE DGEEVX_MKL95(A,WR,WI,VL,VR,BALANC,ILO,IHI,SCALE,    &
     &                                         ABNRM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! DGEEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,WR,WI,VL,LDVL,VR,LDVR,
        !   ILO,IHI,SCALE,ABNRM,RCONDE,RCONDV,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: WR(:)
        REAL(WP), INTENT(OUT) :: WI(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE DGEEVX_MKL95
    PURE SUBROUTINE CGEEVX_MKL95(A,W,VL,VR,BALANC,ILO,IHI,SCALE,ABNRM,  &
     &                                               RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! CGEEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,W,VL,LDVL,VR,LDVR,ILO,
        !   IHI,SCALE,ABNRM,RCONDE,RCONDV,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE CGEEVX_MKL95
    PURE SUBROUTINE ZGEEVX_MKL95(A,W,VL,VR,BALANC,ILO,IHI,SCALE,ABNRM,  &
     &                                               RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! ZGEEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,W,VL,LDVL,VR,LDVR,ILO,
        !   IHI,SCALE,ABNRM,RCONDE,RCONDV,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: SCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE ZGEEVX_MKL95
END INTERFACE GEEVX
INTERFACE GESVD
    PURE SUBROUTINE SGESVD_MKL95(A,S,U,VT,WW,JOB,INFO)
        ! MKL Fortran77 call:
        ! SGESVD(JOBU,JOBVT,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL :: WW(:)
    END SUBROUTINE SGESVD_MKL95
    PURE SUBROUTINE DGESVD_MKL95(A,S,U,VT,WW,JOB,INFO)
        ! MKL Fortran77 call:
        ! DGESVD(JOBU,JOBVT,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL :: WW(:)
    END SUBROUTINE DGESVD_MKL95
    PURE SUBROUTINE CGESVD_MKL95(A,S,U,VT,WW,JOB,INFO)
        ! MKL Fortran77 call:
        ! CGESVD(JOBU,JOBVT,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL :: WW(:)
    END SUBROUTINE CGESVD_MKL95
    PURE SUBROUTINE ZGESVD_MKL95(A,S,U,VT,WW,JOB,INFO)
        ! MKL Fortran77 call:
        ! ZGESVD(JOBU,JOBVT,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,RWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOB
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL :: WW(:)
    END SUBROUTINE ZGESVD_MKL95
END INTERFACE GESVD
INTERFACE GESDD
    PURE SUBROUTINE SGESDD_MKL95(A,S,U,VT,JOBZ,INFO)
        ! MKL Fortran77 call:
        ! SGESDD(JOBZ,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
    END SUBROUTINE SGESDD_MKL95
    PURE SUBROUTINE DGESDD_MKL95(A,S,U,VT,JOBZ,INFO)
        ! MKL Fortran77 call:
        ! DGESDD(JOBZ,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
    END SUBROUTINE DGESDD_MKL95
    PURE SUBROUTINE CGESDD_MKL95(A,S,U,VT,JOBZ,INFO)
        ! MKL Fortran77 call:
        ! CGESDD(JOBZ,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,RWORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
    END SUBROUTINE CGESDD_MKL95
    PURE SUBROUTINE ZGESDD_MKL95(A,S,U,VT,JOBZ,INFO)
        ! MKL Fortran77 call:
        ! ZGESDD(JOBZ,M,N,A,LDA,S,U,LDU,VT,LDVT,WORK,LWORK,RWORK,IWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(OUT) :: S(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VT(:,:)
    END SUBROUTINE ZGESDD_MKL95
END INTERFACE GESDD
INTERFACE GGSVD
    PURE SUBROUTINE SGGSVD_MKL95(A,B,ALPHA,BETA,K,L,U,V,Q,IWORK,INFO)
        ! MKL Fortran77 call:
        ! SGGSVD(JOBU,JOBV,JOBQ,M,N,P,K,L,A,LDA,B,LDB,ALPHA,BETA,U,LDU,
        !   V,LDV,Q,LDQ,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHA(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IWORK(:)
    END SUBROUTINE SGGSVD_MKL95
    PURE SUBROUTINE DGGSVD_MKL95(A,B,ALPHA,BETA,K,L,U,V,Q,IWORK,INFO)
        ! MKL Fortran77 call:
        ! DGGSVD(JOBU,JOBV,JOBQ,M,N,P,K,L,A,LDA,B,LDB,ALPHA,BETA,U,LDU,
        !   V,LDV,Q,LDQ,WORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHA(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IWORK(:)
    END SUBROUTINE DGGSVD_MKL95
    PURE SUBROUTINE CGGSVD_MKL95(A,B,ALPHA,BETA,K,L,U,V,Q,IWORK,INFO)
        ! MKL Fortran77 call:
        ! CGGSVD(JOBU,JOBV,JOBQ,M,N,P,K,L,A,LDA,B,LDB,ALPHA,BETA,U,LDU,
        !   V,LDV,Q,LDQ,WORK,RWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHA(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IWORK(:)
    END SUBROUTINE CGGSVD_MKL95
    PURE SUBROUTINE ZGGSVD_MKL95(A,B,ALPHA,BETA,K,L,U,V,Q,IWORK,INFO)
        ! MKL Fortran77 call:
        ! ZGGSVD(JOBU,JOBV,JOBQ,M,N,P,K,L,A,LDA,B,LDB,ALPHA,BETA,U,LDU,
        !   V,LDV,Q,LDQ,WORK,RWORK,IWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: K
        INTEGER, INTENT(OUT), OPTIONAL :: L
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHA(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: U(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: V(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IWORK(:)
    END SUBROUTINE ZGGSVD_MKL95
END INTERFACE GGSVD
INTERFACE SYGV
    PURE SUBROUTINE SSYGV_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYGV(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE SSYGV_MKL95
    PURE SUBROUTINE DSYGV_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYGV(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE DSYGV_MKL95
END INTERFACE SYGV
INTERFACE HEGV
    PURE SUBROUTINE CHEGV_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHEGV(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE CHEGV_MKL95
    PURE SUBROUTINE ZHEGV_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHEGV(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE ZHEGV_MKL95
END INTERFACE HEGV
INTERFACE SYGVD
    PURE SUBROUTINE SSYGVD_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! SSYGVD(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE SSYGVD_MKL95
    PURE SUBROUTINE DSYGVD_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! DSYGVD(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE DSYGVD_MKL95
END INTERFACE SYGVD
INTERFACE HEGVD
    PURE SUBROUTINE CHEGVD_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! CHEGVD(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,RWORK,
        !   LRWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE CHEGVD_MKL95
    PURE SUBROUTINE ZHEGVD_MKL95(A,B,W,ITYPE,JOBZ,UPLO,INFO)
        ! MKL Fortran77 call:
        ! ZHEGVD(ITYPE,JOBZ,UPLO,N,A,LDA,B,LDB,W,WORK,LWORK,RWORK,
        !   LRWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: JOBZ
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
    END SUBROUTINE ZHEGVD_MKL95
END INTERFACE HEGVD
INTERFACE SYGVX
    PURE SUBROUTINE SSYGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! SSYGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,LDA,B,LDB,VL,VU,IL,IU,ABSTOL,
        !   M,W,Z,LDZ,WORK,LWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE SSYGVX_MKL95
    PURE SUBROUTINE DSYGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! DSYGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,LDA,B,LDB,VL,VU,IL,IU,ABSTOL,
        !   M,W,Z,LDZ,WORK,LWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE DSYGVX_MKL95
END INTERFACE SYGVX
INTERFACE HEGVX
    PURE SUBROUTINE CHEGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! CHEGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,LDA,B,LDB,VL,VU,IL,IU,ABSTOL,
        !   M,W,Z,LDZ,WORK,LWORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE CHEGVX_MKL95
    PURE SUBROUTINE ZHEGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! ZHEGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,LDA,B,LDB,VL,VU,IL,IU,ABSTOL,
        !   M,W,Z,LDZ,WORK,LWORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE ZHEGVX_MKL95
END INTERFACE HEGVX
INTERFACE SPGV
    PURE SUBROUTINE SSPGV_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSPGV(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSPGV_MKL95
    PURE SUBROUTINE DSPGV_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSPGV(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSPGV_MKL95
END INTERFACE SPGV
INTERFACE HPGV
    PURE SUBROUTINE CHPGV_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHPGV(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHPGV_MKL95
    PURE SUBROUTINE ZHPGV_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHPGV(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHPGV_MKL95
END INTERFACE HPGV
INTERFACE SPGVD
    PURE SUBROUTINE SSPGVD_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSPGVD(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,LWORK,IWORK,LIWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSPGVD_MKL95
    PURE SUBROUTINE DSPGVD_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSPGVD(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,LWORK,IWORK,LIWORK,
        !   INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSPGVD_MKL95
END INTERFACE SPGVD
INTERFACE HPGVD
    PURE SUBROUTINE CHPGVD_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHPGVD(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,LWORK,RWORK,LRWORK,
        !   IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHPGVD_MKL95
    PURE SUBROUTINE ZHPGVD_MKL95(A,B,W,ITYPE,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHPGVD(ITYPE,JOBZ,UPLO,N,A,B,W,Z,LDZ,WORK,LWORK,RWORK,LRWORK,
        !   IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHPGVD_MKL95
END INTERFACE HPGVD
INTERFACE SPGVX
    PURE SUBROUTINE SSPGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! SSPGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,B,VL,VU,IL,IU,ABSTOL,M,W,Z,
        !   LDZ,WORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE SSPGVX_MKL95
    PURE SUBROUTINE DSPGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! DSPGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,B,VL,VU,IL,IU,ABSTOL,M,W,Z,
        !   LDZ,WORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:)
        REAL(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE DSPGVX_MKL95
END INTERFACE SPGVX
INTERFACE HPGVX
    PURE SUBROUTINE CHPGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! CHPGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,B,VL,VU,IL,IU,ABSTOL,M,W,Z,
        !   LDZ,WORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE CHPGVX_MKL95
    PURE SUBROUTINE ZHPGVX_MKL95(A,B,W,ITYPE,UPLO,Z,VL,VU,IL,IU,M,IFAIL,&
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! ZHPGVX(ITYPE,JOBZ,RANGE,UPLO,N,A,B,VL,VU,IL,IU,ABSTOL,M,W,Z,
        !   LDZ,WORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(IN), OPTIONAL :: ITYPE
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:)
        COMPLEX(WP), INTENT(INOUT) :: B(:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
    END SUBROUTINE ZHPGVX_MKL95
END INTERFACE HPGVX
INTERFACE SBGV
    PURE SUBROUTINE SSBGV_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSBGV(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSBGV_MKL95
    PURE SUBROUTINE DSBGV_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSBGV(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSBGV_MKL95
END INTERFACE SBGV
INTERFACE HBGV
    PURE SUBROUTINE CHBGV_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHBGV(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHBGV_MKL95
    PURE SUBROUTINE ZHBGV_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHBGV(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHBGV_MKL95
END INTERFACE HBGV
INTERFACE SBGVD
    PURE SUBROUTINE SSBGVD_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! SSBGVD(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,LWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE SSBGVD_MKL95
    PURE SUBROUTINE DSBGVD_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! DSBGVD(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,LWORK,IWORK,
        !   LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE DSBGVD_MKL95
END INTERFACE SBGVD
INTERFACE HBGVD
    PURE SUBROUTINE CHBGVD_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! CHBGVD(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,LWORK,RWORK,
        !   LRWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE CHBGVD_MKL95
    PURE SUBROUTINE ZHBGVD_MKL95(A,B,W,UPLO,Z,INFO)
        ! MKL Fortran77 call:
        ! ZHBGVD(JOBZ,UPLO,N,KA,KB,A,LDA,B,LDB,W,Z,LDZ,WORK,LWORK,RWORK,
        !   LRWORK,IWORK,LIWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
    END SUBROUTINE ZHBGVD_MKL95
END INTERFACE HBGVD
INTERFACE SBGVX
    PURE SUBROUTINE SSBGVX_MKL95(A,B,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,    &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! SSBGVX(JOBZ,RANGE,UPLO,N,KA,KB,A,LDA,B,LDB,Q,LDQ,VL,VU,IL,IU,
        !   ABSTOL,M,W,Z,LDZ,WORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE SSBGVX_MKL95
    PURE SUBROUTINE DSBGVX_MKL95(A,B,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,    &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! DSBGVX(JOBZ,RANGE,UPLO,N,KA,KB,A,LDA,B,LDB,Q,LDQ,VL,VU,IL,IU,
        !   ABSTOL,M,W,Z,LDZ,WORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE DSBGVX_MKL95
END INTERFACE SBGVX
INTERFACE HBGVX
    PURE SUBROUTINE CHBGVX_MKL95(A,B,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,    &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! CHBGVX(JOBZ,RANGE,UPLO,N,KA,KB,A,LDA,B,LDB,Q,LDQ,VL,VU,IL,IU,
        !   ABSTOL,M,W,Z,LDZ,WORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE CHBGVX_MKL95
    PURE SUBROUTINE ZHBGVX_MKL95(A,B,W,UPLO,Z,VL,VU,IL,IU,M,IFAIL,Q,    &
     &                                                      ABSTOL,INFO)
        ! MKL Fortran77 call:
        ! ZHBGVX(JOBZ,RANGE,UPLO,N,KA,KB,A,LDA,B,LDB,Q,LDQ,VL,VU,IL,IU,
        !   ABSTOL,M,W,Z,LDZ,WORK,RWORK,IWORK,IFAIL,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: UPLO
        REAL(WP), INTENT(IN), OPTIONAL :: VL
        REAL(WP), INTENT(IN), OPTIONAL :: VU
        INTEGER, INTENT(IN), OPTIONAL :: IL
        INTEGER, INTENT(IN), OPTIONAL :: IU
        INTEGER, INTENT(OUT), OPTIONAL :: M
        REAL(WP), INTENT(IN), OPTIONAL :: ABSTOL
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: W(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Z(:,:)
        INTEGER, INTENT(OUT), OPTIONAL, TARGET :: IFAIL(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: Q(:,:)
    END SUBROUTINE ZHBGVX_MKL95
END INTERFACE HBGVX
INTERFACE GGES
    PURE SUBROUTINE SGGES_MKL95(A,B,ALPHAR,ALPHAI,BETA,VSL,VSR,SELECT,  &
     &                                                        SDIM,INFO)
        ! MKL Fortran77 call:
        ! SGGES(JOBVSL,JOBVSR,SORT,SELECT,N,A,LDA,B,LDB,SDIM,ALPHAR,
        !   ALPHAI,BETA,VSL,LDVSL,VSR,LDVSR,WORK,LWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHAR,ALPHAI,BETA)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: ALPHAR,ALPHAI,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE SGGES_MKL95
    PURE SUBROUTINE DGGES_MKL95(A,B,ALPHAR,ALPHAI,BETA,VSL,VSR,SELECT,  &
     &                                                        SDIM,INFO)
        ! MKL Fortran77 call:
        ! DGGES(JOBVSL,JOBVSR,SORT,SELECT,N,A,LDA,B,LDB,SDIM,ALPHAR,
        !   ALPHAI,BETA,VSL,LDVSL,VSR,LDVSR,WORK,LWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHAR,ALPHAI,BETA)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: ALPHAR,ALPHAI,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE DGGES_MKL95
    PURE SUBROUTINE CGGES_MKL95(A,B,ALPHA,BETA,VSL,VSR,SELECT,SDIM,INFO)
        ! MKL Fortran77 call:
        ! CGGES(JOBVSL,JOBVSR,SORT,SELECT,N,A,LDA,B,LDB,SDIM,ALPHA,BETA,
        !   VSL,LDVSL,VSR,LDVSR,WORK,LWORK,RWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHA,BETA)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: ALPHA,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE CGGES_MKL95
    PURE SUBROUTINE ZGGES_MKL95(A,B,ALPHA,BETA,VSL,VSR,SELECT,SDIM,INFO)
        ! MKL Fortran77 call:
        ! ZGGES(JOBVSL,JOBVSR,SORT,SELECT,N,A,LDA,B,LDB,SDIM,ALPHA,BETA,
        !   VSL,LDVSL,VSR,LDVSR,WORK,LWORK,RWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHA,BETA)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: ALPHA,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE ZGGES_MKL95
END INTERFACE GGES
INTERFACE GGESX
    PURE SUBROUTINE SGGESX_MKL95(A,B,ALPHAR,ALPHAI,BETA,VSL,VSR,SELECT, &
     &                                          SDIM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! SGGESX(JOBVSL,JOBVSR,SORT,SELECT,SENSE,N,A,LDA,B,LDB,SDIM,
        !   ALPHAR,ALPHAI,BETA,VSL,LDVSL,VSR,LDVSR,RCONDE,RCONDV,WORK,
        !   LWORK,IWORK,LIWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(2)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(2)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHAR,ALPHAI,BETA)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: ALPHAR,ALPHAI,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE SGGESX_MKL95
    PURE SUBROUTINE DGGESX_MKL95(A,B,ALPHAR,ALPHAI,BETA,VSL,VSR,SELECT, &
     &                                          SDIM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! DGGESX(JOBVSL,JOBVSR,SORT,SELECT,SENSE,N,A,LDA,B,LDB,SDIM,
        !   ALPHAR,ALPHAI,BETA,VSL,LDVSL,VSR,LDVSR,RCONDE,RCONDV,WORK,
        !   LWORK,IWORK,LIWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(2)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(2)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHAR,ALPHAI,BETA)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: ALPHAR,ALPHAI,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE DGGESX_MKL95
    PURE SUBROUTINE CGGESX_MKL95(A,B,ALPHA,BETA,VSL,VSR,SELECT,SDIM,    &
     &                                               RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! CGGESX(JOBVSL,JOBVSR,SORT,SELECT,SENSE,N,A,LDA,B,LDB,SDIM,
        !   ALPHA,BETA,VSL,LDVSL,VSR,LDVSR,RCONDE,RCONDV,WORK,LWORK,
        !   RWORK,IWORK,LIWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(2)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(2)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHA,BETA)
                USE MKL95_PRECISION, ONLY: WP => SP
                REAL(WP), INTENT(IN) :: ALPHA,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE CGGESX_MKL95
    PURE SUBROUTINE ZGGESX_MKL95(A,B,ALPHA,BETA,VSL,VSR,SELECT,SDIM,    &
     &                                               RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! ZGGESX(JOBVSL,JOBVSR,SORT,SELECT,SENSE,N,A,LDA,B,LDB,SDIM,
        !   ALPHA,BETA,VSL,LDVSL,VSR,LDVSR,RCONDE,RCONDV,WORK,LWORK,
        !   RWORK,IWORK,LIWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: SDIM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VSR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(2)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(2)
        INTERFACE
            PURE LOGICAL FUNCTION SELECT(ALPHA,BETA)
                USE MKL95_PRECISION, ONLY: WP => DP
                REAL(WP), INTENT(IN) :: ALPHA,BETA
            END FUNCTION SELECT
        END INTERFACE
        OPTIONAL :: SELECT
    END SUBROUTINE ZGGESX_MKL95
END INTERFACE GGESX
INTERFACE GGEV
    PURE SUBROUTINE SGGEV_MKL95(A,B,ALPHAR,ALPHAI,BETA,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! SGGEV(JOBVL,JOBVR,N,A,LDA,B,LDB,ALPHAR,ALPHAI,BETA,VL,LDVL,VR,
        !   LDVR,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE SGGEV_MKL95
    PURE SUBROUTINE DGGEV_MKL95(A,B,ALPHAR,ALPHAI,BETA,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! DGGEV(JOBVL,JOBVR,N,A,LDA,B,LDB,ALPHAR,ALPHAI,BETA,VL,LDVL,VR,
        !   LDVR,WORK,LWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE DGGEV_MKL95
    PURE SUBROUTINE CGGEV_MKL95(A,B,ALPHA,BETA,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! CGGEV(JOBVL,JOBVR,N,A,LDA,B,LDB,ALPHA,BETA,VL,LDVL,VR,LDVR,
        !   WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE CGGEV_MKL95
    PURE SUBROUTINE ZGGEV_MKL95(A,B,ALPHA,BETA,VL,VR,INFO)
        ! MKL Fortran77 call:
        ! ZGGEV(JOBVL,JOBVR,N,A,LDA,B,LDB,ALPHA,BETA,VL,LDVL,VR,LDVR,
        !   WORK,LWORK,RWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
    END SUBROUTINE ZGGEV_MKL95
END INTERFACE GGEV
INTERFACE GGEVX
    PURE SUBROUTINE SGGEVX_MKL95(A,B,ALPHAR,ALPHAI,BETA,VL,VR,BALANC,   &
     &             ILO,IHI,LSCALE,RSCALE,ABNRM,BBNRM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! SGGEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,B,LDB,ALPHAR,ALPHAI,
        !   BETA,VL,LDVL,VR,LDVR,ILO,IHI,LSCALE,RSCALE,ABNRM,BBNRM,
        !   RCONDE,RCONDV,WORK,LWORK,IWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        REAL(WP), INTENT(OUT), OPTIONAL :: BBNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE SGGEVX_MKL95
    PURE SUBROUTINE DGGEVX_MKL95(A,B,ALPHAR,ALPHAI,BETA,VL,VR,BALANC,   &
     &             ILO,IHI,LSCALE,RSCALE,ABNRM,BBNRM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! DGGEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,B,LDB,ALPHAR,ALPHAI,
        !   BETA,VL,LDVL,VR,LDVR,ILO,IHI,LSCALE,RSCALE,ABNRM,BBNRM,
        !   RCONDE,RCONDV,WORK,LWORK,IWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        REAL(WP), INTENT(OUT), OPTIONAL :: BBNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        REAL(WP), INTENT(INOUT) :: A(:,:)
        REAL(WP), INTENT(INOUT) :: B(:,:)
        REAL(WP), INTENT(OUT) :: ALPHAR(:)
        REAL(WP), INTENT(OUT) :: ALPHAI(:)
        REAL(WP), INTENT(OUT) :: BETA(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE DGGEVX_MKL95
    PURE SUBROUTINE CGGEVX_MKL95(A,B,ALPHA,BETA,VL,VR,BALANC,ILO,IHI,   &
     &                     LSCALE,RSCALE,ABNRM,BBNRM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! CGGEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,B,LDB,ALPHA,BETA,VL,
        !   LDVL,VR,LDVR,ILO,IHI,LSCALE,RSCALE,ABNRM,BBNRM,RCONDE,
        !   RCONDV,WORK,LWORK,RWORK,IWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => SP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        REAL(WP), INTENT(OUT), OPTIONAL :: BBNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE CGGEVX_MKL95
    PURE SUBROUTINE ZGGEVX_MKL95(A,B,ALPHA,BETA,VL,VR,BALANC,ILO,IHI,   &
     &                     LSCALE,RSCALE,ABNRM,BBNRM,RCONDE,RCONDV,INFO)
        ! MKL Fortran77 call:
        ! ZGGEVX(BALANC,JOBVL,JOBVR,SENSE,N,A,LDA,B,LDB,ALPHA,BETA,VL,
        !   LDVL,VR,LDVR,ILO,IHI,LSCALE,RSCALE,ABNRM,BBNRM,RCONDE,
        !   RCONDV,WORK,LWORK,RWORK,IWORK,BWORK,INFO)
        USE MKL95_PRECISION, ONLY: WP => DP
        CHARACTER(LEN=1), INTENT(IN), OPTIONAL :: BALANC
        INTEGER, INTENT(OUT), OPTIONAL :: ILO
        INTEGER, INTENT(OUT), OPTIONAL :: IHI
        REAL(WP), INTENT(OUT), OPTIONAL :: ABNRM
        REAL(WP), INTENT(OUT), OPTIONAL :: BBNRM
        INTEGER, INTENT(OUT), OPTIONAL :: INFO
        COMPLEX(WP), INTENT(INOUT) :: A(:,:)
        COMPLEX(WP), INTENT(INOUT) :: B(:,:)
        COMPLEX(WP), INTENT(OUT) :: ALPHA(:)
        COMPLEX(WP), INTENT(OUT) :: BETA(:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VL(:,:)
        COMPLEX(WP), INTENT(OUT), OPTIONAL, TARGET :: VR(:,:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: LSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RSCALE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDE(:)
        REAL(WP), INTENT(OUT), OPTIONAL, TARGET :: RCONDV(:)
    END SUBROUTINE ZGGEVX_MKL95
END INTERFACE GGEVX
END MODULE MKL95_LAPACK