#!/bin/bash
#==================================================================================================
#
#  Configuration script for the Blaze benchmark suite
#
#  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
#
#  This file is part of the Blaze library. You can redistribute it and/or modify it under
#  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
#  forms, with or without modification, are permitted provided that the following conditions
#  are met:
#
#  1. Redistributions of source code must retain the above copyright notice, this list of
#     conditions and the following disclaimer.
#  2. Redistributions in binary form must reproduce the above copyright notice, this list
#     of conditions and the following disclaimer in the documentation and/or other materials
#     provided with the distribution.
#  3. Neither the names of the Blaze development group nor the names of its contributors
#     may be used to endorse or promote products derived from this software without specific
#     prior written permission.
#
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
#  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
#  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
#  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
#  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
#  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
#  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
#  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
#  DAMAGE.
#
#==================================================================================================


#######################################
# Parsing the command line arguments

# Printing the help
if [ "$1" = "--help" ] || [ "$1" = "-help" ] || [ "$1" = "-h" ]; then
   echo
   echo "Usage: ./configure [<config_file>]"
   echo
   echo "Configuration of the compilation process of the Blaze benchmark suite. The according"
   echo "system-specific settings are specified via the given configuration file <config_file>."
   echo "In case no <config_file> is specified, the settings of the default 'Configfile' are"
   echo "used."
   echo
   echo "Options:"
   echo " -h, -help, --help  Displays this information"
   echo
   exit 0
fi

# Set the verbosity of the build
SILENT="@"
if [ "$1" = "--verbose" ] || [ "$1" = "-verbose" ] || [ "$1" = "-v" ]; then
   unset SILENT
   shift
fi

# Checking the number of command line arguments
if [ $# -ge 2 ]; then
   echo "Invalid use of the Blazemark configuration script. Type './configure -h' to display the help."
   exit 1
fi


#####################################
# Selecting the configuration file

CONFIGFILE="Configfile"

if [ $# = 1 ]; then
   if [ ! -f "$1" ]; then
      echo "Config file '$1' cannot be found."
      exit 1
   else
      CONFIGFILE="$1"
   fi
fi

source $CONFIGFILE


##########################
# Checking the settings

# Checking the compiler settings
if [ ! -n $CXX ]; then
   echo "Compiler unspecified. Please select a compiler for the compilation process!"
   exit 1
fi

# Checking the settings for the BLAS module
if [ "$BLAS" != "yes" ] && [ "$BLAS" != "no" ]; then
   echo "Invalid setting for the BLAS module."
   exit 1
fi

# Checking the settings for the Blitz++ library
if [ "$BLITZ" != "yes" ] && [ "$BLITZ" != "no" ]; then
   echo "Invalid setting for the Blitz++ library."
   exit 1
fi

# Checking the settings for the GMM++ library
if [ "$GMM" != "yes" ] && [ "$GMM" != "no" ]; then
   echo "Invalid setting for the GMM++ library."
   exit 1
fi
if [ "$GMM_ATLAS_INSTALLED" != "yes" ] && [ "$GMM_ATLAS_INSTALLED" != "no" ]; then
   echo "Invalid setting for the GMM_ATLAS_INSTALLED flag."
   exit 1
fi

# Checking the settings for the Armadillo library
if [ "$ARMADILLO" != "yes" ] && [ "$ARMADILLO" != "no" ]; then
   echo "Invalid setting for the Armadillo library."
   exit 1
fi

# Checking the settings for the FLENS library
if [ "$FLENS" != "yes" ] && [ "$FLENS" != "no" ]; then
   echo "Invalid setting for the FLENS library."
   exit 1
fi
if [ "$FLENS_ATLAS_INSTALLED" != "yes" ] && [ "$FLENS_ATLAS_INSTALLED" != "no" ]; then
   echo "Invalid setting for the FLENS_ATLAS_INSTALLED flag."
   exit 1
fi
if [ "$FLENS_GOTO_INSTALLED" != "yes" ] && [ "$FLENS_GOTO_INSTALLED" != "no" ]; then
   echo "Invalid setting for the FLENS_GOTO_INSTALLED flag."
   exit 1
fi
if [ "$FLENS_MKL_INSTALLED" != "yes" ] && [ "$FLENS_MKL_INSTALLED" != "no" ]; then
   echo "Invalid setting for the FLENS_MKL_INSTALLED flag."
   exit 1
fi
if [ "$FLENS_ATLAS_INSTALLED" = "yes" ] && [ "$FLENS_GOTO_INSTALLED" = "yes" ]; then
   echo "Invalid setting for the FLENS BLAS support. Only one BLAS library must be selected."
   exit 1
fi
if [ "$FLENS_ATLAS_INSTALLED" = "yes" ] && [ "$FLENS_MKL_INSTALLED" = "yes" ]; then
   echo "Invalid setting for the FLENS BLAS support. Only one BLAS library must be selected."
   exit 1
fi

# Checking the settings for the MTL library
if [ "$MTL" != "yes" ] && [ "$MTL" != "no" ]; then
   echo "Invalid setting for the MTL library."
   exit 1
fi

# Checking the settings for the Eigen library
if [ "$EIGEN" != "yes" ] && [ "$EIGEN" != "no" ]; then
   echo "Invalid setting for the EIGEN library."
   exit 1
fi

# Checking the settings for the Eigen library
if [ "$EIGEN_MKL_INSTALLED" != "yes" ] && [ "$EIGEN_MKL_INSTALLED" != "no" ]; then
   echo "Invalid setting for the EIGEN_MKL_INSTALLED flag."
   exit 1
fi


################################
# Blazemark specific settings

INSTALL_PATH="$( cd "$( dirname "$0" )" && pwd )"
BLAZE_PATH="${INSTALL_PATH%%/blazemark}"


############################
# Generating the Makefile

# Configuration of the compiler flags
if [ "$GMM" = "yes" ] && [ "$GMM_ATLAS_INSTALLED" = "yes" ]; then
   CXXFLAGS="$CXXFLAGS -DGMM_USES_LAPACK"
fi
if [ "$FLENS" = "yes" ] && [ "FLENS_ATLAS_INSTALLED" = "yes" ]; then
   CXXFLAGS="$CXXFLAGS -DWITH_ATLAS"
fi
if [ "$FLENS" = "yes" ] && [ "FLENS_GOTO_INSTALLED" = "yes" ]; then
   CXXFLAGS="$CXXFLAGS -DWITH_GOTOBLAS"
fi
if [ "$FLENS" = "yes" ] && [ "FLENS_MKL_INSTALLED" = "yes" ]; then
   CXXFLAGS="$CXXFLAGS -DWITH_MKL"
fi
if [ "$MTL" = "yes" ] && [ "$BLAS" = "yes" ]; then
   CXXFLAGS="$CXXFLAGS -DMTL_HAS_BLAS"
fi
if [ "$EIGEN" = "yes" ] && [ "$EIGEN_MKL_INSTALLED" = "yes" ]; then
   CXXFLAGS="$CXXFLAGS -DEIGEN_USE_BLAS"
fi

# Configuration of the include paths
INCLUDES="$INCLUDE_DIRECTIVES -isystem $INSTALL_PATH -isystem $BLAZE_PATH "

BLAS_INCLUDE_PATH=${BLAS_INCLUDE_PATH%"/"}
if [ "$BLAS" = "yes" ]; then
   if [ -n "$BLAS_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$BLAS_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $BLAS_INCLUDE_PATH "
   fi
fi

BOOST_INCLUDE_PATH=${BOOST_INCLUDE_PATH%"/"}
if [ "$BOOST" = "yes" ]; then
   if [ -n "$BOOST_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$BOOST_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $BOOST_INCLUDE_PATH "
   fi
fi

BLITZ_INCLUDE_PATH=${BLITZ_INCLUDE_PATH%"/"}
if [ "$BLITZ" = "yes" ]; then
   if [ -n "$BLITZ_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$BLITZ_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $BLITZ_INCLUDE_PATH "
   fi
fi

GMM_INCLUDE_PATH=${GMM_INCLUDE_PATH%"/"}
if [ "$GMM" = "yes" ]; then
   if [ -n "$GMM_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$GMM_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $GMM_INCLUDE_PATH "
   fi
fi

ARMADILLO_INCLUDE_PATH=${ARMADILLO_INCLUDE_PATH%"/"}
if [ "$ARMADILLO" = "yes" ]; then
   if [ -n "$ARMADILLO_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$ARMADILLO_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $ARMADILLO_INCLUDE_PATH "
   fi
fi

FLENS_INCLUDE_PATH=${FLENS_INCLUDE_PATH%"/"}
if [ "$FLENS" = "yes" ]; then
   if [ -n "$FLENS_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$FLENS_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $FLENS_INCLUDE_PATH "
   fi
fi

MTL_INCLUDE_PATH=${MTL_INCLUDE_PATH%"/"}
if [ "$MTL" = "yes" ]; then
   if [ -n "$MTL_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$MTL_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $MTL_INCLUDE_PATH "
   fi
fi

EIGEN_INCLUDE_PATH=${EIGEN_INCLUDE_PATH%"/"}
if [ "$EIGEN" = "yes" ]; then
   if [ -n "$EIGEN_INCLUDE_PATH" ] && [[ ! "$INCLUDES" =~ "$EIGEN_INCLUDE_PATH " ]]; then
      INCLUDES="${INCLUDES%" "} -isystem $EIGEN_INCLUDE_PATH "
   fi
fi

INCLUDES=${INCLUDES%" "}

# Configuration of the library path and link libraries
LIBRARIES="$LIBRARY_DIRECTIVES"

if [ "$BLAS" = "yes" ]; then
   if [ -n "$BLAS_LIBRARY_PATH" ] && [[ ! "$LIBRARIES" =~ "$BLAS_LIBRARY_PATH " ]]; then
      LIBRARIES="${LIBRARIES%" "} -L$BLAS_LIBRARY_PATH "
   fi
   if [ -n "$BLAS_LIBRARIES" ]; then
      LIBRARIES="${LIBRARIES%" "} $BLAS_LIBRARIES"
   fi
fi

if [ -n "$LAPACK_LIBRARY_PATH" ] && [[ ! "$LIBRARIES" =~ "$LAPACK_LIBRARY_PATH " ]]; then
   LIBRARIES="${LIBRARIES%" "} -L$LAPACK_LIBRARY_PATH "
fi
if [ -n "$LAPACK_LIBRARIES" ]; then
   LIBRARIES="${LIBRARIES%" "} $LAPACK_LIBRARIES"
fi

if [ "$BOOST" = "yes" ]; then
   BOOST_LIBRARY_PATH=${BOOST_LIBRARY_PATH%"/"}
   if [ -n "$BOOST_LIBRARY_PATH" ] && [[ ! "$LIBRARIES" =~ "$BOOST_LIBRARY_PATH " ]]; then
      LIBRARIES="${LIBRARIES%" "} -L$BOOST_LIBRARY_PATH "
   fi

   BOOST_SYSTEM_LIBRARY=${BOOST_SYSTEM_LIBRARY#"lib"}
   if [ -n "$BOOST_SYSTEM_LIBRARY" ]; then
      LIBRARIES="${LIBRARIES%" "} -l$BOOST_SYSTEM_LIBRARY"
   else
      LIBRARIES="${LIBRARIES%" "} -lboost_system"
   fi

   BOOST_THREAD_LIBRARY=${BOOST_THREAD_LIBRARY#"lib"}
   if [ -n "$BOOST_THREAD_LIBRARY" ]; then
      LIBRARIES="${LIBRARIES%" "} -l$BOOST_THREAD_LIBRARY"
   else
      LIBRARIES="${LIBRARIES%" "} -lboost_thread"
   fi
fi

if [ "$BLITZ" = "yes" ]; then
   if [ -n "$BLITZ_LIBRARY_PATH" ] && [[ ! "$LIBRARIES" =~ "$BLITZ_LIBRARY_PATH " ]]; then
      LIBRARIES="${LIBRARIES%" "} -L$BLITZ_LIBRARY_PATH "
   fi
   LIBRARIES="${LIBRARIES%" "} -lblitz"
fi

if [ -n "$ARMADILLO_LIBRARY_PATH" ]; then
   if [[ ! "$LIBRARIES" =~ "$ARMADILLO_LIBRARY_PATH " ]]; then
      LIBRARIES="${LIBRARIES%" "} -L$ARMADILLO_LIBRARY_PATH "
   fi
   LIBRARIES="${LIBRARIES%" "} -larmadillo "
fi

LIBRARIES=${LIBRARIES%" "}

# Configuration of the modules
MODULES="clike classic"
if [ "$BLAS" = "yes" ]; then
   MODULES="$MODULES blas"
fi
MODULES="$MODULES blaze"
if [ "$BOOST" = "yes" ]; then
   MODULES="$MODULES boost"
fi
if [ "$BLITZ" = "yes" ]; then
   MODULES="$MODULES blitz"
fi
if [ "$GMM" = "yes" ]; then
   MODULES="$MODULES gmm"
fi
if [ "$ARMADILLO" = "yes" ]; then
   MODULES="$MODULES armadillo"
fi
if [ "$FLENS" = "yes" ]; then
   MODULES="$MODULES flens"
fi
if [ "$MTL" = "yes" ]; then
   MODULES="$MODULES mtl"
fi
if [ "$EIGEN" = "yes" ]; then
   MODULES="$MODULES eigen"
fi
MODULES="$MODULES main"

# Configuration of the dense vector/dense vector addition benchmark
DVECDVECADD="\$(OBJECT_PATH)/CLIKE_DVecDVecAdd.o \$(OBJECT_PATH)/CLASSIC_DVecDVecAdd.o \$(OBJECT_PATH)/BLAZE_DVecDVecAdd.o"
if [ "$BOOST" = "yes" ]; then
   DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/BOOST_DVecDVecAdd.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/BLITZ_DVecDVecAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/GMM_DVecDVecAdd.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/ARMADILLO_DVecDVecAdd.o"
fi
if [ "$FLENS" = "yes" ]; then
   DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/FLENS_DVecDVecAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/MTL_DVecDVecAdd.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/EIGEN_DVecDVecAdd.o"
fi
DVECDVECADD="$DVECDVECADD \$(OBJECT_PATH)/MAIN_DVecDVecAdd.o"

# Configuration of the dense vector/sparse vector addition benchmark
DVECSVECADD="\$(OBJECT_PATH)/BLAZE_DVecSVecAdd.o"
if [ "$BOOST" = "yes" ]; then
   DVECSVECADD="$DVECSVECADD \$(OBJECT_PATH)/BOOST_DVecSVecAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   DVECSVECADD="$DVECSVECADD \$(OBJECT_PATH)/GMM_DVecSVecAdd.o"
fi
DVECSVECADD="$DVECSVECADD \$(OBJECT_PATH)/MAIN_DVecSVecAdd.o"

# Configuration of the sparse vector/dense vector addition benchmark
SVECDVECADD="\$(OBJECT_PATH)/BLAZE_SVecDVecAdd.o"
if [ "$BOOST" = "yes" ]; then
   SVECDVECADD="$SVECDVECADD \$(OBJECT_PATH)/BOOST_SVecDVecAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   SVECDVECADD="$SVECDVECADD \$(OBJECT_PATH)/GMM_SVecDVecAdd.o"
fi
SVECDVECADD="$SVECDVECADD \$(OBJECT_PATH)/MAIN_SVecDVecAdd.o"

# Configuration of the sparse vector/sparse vector addition benchmark
SVECSVECADD="\$(OBJECT_PATH)/BLAZE_SVecSVecAdd.o"
if [ "$BOOST" = "yes" ]; then
   SVECSVECADD="$SVECSVECADD \$(OBJECT_PATH)/BOOST_SVecSVecAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   SVECSVECADD="$SVECSVECADD \$(OBJECT_PATH)/GMM_SVecSVecAdd.o"
fi
SVECSVECADD="$SVECSVECADD \$(OBJECT_PATH)/MAIN_SVecSVecAdd.o"

# Configuration of the dense vector/dense vector subtraction benchmark
DVECDVECSUB="\$(OBJECT_PATH)/CLIKE_DVecDVecSub.o \$(OBJECT_PATH)/CLASSIC_DVecDVecSub.o \$(OBJECT_PATH)/BLAZE_DVecDVecSub.o"
if [ "$BOOST" = "yes" ]; then
   DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/BOOST_DVecDVecSub.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/BLITZ_DVecDVecSub.o"
fi
if [ "$GMM" = "yes" ]; then
   DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/GMM_DVecDVecSub.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/ARMADILLO_DVecDVecSub.o"
fi
if [ "$FLENS" = "yes" ]; then
   DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/FLENS_DVecDVecSub.o"
fi
if [ "$MTL" = "yes" ]; then
   DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/MTL_DVecDVecSub.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/EIGEN_DVecDVecSub.o"
fi
DVECDVECSUB="$DVECDVECSUB \$(OBJECT_PATH)/MAIN_DVecDVecSub.o"

# Configuration of the dense vector/scalar multiplication benchmark
DVECSCALARMULT="\$(OBJECT_PATH)/CLASSIC_DVecScalarMult.o \$(OBJECT_PATH)/BLAZE_DVecScalarMult.o"
if [ "$BOOST" = "yes" ]; then
   DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/BOOST_DVecScalarMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/BLITZ_DVecScalarMult.o"
fi
if [ "$GMM" = "yes" ]; then
   DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/GMM_DVecScalarMult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/ARMADILLO_DVecScalarMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/FLENS_DVecScalarMult.o"
fi
if [ "$MTL" = "yes" ]; then
   DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/MTL_DVecScalarMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/EIGEN_DVecScalarMult.o"
fi
DVECSCALARMULT="$DVECSCALARMULT \$(OBJECT_PATH)/MAIN_DVecScalarMult.o"

# Configuration of the sparse vector/scalar multiplication benchmark
SVECSCALARMULT="\$(OBJECT_PATH)/BLAZE_SVecScalarMult.o"
if [ "$BOOST" = "yes" ]; then
   SVECSCALARMULT="$SVECSCALARMULT \$(OBJECT_PATH)/BOOST_SVecScalarMult.o"
fi
if [ "$GMM" = "yes" ]; then
   SVECSCALARMULT="$SVECSCALARMULT \$(OBJECT_PATH)/GMM_SVecScalarMult.o"
fi
SVECSCALARMULT="$SVECSCALARMULT \$(OBJECT_PATH)/MAIN_SVecScalarMult.o"

# Configuration of the dense vector/dense vector multiplication benchmark
DVECDVECMULT="\$(OBJECT_PATH)/CLIKE_DVecDVecMult.o \$(OBJECT_PATH)/CLASSIC_DVecDVecMult.o \$(OBJECT_PATH)/BLAZE_DVecDVecMult.o"
if [ "$BOOST" = "yes" ]; then
   DVECDVECMULT="$DVECDVECMULT \$(OBJECT_PATH)/BOOST_DVecDVecMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DVECDVECMULT="$DVECDVECMULT \$(OBJECT_PATH)/BLITZ_DVecDVecMult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DVECDVECMULT="$DVECDVECMULT \$(OBJECT_PATH)/ARMADILLO_DVecDVecMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECDVECMULT="$DVECDVECMULT \$(OBJECT_PATH)/EIGEN_DVecDVecMult.o"
fi
DVECDVECMULT="$DVECDVECMULT \$(OBJECT_PATH)/MAIN_DVecDVecMult.o"

# Configuration of the dense vector/sparse vector multiplication benchmark
DVECSVECMULT="\$(OBJECT_PATH)/BLAZE_DVecSVecMult.o"
if [ "$BOOST" = "yes" ]; then
   DVECDVECMULT="$DVECSVECMULT \$(OBJECT_PATH)/BOOST_DVecSVecMult.o"
fi
DVECSVECMULT="$DVECSVECMULT \$(OBJECT_PATH)/MAIN_DVecSVecMult.o"

# Configuration of the sparse vector/dense vector multiplication benchmark
SVECDVECMULT="\$(OBJECT_PATH)/BLAZE_SVecDVecMult.o"
if [ "$BOOST" = "yes" ]; then
   SVECDVECMULT="$SVECDVECMULT \$(OBJECT_PATH)/BOOST_SVecDVecMult.o"
fi
SVECDVECMULT="$SVECDVECMULT \$(OBJECT_PATH)/MAIN_SVecDVecMult.o"

# Configuration of the sparse vector/sparse vector multiplication benchmark
SVECSVECMULT="\$(OBJECT_PATH)/BLAZE_SVecSVecMult.o"
if [ "$BOOST" = "yes" ]; then
   SVECSVECMULT="$SVECSVECMULT \$(OBJECT_PATH)/BOOST_SVecSVecMult.o"
fi
SVECSVECMULT="$SVECSVECMULT \$(OBJECT_PATH)/MAIN_SVecSVecMult.o"

# Configuration of the daxpy product benchmark
DAXPY="\$(OBJECT_PATH)/CLIKE_Daxpy.o \$(OBJECT_PATH)/CLASSIC_Daxpy.o"
if [ "$BLAS" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/BLAS_Daxpy.o"
fi
DAXPY="$DAXPY \$(OBJECT_PATH)/BLAZE_Daxpy.o"
if [ "$BOOST" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/BOOST_Daxpy.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/BLITZ_Daxpy.o"
fi
if [ "$GMM" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/GMM_Daxpy.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/ARMADILLO_Daxpy.o"
fi
if [ "$FLENS" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/FLENS_Daxpy.o"
fi
if [ "$MTL" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/MTL_Daxpy.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DAXPY="$DAXPY \$(OBJECT_PATH)/EIGEN_Daxpy.o"
fi
DAXPY="$DAXPY \$(OBJECT_PATH)/MAIN_Daxpy.o"

# Configuration of the dense vector/dense vector cross product benchmark
DVECDVECCROSS="\$(OBJECT_PATH)/CLIKE_DVecDVecCross.o \$(OBJECT_PATH)/BLAZE_DVecDVecCross.o"
if [ "$ARMADILLO" = "yes" ]; then
   DVECDVECCROSS="$DVECDVECCROSS \$(OBJECT_PATH)/ARMADILLO_DVecDVecCross.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECDVECCROSS="$DVECDVECCROSS \$(OBJECT_PATH)/EIGEN_DVecDVecCross.o"
fi
DVECDVECCROSS="$DVECDVECCROSS \$(OBJECT_PATH)/MAIN_DVecDVecCross.o"

# Configuration of the dense vector/sparse vector cross product benchmark
DVECSVECCROSS="\$(OBJECT_PATH)/BLAZE_DVecSVecCross.o \$(OBJECT_PATH)/MAIN_DVecSVecCross.o"

# Configuration of the sparse vector/dense vector cross product benchmark
SVECDVECCROSS="\$(OBJECT_PATH)/BLAZE_SVecDVecCross.o \$(OBJECT_PATH)/MAIN_SVecDVecCross.o"

# Configuration of the sparse vector/sparse vector cross product benchmark
SVECSVECCROSS="\$(OBJECT_PATH)/BLAZE_SVecSVecCross.o \$(OBJECT_PATH)/MAIN_SVecSVecCross.o"

# Configuration of the vector norm benchmark
DVECNORM="\$(OBJECT_PATH)/CLASSIC_DVecNorm.o \$(OBJECT_PATH)/BLAZE_DVecNorm.o"
if [ "$BOOST" = "yes" ]; then
   DVECNORM="$DVECNORM \$(OBJECT_PATH)/BOOST_DVecNorm.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DVECNORM="$DVECNORM \$(OBJECT_PATH)/BLITZ_DVecNorm.o"
fi
if [ "$GMM" = "yes" ]; then
   DVECNORM="$DVECNORM \$(OBJECT_PATH)/GMM_DVecNorm.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DVECNORM="$DVECNORM \$(OBJECT_PATH)/ARMADILLO_DVecNorm.o"
fi
if [ "$FLENS" = "yes" ]; then
   DVECNORM="$DVECNORM \$(OBJECT_PATH)/FLENS_DVecNorm.o"
fi
if [ "$MTL" = "yes" ]; then
   DVECNORM="$DVECNORM \$(OBJECT_PATH)/MTL_DVecNorm.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECNORM="$DVECNORM \$(OBJECT_PATH)/EIGEN_DVecNorm.o"
fi
DVECNORM="$DVECNORM \$(OBJECT_PATH)/MAIN_DVecNorm.o"

# Configuration of the dense vector/dense vector inner product benchmark
DVECDVECINNER="\$(OBJECT_PATH)/CLASSIC_DVecDVecInner.o \$(OBJECT_PATH)/BLAZE_DVecDVecInner.o"
if [ "$BOOST" = "yes" ]; then
   DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/BOOST_DVecDVecInner.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/BLITZ_DVecDVecInner.o"
fi
if [ "$GMM" = "yes" ]; then
   DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/GMM_DVecDVecInner.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/ARMADILLO_DVecDVecInner.o"
fi
if [ "$FLENS" = "yes" ]; then
   DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/FLENS_DVecDVecInner.o"
fi
if [ "$MTL" = "yes" ]; then
   DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/MTL_DVecDVecInner.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/EIGEN_DVecDVecInner.o"
fi
DVECDVECINNER="$DVECDVECINNER \$(OBJECT_PATH)/MAIN_DVecDVecInner.o"

# Configuration of the dense vector/sparse vector inner product benchmark
DVECSVECINNER="\$(OBJECT_PATH)/BLAZE_DVecSVecInner.o"
if [ "$BOOST" = "yes" ]; then
   DVECSVECINNER="$DVECSVECINNER \$(OBJECT_PATH)/BOOST_DVecSVecInner.o"
fi
if [ "$GMM" = "yes" ]; then
   DVECSVECINNER="$DVECSVECINNER \$(OBJECT_PATH)/GMM_DVecSVecInner.o"
fi
DVECSVECINNER="$DVECSVECINNER \$(OBJECT_PATH)/MAIN_DVecSVecInner.o"

# Configuration of the sparse vector/dense vector inner product benchmark
SVECDVECINNER="\$(OBJECT_PATH)/BLAZE_SVecDVecInner.o"
if [ "$BOOST" = "yes" ]; then
   SVECDVECINNER="$SVECDVECINNER \$(OBJECT_PATH)/BOOST_SVecDVecInner.o"
fi
if [ "$GMM" = "yes" ]; then
   SVECDVECINNER="$SVECDVECINNER \$(OBJECT_PATH)/GMM_SVecDVecInner.o"
fi
SVECDVECINNER="$SVECDVECINNER \$(OBJECT_PATH)/MAIN_SVecDVecInner.o"

# Configuration of the sparse vector/sparse vector inner product benchmark
SVECSVECINNER="\$(OBJECT_PATH)/BLAZE_SVecSVecInner.o"
if [ "$BOOST" = "yes" ]; then
   SVECSVECINNER="$SVECSVECINNER \$(OBJECT_PATH)/BOOST_SVecSVecInner.o"
fi
if [ "$GMM" = "yes" ]; then
   SVECSVECINNER="$SVECSVECINNER \$(OBJECT_PATH)/GMM_SVecSVecInner.o"
fi
SVECSVECINNER="$SVECSVECINNER \$(OBJECT_PATH)/MAIN_SVecSVecInner.o"

# Configuration of the dense vector/dense vector outer product benchmark
DVECDVECOUTER="\$(OBJECT_PATH)/CLASSIC_DVecDVecOuter.o \$(OBJECT_PATH)/BLAZE_DVecDVecOuter.o"
if [ "$BOOST" = "yes" ]; then
   DVECDVECOUTER="$DVECDVECOUTER \$(OBJECT_PATH)/BOOST_DVecDVecOuter.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DVECDVECOUTER="$DVECDVECOUTER \$(OBJECT_PATH)/BLITZ_DVecDVecOuter.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DVECDVECOUTER="$DVECDVECOUTER \$(OBJECT_PATH)/EIGEN_DVecDVecOuter.o"
fi
DVECDVECOUTER="$DVECDVECOUTER \$(OBJECT_PATH)/MAIN_DVecDVecOuter.o"

# Configuration of the dense vector/sparse vector outer product benchmark
DVECSVECOUTER="\$(OBJECT_PATH)/BLAZE_DVecSVecOuter.o"
if [ "$BOOST" = "yes" ]; then
   DVECSVECOUTER="$DVECSVECOUTER \$(OBJECT_PATH)/BOOST_DVecSVecOuter.o"
fi
DVECSVECOUTER="$DVECSVECOUTER \$(OBJECT_PATH)/MAIN_DVecSVecOuter.o"

# Configuration of the sparse vector/dense vector outer product benchmark
SVECDVECOUTER="\$(OBJECT_PATH)/BLAZE_SVecDVecOuter.o"
if [ "$BOOST" = "yes" ]; then
   SVECDVECOUTER="$SVECDVECOUTER \$(OBJECT_PATH)/BOOST_SVecDVecOuter.o"
fi
SVECDVECOUTER="$SVECDVECOUTER \$(OBJECT_PATH)/MAIN_SVecDVecOuter.o"

# Configuration of the sparse vector/sparse vector outer product benchmark
SVECSVECOUTER="\$(OBJECT_PATH)/BLAZE_SVecSVecOuter.o"
if [ "$BOOST" = "yes" ]; then
   SVECSVECOUTER="$SVECSVECOUTER \$(OBJECT_PATH)/BOOST_SVecSVecOuter.o"
fi
SVECSVECOUTER="$SVECSVECOUTER \$(OBJECT_PATH)/MAIN_SVecSVecOuter.o"

# Configuration of the dense matrix/dense vector multiplication benchmark
DMATDVECMULT="\$(OBJECT_PATH)/CLASSIC_DMatDVecMult.o"
if [ "$BLAS" = "yes" ]; then
   DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/BLAS_DMatDVecMult.o"
fi
DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/BLAZE_DMatDVecMult.o"
if [ "$BOOST" = "yes" ]; then
   DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/BOOST_DMatDVecMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/BLITZ_DMatDVecMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/FLENS_DMatDVecMult.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/MTL_DMatDVecMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/EIGEN_DMatDVecMult.o"
fi
DMATDVECMULT="$DMATDVECMULT \$(OBJECT_PATH)/MAIN_DMatDVecMult.o"

# Configuration of the transpose dense matrix/dense vector multiplication benchmark
TDMATDVECMULT="\$(OBJECT_PATH)/CLASSIC_TDMatDVecMult.o"
if [ "$BLAS" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/BLAS_TDMatDVecMult.o"
fi
TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/BLAZE_TDMatDVecMult.o"
if [ "$BOOST" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/BOOST_TDMatDVecMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/BLITZ_TDMatDVecMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/GMM_TDMatDVecMult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/ARMADILLO_TDMatDVecMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/FLENS_TDMatDVecMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/MTL_TDMatDVecMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/EIGEN_TDMatDVecMult.o"
fi
TDMATDVECMULT="$TDMATDVECMULT \$(OBJECT_PATH)/MAIN_TDMatDVecMult.o"

# Configuration of the dense matrix/sparse vector multiplication benchmark
DMATSVECMULT="\$(OBJECT_PATH)/BLAZE_DMatSVecMult.o"
if [ "$BOOST" = "yes" ]; then
   DMATSVECMULT="$DMATSVECMULT \$(OBJECT_PATH)/BOOST_DMatSVecMult.o"
fi
DMATSVECMULT="$DMATSVECMULT \$(OBJECT_PATH)/MAIN_DMatSVecMult.o"

# Configuration of the transpose dense matrix/sparse vector multiplication benchmark
TDMATSVECMULT="\$(OBJECT_PATH)/BLAZE_TDMatSVecMult.o"
if [ "$BOOST" = "yes" ]; then
   TDMATSVECMULT="$TDMATSVECMULT \$(OBJECT_PATH)/BOOST_TDMatSVecMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATSVECMULT="$TDMATSVECMULT \$(OBJECT_PATH)/GMM_TDMatSVecMult.o"
fi
TDMATSVECMULT="$TDMATSVECMULT \$(OBJECT_PATH)/MAIN_TDMatSVecMult.o"

# Configuration of the sparse matrix/dense vector multiplication benchmark
SMATDVECMULT="\$(OBJECT_PATH)/CLIKE_SMatDVecMult.o \$(OBJECT_PATH)/BLAZE_SMatDVecMult.o"
if [ "$BOOST" = "yes" ]; then
   SMATDVECMULT="$SMATDVECMULT \$(OBJECT_PATH)/BOOST_SMatDVecMult.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATDVECMULT="$SMATDVECMULT \$(OBJECT_PATH)/GMM_SMatDVecMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   SMATDVECMULT="$SMATDVECMULT \$(OBJECT_PATH)/FLENS_SMatDVecMult.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATDVECMULT="$SMATDVECMULT \$(OBJECT_PATH)/MTL_SMatDVecMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATDVECMULT="$SMATDVECMULT \$(OBJECT_PATH)/EIGEN_SMatDVecMult.o"
fi
SMATDVECMULT="$SMATDVECMULT \$(OBJECT_PATH)/MAIN_SMatDVecMult.o"

# Configuration of the transpose sparse matrix/dense vector multiplication benchmark
TSMATDVECMULT="\$(OBJECT_PATH)/BLAZE_TSMatDVecMult.o"
if [ "$BOOST" = "yes" ]; then
   TSMATDVECMULT="$TSMATDVECMULT \$(OBJECT_PATH)/BOOST_TSMatDVecMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATDVECMULT="$TSMATDVECMULT \$(OBJECT_PATH)/GMM_TSMatDVecMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TSMATDVECMULT="$TSMATDVECMULT \$(OBJECT_PATH)/FLENS_TSMatDVecMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATDVECMULT="$TSMATDVECMULT \$(OBJECT_PATH)/MTL_TSMatDVecMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TSMATDVECMULT="$TSMATDVECMULT \$(OBJECT_PATH)/EIGEN_TSMatDVecMult.o"
fi
TSMATDVECMULT="$TSMATDVECMULT \$(OBJECT_PATH)/MAIN_TSMatDVecMult.o"

# Configuration of the sparse matrix/sparse vector multiplication benchmark
SMATSVECMULT="\$(OBJECT_PATH)/BLAZE_SMatSVecMult.o"
if [ "$BOOST" = "yes" ]; then
   SMATSVECMULT="$SMATSVECMULT \$(OBJECT_PATH)/BOOST_SMatSVecMult.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATSVECMULT="$SMATSVECMULT \$(OBJECT_PATH)/GMM_SMatSVecMult.o"
fi
SMATSVECMULT="$SMATSVECMULT \$(OBJECT_PATH)/MAIN_SMatSVecMult.o"

# Configuration of the transpose sparse matrix/sparse vector multiplication benchmark
TSMATSVECMULT="\$(OBJECT_PATH)/BLAZE_TSMatSVecMult.o"
if [ "$BOOST" = "yes" ]; then
   TSMATSVECMULT="$TSMATSVECMULT \$(OBJECT_PATH)/BOOST_TSMatSVecMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATSVECMULT="$TSMATSVECMULT \$(OBJECT_PATH)/GMM_TSMatSVecMult.o"
fi
TSMATSVECMULT="$TSMATSVECMULT \$(OBJECT_PATH)/MAIN_TSMatSVecMult.o"

# Configuration of the transpose dense vector/dense matrix multiplication benchmark
TDVECDMATMULT="\$(OBJECT_PATH)/CLASSIC_TDVecDMatMult.o"
if [ "$BLAS" = "yes" ]; then
   TDVECDMATMULT="$TDVECDMATMULT \$(OBJECT_PATH)/BLAS_TDVecDMatMult.o"
fi
TDVECDMATMULT="$TDVECDMATMULT \$(OBJECT_PATH)/BLAZE_TDVecDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDVECDMATMULT="$TDVECDMATMULT \$(OBJECT_PATH)/BOOST_TDVecDMatMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TDVECDMATMULT="$TDVECDMATMULT \$(OBJECT_PATH)/BLITZ_TDVecDMatMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TDVECDMATMULT="$TDVECDMATMULT \$(OBJECT_PATH)/FLENS_TDVecDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDVECDMATMULT="$TDVECDMATMULT \$(OBJECT_PATH)/EIGEN_TDVecDMatMult.o"
fi
TDVECDMATMULT="$TDVECDMATMULT \$(OBJECT_PATH)/MAIN_TDVecDMatMult.o"

# Configuration of the transpose dense vector/transpose dense matrix multiplication benchmark
TDVECTDMATMULT=""
if [ "$BLAS" = "yes" ]; then
   TDVECTDMATMULT="$TDVECTDMATMULT \$(OBJECT_PATH)/BLAS_TDVecTDMatMult.o"
fi
TDVECTDMATMULT="$TDVECTDMATMULT \$(OBJECT_PATH)/BLAZE_TDVecTDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDVECTDMATMULT="$TDVECTDMATMULT \$(OBJECT_PATH)/BOOST_TDVecTDMatMult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TDVECTDMATMULT="$TDVECTDMATMULT \$(OBJECT_PATH)/ARMADILLO_TDVecTDMatMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TDVECTDMATMULT="$TDVECTDMATMULT \$(OBJECT_PATH)/FLENS_TDVecTDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDVECTDMATMULT="$TDVECTDMATMULT \$(OBJECT_PATH)/EIGEN_TDVecTDMatMult.o"
fi
TDVECTDMATMULT="$TDVECTDMATMULT \$(OBJECT_PATH)/MAIN_TDVecTDMatMult.o"

# Configuration of the transpose sparse vector/dense matrix multiplication benchmark
TSVECDMATMULT="\$(OBJECT_PATH)/BLAZE_TSVecDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSVECDMATMULT="$TSVECDMATMULT \$(OBJECT_PATH)/BOOST_TSVecDMatMult.o"
fi
TSVECDMATMULT="$TSVECDMATMULT \$(OBJECT_PATH)/MAIN_TSVecDMatMult.o"

# Configuration of the transpose sparse vector/transpose dense matrix multiplication benchmark
TSVECTDMATMULT="\$(OBJECT_PATH)/BLAZE_TSVecTDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSVECTDMATMULT="$TSVECTDMATMULT \$(OBJECT_PATH)/BOOST_TSVecTDMatMult.o"
fi
TSVECTDMATMULT="$TSVECTDMATMULT \$(OBJECT_PATH)/MAIN_TSVecTDMatMult.o"

# Configuration of the transpose dense vector/sparse matrix multiplication benchmark
TDVECSMATMULT="\$(OBJECT_PATH)/BLAZE_TDVecSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDVECSMATMULT="$TDVECSMATMULT \$(OBJECT_PATH)/BOOST_TDVecSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDVECSMATMULT="$TDVECSMATMULT \$(OBJECT_PATH)/EIGEN_TDVecSMatMult.o"
fi
TDVECSMATMULT="$TDVECSMATMULT \$(OBJECT_PATH)/MAIN_TDVecSMatMult.o"

# Configuration of the transpose dense vector/transpose sparse matrix multiplication benchmark
TDVECTSMATMULT="\$(OBJECT_PATH)/BLAZE_TDVecTSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDVECTSMATMULT="$TDVECTSMATMULT \$(OBJECT_PATH)/BOOST_TDVecTSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDVECTSMATMULT="$TDVECTSMATMULT \$(OBJECT_PATH)/EIGEN_TDVecTSMatMult.o"
fi
TDVECTSMATMULT="$TDVECTSMATMULT \$(OBJECT_PATH)/MAIN_TDVecTSMatMult.o"

# Configuration of the transpose sparse vector/sparse matrix multiplication benchmark
TSVECSMATMULT="\$(OBJECT_PATH)/BLAZE_TSVecSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSVECSMATMULT="$TSVECSMATMULT \$(OBJECT_PATH)/BOOST_TSVecSMatMult.o"
fi
TSVECSMATMULT="$TSVECSMATMULT \$(OBJECT_PATH)/MAIN_TSVecSMatMult.o"

# Configuration of the transpose sparse vector/transpose sparse matrix multiplication benchmark
TSVECTSMATMULT="\$(OBJECT_PATH)/BLAZE_TSVecTSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSVECTSMATMULT="$TSVECTSMATMULT \$(OBJECT_PATH)/BOOST_TSVecTSMatMult.o "
fi
TSVECTSMATMULT="$TSVECTSMATMULT \$(OBJECT_PATH)/MAIN_TSVecTSMatMult.o"

# Configuration of the dense matrix transpose benchmark
DMATTRANS="\$(OBJECT_PATH)/BLAZE_DMatTrans.o"
if [ "$BOOST" = "yes" ]; then
   DMATTRANS="$DMATTRANS \$(OBJECT_PATH)/BOOST_DMatTrans.o"
fi
if [ "$GMM" = "yes" ]; then
   DMATTRANS="$DMATTRANS \$(OBJECT_PATH)/GMM_DMatTrans.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DMATTRANS="$DMATTRANS \$(OBJECT_PATH)/ARMADILLO_DMatTrans.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATTRANS="$DMATTRANS \$(OBJECT_PATH)/FLENS_DMatTrans.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATTRANS="$DMATTRANS \$(OBJECT_PATH)/MTL_DMatTrans.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATTRANS="$DMATTRANS \$(OBJECT_PATH)/EIGEN_DMatTrans.o"
fi
DMATTRANS="$DMATTRANS \$(OBJECT_PATH)/MAIN_DMatTrans.o"

# Configuration of the sparse matrix transpose benchmark
SMATTRANS="\$(OBJECT_PATH)/BLAZE_SMatTrans.o"
if [ "BOOST" = "yes" ]; then
   SMATTRANS="$SMATTRANS \$(OBJECT_PATH)/BOOST_SMatTrans.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATTRANS="$SMATTRANS \$(OBJECT_PATH)/GMM_SMatTrans.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATTRANS="$SMATTRANS \$(OBJECT_PATH)/MTL_SMatTrans.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATTRANS="$SMATTRANS \$(OBJECT_PATH)/EIGEN_SMatTrans.o"
fi
SMATTRANS="$SMATTRANS \$(OBJECT_PATH)/MAIN_SMatTrans.o"

# Configuration of the dense matrix inversion benchmark
DMATINV="\$(OBJECT_PATH)/BLAZE_DMatInv.o"
if [ "$BOOST" = "yes" ]; then
   DMATINV="$DMATINV \$(OBJECT_PATH)/BOOST_DMatInv.o"
fi
if [ "$GMM" = "yes" ]; then
   DMATINV="$DMATINV \$(OBJECT_PATH)/GMM_DMatInv.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DMATINV="$DMATINV \$(OBJECT_PATH)/ARMADILLO_DMatInv.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATINV="$DMATINV \$(OBJECT_PATH)/MTL_DMatInv.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATINV="$DMATINV \$(OBJECT_PATH)/EIGEN_DMatInv.o"
fi
DMATINV="$DMATINV \$(OBJECT_PATH)/MAIN_DMatInv.o"

# Configuration of the dense matrix/dense matrix addition benchmark
DMATDMATADD="\$(OBJECT_PATH)/CLASSIC_DMatDMatAdd.o \$(OBJECT_PATH)/BLAZE_DMatDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   DMATDMATADD="$DMATDMATADD \$(OBJECT_PATH)/BOOST_DMatDMatAdd.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DMATDMATADD="$DMATDMATADD \$(OBJECT_PATH)/BLITZ_DMatDMatAdd.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATDMATADD="$DMATDMATADD \$(OBJECT_PATH)/FLENS_DMatDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATDMATADD="$DMATDMATADD \$(OBJECT_PATH)/MTL_DMatDMatAdd.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATDMATADD="$DMATDMATADD \$(OBJECT_PATH)/EIGEN_DMatDMatAdd.o"
fi
DMATDMATADD="$DMATDMATADD \$(OBJECT_PATH)/MAIN_DMatDMatAdd.o"

# Configuration of the dense matrix/transpose dense matrix addition benchmark
DMATTDMATADD="\$(OBJECT_PATH)/BLAZE_DMatTDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   DMATTDMATADD="$DMATTDMATADD \$(OBJECT_PATH)/BOOST_DMatTDMatAdd.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DMATTDMATADD="$DMATTDMATADD \$(OBJECT_PATH)/BLITZ_DMatTDMatAdd.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATTDMATADD="$DMATTDMATADD \$(OBJECT_PATH)/FLENS_DMatTDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATTDMATADD="$DMATTDMATADD \$(OBJECT_PATH)/MTL_DMatTDMatAdd.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATTDMATADD="$DMATTDMATADD \$(OBJECT_PATH)/EIGEN_DMatTDMatAdd.o"
fi
DMATTDMATADD="$DMATTDMATADD \$(OBJECT_PATH)/MAIN_DMatTDMatAdd.o"

# Configuration of the transpose dense matrix/dense matrix addition benchmark
TDMATDMATADD="\$(OBJECT_PATH)/BLAZE_TDMatDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TDMATDMATADD="$TDMATDMATADD \$(OBJECT_PATH)/BOOST_TDMatDMatAdd.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TDMATDMATADD="$TDMATDMATADD \$(OBJECT_PATH)/BLITZ_TDMatDMatAdd.o"
fi
if [ "$FLENS" = "yes" ]; then
   TDMATDMATADD="$TDMATDMATADD \$(OBJECT_PATH)/FLENS_TDMatDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATDMATADD="$TDMATDMATADD \$(OBJECT_PATH)/MTL_TDMatDMatAdd.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDMATDMATADD="$TDMATDMATADD \$(OBJECT_PATH)/EIGEN_TDMatDMatAdd.o"
fi
TDMATDMATADD="$TDMATDMATADD \$(OBJECT_PATH)/MAIN_TDMatDMatAdd.o"

# Configuration of the transpose dense matrix/transpose dense matrix addition benchmark
TDMATTDMATADD="\$(OBJECT_PATH)/BLAZE_TDMatTDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/BOOST_TDMatTDMatAdd.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/BLITZ_TDMatTDMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/GMM_TDMatTDMatAdd.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/ARMADILLO_TDMatTDMatAdd.o"
fi
if [ "$FLENS" = "yes" ]; then
   TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/FLENS_TDMatTDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/MTL_TDMatTDMatAdd.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/EIGEN_TDMatTDMatAdd.o"
fi
TDMATTDMATADD="$TDMATTDMATADD \$(OBJECT_PATH)/MAIN_TDMatTDMatAdd.o"

# Configuration of the dense matrix/sparse matrix addition benchmark
DMATSMATADD="\$(OBJECT_PATH)/BLAZE_DMatSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   DMATSMATADD="$DMATSMATADD \$(OBJECT_PATH)/BOOST_DMatSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATSMATADD="$DMATSMATADD \$(OBJECT_PATH)/MTL_DMatSMatAdd.o"
fi
DMATSMATADD="$DMATSMATADD \$(OBJECT_PATH)/MAIN_DMatSMatAdd.o"

# Configuration of the dense matrix/transpose sparse matrix addition benchmark
DMATTSMATADD="\$(OBJECT_PATH)/BLAZE_DMatTSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   DMATTSMATADD="$DMATTSMATADD \$(OBJECT_PATH)/BOOST_DMatTSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATTSMATADD="$DMATTSMATADD \$(OBJECT_PATH)/MTL_DMatTSMatAdd.o"
fi
DMATTSMATADD="$DMATTSMATADD \$(OBJECT_PATH)/MAIN_DMatTSMatAdd.o"

# Configuration of the transpose dense matrix/sparse matrix addition benchmark
TDMATSMATADD="\$(OBJECT_PATH)/BLAZE_TDMatSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TDMATSMATADD="$TDMATSMATADD \$(OBJECT_PATH)/BOOST_TDMatSMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATSMATADD="$TDMATSMATADD \$(OBJECT_PATH)/GMM_TDMatSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATSMATADD="$TDMATSMATADD \$(OBJECT_PATH)/MTL_TDMatSMatAdd.o"
fi
TDMATSMATADD="$TDMATSMATADD \$(OBJECT_PATH)/MAIN_TDMatSMatAdd.o"

# Configuration of the transpose dense matrix/transpose sparse matrix addition benchmark
TDMATTSMATADD="\$(OBJECT_PATH)/BLAZE_TDMatTSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TDMATTSMATADD="$TDMATTSMATADD \$(OBJECT_PATH)/BOOST_TDMatTSMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATTSMATADD="$TDMATTSMATADD \$(OBJECT_PATH)/GMM_TDMatTSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATTSMATADD="$TDMATTSMATADD \$(OBJECT_PATH)/MTL_TDMatTSMatAdd.o"
fi
TDMATTSMATADD="$TDMATTSMATADD \$(OBJECT_PATH)/MAIN_TDMatTSMatAdd.o"

# Configuration of the sparse matrix/dense matrix addition benchmark
SMATDMATADD="\$(OBJECT_PATH)/BLAZE_SMatDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   SMATDMATADD="$SMATDMATADD \$(OBJECT_PATH)/BOOST_SMatDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATDMATADD="$SMATDMATADD \$(OBJECT_PATH)/MTL_SMatDMatAdd.o"
fi
SMATDMATADD="$SMATDMATADD \$(OBJECT_PATH)/MAIN_SMatDMatAdd.o"

# Configuration of the sparse matrix/transpose dense matrix addition benchmark
SMATTDMATADD="\$(OBJECT_PATH)/BLAZE_SMatTDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   SMATTDMATADD="$SMATTDMATADD \$(OBJECT_PATH)/BOOST_SMatTDMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATTDMATADD="$SMATTDMATADD \$(OBJECT_PATH)/GMM_SMatTDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATTDMATADD="$SMATTDMATADD \$(OBJECT_PATH)/MTL_SMatTDMatAdd.o"
fi
SMATTDMATADD="$SMATTDMATADD \$(OBJECT_PATH)/MAIN_SMatTDMatAdd.o"

# Configuration of the transpose sparse matrix/dense matrix addition benchmark
TSMATDMATADD="\$(OBJECT_PATH)/BLAZE_TSMatDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TSMATDMATADD="$TSMATDMATADD \$(OBJECT_PATH)/BOOST_TSMatDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATDMATADD="$TSMATDMATADD \$(OBJECT_PATH)/MTL_TSMatDMatAdd.o"
fi
TSMATDMATADD="$TSMATDMATADD \$(OBJECT_PATH)/MAIN_TSMatDMatAdd.o"

# Configuration of the transpose sparse matrix/transpose dense matrix addition benchmark
TSMATTDMATADD="\$(OBJECT_PATH)/BLAZE_TSMatTDMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TSMATTDMATADD="$TSMATTDMATADD \$(OBJECT_PATH)/BOOST_TSMatTDMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATTDMATADD="$TSMATTDMATADD \$(OBJECT_PATH)/GMM_TSMatTDMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATTDMATADD="$TSMATTDMATADD \$(OBJECT_PATH)/MTL_TSMatTDMatAdd.o"
fi
TSMATTDMATADD="$TSMATTDMATADD \$(OBJECT_PATH)/MAIN_TSMatTDMatAdd.o"

# Configuration of the sparse matrix/sparse matrix addition benchmark
SMATSMATADD="\$(OBJECT_PATH)/BLAZE_SMatSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   SMATSMATADD="$SMATSMATADD \$(OBJECT_PATH)/BOOST_SMatSMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATSMATADD="$SMATSMATADD \$(OBJECT_PATH)/GMM_SMatSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATSMATADD="$SMATSMATADD \$(OBJECT_PATH)/MTL_SMatSMatAdd.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATSMATADD="$SMATSMATADD \$(OBJECT_PATH)/EIGEN_SMatSMatAdd.o"
fi
SMATSMATADD="$SMATSMATADD \$(OBJECT_PATH)/MAIN_SMatSMatAdd.o"

# Configuration of the sparse matrix/transpose sparse matrix addition benchmark
SMATTSMATADD="\$(OBJECT_PATH)/BLAZE_SMatTSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   SMATTSMATADD="$SMATTSMATADD \$(OBJECT_PATH)/BOOST_SMatTSMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATTSMATADD="$SMATTSMATADD \$(OBJECT_PATH)/GMM_SMatTSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATTSMATADD="$SMATTSMATADD \$(OBJECT_PATH)/MTL_SMatTSMatAdd.o"
fi
SMATTSMATADD="$SMATTSMATADD \$(OBJECT_PATH)/MAIN_SMatTSMatAdd.o"

# Configuration of the transpose sparse matrix/sparse matrix addition benchmark
TSMATSMATADD="\$(OBJECT_PATH)/BLAZE_TSMatSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TSMATSMATADD="$TSMATSMATADD \$(OBJECT_PATH)/BOOST_TSMatSMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATSMATADD="$TSMATSMATADD \$(OBJECT_PATH)/GMM_TSMatSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATSMATADD="$TSMATSMATADD \$(OBJECT_PATH)/MTL_TSMatSMatAdd.o"
fi
TSMATSMATADD="$TSMATSMATADD \$(OBJECT_PATH)/MAIN_TSMatSMatAdd.o"

# Configuration of the transpose sparse matrix/transpose sparse matrix addition benchmark
TSMATTSMATADD="\$(OBJECT_PATH)/BLAZE_TSMatTSMatAdd.o"
if [ "$BOOST" = "yes" ]; then
   TSMATTSMATADD="$TSMATTSMATADD \$(OBJECT_PATH)/BOOST_TSMatTSMatAdd.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATTSMATADD="$TSMATTSMATADD \$(OBJECT_PATH)/GMM_TSMatTSMatAdd.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATTSMATADD="$TSMATTSMATADD \$(OBJECT_PATH)/MTL_TSMatTSMatAdd.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TSMATTSMATADD="$TSMATTSMATADD \$(OBJECT_PATH)/EIGEN_TSMatTSMatAdd.o"
fi
TSMATTSMATADD="$TSMATTSMATADD \$(OBJECT_PATH)/MAIN_TSMatTSMatAdd.o"

# Configuration of the dense matrix/dense matrix subtraction benchmark
DMATDMATSUB="\$(OBJECT_PATH)/CLASSIC_DMatDMatSub.o \$(OBJECT_PATH)/BLAZE_DMatDMatSub.o"
if [ "$BOOST" = "yes" ]; then
   DMATDMATSUB="$DMATDMATSUB \$(OBJECT_PATH)/BOOST_DMatDMatSub.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DMATDMATSUB="$DMATDMATSUB \$(OBJECT_PATH)/BLITZ_DMatDMatSub.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATDMATSUB="$DMATDMATSUB \$(OBJECT_PATH)/FLENS_DMatDMatSub.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATDMATSUB="$DMATDMATSUB \$(OBJECT_PATH)/MTL_DMatDMatSub.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATDMATSUB="$DMATDMATSUB \$(OBJECT_PATH)/EIGEN_DMatDMatSub.o"
fi
DMATDMATSUB="$DMATDMATSUB \$(OBJECT_PATH)/MAIN_DMatDMatSub.o"

# Configuration of the dense matrix/scalar multiplication benchmark
DMATSCALARMULT="\$(OBJECT_PATH)/CLASSIC_DMatScalarMult.o \$(OBJECT_PATH)/BLAZE_DMatScalarMult.o"
if [ "$BOOST" = "yes" ]; then
   DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/BOOST_DMatScalarMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/BLITZ_DMatScalarMult.o"
fi
if [ "$GMM" = "yes" ]; then
   DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/GMM_DMatScalarMult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/ARMADILLO_DMatScalarMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/FLENS_DMatScalarMult.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/MTL_DMatScalarMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/EIGEN_DMatScalarMult.o"
fi
DMATSCALARMULT="$DMATSCALARMULT \$(OBJECT_PATH)/MAIN_DMatScalarMult.o"

# Configuration of the sparse matrix/scalar multiplication benchmark
SMATSCALARMULT="\$(OBJECT_PATH)/BLAZE_SMatScalarMult.o"
if [ "$BOOST" = "yes" ]; then
   SMATSCALARMULT="$SMATSCALARMULT \$(OBJECT_PATH)/BOOST_SMatScalarMult.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATSCALARMULT="$SMATSCALARMULT \$(OBJECT_PATH)/GMM_SMatScalarMult.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATSCALARMULT="$SMATSCALARMULT \$(OBJECT_PATH)/MTL_SMatScalarMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATSCALARMULT="$SMATSCALARMULT \$(OBJECT_PATH)/EIGEN_SMatScalarMult.o"
fi
SMATSCALARMULT="$SMATSCALARMULT \$(OBJECT_PATH)/MAIN_SMatScalarMult.o"

# Configuration of the dense matrix/dense matrix multiplication benchmark
DMATDMATMULT="\$(OBJECT_PATH)/CLASSIC_DMatDMatMult.o"
if [ "$BLAS" = "yes" ]; then
   DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/BLAS_DMatDMatMult.o"
fi
DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/BLAZE_DMatDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/BOOST_DMatDMatMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/BLITZ_DMatDMatMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/FLENS_DMatDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/MTL_DMatDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/EIGEN_DMatDMatMult.o"
fi
DMATDMATMULT="$DMATDMATMULT \$(OBJECT_PATH)/MAIN_DMatDMatMult.o"

# Configuration of the dense matrix/transpose dense matrix multiplication benchmark
DMATTDMATMULT=""
if [ "$BLAS" = "yes" ]; then
   DMATTDMATMULT="$DMATTDMATMULT \$(OBJECT_PATH)/BLAS_DMatTDMatMult.o"
fi
DMATTDMATMULT="$DMATTDMATMULT \$(OBJECT_PATH)/BLAZE_DMatTDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   DMATTDMATMULT="$DMATTDMATMULT \$(OBJECT_PATH)/BOOST_DMatTDMatMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   DMATTDMATMULT="$DMATTDMATMULT \$(OBJECT_PATH)/FLENS_DMatTDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATTDMATMULT="$DMATTDMATMULT \$(OBJECT_PATH)/MTL_DMatTDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATTDMATMULT="$DMATTDMATMULT \$(OBJECT_PATH)/EIGEN_DMatTDMatMult.o"
fi
DMATTDMATMULT="$DMATTDMATMULT \$(OBJECT_PATH)/MAIN_DMatTDMatMult.o"

# Configuration of the transpose dense matrix/dense matrix multiplication benchmark
TDMATDMATMULT=""
if [ "$BLAS" = "yes" ]; then
   TDMATDMATMULT="$TDMATDMATMULT \$(OBJECT_PATH)/BLAS_TDMatDMatMult.o"
fi
TDMATDMATMULT="$TDMATDMATMULT \$(OBJECT_PATH)/BLAZE_TDMatDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDMATDMATMULT="$TDMATDMATMULT \$(OBJECT_PATH)/BOOST_TDMatDMatMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TDMATDMATMULT="$TDMATDMATMULT \$(OBJECT_PATH)/FLENS_TDMatDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATDMATMULT="$TDMATDMATMULT \$(OBJECT_PATH)/MTL_TDMatDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDMATDMATMULT="$TDMATDMATMULT \$(OBJECT_PATH)/EIGEN_TDMatDMatMult.o"
fi
TDMATDMATMULT="$TDMATDMATMULT \$(OBJECT_PATH)/MAIN_TDMatDMatMult.o"

# Configuration of the transpose dense matrix/transpose dense matrix multiplication benchmark
TDMATTDMATMULT="\$(OBJECT_PATH)/CLASSIC_TDMatTDMatMult.o"
if [ "$BLAS" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/BLAS_TDMatTDMatMult.o"
fi
TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/BLAZE_TDMatTDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/BOOST_TDMatTDMatMult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/BLITZ_TDMatTDMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/GMM_TDMatTDMatMult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/ARMADILLO_TDMatTDMatMult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/FLENS_TDMatTDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/MTL_TDMatTDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/EIGEN_TDMatTDMatMult.o"
fi
TDMATTDMATMULT="$TDMATTDMATMULT \$(OBJECT_PATH)/MAIN_TDMatTDMatMult.o"

# Configuration of the dense matrix/sparse matrix multiplication benchmark
DMATSMATMULT="\$(OBJECT_PATH)/BLAZE_DMatSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   DMATSMATMULT="$DMATSMATMULT \$(OBJECT_PATH)/BOOST_DMatSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATSMATMULT="$DMATSMATMULT \$(OBJECT_PATH)/MTL_DMatSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATSMATMULT="$DMATSMATMULT \$(OBJECT_PATH)/EIGEN_DMatSMatMult.o"
fi
DMATSMATMULT="$DMATSMATMULT \$(OBJECT_PATH)/MAIN_DMatSMatMult.o"

# Configuration of the dense matrix/transpose sparse matrix multiplication benchmark
DMATTSMATMULT="\$(OBJECT_PATH)/BLAZE_DMatTSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   DMATTSMATMULT="$DMATTSMATMULT \$(OBJECT_PATH)/BOOST_DMatTSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   DMATTSMATMULT="$DMATTSMATMULT \$(OBJECT_PATH)/MTL_DMatTSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   DMATTSMATMULT="$DMATTSMATMULT \$(OBJECT_PATH)/EIGEN_DMatTSMatMult.o"
fi
DMATTSMATMULT="$DMATTSMATMULT \$(OBJECT_PATH)/MAIN_DMatTSMatMult.o"

# Configuration of the transpose dense matrix/sparse matrix multiplication benchmark
TDMATSMATMULT="\$(OBJECT_PATH)/BLAZE_TDMatSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDMATSMATMULT="$TDMATSMATMULT \$(OBJECT_PATH)/BOOST_TDMatSMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATSMATMULT="$TDMATSMATMULT \$(OBJECT_PATH)/GMM_TDMatSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATSMATMULT="$TDMATSMATMULT \$(OBJECT_PATH)/MTL_TDMatSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDMATSMATMULT="$TDMATSMATMULT \$(OBJECT_PATH)/EIGEN_TDMatSMatMult.o"
fi
TDMATSMATMULT="$TDMATSMATMULT \$(OBJECT_PATH)/MAIN_TDMatSMatMult.o"

# Configuration of the transpose dense matrix/transpose sparse matrix multiplication benchmark
TDMATTSMATMULT="\$(OBJECT_PATH)/BLAZE_TDMatTSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TDMATTSMATMULT="$TDMATTSMATMULT \$(OBJECT_PATH)/BOOST_TDMatTSMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TDMATTSMATMULT="$TDMATTSMATMULT \$(OBJECT_PATH)/GMM_TDMatTSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TDMATTSMATMULT="$TDMATTSMATMULT \$(OBJECT_PATH)/MTL_TDMatTSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TDMATTSMATMULT="$TDMATTSMATMULT \$(OBJECT_PATH)/EIGEN_TDMatTSMatMult.o"
fi
TDMATTSMATMULT="$TDMATTSMATMULT \$(OBJECT_PATH)/MAIN_TDMatTSMatMult.o"

# Configuration of the sparse matrix/dense matrix multiplication benchmark
SMATDMATMULT="\$(OBJECT_PATH)/BLAZE_SMatDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   SMATDMATMULT="$SMATDMATMULT \$(OBJECT_PATH)/BOOST_SMatDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATDMATMULT="$SMATDMATMULT \$(OBJECT_PATH)/MTL_SMatDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATDMATMULT="$SMATDMATMULT \$(OBJECT_PATH)/EIGEN_SMatDMatMult.o"
fi
SMATDMATMULT="$SMATDMATMULT \$(OBJECT_PATH)/MAIN_SMatDMatMult.o"

# Configuration of the sparse matrix/transpose dense matrix multiplication benchmark
SMATTDMATMULT="\$(OBJECT_PATH)/BLAZE_SMatTDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   SMATTDMATMULT="$SMATTDMATMULT \$(OBJECT_PATH)/BOOST_SMatTDMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATTDMATMULT="$SMATTDMATMULT \$(OBJECT_PATH)/GMM_SMatTDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATTDMATMULT="$SMATTDMATMULT \$(OBJECT_PATH)/MTL_SMatTDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATTDMATMULT="$SMATTDMATMULT \$(OBJECT_PATH)/EIGEN_SMatTDMatMult.o"
fi
SMATTDMATMULT="$SMATTDMATMULT \$(OBJECT_PATH)/MAIN_SMatTDMatMult.o"

# Configuration of the transpose sparse matrix/dense matrix multiplication benchmark
TSMATDMATMULT="\$(OBJECT_PATH)/BLAZE_TSMatDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSMATDMATMULT="$TSMATDMATMULT \$(OBJECT_PATH)/BOOST_TSMatDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATDMATMULT="$TSMATDMATMULT \$(OBJECT_PATH)/MTL_TSMatDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TSMATDMATMULT="$TSMATDMATMULT \$(OBJECT_PATH)/EIGEN_TSMatDMatMult.o"
fi
TSMATDMATMULT="$TSMATDMATMULT \$(OBJECT_PATH)/MAIN_TSMatDMatMult.o"

# Configuration of the transpose sparse matrix/transpose dense matrix multiplication benchmark
TSMATTDMATMULT="\$(OBJECT_PATH)/BLAZE_TSMatTDMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSMATTDMATMULT="$TSMATTDMATMULT \$(OBJECT_PATH)/BOOST_TSMatTDMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATTDMATMULT="$TSMATTDMATMULT \$(OBJECT_PATH)/GMM_TSMatTDMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATTDMATMULT="$TSMATTDMATMULT \$(OBJECT_PATH)/MTL_TSMatTDMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TSMATTDMATMULT="$TSMATTDMATMULT \$(OBJECT_PATH)/EIGEN_TSMatTDMatMult.o"
fi
TSMATTDMATMULT="$TSMATTDMATMULT \$(OBJECT_PATH)/MAIN_TSMatTDMatMult.o"

# Configuration of the sparse matrix/sparse matrix multiplication benchmark
SMATSMATMULT="\$(OBJECT_PATH)/BLAZE_SMatSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   SMATSMATMULT="$SMATSMATMULT \$(OBJECT_PATH)/BOOST_SMatSMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATSMATMULT="$SMATSMATMULT \$(OBJECT_PATH)/GMM_SMatSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATSMATMULT="$SMATSMATMULT \$(OBJECT_PATH)/MTL_SMatSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATSMATMULT="$SMATSMATMULT \$(OBJECT_PATH)/EIGEN_SMatSMatMult.o"
fi
SMATSMATMULT="$SMATSMATMULT \$(OBJECT_PATH)/MAIN_SMatSMatMult.o"

# Configuration of the sparse matrix/transpose sparse matrix multiplication benchmark
SMATTSMATMULT="\$(OBJECT_PATH)/BLAZE_SMatTSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   SMATTSMATMULT="$SMATTSMATMULT \$(OBJECT_PATH)/BOOST_SMatTSMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   SMATTSMATMULT="$SMATTSMATMULT \$(OBJECT_PATH)/GMM_SMatTSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   SMATTSMATMULT="$SMATTSMATMULT \$(OBJECT_PATH)/MTL_SMatTSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   SMATTSMATMULT="$SMATTSMATMULT \$(OBJECT_PATH)/EIGEN_SMatTSMatMult.o"
fi
SMATTSMATMULT="$SMATTSMATMULT \$(OBJECT_PATH)/MAIN_SMatTSMatMult.o"

# Configuration of the transpose sparse matrix/sparse matrix multiplication benchmark
TSMATSMATMULT="\$(OBJECT_PATH)/BLAZE_TSMatSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSMATSMATMULT="$TSMATSMATMULT \$(OBJECT_PATH)/BOOST_TSMatSMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATSMATMULT="$TSMATSMATMULT \$(OBJECT_PATH)/GMM_TSMatSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATSMATMULT="$TSMATSMATMULT \$(OBJECT_PATH)/MTL_TSMatSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TSMATSMATMULT="$TSMATSMATMULT \$(OBJECT_PATH)/EIGEN_TSMatSMatMult.o"
fi
TSMATSMATMULT="$TSMATSMATMULT \$(OBJECT_PATH)/MAIN_TSMatSMatMult.o"

# Configuration of the transpose sparse matrix/transpose sparse matrix multiplication benchmark
TSMATTSMATMULT="\$(OBJECT_PATH)/BLAZE_TSMatTSMatMult.o"
if [ "$BOOST" = "yes" ]; then
   TSMATTSMATMULT="$TSMATTSMATMULT \$(OBJECT_PATH)/BOOST_TSMatTSMatMult.o"
fi
if [ "$GMM" = "yes" ]; then
   TSMATTSMATMULT="$TSMATTSMATMULT \$(OBJECT_PATH)/GMM_TSMatTSMatMult.o"
fi
if [ "$MTL" = "yes" ]; then
   TSMATTSMATMULT="$TSMATTSMATMULT \$(OBJECT_PATH)/MTL_TSMatTSMatMult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TSMATTSMATMULT="$TSMATTSMATMULT \$(OBJECT_PATH)/EIGEN_TSMatTSMatMult.o"
fi
TSMATTSMATMULT="$TSMATTSMATMULT \$(OBJECT_PATH)/MAIN_TSMatTSMatMult.o"

# Configuration of the 3-dimensional vector/vector addition benchmark
VEC3VEC3ADD="\$(OBJECT_PATH)/BLAZE_Vec3Vec3Add.o"
if [ "$BOOST" = "yes" ]; then
   VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/BOOST_Vec3Vec3Add.o"
fi
if [ "$BLITZ" = "yes" ]; then
   VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/BLITZ_Vec3Vec3Add.o"
fi
if [ "$GMM" = "yes" ]; then
   VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/GMM_Vec3Vec3Add.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/ARMADILLO_Vec3Vec3Add.o"
fi
if [ "$FLENS" = "yes" ]; then
   VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/FLENS_Vec3Vec3Add.o"
fi
if [ "$MTL" = "yes" ]; then
   VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/MTL_Vec3Vec3Add.o"
fi
if [ "$EIGEN" = "yes" ]; then
   VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/EIGEN_Vec3Vec3Add.o"
fi
VEC3VEC3ADD="$VEC3VEC3ADD \$(OBJECT_PATH)/MAIN_Vec3Vec3Add.o"

# Configuration of the 6-dimensional vector/vector addition benchmark
VEC6VEC6ADD="\$(OBJECT_PATH)/BLAZE_Vec6Vec6Add.o"
if [ "$BOOST" = "yes" ]; then
   VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/BOOST_Vec6Vec6Add.o"
fi
if [ "$BLITZ" = "yes" ]; then
   VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/BLITZ_Vec6Vec6Add.o"
fi
if [ "$GMM" = "yes" ]; then
   VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/GMM_Vec6Vec6Add.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/ARMADILLO_Vec6Vec6Add.o"
fi
if [ "$FLENS" = "yes" ]; then
   VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/FLENS_Vec6Vec6Add.o"
fi
if [ "$MTL" = "yes" ]; then
   VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/MTL_Vec6Vec6Add.o"
fi
if [ "$EIGEN" = "yes" ]; then
   VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/EIGEN_Vec6Vec6Add.o"
fi
VEC6VEC6ADD="$VEC6VEC6ADD \$(OBJECT_PATH)/MAIN_Vec6Vec6Add.o"

# Configuration of the 3-dimensional matrix/vector multiplication benchmark
MAT3VEC3MULT="\$(OBJECT_PATH)/CLIKE_Mat3Vec3Mult.o \$(OBJECT_PATH)/BLAZE_Mat3Vec3Mult.o"
if [ "$BOOST" = "yes" ]; then
   MAT3VEC3MULT="$MAT3VEC3MULT \$(OBJECT_PATH)/BOOST_Mat3Vec3Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT3VEC3MULT="$MAT3VEC3MULT \$(OBJECT_PATH)/BLITZ_Mat3Vec3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT3VEC3MULT="$MAT3VEC3MULT \$(OBJECT_PATH)/FLENS_Mat3Vec3Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT3VEC3MULT="$MAT3VEC3MULT \$(OBJECT_PATH)/MTL_Mat3Vec3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT3VEC3MULT="$MAT3VEC3MULT \$(OBJECT_PATH)/EIGEN_Mat3Vec3Mult.o"
fi
MAT3VEC3MULT="$MAT3VEC3MULT \$(OBJECT_PATH)/MAIN_Mat3Vec3Mult.o"

# Configuration of the 3-dimensional transpose matrix/vector multiplication benchmark
TMAT3VEC3MULT="\$(OBJECT_PATH)/CLIKE_TMat3Vec3Mult.o \$(OBJECT_PATH)/BLAZE_TMat3Vec3Mult.o"
if [ "$BOOST" = "yes" ]; then
   TMAT3VEC3MULT="$TMAT3VEC3MULT \$(OBJECT_PATH)/BOOST_TMat3Vec3Mult.o"
fi
if [ "$GMM" = "yes" ]; then
   TMAT3VEC3MULT="$TMAT3VEC3MULT \$(OBJECT_PATH)/GMM_TMat3Vec3Mult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TMAT3VEC3MULT="$TMAT3VEC3MULT \$(OBJECT_PATH)/ARMADILLO_TMat3Vec3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT3VEC3MULT="$TMAT3VEC3MULT \$(OBJECT_PATH)/FLENS_TMat3Vec3Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT3VEC3MULT="$TMAT3VEC3MULT \$(OBJECT_PATH)/MTL_TMat3Vec3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT3VEC3MULT="$TMAT3VEC3MULT \$(OBJECT_PATH)/EIGEN_TMat3Vec3Mult.o"
fi
TMAT3VEC3MULT="$TMAT3VEC3MULT \$(OBJECT_PATH)/MAIN_TMat3Vec3Mult.o"

# Configuration of the 6-dimensional matrix/vector multiplication benchmark
MAT6VEC6MULT="\$(OBJECT_PATH)/BLAZE_Mat6Vec6Mult.o"
if [ "$BOOST" = "yes" ]; then
   MAT6VEC6MULT="$MAT6VEC6MULT \$(OBJECT_PATH)/BOOST_Mat6Vec6Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT6VEC6MULT="$MAT6VEC6MULT \$(OBJECT_PATH)/BLITZ_Mat6Vec6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT6VEC6MULT="$MAT6VEC6MULT \$(OBJECT_PATH)/FLENS_Mat6Vec6Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT6VEC6MULT="$MAT6VEC6MULT \$(OBJECT_PATH)/MTL_Mat6Vec6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT6VEC6MULT="$MAT6VEC6MULT \$(OBJECT_PATH)/EIGEN_Mat6Vec6Mult.o"
fi
MAT6VEC6MULT="$MAT6VEC6MULT \$(OBJECT_PATH)/MAIN_Mat6Vec6Mult.o"

# Configuration of the 6-dimensional transpose matrix/vector multiplication benchmark
TMAT6VEC6MULT="\$(OBJECT_PATH)/BLAZE_TMat6Vec6Mult.o"
if [ "$BOOST" = "yes" ]; then
   TMAT6VEC6MULT="$TMAT6VEC6MULT \$(OBJECT_PATH)/BOOST_TMat6Vec6Mult.o"
fi
if [ "$GMM" = "yes" ]; then
   TMAT6VEC6MULT="$TMAT6VEC6MULT \$(OBJECT_PATH)/GMM_TMat6Vec6Mult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TMAT6VEC6MULT="$TMAT6VEC6MULT \$(OBJECT_PATH)/ARMADILLO_TMat6Vec6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT6VEC6MULT="$TMAT6VEC6MULT \$(OBJECT_PATH)/FLENS_TMat6Vec6Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT6VEC6MULT="$TMAT6VEC6MULT \$(OBJECT_PATH)/MTL_TMat6Vec6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT6VEC6MULT="$TMAT6VEC6MULT \$(OBJECT_PATH)/EIGEN_TMat6Vec6Mult.o"
fi
TMAT6VEC6MULT="$TMAT6VEC6MULT \$(OBJECT_PATH)/MAIN_TMat6Vec6Mult.o"

# Configuration of the 3-dimensional transpose vector/matrix multiplication benchmark
TVEC3MAT3MULT="\$(OBJECT_PATH)/BLAZE_TVec3Mat3Mult.o"
if [ "$BOOST" = "yes" ]; then
   TVEC3MAT3MULT="$TVEC3MAT3MULT \$(OBJECT_PATH)/BOOST_TVec3Mat3Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TVEC3MAT3MULT="$TVEC3MAT3MULT \$(OBJECT_PATH)/BLITZ_TVec3Mat3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TVEC3MAT3MULT="$TVEC3MAT3MULT \$(OBJECT_PATH)/FLENS_TVec3Mat3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TVEC3MAT3MULT="$TVEC3MAT3MULT \$(OBJECT_PATH)/EIGEN_TVec3Mat3Mult.o"
fi
TVEC3MAT3MULT="$TVEC3MAT3MULT \$(OBJECT_PATH)/MAIN_TVec3Mat3Mult.o"

# Configuration of the 3-dimensional transpose vector/transpose matrix multiplication benchmark
TVEC3TMAT3MULT="\$(OBJECT_PATH)/BLAZE_TVec3TMat3Mult.o"
if [ "$BOOST" = "yes" ]; then
   TVEC3TMAT3MULT="$TVEC3TMAT3MULT \$(OBJECT_PATH)/BOOST_TVec3TMat3Mult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TVEC3TMAT3MULT="$TVEC3TMAT3MULT \$(OBJECT_PATH)/ARMADILLO_TVec3TMat3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TVEC3TMAT3MULT="$TVEC3TMAT3MULT \$(OBJECT_PATH)/FLENS_TVec3TMat3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TVEC3TMAT3MULT="$TVEC3TMAT3MULT \$(OBJECT_PATH)/EIGEN_TVec3TMat3Mult.o"
fi
TVEC3TMAT3MULT="$TVEC3TMAT3MULT \$(OBJECT_PATH)/MAIN_TVec3TMat3Mult.o"

# Configuration of the 6-dimensional transpose vector/matrix multiplication benchmark
TVEC6MAT6MULT="\$(OBJECT_PATH)/BLAZE_TVec6Mat6Mult.o"
if [ "$BOOST" = "yes" ]; then
   TVEC6MAT6MULT="$TVEC6MAT6MULT \$(OBJECT_PATH)/BOOST_TVec6Mat6Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TVEC6MAT6MULT="$TVEC6MAT6MULT \$(OBJECT_PATH)/BLITZ_TVec6Mat6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TVEC6MAT6MULT="$TVEC6MAT6MULT \$(OBJECT_PATH)/EIGEN_TVec6Mat6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TVEC6MAT6MULT="$TVEC6MAT6MULT \$(OBJECT_PATH)/FLENS_TVec6Mat6Mult.o"
fi
TVEC6MAT6MULT="$TVEC6MAT6MULT \$(OBJECT_PATH)/MAIN_TVec6Mat6Mult.o"

# Configuration of the 6-dimensional transpose vector/transpose matrix multiplication benchmark
TVEC6TMAT6MULT="\$(OBJECT_PATH)/BLAZE_TVec6TMat6Mult.o"
if [ "$BOOST" = "yes" ]; then
   TVEC6TMAT6MULT="$TVEC6TMAT6MULT \$(OBJECT_PATH)/BOOST_TVec6TMat6Mult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TVEC6TMAT6MULT="$TVEC6TMAT6MULT \$(OBJECT_PATH)/ARMADILLO_TVec6TMat6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TVEC6TMAT6MULT="$TVEC6TMAT6MULT \$(OBJECT_PATH)/FLENS_TVec6TMat6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TVEC6TMAT6MULT="$TVEC6TMAT6MULT \$(OBJECT_PATH)/EIGEN_TVec6TMat6Mult.o"
fi
TVEC6TMAT6MULT="$TVEC6TMAT6MULT \$(OBJECT_PATH)/MAIN_TVec6TMat6Mult.o"

# Configuration of the 3-dimensional matrix/matrix addition benchmark
MAT3MAT3ADD="\$(OBJECT_PATH)/BLAZE_Mat3Mat3Add.o"
if [ "$BOOST" = "yes" ]; then
   MAT3MAT3ADD="$MAT3MAT3ADD \$(OBJECT_PATH)/BOOST_Mat3Mat3Add.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT3MAT3ADD="$MAT3MAT3ADD \$(OBJECT_PATH)/BLITZ_Mat3Mat3Add.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT3MAT3ADD="$MAT3MAT3ADD \$(OBJECT_PATH)/FLENS_Mat3Mat3Add.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT3MAT3ADD="$MAT3MAT3ADD \$(OBJECT_PATH)/MTL_Mat3Mat3Add.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT3MAT3ADD="$MAT3MAT3ADD \$(OBJECT_PATH)/EIGEN_Mat3Mat3Add.o"
fi
MAT3MAT3ADD="$MAT3MAT3ADD \$(OBJECT_PATH)/MAIN_Mat3Mat3Add.o"

# Configuration of the 3-dimensional transpose matrix/transpose matrix addition benchmark
TMAT3TMAT3ADD="\$(OBJECT_PATH)/BLAZE_TMat3TMat3Add.o"
if [ "$BOOST" = "yes" ]; then
   TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/BOOST_TMat3TMat3Add.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/BLITZ_TMat3TMat3Add.o"
fi
if [ "$GMM" = "yes" ]; then
   TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/GMM_TMat3TMat3Add.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/ARMADILLO_TMat3TMat3Add.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/FLENS_TMat3TMat3Add.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/MTL_TMat3TMat3Add.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/EIGEN_TMat3TMat3Add.o"
fi
TMAT3TMAT3ADD="$TMAT3TMAT3ADD \$(OBJECT_PATH)/MAIN_TMat3TMat3Add.o"

# Configuration of the 6-dimensional matrix/matrix addition benchmark
MAT6MAT6ADD="\$(OBJECT_PATH)/BLAZE_Mat6Mat6Add.o"
if [ "$BOOST" = "yes" ]; then
   MAT6MAT6ADD="$MAT6MAT6ADD \$(OBJECT_PATH)/BOOST_Mat6Mat6Add.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT6MAT6ADD="$MAT6MAT6ADD \$(OBJECT_PATH)/BLITZ_Mat6Mat6Add.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT6MAT6ADD="$MAT6MAT6ADD \$(OBJECT_PATH)/FLENS_Mat6Mat6Add.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT6MAT6ADD="$MAT6MAT6ADD \$(OBJECT_PATH)/MTL_Mat6Mat6Add.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT6MAT6ADD="$MAT6MAT6ADD \$(OBJECT_PATH)/EIGEN_Mat6Mat6Add.o"
fi
MAT6MAT6ADD="$MAT6MAT6ADD \$(OBJECT_PATH)/MAIN_Mat6Mat6Add.o"

# Configuration of the 6-dimensional transpose matrix/transpose matrix addition benchmark
TMAT6TMAT6ADD="\$(OBJECT_PATH)/BLAZE_TMat6TMat6Add.o"
if [ "$BOOST" = "yes" ]; then
   TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/BOOST_TMat6TMat6Add.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/BLITZ_TMat6TMat6Add.o"
fi
if [ "$GMM" = "yes" ]; then
   TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/GMM_TMat6TMat6Add.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/ARMADILLO_TMat6TMat6Add.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/FLENS_TMat6TMat6Add.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/MTL_TMat6TMat6Add.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/EIGEN_TMat6TMat6Add.o"
fi
TMAT6TMAT6ADD="$TMAT6TMAT6ADD \$(OBJECT_PATH)/MAIN_TMat6TMat6Add.o"

# Configuration of the 3-dimensional matrix/matrix multiplication benchmark
MAT3MAT3MULT="\$(OBJECT_PATH)/BLAZE_Mat3Mat3Mult.o"
if [ "$BOOST" = "yes" ]; then
   MAT3MAT3MULT="$MAT3MAT3MULT \$(OBJECT_PATH)/BOOST_Mat3Mat3Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT3MAT3MULT="$MAT3MAT3MULT \$(OBJECT_PATH)/BLITZ_Mat3Mat3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT3MAT3MULT="$MAT3MAT3MULT \$(OBJECT_PATH)/FLENS_Mat3Mat3Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT3MAT3MULT="$MAT3MAT3MULT \$(OBJECT_PATH)/MTL_Mat3Mat3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT3MAT3MULT="$MAT3MAT3MULT \$(OBJECT_PATH)/EIGEN_Mat3Mat3Mult.o"
fi
MAT3MAT3MULT="$MAT3MAT3MULT \$(OBJECT_PATH)/MAIN_Mat3Mat3Mult.o"

# Configuration of the 3-dimensional matrix/transpose matrix multiplication benchmark
MAT3TMAT3MULT="\$(OBJECT_PATH)/BLAZE_Mat3TMat3Mult.o"
if [ "$BOOST" = "yes" ]; then
   MAT3TMAT3MULT="$MAT3TMAT3MULT \$(OBJECT_PATH)/BOOST_Mat3TMat3Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT3TMAT3MULT="$MAT3TMAT3MULT \$(OBJECT_PATH)/BLITZ_Mat3TMat3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT3TMAT3MULT="$MAT3TMAT3MULT \$(OBJECT_PATH)/FLENS_Mat3TMat3Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT3TMAT3MULT="$MAT3TMAT3MULT \$(OBJECT_PATH)/MTL_Mat3TMat3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT3TMAT3MULT="$MAT3TMAT3MULT \$(OBJECT_PATH)/EIGEN_Mat3TMat3Mult.o"
fi
MAT3TMAT3MULT="$MAT3TMAT3MULT \$(OBJECT_PATH)/MAIN_Mat3TMat3Mult.o"

# Configuration of the 3-dimensional transpose matrix/matrix multiplication benchmark
TMAT3MAT3MULT="\$(OBJECT_PATH)/BLAZE_TMat3Mat3Mult.o"
if [ "$BOOST" = "yes" ]; then
   TMAT3MAT3MULT="$TMAT3MAT3MULT \$(OBJECT_PATH)/BOOST_TMat3Mat3Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TMAT3MAT3MULT="$TMAT3MAT3MULT \$(OBJECT_PATH)/BLITZ_TMat3Mat3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT3MAT3MULT="$TMAT3MAT3MULT \$(OBJECT_PATH)/FLENS_TMat3Mat3Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT3MAT3MULT="$TMAT3MAT3MULT \$(OBJECT_PATH)/MTL_TMat3Mat3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT3MAT3MULT="$TMAT3MAT3MULT \$(OBJECT_PATH)/EIGEN_TMat3Mat3Mult.o"
fi
TMAT3MAT3MULT="$TMAT3MAT3MULT \$(OBJECT_PATH)/MAIN_TMat3Mat3Mult.o"

# Configuration of the 3-dimensional transpose matrix/transpose matrix multiplication benchmark
TMAT3TMAT3MULT="\$(OBJECT_PATH)/BLAZE_TMat3TMat3Mult.o"
if [ "$BOOST" = "yes" ]; then
   TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/BOOST_TMat3TMat3Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/BLITZ_TMat3TMat3Mult.o"
fi
if [ "$GMM" = "yes" ]; then
   TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/GMM_TMat3TMat3Mult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/ARMADILLO_TMat3TMat3Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/FLENS_TMat3TMat3Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/MTL_TMat3TMat3Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/EIGEN_TMat3TMat3Mult.o"
fi
TMAT3TMAT3MULT="$TMAT3TMAT3MULT \$(OBJECT_PATH)/MAIN_TMat3TMat3Mult.o"

# Configuration of the 6-dimensional matrix/matrix multiplication benchmark
MAT6MAT6MULT="\$(OBJECT_PATH)/BLAZE_Mat6Mat6Mult.o"
if [ "$BOOST" = "yes" ]; then
   MAT6MAT6MULT="$MAT6MAT6MULT \$(OBJECT_PATH)/BOOST_Mat6Mat6Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT6MAT6MULT="$MAT6MAT6MULT \$(OBJECT_PATH)/BLITZ_Mat6Mat6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT6MAT6MULT="$MAT6MAT6MULT \$(OBJECT_PATH)/FLENS_Mat6Mat6Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT6MAT6MULT="$MAT6MAT6MULT \$(OBJECT_PATH)/MTL_Mat6Mat6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT6MAT6MULT="$MAT6MAT6MULT \$(OBJECT_PATH)/EIGEN_Mat6Mat6Mult.o"
fi
MAT6MAT6MULT="$MAT6MAT6MULT \$(OBJECT_PATH)/MAIN_Mat6Mat6Mult.o"

# Configuration of the 6-dimensional matrix/transpose matrix multiplication benchmark
MAT6TMAT6MULT="\$(OBJECT_PATH)/BLAZE_Mat6TMat6Mult.o"
if [ "$BOOST" = "yes" ]; then
   MAT6TMAT6MULT="$MAT6TMAT6MULT \$(OBJECT_PATH)/BOOST_Mat6TMat6Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   MAT6TMAT6MULT="$MAT6TMAT6MULT \$(OBJECT_PATH)/BLITZ_Mat6TMat6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   MAT6TMAT6MULT="$MAT6TMAT6MULT \$(OBJECT_PATH)/FLENS_Mat6TMat6Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   MAT6TMAT6MULT="$MAT6TMAT6MULT \$(OBJECT_PATH)/MTL_Mat6TMat6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   MAT6TMAT6MULT="$MAT6TMAT6MULT \$(OBJECT_PATH)/EIGEN_Mat6TMat6Mult.o"
fi
MAT6TMAT6MULT="$MAT6TMAT6MULT \$(OBJECT_PATH)/MAIN_Mat6TMat6Mult.o"

# Configuration of the 6-dimensional transpose matrix/matrix multiplication benchmark
TMAT6MAT6MULT="\$(OBJECT_PATH)/BLAZE_TMat6Mat6Mult.o"
if [ "$BOOST" = "yes" ]; then
   TMAT6MAT6MULT="$TMAT6MAT6MULT \$(OBJECT_PATH)/BOOST_TMat6Mat6Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TMAT6MAT6MULT="$TMAT6MAT6MULT \$(OBJECT_PATH)/BLITZ_TMat6Mat6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT6MAT6MULT="$TMAT6MAT6MULT \$(OBJECT_PATH)/FLENS_TMat6Mat6Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT6MAT6MULT="$TMAT6MAT6MULT \$(OBJECT_PATH)/MTL_TMat6Mat6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT6MAT6MULT="$TMAT6MAT6MULT \$(OBJECT_PATH)/EIGEN_TMat6Mat6Mult.o"
fi
TMAT6MAT6MULT="$TMAT6MAT6MULT \$(OBJECT_PATH)/MAIN_TMat6Mat6Mult.o"

# Configuration of the 6-dimensional transpose matrix/transpose matrix multiplication benchmark
TMAT6TMAT6MULT="\$(OBJECT_PATH)/BLAZE_TMat6TMat6Mult.o"
if [ "$BOOST" = "yes" ]; then
   TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/BOOST_TMat6TMat6Mult.o"
fi
if [ "$BLITZ" = "yes" ]; then
   TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/BLITZ_TMat6TMat6Mult.o"
fi
if [ "$GMM" = "yes" ]; then
   TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/GMM_TMat6TMat6Mult.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/ARMADILLO_TMat6TMat6Mult.o"
fi
if [ "$FLENS" = "yes" ]; then
   TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/FLENS_TMat6TMat6Mult.o"
fi
if [ "$MTL" = "yes" ]; then
   TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/MTL_TMat6TMat6Mult.o"
fi
if [ "$EIGEN" = "yes" ]; then
   TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/EIGEN_TMat6TMat6Mult.o"
fi
TMAT6TMAT6MULT="$TMAT6TMAT6MULT \$(OBJECT_PATH)/MAIN_TMat6TMat6Mult.o"

# Configuration of the benchmark for the complex expression d = A * ( a + b )
COMPLEX1="\$(OBJECT_PATH)/CLASSIC_Complex1.o \$(OBJECT_PATH)/BLAZE_Complex1.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/BOOST_Complex1.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/BLITZ_Complex1.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/GMM_Complex1.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/ARMADILLO_Complex1.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/FLENS_Complex1.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/MTL_Complex1.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/EIGEN_Complex1.o"
fi
COMPLEX1="$COMPLEX1 \$(OBJECT_PATH)/MAIN_Complex1.o"

# Configuration of the benchmark for the complex expression d = A * ( a + b + c )
COMPLEX2="\$(OBJECT_PATH)/CLASSIC_Complex2.o \$(OBJECT_PATH)/BLAZE_Complex2.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/BOOST_Complex2.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/BLITZ_Complex2.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/GMM_Complex2.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/ARMADILLO_Complex2.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/FLENS_Complex2.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/MTL_Complex2.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/EIGEN_Complex2.o"
fi
COMPLEX2="$COMPLEX2 \$(OBJECT_PATH)/MAIN_Complex2.o"

# Configuration of the benchmark for the complex expression c = A * B * ( a + b )
COMPLEX3="\$(OBJECT_PATH)/CLASSIC_Complex3.o \$(OBJECT_PATH)/BLAZE_Complex3.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/BOOST_Complex3.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/BLITZ_Complex3.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/GMM_Complex3.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/ARMADILLO_Complex3.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/FLENS_Complex3.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/MTL_Complex3.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/EIGEN_Complex3.o"
fi
COMPLEX3="$COMPLEX3 \$(OBJECT_PATH)/MAIN_Complex3.o"

# Configuration of the benchmark for the complex expression b += s * A * a
COMPLEX4="\$(OBJECT_PATH)/CLASSIC_Complex4.o \$(OBJECT_PATH)/BLAZE_Complex4.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/BOOST_Complex4.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/BLITZ_Complex4.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/GMM_Complex4.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/ARMADILLO_Complex4.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/FLENS_Complex4.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/MTL_Complex4.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/EIGEN_Complex4.o"
fi
COMPLEX4="$COMPLEX4 \$(OBJECT_PATH)/MAIN_Complex4.o"

# Configuration of the benchmark for the complex expression D = ( A * B ) + C
COMPLEX5="\$(OBJECT_PATH)/CLASSIC_Complex5.o \$(OBJECT_PATH)/BLAZE_Complex5.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/BOOST_Complex5.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/BLITZ_Complex5.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/GMM_Complex5.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/ARMADILLO_Complex5.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/FLENS_Complex5.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/MTL_Complex5.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/EIGEN_Complex5.o"
fi
COMPLEX5="$COMPLEX5 \$(OBJECT_PATH)/MAIN_Complex5.o"

# Configuration of the benchmark for the complex expression D = A * B * C
COMPLEX6="\$(OBJECT_PATH)/CLASSIC_Complex6.o \$(OBJECT_PATH)/BLAZE_Complex6.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/BOOST_Complex6.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/BLITZ_Complex6.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/GMM_Complex6.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/ARMADILLO_Complex6.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/FLENS_Complex6.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/MTL_Complex6.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/EIGEN_Complex6.o"
fi
COMPLEX6="$COMPLEX6 \$(OBJECT_PATH)/MAIN_Complex6.o"

# Configuration of the benchmark for the complex expression E = ( A + B ) * ( C - D )
COMPLEX7="\$(OBJECT_PATH)/CLASSIC_Complex7.o \$(OBJECT_PATH)/BLAZE_Complex7.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/BOOST_Complex7.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/BLITZ_Complex7.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/GMM_Complex7.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/ARMADILLO_Complex7.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/FLENS_Complex7.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/MTL_Complex7.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/EIGEN_Complex7.o"
fi
COMPLEX7="$COMPLEX7 \$(OBJECT_PATH)/MAIN_Complex7.o"

# Configuration of the benchmark for the complex expression C += s * A * B
COMPLEX8="\$(OBJECT_PATH)/CLASSIC_Complex8.o \$(OBJECT_PATH)/BLAZE_Complex8.o"
if [ "$BOOST" = "yes" ]; then
   COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/BOOST_Complex8.o"
fi
if [ "$BLITZ" = "yes" ]; then
   COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/BLITZ_Complex8.o"
fi
if [ "$GMM" = "yes" ]; then
   COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/GMM_Complex8.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/ARMADILLO_Complex8.o"
fi
if [ "$FLENS" = "yes" ]; then
   COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/FLENS_Complex8.o"
fi
if [ "$MTL" = "yes" ]; then
   COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/MTL_Complex8.o"
fi
if [ "$EIGEN" = "yes" ]; then
   COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/EIGEN_Complex8.o"
fi
COMPLEX8="$COMPLEX8 \$(OBJECT_PATH)/MAIN_Complex8.o"

# Configuration of the conjugate gradient benchmark
CG="\$(OBJECT_PATH)/BLAZE_CG.o"
if [ "$BOOST" = "yes" ]; then
   CG="$CG \$(OBJECT_PATH)/BOOST_CG.o"
fi
if [ "$GMM" = "yes" ]; then
   CG="$CG \$(OBJECT_PATH)/GMM_CG.o"
fi
if [ "$MTL" = "yes" ]; then
   CG="$CG \$(OBJECT_PATH)/MTL_CG.o"
fi
if [ "$EIGEN" = "yes" ]; then
   CG="$CG \$(OBJECT_PATH)/EIGEN_CG.o"
fi
CG="$CG \$(OBJECT_PATH)/MAIN_CG.o"

# Configuration of the benchmark for custom expressions
CUSTOM="\$(OBJECT_PATH)/BLAZE_Custom.o"
if [ "$BOOST" = "yes" ]; then
   CUSTOM="$CUSTOM \$(OBJECT_PATH)/BOOST_Custom.o"
fi
if [ "$BLITZ" = "yes" ]; then
   CUSTOM="$CUSTOM \$(OBJECT_PATH)/BLITZ_Custom.o"
fi
if [ "$GMM" = "yes" ]; then
   CUSTOM="$CUSTOM \$(OBJECT_PATH)/GMM_Custom.o"
fi
if [ "$ARMADILLO" = "yes" ]; then
   CUSTOM="$CUSTOM \$(OBJECT_PATH)/ARMADILLO_Custom.o"
fi
if [ "$MTL" = "yes" ]; then
   CUSTOM="$CUSTOM \$(OBJECT_PATH)/MTL_Custom.o"
fi
if [ "$EIGEN" = "yes" ]; then
   CUSTOM="$CUSTOM \$(OBJECT_PATH)/EIGEN_Custom.o"
fi
CUSTOM="$CUSTOM \$(OBJECT_PATH)/MAIN_Custom.o"

# Writing the Makefile
cat > Makefile <<EOF
#==================================================================================================
#
#  Makefile for the Blaze benchmark suite
#
#  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
#
#  This file is part of the Blaze library. You can redistribute it and/or modify it under
#  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
#  forms, with or without modification, are permitted provided that the following conditions
#  are met:
#
#  1. Redistributions of source code must retain the above copyright notice, this list of
#     conditions and the following disclaimer.
#  2. Redistributions in binary form must reproduce the above copyright notice, this list
#     of conditions and the following disclaimer in the documentation and/or other materials
#     provided with the distribution.
#  3. Neither the names of the Blaze development group nor the names of its contributors
#     may be used to endorse or promote products derived from this software without specific
#     prior written permission.
#
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
#  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
#  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
#  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
#  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
#  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
#  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
#  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
#  DAMAGE.
#
#==================================================================================================


# Compiler configuration
export CXX      = $CXX
export CXXFLAGS = $CXXFLAGS

# Exporting the installation path, object path and binary path
export INSTALL_PATH = $INSTALL_PATH
export OBJECT_PATH  = \$(INSTALL_PATH)/obj
export BINARY_PATH  = \$(INSTALL_PATH)/bin

# Exporting the Blaze include path
export BLAZE_INCLUDE_PATH = $BLAZE_PATH
EOF

if [ -n "$BOOST_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the Boost include path
export BOOST_INCLUDE_PATH = $BOOST_INCLUDE_PATH
EOF
fi

if [ -n "$BLAS_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the BLAS include path
export BLAS_INCLUDE_PATH = $BLAS_INCLUDE_PATH
EOF
fi

if [ -n "$BLITZ_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the Blitz++ include path
export BLITZ_INCLUDE_PATH = $BLITZ_INCLUDE_PATH
EOF
fi

if [ -n "$GMM_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the GMM++ include path
export GMM_INCLUDE_PATH = $GMM_INCLUDE_PATH
EOF
fi

if [ -n "$ARMADILLO_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the Armadillo include path
export ARMADILLO_INCLUDE_PATH = $ARMADILLO_INCLUDE_PATH
EOF
fi

if [ -n "$FLENS_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the FLENS include path
export FLENS_INCLUDE_PATH = $FLENS_INCLUDE_PATH
EOF
fi

if [ -n "$MTL_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the MTL include path
export MTL_INCLUDE_PATH = $MTL_INCLUDE_PATH
EOF
fi

if [ -n "$EIGEN_INCLUDE_PATH" ]; then
cat >> Makefile <<EOF

# Exporting the Eigen include path
export EIGEN_INCLUDE_PATH = $EIGEN_INCLUDE_PATH
EOF
fi

cat >> Makefile <<EOF

# Includes
INCLUDES = $INCLUDES

# Libraries
LIBRARIES = $LIBRARIES


# Build rules
default: binaries

clike:
	@echo
	@echo "Building the C-like kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/clike
	@echo "... finished!"
	@echo

classic:
	@echo "Building the classic kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/classic
	@echo "... finished!"
	@echo
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF

blas:
	@echo "Building the BLAS kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/blas
	@echo "... finished!"
	@echo
EOF
fi

cat >> Makefile <<EOF

blaze:
	@echo "Building the Blaze kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/blaze
	@echo "... finished!"
	@echo
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF

boost:
	@echo "Building the Boost uBLAS kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/boost
	@echo "... finished!"
	@echo
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF

blitz:
	@echo "Building the Blitz++ kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/blitz
	@echo "... finished!"
	@echo
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF

gmm:
	@echo "Building the GMM++ kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/gmm
	@echo "... finished!"
	@echo
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF

armadillo:
	@echo "Building the Armadillo kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/armadillo
	@echo "... finished!"
	@echo
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF

flens:
	@echo "Building the FLENS kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/flens
	@echo "... finished!"
	@echo
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF

mtl:
	@echo "Building the MTL kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/mtl
	@echo "... finished!"
	@echo
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF

eigen:
	@echo "Building the Eigen kernels..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/eigen
	@echo "... finished!"
	@echo
EOF
fi

cat >> Makefile <<EOF

main:
	@echo "Building the benchmarks..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/main
	@echo "... finished!"
	@echo

binaries: $MODULES
	@echo "Building the binaries..."
	@echo "  Building the memory sweep binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/memorysweep \$(INSTALL_PATH)/src/main/MemorySweep.cpp
	@echo "  Building dense vector/dense vector addition (dvecdvecadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecdvecadd $DVECDVECADD \$(LIBRARIES)
	@echo "  Building dense vector/sparse vector addition (dvecsvecadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecsvecadd $DVECSVECADD \$(LIBRARIES)
	@echo "  Building sparse vector/dense vector addition (svecdvecadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecdvecadd $SVECDVECADD \$(LIBRARIES)
	@echo "  Building sparse vector/sparse vector addition (svecsvecadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecsvecadd $SVECSVECADD \$(LIBRARIES)
	@echo "  Building dense vector/dense vector subtraction (dvecdvecsub) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecdvecsub $DVECDVECSUB \$(LIBRARIES)
	@echo "  Building dense vector/scalar multiplication (dvecscalarmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecscalarmult $DVECSCALARMULT \$(LIBRARIES)
	@echo "  Building sparse vector/scalar multiplication (svecscalarmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecscalarmult $SVECSCALARMULT \$(LIBRARIES)
	@echo "  Building dense vector/dense vector multiplication (dvecdvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecdvecmult $DVECDVECMULT \$(LIBRARIES)
	@echo "  Building dense vector/sparse vector multiplication (dvecsvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecsvecmult $DVECSVECMULT \$(LIBRARIES)
	@echo "  Building sparse vector/dense vector multiplication (svecdvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecdvecmult $SVECDVECMULT \$(LIBRARIES)
	@echo "  Building sparse vector/sparse vector multiplication (svecsvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecsvecmult $SVECSVECMULT \$(LIBRARIES)
	@echo "  Building daxpy product (daxpy) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/daxpy $DAXPY \$(LIBRARIES)
	@echo "  Building dense vector/dense vector cross product (dvecdveccross) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecdveccross $DVECDVECCROSS \$(LIBRARIES)
	@echo "  Building dense vector/sparse vector cross product (dvecsveccross) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecsveccross $DVECSVECCROSS \$(LIBRARIES)
	@echo "  Building sparse vector/dense vector cross product (svecdveccross) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecdveccross $SVECDVECCROSS \$(LIBRARIES)
	@echo "  Building sparse vector/sparse vector cross product (svecsveccross) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecsveccross $SVECSVECCROSS \$(LIBRARIES)
	@echo "  Building dense vector norm (dvecnorm) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecnorm $DVECNORM \$(LIBRARIES)
	@echo "  Building dense vector/dense vector inner product (dvecdvecinner) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecdvecinner $DVECDVECINNER \$(LIBRARIES)
	@echo "  Building dense vector/sparse vector inner product (dvecsvecinner) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecsvecinner $DVECSVECINNER \$(LIBRARIES)
	@echo "  Building sparse vector/dense vector inner product (svecdvecinner) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecdvecinner $SVECDVECINNER \$(LIBRARIES)
	@echo "  Building sparse vector/sparse vector inner product (svecsvecinner) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecsvecinner $SVECSVECINNER \$(LIBRARIES)
	@echo "  Building dense vector/dense vector outer product (dvecdvecouter) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecdvecouter $DVECDVECOUTER \$(LIBRARIES)
	@echo "  Building dense vector/sparse vector outer product (dvecsvecouter) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dvecsvecouter $DVECSVECOUTER \$(LIBRARIES)
	@echo "  Building sparse vector/dense vector outer product (svecdvecouter) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecdvecouter $SVECDVECOUTER \$(LIBRARIES)
	@echo "  Building sparse vector/sparse vector outer product (svecsvecouter) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/svecsvecouter $SVECSVECOUTER \$(LIBRARIES)
	@echo "  Building dense matrix/dense vector multiplication (dmatdvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatdvecmult $DMATDVECMULT \$(LIBRARIES)
	@echo "  Building transpose dense matrix/dense vector multiplication (tdmatdvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmatdvecmult $TDMATDVECMULT \$(LIBRARIES)
	@echo "  Building dense matrix/sparse vector multiplication (dmatsvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatsvecmult $DMATSVECMULT \$(LIBRARIES)
	@echo "  Building transpose dense matrix/sparse vector multiplication (tdmatsvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmatsvecmult $TDMATSVECMULT \$(LIBRARIES)
	@echo "  Building sparse matrix/dense vector multiplication (smatdvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smatdvecmult $SMATDVECMULT \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/dense vector multiplication (tsmatdvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmatdvecmult $TSMATDVECMULT \$(LIBRARIES)
	@echo "  Building sparse matrix/sparse vector multiplication (smatsvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smatsvecmult $SMATSVECMULT \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/sparse vector multiplication (tsmatsvecmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmatsvecmult $TSMATSVECMULT \$(LIBRARIES)
	@echo "  Building transpose dense vector/dense matrix multiplication (tdvecdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdvecdmatmult $TDVECDMATMULT \$(LIBRARIES)
	@echo "  Building transpose dense vector/transpose dense matrix multiplication (tdvectdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdvectdmatmult $TDVECTDMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse vector/dense matrix multiplication (tsvecdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsvecdmatmult $TSVECDMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse vector/transpose dense matrix multiplication (tsvectdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsvectdmatmult $TSVECTDMATMULT \$(LIBRARIES)
	@echo "  Building transpose dense vector/sparse matrix multiplication (tdvecsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdvecsmatmult $TDVECSMATMULT \$(LIBRARIES)
	@echo "  Building transpose dense vector/transpose sparse matrix multiplication (tdvectsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdvectsmatmult $TDVECTSMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse vector/sparse matrix multiplication (tsvecsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsvecsmatmult $TSVECSMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse vector/transpose sparse matrix multiplication (tsvectsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsvectsmatmult $TSVECTSMATMULT \$(LIBRARIES)
	@echo "  Building dense matrix transpose (dmattrans) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmattrans $DMATTRANS \$(LIBRARIES)
	@echo "  Building sparse matrix transpose (smattrans) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smattrans $SMATTRANS \$(LIBRARIES)
	@echo "  Building dense matrix inversion (dmatinv) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatinv $DMATINV \$(LIBRARIES)
	@echo "  Building dense matrix/dense matrix addition (dmatdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatdmatadd $DMATDMATADD \$(LIBRARIES)
	@echo "  Building dense matrix/transpose dense matrix addition (dmattdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmattdmatadd $DMATTDMATADD \$(LIBRARIES)
	@echo "  Building transpose dense matrix/dense matrix addition (tdmatdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmatdmatadd $TDMATDMATADD \$(LIBRARIES)
	@echo "  Building transpose dense matrix/transpose dense matrix addition (tdmattdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmattdmatadd $TDMATTDMATADD \$(LIBRARIES)
	@echo "  Building dense matrix/sparse matrix addition (dmatsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatsmatadd $DMATSMATADD \$(LIBRARIES)
	@echo "  Building dense matrix/transpose sparse matrix addition (dmattsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmattsmatadd $DMATTSMATADD \$(LIBRARIES)
	@echo "  Building transpose dense matrix/sparse matrix addition (tdmatsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmatsmatadd $TDMATSMATADD \$(LIBRARIES)
	@echo "  Building transpose dense matrix/transpose sparse matrix addition (tdmattsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmattsmatadd $TDMATTSMATADD \$(LIBRARIES)
	@echo "  Building sparse matrix/dense matrix addition (smatdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smatdmatadd $SMATDMATADD \$(LIBRARIES)
	@echo "  Building sparse matrix/transpose dense matrix addition (smattdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smattdmatadd $SMATTDMATADD \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/dense matrix addition (tsmatdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmatdmatadd $TSMATDMATADD \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/transpose dense matrix addition (tsmatdmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmattdmatadd $TSMATTDMATADD \$(LIBRARIES)
	@echo "  Building sparse matrix/sparse matrix addition (smatsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smatsmatadd $SMATSMATADD \$(LIBRARIES)
	@echo "  Building sparse matrix/transpose sparse matrix addition (smattsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smattsmatadd $SMATTSMATADD \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/sparse matrix addition (tsmatsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmatsmatadd $TSMATSMATADD \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/transpose sparse matrix addition (tsmattsmatadd) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmattsmatadd $TSMATTSMATADD \$(LIBRARIES)
	@echo "  Building dense matrix/dense matrix subtraction (dmatdmatsub) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatdmatsub $DMATDMATSUB \$(LIBRARIES)
	@echo "  Building dense matrix/scalar multiplication (dmatscalarmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatscalarmult $DMATSCALARMULT \$(LIBRARIES)
	@echo "  Building sparse matrix/scalar multiplication (smatscalarmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smatscalarmult $SMATSCALARMULT \$(LIBRARIES)
	@echo "  Building dense matrix/dense matrix multiplication (dmatdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatdmatmult $DMATDMATMULT \$(LIBRARIES)
	@echo "  Building dense matrix/transpose dense matrix multiplication (dmattdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmattdmatmult $DMATTDMATMULT \$(LIBRARIES)
	@echo "  Building transpose dense matrix/dense matrix multiplication (tdmatdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmatdmatmult $TDMATDMATMULT \$(LIBRARIES)
	@echo "  Building transpose dense matrix/transpose dense matrix multiplication (tdmattdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmattdmatmult $TDMATTDMATMULT \$(LIBRARIES)
	@echo "  Building dense matrix/sparse matrix multiplication (dmatsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmatsmatmult $DMATSMATMULT \$(LIBRARIES)
	@echo "  Building dense matrix/transpose sparse matrix multiplication (dmattsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/dmattsmatmult $DMATTSMATMULT \$(LIBRARIES)
	@echo "  Building transpose dense matrix/sparse matrix multiplication (tdmatsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmatsmatmult $TDMATSMATMULT \$(LIBRARIES)
	@echo "  Building transpose dense matrix/transpose sparse matrix multiplication (tdmattsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tdmattsmatmult $TDMATTSMATMULT \$(LIBRARIES)
	@echo "  Building sparse matrix/dense matrix multiplication (smatdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smatdmatmult $SMATDMATMULT \$(LIBRARIES)
	@echo "  Building sparse matrix/transpose dense matrix multiplication (smattdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smattdmatmult $SMATTDMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/dense matrix multiplication (tsmatdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmatdmatmult $TSMATDMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/transpose dense matrix multiplication (tsmattdmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmattdmatmult $TSMATTDMATMULT \$(LIBRARIES)
	@echo "  Building sparse matrix/sparse matrix multiplication (smatsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smatsmatmult $SMATSMATMULT \$(LIBRARIES)
	@echo "  Building sparse matrix/transpose sparse matrix multiplication (smattsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/smattsmatmult $SMATTSMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/sparse matrix multiplication (tsmatsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmatsmatmult $TSMATSMATMULT \$(LIBRARIES)
	@echo "  Building transpose sparse matrix/transpose sparse matrix multiplication (tsmattsmatmult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tsmattsmatmult $TSMATTSMATMULT \$(LIBRARIES)
	@echo "  Building 3-dimensional vector/vector addition (vec3vec3add) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/vec3vec3add $VEC3VEC3ADD \$(LIBRARIES)
	@echo "  Building 6-dimensional vector/vector addition (vec6vec6add) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/vec6vec6add $VEC6VEC6ADD \$(LIBRARIES)
	@echo "  Building 3-dimensional matrix/vector multiplication (mat3vec3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat3vec3mult $MAT3VEC3MULT \$(LIBRARIES)
	@echo "  Building 3-dimensional transpose matrix/vector multiplication (tmat3vec3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat3vec3mult $TMAT3VEC3MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional matrix/vector multiplication (mat6vec6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat6vec6mult $MAT6VEC6MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional transpose matrix/vector multiplication (tmat6vec6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat6vec6mult $TMAT6VEC6MULT \$(LIBRARIES)
	@echo "  Building 3-dimensional transpose vector/matrix multiplication (tvec3mat3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tvec3mat3mult $TVEC3MAT3MULT \$(LIBRARIES)
	@echo "  Building 3-dimensional transpose vector/transpose matrix multiplication (tvec3tmat3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tvec3tmat3mult $TVEC3TMAT3MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional transpose vector/matrix multiplication (tvec6mat6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tvec6mat6mult $TVEC6MAT6MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional transpose vector/transpose matrix multiplication (tvec6tmat6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tvec6tmat6mult $TVEC6TMAT6MULT \$(LIBRARIES)
	@echo "  Building 3-dimensional matrix/matrix addition (mat3mat3add) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat3mat3add $MAT3MAT3ADD \$(LIBRARIES)
	@echo "  Building 3-dimensional transpose matrix/transpose matrix addition (tmat3tmat3add) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat3tmat3add $TMAT3TMAT3ADD \$(LIBRARIES)
	@echo "  Building 6-dimensional matrix/matrix addition (mat6mat6add) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat6mat6add $MAT6MAT6ADD \$(LIBRARIES)
	@echo "  Building 6-dimensional transpose matrix/transpose matrix addition (tmat6tmat6add) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat6tmat6add $TMAT6TMAT6ADD \$(LIBRARIES)
	@echo "  Building 3-dimensional matrix/matrix multiplication (mat3mat3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat3mat3mult $MAT3MAT3MULT \$(LIBRARIES)
	@echo "  Building 3-dimensional matrix/transpose matrix multiplication (mat3tmat3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat3tmat3mult $MAT3TMAT3MULT \$(LIBRARIES)
	@echo "  Building 3-dimensional transpose matrix/matrix multiplication (tmat3mat3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat3mat3mult $TMAT3MAT3MULT \$(LIBRARIES)
	@echo "  Building 3-dimensional transpose matrix/transpose matrix multiplication (tmat3tmat3mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat3tmat3mult $TMAT3TMAT3MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional matrix/matrix multiplication (mat6mat6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat6mat6mult $MAT6MAT6MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional matrix/transpose matrix multiplication (mat6tmat6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/mat6tmat6mult $MAT6TMAT6MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional transpose matrix/matrix multiplication (tmat6mat6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat6mat6mult $TMAT6MAT6MULT \$(LIBRARIES)
	@echo "  Building 6-dimensional transpose matrix/transpose matrix multiplication (tmat6tmat6mult) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/tmat6tmat6mult $TMAT6TMAT6MULT \$(LIBRARIES)
	@echo "  Building complex expression ( c = A * ( a + b ) ) (complex1) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex1 $COMPLEX1 \$(LIBRARIES)
	@echo "  Building complex expression ( d = A * ( a + b + c ) ) (complex2) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex2 $COMPLEX2 \$(LIBRARIES)
	@echo "  Building complex expression ( c = A * B * ( a + b ) ) (complex3) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex3 $COMPLEX3 \$(LIBRARIES)
	@echo "  Building complex expression ( b += s * A * a ) (complex4) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex4 $COMPLEX4 \$(LIBRARIES)
	@echo "  Building complex expression ( D = ( A * B ) + C ) (complex5) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex5 $COMPLEX5 \$(LIBRARIES)
	@echo "  Building complex expression ( D = A * B * C ) (complex6) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex6 $COMPLEX6 \$(LIBRARIES)
	@echo "  Building complex expression ( E = ( A + B ) * ( C - D ) ) (complex7) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex7 $COMPLEX7 \$(LIBRARIES)
	@echo "  Building complex expression ( C += s * A * B ) (complex8) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/complex8 $COMPLEX8 \$(LIBRARIES)
	@echo "  Building conjugate gradient (cg) binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/cg $CG \$(LIBRARIES)
	@echo

memorysweep:
	@echo
	@echo "Building the memory sweep binary..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(INSTALL_PATH)/bin/memorysweep \$(INSTALL_PATH)/src/main/MemorySweep.cpp
	@echo "... finished"
	@echo
EOF


# Dense vector/dense vector addition
cat >> Makefile <<EOF

dvecdvecadd: \$(BINARY_PATH)/dvecdvecadd
\$(BINARY_PATH)/dvecdvecadd: $DVECDVECADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecdvecadd $DVECDVECADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_DVecDVecAdd.o:
	@echo
	@echo "Building dense vector/dense vector addition (dvecdvecadd) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_DVecDVecAdd.o \$(INSTALL_PATH)/src/clike/DVecDVecAdd.cpp \$(INCLUDES)
\$(OBJECT_PATH)/CLASSIC_DVecDVecAdd.o:
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DVecDVecAdd.o \$(INSTALL_PATH)/src/classic/DVecDVecAdd.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecDVecAdd.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecDVecAdd.o \$(INSTALL_PATH)/src/blaze/DVecDVecAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecDVecAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecDVecAdd.o \$(INSTALL_PATH)/src/boost/DVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DVecDVecAdd.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DVecDVecAdd.o \$(INSTALL_PATH)/src/blitz/DVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DVecDVecAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DVecDVecAdd.o \$(INSTALL_PATH)/src/gmm/DVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DVecDVecAdd.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DVecDVecAdd.o \$(INSTALL_PATH)/src/armadillo/DVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DVecDVecAdd.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DVecDVecAdd.o \$(INSTALL_PATH)/src/flens/DVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DVecDVecAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DVecDVecAdd.o \$(INSTALL_PATH)/src/mtl/DVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecDVecAdd.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecDVecAdd.o \$(INSTALL_PATH)/src/eigen/DVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecDVecAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecDVecAdd.o \$(INSTALL_PATH)/src/main/DVecDVecAdd.cpp \$(INCLUDES)
EOF


# Dense vector/sparse vector addition
cat >> Makefile <<EOF

dvecsvecadd: \$(BINARY_PATH)/dvecsvecadd
\$(BINARY_PATH)/dvecsvecadd: $DVECSVECADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecsvecadd $DVECSVECADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DVecSVecAdd.o:
	@echo
	@echo "Building dense vector/sparse vector addition (dvecsvecadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecSVecAdd.o \$(INSTALL_PATH)/src/blaze/DVecSVecAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecSVecAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecSVecAdd.o \$(INSTALL_PATH)/src/boost/DVecSVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DVecSVecAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DVecSVecAdd.o \$(INSTALL_PATH)/src/gmm/DVecSVecAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecSVecAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecSVecAdd.o \$(INSTALL_PATH)/src/main/DVecSVecAdd.cpp \$(INCLUDES)
EOF


# Sparse vector/dense vector addition
cat >> Makefile <<EOF

svecdvecadd: \$(BINARY_PATH)/svecdvecadd
\$(BINARY_PATH)/svecdvecadd: $SVECDVECADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecdvecadd $SVECDVECADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecDVecAdd.o:
	@echo
	@echo "Building sparse vector/dense vector addition (svecdvecadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecDVecAdd.o \$(INSTALL_PATH)/src/blaze/SVecDVecAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecDVecAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecDVecAdd.o \$(INSTALL_PATH)/src/boost/SVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SVecDVecAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SVecDVecAdd.o \$(INSTALL_PATH)/src/gmm/SVecDVecAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecDVecAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecDVecAdd.o \$(INSTALL_PATH)/src/main/SVecDVecAdd.cpp \$(INCLUDES)
EOF


# Sparse vector/sparse vector addition
cat >> Makefile <<EOF

svecsvecadd: \$(BINARY_PATH)/svecsvecadd
\$(BINARY_PATH)/svecsvecadd: $SVECSVECADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecsvecadd $SVECSVECADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecSVecAdd.o:
	@echo
	@echo "Building sparse vector/sparse vector addition (svecsvecadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecSVecAdd.o \$(INSTALL_PATH)/src/blaze/SVecSVecAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecSVecAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecSVecAdd.o \$(INSTALL_PATH)/src/boost/SVecSVecAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SVecSVecAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SVecSVecAdd.o \$(INSTALL_PATH)/src/gmm/SVecSVecAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecSVecAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecSVecAdd.o \$(INSTALL_PATH)/src/main/SVecSVecAdd.cpp \$(INCLUDES)
EOF


# Dense vector/dense vector subtraction
cat >> Makefile <<EOF

dvecdvecsub: \$(BINARY_PATH)/dvecdvecsub
\$(BINARY_PATH)/dvecdvecsub: $DVECDVECSUB
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecdvecsub $DVECDVECSUB \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_DVecDVecSub.o:
	@echo
	@echo "Building dense vector/dense vector subtraction (dvecdvecsub) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_DVecDVecSub.o \$(INSTALL_PATH)/src/clike/DVecDVecSub.cpp \$(INCLUDES)
\$(OBJECT_PATH)/CLASSIC_DVecDVecSub.o:
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DVecDVecSub.o \$(INSTALL_PATH)/src/classic/DVecDVecSub.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecDVecSub.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecDVecSub.o \$(INSTALL_PATH)/src/blaze/DVecDVecSub.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecDVecSub.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecDVecSub.o \$(INSTALL_PATH)/src/boost/DVecDVecSub.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DVecDVecSub.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DVecDVecSub.o \$(INSTALL_PATH)/src/blitz/DVecDVecSub.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DVecDVecSub.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DVecDVecSub.o \$(INSTALL_PATH)/src/gmm/DVecDVecSub.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DVecDVecSub.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DVecDVecSub.o \$(INSTALL_PATH)/src/armadillo/DVecDVecSub.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DVecDVecSub.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DVecDVecSub.o \$(INSTALL_PATH)/src/flens/DVecDVecSub.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DVecDVecSub.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DVecDVecSub.o \$(INSTALL_PATH)/src/mtl/DVecDVecSub.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecDVecSub.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecDVecSub.o \$(INSTALL_PATH)/src/eigen/DVecDVecSub.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecDVecSub.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecDVecSub.o \$(INSTALL_PATH)/src/main/DVecDVecSub.cpp \$(INCLUDES)
EOF


# Dense vector/scalar multiplication
cat >> Makefile <<EOF

dvecscalarmult: \$(BINARY_PATH)/dvecscalarmult
\$(BINARY_PATH)/dvecscalarmult: $DVECSCALARMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecscalarmult $DVECSCALARMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DVecScalarMult.o:
	@echo
	@echo "Building dense vector/scalar multiplication (dvecscalarmult) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DVecScalarMult.o \$(INSTALL_PATH)/src/classic/DVecScalarMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecScalarMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecScalarMult.o \$(INSTALL_PATH)/src/blaze/DVecScalarMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecScalarMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecScalarMult.o \$(INSTALL_PATH)/src/boost/DVecScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DVecScalarMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DVecScalarMult.o \$(INSTALL_PATH)/src/blitz/DVecScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DVecScalarMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DVecScalarMult.o \$(INSTALL_PATH)/src/gmm/DVecScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DVecScalarMult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DVecScalarMult.o \$(INSTALL_PATH)/src/armadillo/DVecScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DVecScalarMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DVecScalarMult.o \$(INSTALL_PATH)/src/flens/DVecScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DVecScalarMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DVecScalarMult.o \$(INSTALL_PATH)/src/mtl/DVecScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecScalarMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecScalarMult.o \$(INSTALL_PATH)/src/eigen/DVecScalarMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecScalarMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecScalarMult.o \$(INSTALL_PATH)/src/main/DVecScalarMult.cpp \$(INCLUDES)
EOF


# Sparse vector/scalar multiplication
cat >> Makefile <<EOF

svecscalarmult: \$(BINARY_PATH)/svecscalarmult
\$(BINARY_PATH)/svecscalarmult: $SVECSCALARMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecscalarmult $SVECSCALARMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecScalarMult.o:
	@echo
	@echo "Building sparse vector/scalar multiplication (svecscalarmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecScalarMult.o \$(INSTALL_PATH)/src/blaze/SVecScalarMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecScalarMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecScalarMult.o \$(INSTALL_PATH)/src/boost/SVecScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SVecScalarMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SVecScalarMult.o \$(INSTALL_PATH)/src/gmm/SVecScalarMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecScalarMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecScalarMult.o \$(INSTALL_PATH)/src/main/SVecScalarMult.cpp \$(INCLUDES)
EOF


# Dense vector/dense vector multiplication
cat >> Makefile <<EOF

dvecdvecmult: \$(BINARY_PATH)/dvecdvecmult
\$(BINARY_PATH)/dvecdvecmult: $DVECDVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecdvecmult $DVECDVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_DVecDVecMult.o:
	@echo
	@echo "Building dense vector/dense vector multiplication (dvecdvecmult) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_DVecDVecMult.o \$(INSTALL_PATH)/src/clike/DVecDVecMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/CLASSIC_DVecDVecMult.o:
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DVecDVecMult.o \$(INSTALL_PATH)/src/classic/DVecDVecMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecDVecMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecDVecMult.o \$(INSTALL_PATH)/src/blaze/DVecDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecDVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecDVecMult.o \$(INSTALL_PATH)/src/boost/DVecDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DVecDVecMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DVecDVecMult.o \$(INSTALL_PATH)/src/blitz/DVecDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DVecDVecMult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DVecDVecMult.o \$(INSTALL_PATH)/src/armadillo/DVecDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecDVecMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecDVecMult.o \$(INSTALL_PATH)/src/eigen/DVecDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecDVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecDVecMult.o \$(INSTALL_PATH)/src/main/DVecDVecMult.cpp \$(INCLUDES)
EOF


# Dense vector/sparse vector multiplication
cat >> Makefile <<EOF

dvecsvecmult: \$(BINARY_PATH)/dvecsvecmult
\$(BINARY_PATH)/dvecsvecmult: $DVECSVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecsvecmult $DVECSVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DVecSVecMult.o:
	@echo
	@echo "Building dense vector/sparse vector multiplication (dvecsvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecSVecMult.o \$(INSTALL_PATH)/src/blaze/DVecSVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecSVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecSVecMult.o \$(INSTALL_PATH)/src/boost/DVecSVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecSVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecSVecMult.o \$(INSTALL_PATH)/src/main/DVecSVecMult.cpp \$(INCLUDES)
EOF


# Sparse vector/dense vector multiplication
cat >> Makefile <<EOF

svecdvecmult: \$(BINARY_PATH)/svecdvecmult
\$(BINARY_PATH)/svecdvecmult: $SVECDVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecdvecmult $SVECDVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecDVecMult.o:
	@echo
	@echo "Building sparse vector/dense vector multiplication (svecdvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecDVecMult.o \$(INSTALL_PATH)/src/blaze/SVecDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecDVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecDVecMult.o \$(INSTALL_PATH)/src/boost/SVecDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecDVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecDVecMult.o \$(INSTALL_PATH)/src/main/SVecDVecMult.cpp \$(INCLUDES)
EOF


# Sparse vector/sparse vector multiplication
cat >> Makefile <<EOF

svecsvecmult: \$(BINARY_PATH)/svecsvecmult
\$(BINARY_PATH)/svecsvecmult: $SVECSVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecsvecmult $SVECSVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecSVecMult.o:
	@echo
	@echo "Building sparse vector/sparse vector multiplication (svecsvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecSVecMult.o \$(INSTALL_PATH)/src/blaze/SVecSVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecSVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecSVecMult.o \$(INSTALL_PATH)/src/boost/SVecSVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecSVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecSVecMult.o \$(INSTALL_PATH)/src/main/SVecSVecMult.cpp \$(INCLUDES)
EOF


# Daxpy product
cat >> Makefile <<EOF

daxpy: \$(BINARY_PATH)/daxpy
\$(BINARY_PATH)/daxpy: $DAXPY
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/daxpy $DAXPY \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_Daxpy.o:
	@echo
	@echo "Building daxpy product (daxpy) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_Daxpy.o \$(INSTALL_PATH)/src/clike/Daxpy.cpp \$(INCLUDES)
\$(OBJECT_PATH)/CLASSIC_Daxpy.o:
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Daxpy.o \$(INSTALL_PATH)/src/classic/Daxpy.cpp \$(INCLUDES)
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_Daxpy.o:
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_Daxpy.o \$(INSTALL_PATH)/src/blas/Daxpy.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_Daxpy.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Daxpy.o \$(INSTALL_PATH)/src/blaze/Daxpy.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Daxpy.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Daxpy.o \$(INSTALL_PATH)/src/boost/Daxpy.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Daxpy.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Daxpy.o \$(INSTALL_PATH)/src/blitz/Daxpy.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Daxpy.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Daxpy.o \$(INSTALL_PATH)/src/gmm/Daxpy.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Daxpy.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Daxpy.o \$(INSTALL_PATH)/src/armadillo/Daxpy.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Daxpy.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Daxpy.o \$(INSTALL_PATH)/src/flens/Daxpy.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Daxpy.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Daxpy.o \$(INSTALL_PATH)/src/mtl/Daxpy.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Daxpy.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Daxpy.o \$(INSTALL_PATH)/src/eigen/Daxpy.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Daxpy.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Daxpy.o \$(INSTALL_PATH)/src/main/Daxpy.cpp \$(INCLUDES)
EOF


# Dense vector/dense vector cross product
cat >> Makefile <<EOF

dvecdveccross: \$(BINARY_PATH)/dvecdveccross
\$(BINARY_PATH)/dvecdveccross: $DVECDVECCROSS
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecdveccross $DVECDVECCROSS \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_DVecDVecCross.o:
	@echo
	@echo "Building dense vector/dense vector cross product (dvecdveccross) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_DVecDVecCross.o \$(INSTALL_PATH)/src/clike/DVecDVecCross.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecDVecCross.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecDVecCross.o \$(INSTALL_PATH)/src/blaze/DVecDVecCross.cpp \$(INCLUDES)
EOF

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DVecDVecCross.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DVecDVecCross.o \$(INSTALL_PATH)/src/armadillo/DVecDVecCross.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecDVecCross.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecDVecCross.o \$(INSTALL_PATH)/src/eigen/DVecDVecCross.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecDVecCross.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecDVecCross.o \$(INSTALL_PATH)/src/main/DVecDVecCross.cpp \$(INCLUDES)
EOF


# Dense vector/sparse vector cross product
cat >> Makefile <<EOF

dvecsveccross: \$(BINARY_PATH)/dvecsveccross
\$(BINARY_PATH)/dvecsveccross: $DVECSVECCROSS
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecsveccross $DVECSVECCROSS \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DVecSVecCross.o:
	@echo
	@echo "Building dense vector/sparse vector cross product (dvecsveccross) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecSVecCross.o \$(INSTALL_PATH)/src/blaze/DVecSVecCross.cpp \$(INCLUDES)
\$(OBJECT_PATH)/MAIN_DVecSVecCross.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecSVecCross.o \$(INSTALL_PATH)/src/main/DVecSVecCross.cpp \$(INCLUDES)
EOF


# Sparse vector/dense vector cross product
cat >> Makefile <<EOF

svecdveccross: \$(BINARY_PATH)/svecdveccross
\$(BINARY_PATH)/svecdveccross: $SVECDVECCROSS
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecdveccross $SVECDVECCROSS \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecDVecCross.o:
	@echo
	@echo "Building sparse vector/dense vector cross product (svecdveccross) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecDVecCross.o \$(INSTALL_PATH)/src/blaze/SVecDVecCross.cpp \$(INCLUDES)
\$(OBJECT_PATH)/MAIN_SVecDVecCross.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecDVecCross.o \$(INSTALL_PATH)/src/main/SVecDVecCross.cpp \$(INCLUDES)
EOF


# Sparse vector/sparse vector cross product
cat >> Makefile <<EOF

svecsveccross: \$(BINARY_PATH)/svecsveccross
\$(BINARY_PATH)/svecsveccross: $SVECSVECCROSS
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecsveccross $SVECSVECCROSS \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecSVecCross.o:
	@echo
	@echo "Building sparse vector/dense vector cross product (svecsveccross) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecSVecCross.o \$(INSTALL_PATH)/src/blaze/SVecSVecCross.cpp \$(INCLUDES)
\$(OBJECT_PATH)/MAIN_SVecSVecCross.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecSVecCross.o \$(INSTALL_PATH)/src/main/SVecSVecCross.cpp \$(INCLUDES)
EOF


# Dense vector norm
cat >> Makefile <<EOF

dvecnorm: \$(BINARY_PATH)/dvecnorm
\$(BINARY_PATH)/dvecnorm: $DVECNORM
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecnorm $DVECNORM \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DVecNorm.o:
	@echo
	@echo "Building dense vector norm (dvecnorm) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DVecNorm.o \$(INSTALL_PATH)/src/classic/DVecNorm.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecNorm.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecNorm.o \$(INSTALL_PATH)/src/blaze/DVecNorm.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecNorm.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecNorm.o \$(INSTALL_PATH)/src/boost/DVecNorm.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DVecNorm.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DVecNorm.o \$(INSTALL_PATH)/src/blitz/DVecNorm.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DVecNorm.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DVecNorm.o \$(INSTALL_PATH)/src/gmm/DVecNorm.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DVecNorm.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DVecNorm.o \$(INSTALL_PATH)/src/armadillo/DVecNorm.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DVecNorm.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DVecNorm.o \$(INSTALL_PATH)/src/flens/DVecNorm.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DVecNorm.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DVecNorm.o \$(INSTALL_PATH)/src/mtl/DVecNorm.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecNorm.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecNorm.o \$(INSTALL_PATH)/src/eigen/DVecNorm.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecNorm.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecNorm.o \$(INSTALL_PATH)/src/main/DVecNorm.cpp \$(INCLUDES)
EOF


# Dense vector/dense vector inner product
cat >> Makefile <<EOF

dvecdvecinner: \$(BINARY_PATH)/dvecdvecinner
\$(BINARY_PATH)/dvecdvecinner: $DVECDVECINNER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecdvecinner $DVECDVECINNER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DVecDVecInner.o:
	@echo
	@echo "Building dense vector/dense vector inner product (dvecdvecinner) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DVecDVecInner.o \$(INSTALL_PATH)/src/classic/DVecDVecInner.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecDVecInner.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecDVecInner.o \$(INSTALL_PATH)/src/blaze/DVecDVecInner.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecDVecInner.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecDVecInner.o \$(INSTALL_PATH)/src/boost/DVecDVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DVecDVecInner.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DVecDVecInner.o \$(INSTALL_PATH)/src/blitz/DVecDVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DVecDVecInner.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DVecDVecInner.o \$(INSTALL_PATH)/src/gmm/DVecDVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DVecDVecInner.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DVecDVecInner.o \$(INSTALL_PATH)/src/armadillo/DVecDVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DVecDVecInner.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DVecDVecInner.o \$(INSTALL_PATH)/src/flens/DVecDVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DVecDVecInner.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DVecDVecInner.o \$(INSTALL_PATH)/src/mtl/DVecDVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecDVecInner.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecDVecInner.o \$(INSTALL_PATH)/src/eigen/DVecDVecInner.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecDVecInner.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecDVecInner.o \$(INSTALL_PATH)/src/main/DVecDVecInner.cpp \$(INCLUDES)
EOF


# Dense vector/sparse vector inner product
cat >> Makefile <<EOF

dvecsvecinner: \$(BINARY_PATH)/dvecsvecinner
\$(BINARY_PATH)/dvecsvecinner: $DVECSVECINNER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecsvecinner $DVECSVECINNER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DVecSVecInner.o:
	@echo
	@echo "Building dense vector/sparse vector inner product (dvecsvecinner) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecSVecInner.o \$(INSTALL_PATH)/src/blaze/DVecSVecInner.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecSVecInner.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecSVecInner.o \$(INSTALL_PATH)/src/boost/DVecSVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DVecSVecInner.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DVecSVecInner.o \$(INSTALL_PATH)/src/gmm/DVecSVecInner.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecSVecInner.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecSVecInner.o \$(INSTALL_PATH)/src/main/DVecSVecInner.cpp \$(INCLUDES)
EOF


# Sparse vector/dense vector inner product
cat >> Makefile <<EOF

svecdvecinner: \$(BINARY_PATH)/svecdvecinner
\$(BINARY_PATH)/svecdvecinner: $SVECDVECINNER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecdvecinner $SVECDVECINNER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecDVecInner.o:
	@echo
	@echo "Building sparse vector/dense vector inner product (svecdvecinner) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecDVecInner.o \$(INSTALL_PATH)/src/blaze/SVecDVecInner.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecDVecInner.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecDVecInner.o \$(INSTALL_PATH)/src/boost/SVecDVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SVecDVecInner.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SVecDVecInner.o \$(INSTALL_PATH)/src/gmm/SVecDVecInner.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecDVecInner.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecDVecInner.o \$(INSTALL_PATH)/src/main/SVecDVecInner.cpp \$(INCLUDES)
EOF


# Sparse vector/sparse vector inner product
cat >> Makefile <<EOF

svecsvecinner: \$(BINARY_PATH)/svecsvecinner
\$(BINARY_PATH)/svecsvecinner: $SVECSVECINNER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecsvecinner $SVECSVECINNER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecSVecInner.o:
	@echo
	@echo "Building sparse vector/sparse vector inner product (svecsvecinner) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecSVecInner.o \$(INSTALL_PATH)/src/blaze/SVecSVecInner.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecSVecInner.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecSVecInner.o \$(INSTALL_PATH)/src/boost/SVecSVecInner.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SVecSVecInner.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SVecSVecInner.o \$(INSTALL_PATH)/src/gmm/SVecSVecInner.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecSVecInner.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecSVecInner.o \$(INSTALL_PATH)/src/main/SVecSVecInner.cpp \$(INCLUDES)
EOF


# Dense vector/dense vector outer product
cat >> Makefile <<EOF

dvecdvecouter: \$(BINARY_PATH)/dvecdvecouter
\$(BINARY_PATH)/dvecdvecouter: $DVECDVECOUTER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecdvecouter $DVECDVECOUTER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DVecDVecOuter.o:
	@echo
	@echo "Building dense vector/dense vector outer product (dvecdvecouter) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DVecDVecOuter.o \$(INSTALL_PATH)/src/classic/DVecDVecOuter.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DVecDVecOuter.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecDVecOuter.o \$(INSTALL_PATH)/src/blaze/DVecDVecOuter.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecDVecOuter.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecDVecOuter.o \$(INSTALL_PATH)/src/boost/DVecDVecOuter.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DVecDVecOuter.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DVecDVecOuter.o \$(INSTALL_PATH)/src/blitz/DVecDVecOuter.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DVecDVecOuter.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DVecDVecOuter.o \$(INSTALL_PATH)/src/eigen/DVecDVecOuter.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecDVecOuter.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecDVecOuter.o \$(INSTALL_PATH)/src/main/DVecDVecOuter.cpp \$(INCLUDES)
EOF


# Dense vector/sparse vector outer product
cat >> Makefile <<EOF

dvecsvecouter: \$(BINARY_PATH)/dvecsvecouter
\$(BINARY_PATH)/dvecsvecouter: $DVECSVECOUTER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dvecsvecouter $DVECSVECOUTER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DVecSVecOuter.o:
	@echo
	@echo "Building dense vector/sparse vector outer product (dvecsvecouter) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DVecSVecOuter.o \$(INSTALL_PATH)/src/blaze/DVecSVecOuter.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DVecSVecOuter.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DVecSVecOuter.o \$(INSTALL_PATH)/src/boost/DVecSVecOuter.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DVecSVecOuter.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DVecSVecOuter.o \$(INSTALL_PATH)/src/main/DVecSVecOuter.cpp \$(INCLUDES)
EOF


# Sparse vector/dense vector outer product
cat >> Makefile <<EOF

svecdvecouter: \$(BINARY_PATH)/svecdvecouter
\$(BINARY_PATH)/svecdvecouter: $SVECDVECOUTER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecdvecouter $SVECDVECOUTER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecDVecOuter.o:
	@echo
	@echo "Building sparse vector/dense vector outer product (svecdvecouter) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecDVecOuter.o \$(INSTALL_PATH)/src/blaze/SVecDVecOuter.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecDVecOuter.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecDVecOuter.o \$(INSTALL_PATH)/src/boost/SVecDVecOuter.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecDVecOuter.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecDVecOuter.o \$(INSTALL_PATH)/src/main/SVecDVecOuter.cpp \$(INCLUDES)
EOF


# Sparse vector/sparse vector outer product
cat >> Makefile <<EOF

svecsvecouter: \$(BINARY_PATH)/svecsvecouter
\$(BINARY_PATH)/svecsvecouter: $SVECSVECOUTER
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/svecsvecouter $SVECSVECOUTER \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SVecSVecOuter.o:
	@echo
	@echo "Building sparse vector/sparse vector outer product (svecsvecouter) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SVecSVecOuter.o \$(INSTALL_PATH)/src/blaze/SVecSVecOuter.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SVecSVecOuter.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SVecSVecOuter.o \$(INSTALL_PATH)/src/boost/SVecSVecOuter.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SVecSVecOuter.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SVecSVecOuter.o \$(INSTALL_PATH)/src/main/SVecSVecOuter.cpp \$(INCLUDES)
EOF


# Dense matrix/dense vector multiplication
cat >> Makefile <<EOF

dmatdvecmult: \$(BINARY_PATH)/dmatdvecmult
\$(BINARY_PATH)/dmatdvecmult: $DMATDVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatdvecmult $DMATDVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DMatDVecMult.o:
	@echo
	@echo "Building dense matrix/dense vector multiplication (dmatdvecmult) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DMatDVecMult.o \$(INSTALL_PATH)/src/classic/DMatDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_DMatDVecMult.o:
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_DMatDVecMult.o \$(INSTALL_PATH)/src/blas/DMatDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_DMatDVecMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatDVecMult.o \$(INSTALL_PATH)/src/blaze/DMatDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatDVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatDVecMult.o \$(INSTALL_PATH)/src/boost/DMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DMatDVecMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DMatDVecMult.o \$(INSTALL_PATH)/src/blitz/DMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatDVecMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatDVecMult.o \$(INSTALL_PATH)/src/flens/DMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatDVecMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatDVecMult.o \$(INSTALL_PATH)/src/mtl/DMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatDVecMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatDVecMult.o \$(INSTALL_PATH)/src/eigen/DMatDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatDVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatDVecMult.o \$(INSTALL_PATH)/src/main/DMatDVecMult.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/dense vector multiplication
cat >> Makefile <<EOF

tdmatdvecmult: \$(BINARY_PATH)/tdmatdvecmult
\$(BINARY_PATH)/tdmatdvecmult: $TDMATDVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmatdvecmult $TDMATDVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_TDMatDVecMult.o:
	@echo
	@echo "Building transpose dense matrix/dense vector multiplication (tdmatdvecmult) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_TDMatDVecMult.o \$(INSTALL_PATH)/src/classic/TDMatDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_TDMatDVecMult.o:
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_TDMatDVecMult.o \$(INSTALL_PATH)/src/blas/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_TDMatDVecMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatDVecMult.o \$(INSTALL_PATH)/src/blaze/TDMatDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatDVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatDVecMult.o \$(INSTALL_PATH)/src/boost/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TDMatDVecMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TDMatDVecMult.o \$(INSTALL_PATH)/src/blitz/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatDVecMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatDVecMult.o \$(INSTALL_PATH)/src/gmm/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TDMatDVecMult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TDMatDVecMult.o \$(INSTALL_PATH)/src/armadillo/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TDMatDVecMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TDMatDVecMult.o \$(INSTALL_PATH)/src/flens/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatDVecMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatDVecMult.o \$(INSTALL_PATH)/src/mtl/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDMatDVecMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDMatDVecMult.o \$(INSTALL_PATH)/src/eigen/TDMatDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatDVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatDVecMult.o \$(INSTALL_PATH)/src/main/TDMatDVecMult.cpp \$(INCLUDES)
EOF


# Dense matrix/sparse vector multiplication
cat >> Makefile <<EOF

dmatsvecmult: \$(BINARY_PATH)/dmatsvecmult
\$(BINARY_PATH)/dmatsvecmult: $DMATSVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatsvecmult $DMATSVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatSVecMult.o:
	@echo
	@echo "Building dense matrix/sparse vector multiplication (dmatsvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatSVecMult.o \$(INSTALL_PATH)/src/blaze/DMatSVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatSVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatSVecMult.o \$(INSTALL_PATH)/src/boost/DMatSVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatSVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatSVecMult.o \$(INSTALL_PATH)/src/main/DMatSVecMult.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/sparse vector multiplication
cat >> Makefile <<EOF

tdmatsvecmult: \$(BINARY_PATH)/tdmatsvecmult
\$(BINARY_PATH)/tdmatsvecmult: $TDMATSVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmatsvecmult $TDMATSVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDMatSVecMult.o:
	@echo
	@echo "Building transpose dense matrix/sparse vector multiplication (tdmatsvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatSVecMult.o \$(INSTALL_PATH)/src/blaze/TDMatSVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatSVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatSVecMult.o \$(INSTALL_PATH)/src/boost/TDMatSVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatSVecMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatSVecMult.o \$(INSTALL_PATH)/src/gmm/TDMatSVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatSVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatSVecMult.o \$(INSTALL_PATH)/src/main/TDMatSVecMult.cpp \$(INCLUDES)
EOF


# Sparse matrix/dense vector multiplication
cat >> Makefile <<EOF

smatdvecmult: \$(BINARY_PATH)/smatdvecmult
\$(BINARY_PATH)/smatdvecmult: $SMATDVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smatdvecmult $SMATDVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_SMatDVecMult.o:
	@echo
	@echo "Building sparse matrix/dense vector multiplication (smatdvecmult) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_SMatDVecMult.o \$(INSTALL_PATH)/src/clike/SMatDVecMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_SMatDVecMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatDVecMult.o \$(INSTALL_PATH)/src/blaze/SMatDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatDVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatDVecMult.o \$(INSTALL_PATH)/src/boost/SMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatDVecMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatDVecMult.o \$(INSTALL_PATH)/src/gmm/SMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_SMatDVecMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_SMatDVecMult.o \$(INSTALL_PATH)/src/flens/SMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatDVecMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatDVecMult.o \$(INSTALL_PATH)/src/mtl/SMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatDVecMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatDVecMult.o \$(INSTALL_PATH)/src/eigen/SMatDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatDVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatDVecMult.o \$(INSTALL_PATH)/src/main/SMatDVecMult.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/dense vector multiplication
cat >> Makefile <<EOF

tsmatdvecmult: \$(BINARY_PATH)/tsmatdvecmult
\$(BINARY_PATH)/tsmatdvecmult: $TSMATDVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmatdvecmult $TSMATDVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatDVecMult.o:
	@echo
	@echo "Building transpose sparse matrix/dense vector multiplication (tsmatdvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatDVecMult.o \$(INSTALL_PATH)/src/blaze/TSMatDVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatDVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatDVecMult.o \$(INSTALL_PATH)/src/boost/TSMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatDVecMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatDVecMult.o \$(INSTALL_PATH)/src/gmm/TSMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TSMatDVecMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TSMatDVecMult.o \$(INSTALL_PATH)/src/flens/TSMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatDVecMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatDVecMult.o \$(INSTALL_PATH)/src/mtl/TSMatDVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TSMatDVecMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TSMatDVecMult.o \$(INSTALL_PATH)/src/eigen/TSMatDVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatDVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatDVecMult.o \$(INSTALL_PATH)/src/main/TSMatDVecMult.cpp \$(INCLUDES)
EOF


# Sparse matrix/sparse vector multiplication
cat >> Makefile <<EOF

smatsvecmult: \$(BINARY_PATH)/smatsvecmult
\$(BINARY_PATH)/smatsvecmult: $SMATSVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smatsvecmult $SMATSVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatSVecMult.o:
	@echo
	@echo "Building sparse matrix/sparse vector multiplication (smatsvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatSVecMult.o \$(INSTALL_PATH)/src/blaze/SMatSVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatSVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatSVecMult.o \$(INSTALL_PATH)/src/boost/SMatSVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatSVecMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatSVecMult.o \$(INSTALL_PATH)/src/gmm/SMatSVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatSVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatSVecMult.o \$(INSTALL_PATH)/src/main/SMatSVecMult.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/sparse vector multiplication
cat >> Makefile <<EOF

tsmatsvecmult: \$(BINARY_PATH)/tsmatsvecmult
\$(BINARY_PATH)/tsmatsvecmult: $TSMATSVECMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmatsvecmult $TSMATSVECMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatSVecMult.o:
	@echo
	@echo "Building transpose sparse matrix/sparse vector multiplication (tsmatsvecmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatSVecMult.o \$(INSTALL_PATH)/src/blaze/TSMatSVecMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatSVecMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatSVecMult.o \$(INSTALL_PATH)/src/boost/TSMatSVecMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatSVecMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatSVecMult.o \$(INSTALL_PATH)/src/gmm/TSMatSVecMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatSVecMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatSVecMult.o \$(INSTALL_PATH)/src/main/TSMatSVecMult.cpp \$(INCLUDES)
EOF


# Transpose dense vector/dense matrix multiplication
cat >> Makefile <<EOF

tdvecdmatmult: \$(BINARY_PATH)/tdvecdmatmult
\$(BINARY_PATH)/tdvecdmatmult: $TDVECDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdvecdmatmult $TDVECDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_TDVecDMatMult.o:
	@echo
	@echo "Building transpose dense vector/dense matrix multiplication (tdvecdmatmult) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_TDVecDMatMult.o \$(INSTALL_PATH)/src/classic/TDVecDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_TDVecDMatMult.o:
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_TDVecDMatMult.o \$(INSTALL_PATH)/src/blas/TDVecDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_TDVecDMatMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDVecDMatMult.o \$(INSTALL_PATH)/src/blaze/TDVecDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDVecDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDVecDMatMult.o \$(INSTALL_PATH)/src/boost/TDVecDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TDVecDMatMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TDVecDMatMult.o \$(INSTALL_PATH)/src/blitz/TDVecDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TDVecDMatMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TDVecDMatMult.o \$(INSTALL_PATH)/src/flens/TDVecDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDVecDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDVecDMatMult.o \$(INSTALL_PATH)/src/eigen/TDVecDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDVecDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDVecDMatMult.o \$(INSTALL_PATH)/src/main/TDVecDMatMult.cpp \$(INCLUDES)
EOF


# Transpose dense vector/transpose dense matrix multiplication
cat >> Makefile <<EOF

tdvectdmatmult: \$(BINARY_PATH)/tdvectdmatmult
\$(BINARY_PATH)/tdvectdmatmult: $TDVECTDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdvectdmatmult $TDVECTDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_TDVecTDMatMult.o:
	@echo
	@echo "Building transpose dense vector/transpose dense matrix multiplication (tdvectdmatmult) binary..."
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_TDVecTDMatMult.o \$(INSTALL_PATH)/src/blas/TDVecTDMatMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_TDVecTDMatMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDVecTDMatMult.o \$(INSTALL_PATH)/src/blaze/TDVecTDMatMult.cpp \$(INCLUDES)
EOF
else
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_TDVecTDMatMult.o:
	@echo
	@echo "Building transpose dense vector/transpose dense matrix multiplication (tdvectdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDVecTDMatMult.o \$(INSTALL_PATH)/src/blaze/TDVecTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDVecTDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDVecTDMatMult.o \$(INSTALL_PATH)/src/boost/TDVecTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TDVecTDMatMult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TDVecTDMatMult.o \$(INSTALL_PATH)/src/armadillo/TDVecTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TDVecTDMatMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TDVecTDMatMult.o \$(INSTALL_PATH)/src/flens/TDVecTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDVecTDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDVecTDMatMult.o \$(INSTALL_PATH)/src/eigen/TDVecTDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDVecTDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDVecTDMatMult.o \$(INSTALL_PATH)/src/main/TDVecTDMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse vector/dense matrix multiplication
cat >> Makefile <<EOF

tsvecdmatmult: \$(BINARY_PATH)/tsvecdmatmult
\$(BINARY_PATH)/tsvecdmatmult: $TSVECDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsvecdmatmult $TSVECDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSVecDMatMult.o:
	@echo
	@echo "Building transpose sparse vector/dense matrix multiplication (tsvecdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSVecDMatMult.o \$(INSTALL_PATH)/src/blaze/TSVecDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSVecDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSVecDMatMult.o \$(INSTALL_PATH)/src/boost/TSVecDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSVecDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSVecDMatMult.o \$(INSTALL_PATH)/src/main/TSVecDMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse vector/transpose dense matrix multiplication
cat >> Makefile <<EOF

tsvectdmatmult: \$(BINARY_PATH)/tsvectdmatmult
\$(BINARY_PATH)/tsvectdmatmult: $TSVECTDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsvectdmatmult $TSVECTDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSVecTDMatMult.o:
	@echo
	@echo "Building transpose sparse vector/transpose dense matrix multiplication (tsvectdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSVecTDMatMult.o \$(INSTALL_PATH)/src/blaze/TSVecTDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSVecTDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSVecTDMatMult.o \$(INSTALL_PATH)/src/boost/TSVecTDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSVecTDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSVecTDMatMult.o \$(INSTALL_PATH)/src/main/TSVecTDMatMult.cpp \$(INCLUDES)
EOF


# Transpose dense vector/sparse matrix multiplication
cat >> Makefile <<EOF

tdvecsmatmult: \$(BINARY_PATH)/tdvecsmatmult
\$(BINARY_PATH)/tdvecsmatmult: $TDVECSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdvecsmatmult $TDVECSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDVecSMatMult.o:
	@echo
	@echo "Building transpose dense vector/sparse matrix multiplication (tdvecsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDVecSMatMult.o \$(INSTALL_PATH)/src/blaze/TDVecSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDVecSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDVecSMatMult.o \$(INSTALL_PATH)/src/boost/TDVecSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDVecSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDVecSMatMult.o \$(INSTALL_PATH)/src/eigen/TDVecSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDVecSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDVecSMatMult.o \$(INSTALL_PATH)/src/main/TDVecSMatMult.cpp \$(INCLUDES)
EOF


# Transpose dense vector/transpose sparse matrix multiplication
cat >> Makefile <<EOF

tdvectsmatmult: \$(BINARY_PATH)/tdvectsmatmult
\$(BINARY_PATH)/tdvectsmatmult: $TDVECTSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdvectsmatmult $TDVECTSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDVecTSMatMult.o:
	@echo
	@echo "Building transpose dense vector/transpose sparse matrix multiplication (tdvectsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDVecTSMatMult.o \$(INSTALL_PATH)/src/blaze/TDVecTSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDVecTSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDVecTSMatMult.o \$(INSTALL_PATH)/src/boost/TDVecTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDVecTSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDVecTSMatMult.o \$(INSTALL_PATH)/src/eigen/TDVecTSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDVecTSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDVecTSMatMult.o \$(INSTALL_PATH)/src/main/TDVecTSMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse vector/sparse matrix multiplication
cat >> Makefile <<EOF

tsvecsmatmult: \$(BINARY_PATH)/tsvecsmatmult
\$(BINARY_PATH)/tsvecsmatmult: $TSVECSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsvecsmatmult $TSVECSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSVecSMatMult.o:
	@echo
	@echo "Building transpose sparse vector/sparse matrix multiplication (tsvecsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSVecSMatMult.o \$(INSTALL_PATH)/src/blaze/TSVecSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSVecSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSVecSMatMult.o \$(INSTALL_PATH)/src/boost/TSVecSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSVecSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSVecSMatMult.o \$(INSTALL_PATH)/src/main/TSVecSMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse vector/transpose sparse matrix multiplication
cat >> Makefile <<EOF

tsvectsmatmult: \$(BINARY_PATH)/tsvectsmatmult
\$(BINARY_PATH)/tsvectsmatmult: $TSVECTSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsvectsmatmult $TSVECTSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSVecTSMatMult.o:
	@echo
	@echo "Building transpose sparse vector/transpose sparse matrix multiplication (tsvectsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSVecTSMatMult.o \$(INSTALL_PATH)/src/blaze/TSVecTSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSVecTSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSVecTSMatMult.o \$(INSTALL_PATH)/src/boost/TSVecTSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSVecTSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSVecTSMatMult.o \$(INSTALL_PATH)/src/main/TSVecTSMatMult.cpp \$(INCLUDES)
EOF


# Dense matrix transposition
cat >> Makefile <<EOF

dmattrans: \$(BINARY_PATH)/dmattrans
\$(BINARY_PATH)/dmattrans: $DMATTRANS
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmattrans $DMATTRANS \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatTrans.o:
	@echo
	@echo "Building dense matrix transpose (dmattrans) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatTrans.o \$(INSTALL_PATH)/src/blaze/DMatTrans.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatTrans.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatTrans.o \$(INSTALL_PATH)/src/boost/DMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DMatTrans.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DMatTrans.o \$(INSTALL_PATH)/src/gmm/DMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DMatTrans.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DMatTrans.o \$(INSTALL_PATH)/src/armadillo/DMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatTrans.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatTrans.o \$(INSTALL_PATH)/src/flens/DMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatTrans.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatTrans.o \$(INSTALL_PATH)/src/mtl/DMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatTrans.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatTrans.o \$(INSTALL_PATH)/src/eigen/DMatTrans.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatTrans.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatTrans.o \$(INSTALL_PATH)/src/main/DMatTrans.cpp \$(INCLUDES)
EOF


# Sparse matrix transposition
cat >> Makefile <<EOF

smattrans: \$(BINARY_PATH)/smattrans
\$(BINARY_PATH)/smattrans: $SMATTRANS
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smattrans $SMATTRANS \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatTrans.o:
	@echo
	@echo "Building sparse matrix transpose (smattrans) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatTrans.o \$(INSTALL_PATH)/src/blaze/SMatTrans.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatTrans.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatTrans.o \$(INSTALL_PATH)/src/boost/SMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatTrans.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatTrans.o \$(INSTALL_PATH)/src/gmm/SMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatTrans.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatTrans.o \$(INSTALL_PATH)/src/mtl/SMatTrans.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatTrans.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatTrans.o \$(INSTALL_PATH)/src/eigen/SMatTrans.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatTrans.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatTrans.o \$(INSTALL_PATH)/src/main/SMatTrans.cpp \$(INCLUDES)
EOF


# Dense matrix inversion
cat >> Makefile <<EOF

dmatinv: \$(BINARY_PATH)/dmatinv
\$(BINARY_PATH)/dmatinv: $DMATINV
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatinv $DMATINV \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatInv.o:
	@echo
	@echo "Building dense matrix inversion (dmatinv) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatInv.o \$(INSTALL_PATH)/src/blaze/DMatInv.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatInv.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatInv.o \$(INSTALL_PATH)/src/boost/DMatInv.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DMatInv.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DMatInv.o \$(INSTALL_PATH)/src/gmm/DMatInv.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DMatInv.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DMatInv.o \$(INSTALL_PATH)/src/armadillo/DMatInv.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatInv.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatInv.o \$(INSTALL_PATH)/src/mtl/DMatInv.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatInv.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatInv.o \$(INSTALL_PATH)/src/eigen/DMatInv.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatInv.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatInv.o \$(INSTALL_PATH)/src/main/DMatInv.cpp \$(INCLUDES)
EOF


# Dense matrix/dense matrix addition
cat >> Makefile <<EOF

dmatdmatadd: \$(BINARY_PATH)/dmatdmatadd
\$(BINARY_PATH)/dmatdmatadd: $DMATDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatdmatadd $DMATDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DMatDMatAdd.o:
	@echo
	@echo "Building dense matrix/dense matrix addition (dmatdmatadd) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DMatDMatAdd.o \$(INSTALL_PATH)/src/classic/DMatDMatAdd.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DMatDMatAdd.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatDMatAdd.o \$(INSTALL_PATH)/src/blaze/DMatDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatDMatAdd.o \$(INSTALL_PATH)/src/boost/DMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DMatDMatAdd.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DMatDMatAdd.o \$(INSTALL_PATH)/src/blitz/DMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatDMatAdd.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatDMatAdd.o \$(INSTALL_PATH)/src/flens/DMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatDMatAdd.o \$(INSTALL_PATH)/src/mtl/DMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatDMatAdd.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatDMatAdd.o \$(INSTALL_PATH)/src/eigen/DMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatDMatAdd.o \$(INSTALL_PATH)/src/main/DMatDMatAdd.cpp \$(INCLUDES)
EOF


# Dense matrix/transpose dense matrix addition
cat >> Makefile <<EOF

dmattdmatadd: \$(BINARY_PATH)/dmattdmatadd
\$(BINARY_PATH)/dmattdmatadd: $DMATTDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmattdmatadd $DMATTDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatTDMatAdd.o:
	@echo
	@echo "Building dense matrix/transpose dense matrix addition (dmattdmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatTDMatAdd.o \$(INSTALL_PATH)/src/blaze/DMatTDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatTDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatTDMatAdd.o \$(INSTALL_PATH)/src/boost/DMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DMatTDMatAdd.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DMatTDMatAdd.o \$(INSTALL_PATH)/src/blitz/DMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatTDMatAdd.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatTDMatAdd.o \$(INSTALL_PATH)/src/flens/DMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatTDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatTDMatAdd.o \$(INSTALL_PATH)/src/mtl/DMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatTDMatAdd.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatTDMatAdd.o \$(INSTALL_PATH)/src/eigen/DMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatTDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatTDMatAdd.o \$(INSTALL_PATH)/src/main/DMatTDMatAdd.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/dense matrix addition
cat >> Makefile <<EOF

tdmatdmatadd: \$(BINARY_PATH)/tdmatdmatadd
\$(BINARY_PATH)/tdmatdmatadd: $TDMATDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmatdmatadd $TDMATDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDMatDMatAdd.o:
	@echo
	@echo "Building transpose dense matrix/dense matrix addition (tdmatdmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatDMatAdd.o \$(INSTALL_PATH)/src/blaze/TDMatDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatDMatAdd.o \$(INSTALL_PATH)/src/boost/TDMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TDMatDMatAdd.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TDMatDMatAdd.o \$(INSTALL_PATH)/src/blitz/TDMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TDMatDMatAdd.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TDMatDMatAdd.o \$(INSTALL_PATH)/src/flens/TDMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatDMatAdd.o \$(INSTALL_PATH)/src/mtl/TDMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDMatDMatAdd.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDMatDMatAdd.o \$(INSTALL_PATH)/src/eigen/TDMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatDMatAdd.o \$(INSTALL_PATH)/src/main/TDMatDMatAdd.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/transpose dense matrix addition
cat >> Makefile <<EOF

tdmattdmatadd: \$(BINARY_PATH)/tdmattdmatadd
\$(BINARY_PATH)/tdmattdmatadd: $TDMATTDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmattdmatadd $TDMATTDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDMatTDMatAdd.o:
	@echo
	@echo "Building transpose dense matrix/transpose dense matrix addition (tdmattdmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/blaze/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatTDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/boost/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TDMatTDMatAdd.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/blitz/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatTDMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/gmm/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TDMatTDMatAdd.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/armadillo/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TDMatTDMatAdd.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/flens/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatTDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/mtl/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDMatTDMatAdd.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/eigen/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatTDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatTDMatAdd.o \$(INSTALL_PATH)/src/main/TDMatTDMatAdd.cpp \$(INCLUDES)
EOF


# Dense matrix/sparse matrix addition
cat >> Makefile <<EOF

dmatsmatadd: \$(BINARY_PATH)/dmatsmatadd
\$(BINARY_PATH)/dmatsmatadd: $DMATSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatsmatadd $DMATSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatSMatAdd.o:
	@echo
	@echo "Building dense matrix/sparse matrix addition (dmatsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatSMatAdd.o \$(INSTALL_PATH)/src/blaze/DMatSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatSMatAdd.o \$(INSTALL_PATH)/src/boost/DMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatSMatAdd.o \$(INSTALL_PATH)/src/mtl/DMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatSMatAdd.o \$(INSTALL_PATH)/src/main/DMatSMatAdd.cpp \$(INCLUDES)
EOF


# Dense matrix/transpose sparse matrix addition
cat >> Makefile <<EOF

dmattsmatadd: \$(BINARY_PATH)/dmattsmatadd
\$(BINARY_PATH)/dmattsmatadd: $DMATTSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmattsmatadd $DMATTSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatTSMatAdd.o:
	@echo
	@echo "Building dense matrix/transpose sparse matrix addition (dmattsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatTSMatAdd.o \$(INSTALL_PATH)/src/blaze/DMatTSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatTSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatTSMatAdd.o \$(INSTALL_PATH)/src/boost/DMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatTSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatTSMatAdd.o \$(INSTALL_PATH)/src/mtl/DMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatTSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatTSMatAdd.o \$(INSTALL_PATH)/src/main/DMatTSMatAdd.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/sparse matrix addition
cat >> Makefile <<EOF

tdmatsmatadd: \$(BINARY_PATH)/tdmatsmatadd
\$(BINARY_PATH)/tdmatsmatadd: $TDMATSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmatsmatadd $TDMATSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDMatSMatAdd.o:
	@echo
	@echo "Building transpose dense matrix/sparse matrix addition (tdmatsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatSMatAdd.o \$(INSTALL_PATH)/src/blaze/TDMatSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatSMatAdd.o \$(INSTALL_PATH)/src/boost/TDMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatSMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatSMatAdd.o \$(INSTALL_PATH)/src/gmm/TDMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatSMatAdd.o \$(INSTALL_PATH)/src/mtl/TDMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatSMatAdd.o \$(INSTALL_PATH)/src/main/TDMatSMatAdd.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/transpose sparse matrix addition
cat >> Makefile <<EOF

tdmattsmatadd: \$(BINARY_PATH)/tdmattsmatadd
\$(BINARY_PATH)/tdmattsmatadd: $TDMATTSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmattsmatadd $TDMATTSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDMatTSMatAdd.o:
	@echo
	@echo "Building transpose dense matrix/transpose sparse matrix addition (tdmattsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatTSMatAdd.o \$(INSTALL_PATH)/src/blaze/TDMatTSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatTSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatTSMatAdd.o \$(INSTALL_PATH)/src/boost/TDMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatTSMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatTSMatAdd.o \$(INSTALL_PATH)/src/gmm/TDMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatTSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatTSMatAdd.o \$(INSTALL_PATH)/src/mtl/TDMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatTSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatTSMatAdd.o \$(INSTALL_PATH)/src/main/TDMatTSMatAdd.cpp \$(INCLUDES)
EOF


# Sparse matrix/dense matrix addition
cat >> Makefile <<EOF

smatdmatadd: \$(BINARY_PATH)/smatdmatadd
\$(BINARY_PATH)/smatdmatadd: $SMATDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smatdmatadd $SMATDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatDMatAdd.o:
	@echo
	@echo "Building sparse matrix/dense matrix addition (smatdmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatDMatAdd.o \$(INSTALL_PATH)/src/blaze/SMatDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatDMatAdd.o \$(INSTALL_PATH)/src/boost/SMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatDMatAdd.o \$(INSTALL_PATH)/src/mtl/SMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatDMatAdd.o \$(INSTALL_PATH)/src/main/SMatDMatAdd.cpp \$(INCLUDES)
EOF


# Sparse matrix/transpose dense matrix addition
cat >> Makefile <<EOF

smattdmatadd: \$(BINARY_PATH)/smattdmatadd
\$(BINARY_PATH)/smattdmatadd: $SMATTDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smattdmatadd $SMATTDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatTDMatAdd.o:
	@echo
	@echo "Building sparse matrix/transpose dense matrix addition (smattdmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatTDMatAdd.o \$(INSTALL_PATH)/src/blaze/SMatTDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatTDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatTDMatAdd.o \$(INSTALL_PATH)/src/boost/SMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatTDMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatTDMatAdd.o \$(INSTALL_PATH)/src/gmm/SMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatTDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatTDMatAdd.o \$(INSTALL_PATH)/src/mtl/SMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatTDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatTDMatAdd.o \$(INSTALL_PATH)/src/main/SMatTDMatAdd.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/dense matrix addition
cat >> Makefile <<EOF

tsmatdmatadd: \$(BINARY_PATH)/tsmatdmatadd
\$(BINARY_PATH)/tsmatdmatadd: $TSMATDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmatdmatadd $TSMATDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatDMatAdd.o:
	@echo
	@echo "Building transpose sparse matrix/dense matrix addition (tsmatdmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatDMatAdd.o \$(INSTALL_PATH)/src/blaze/TSMatDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatDMatAdd.o \$(INSTALL_PATH)/src/boost/TSMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatDMatAdd.o \$(INSTALL_PATH)/src/mtl/TSMatDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatDMatAdd.o \$(INSTALL_PATH)/src/main/TSMatDMatAdd.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/transpose dense matrix addition
cat >> Makefile <<EOF

tsmattdmatadd: \$(BINARY_PATH)/tsmattdmatadd
\$(BINARY_PATH)/tsmattdmatadd: $TSMATTDMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmattdmatadd $TSMATTDMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatTDMatAdd.o:
	@echo
	@echo "Building transpose sparse matrix/transpose dense matrix addition (tsmattdmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatTDMatAdd.o \$(INSTALL_PATH)/src/blaze/TSMatTDMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatTDMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatTDMatAdd.o \$(INSTALL_PATH)/src/boost/TSMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatTDMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatTDMatAdd.o \$(INSTALL_PATH)/src/gmm/TSMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatTDMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatTDMatAdd.o \$(INSTALL_PATH)/src/mtl/TSMatTDMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatTDMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatTDMatAdd.o \$(INSTALL_PATH)/src/main/TSMatTDMatAdd.cpp \$(INCLUDES)
EOF


# Sparse matrix/sparse matrix addition
cat >> Makefile <<EOF

smatsmatadd: \$(BINARY_PATH)/smatsmatadd
\$(BINARY_PATH)/smatsmatadd: $SMATSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smatsmatadd $SMATSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatSMatAdd.o:
	@echo
	@echo "Building sparse matrix/sparse matrix addition (smatsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatSMatAdd.o \$(INSTALL_PATH)/src/blaze/SMatSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatSMatAdd.o \$(INSTALL_PATH)/src/boost/SMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatSMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatSMatAdd.o \$(INSTALL_PATH)/src/gmm/SMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatSMatAdd.o \$(INSTALL_PATH)/src/mtl/SMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatSMatAdd.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatSMatAdd.o \$(INSTALL_PATH)/src/eigen/SMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatSMatAdd.o \$(INSTALL_PATH)/src/main/SMatSMatAdd.cpp \$(INCLUDES)
EOF


# Sparse matrix/transpose sparse matrix addition
cat >> Makefile <<EOF

smattsmatadd: \$(BINARY_PATH)/smattsmatadd
\$(BINARY_PATH)/smattsmatadd: $SMATTSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smattsmatadd $SMATTSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatTSMatAdd.o:
	@echo
	@echo "Building sparse matrix/transpose sparse matrix addition (smattsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatTSMatAdd.o \$(INSTALL_PATH)/src/blaze/SMatTSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatTSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatTSMatAdd.o \$(INSTALL_PATH)/src/boost/SMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatTSMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatTSMatAdd.o \$(INSTALL_PATH)/src/gmm/SMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatTSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatTSMatAdd.o \$(INSTALL_PATH)/src/mtl/SMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatTSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatTSMatAdd.o \$(INSTALL_PATH)/src/main/SMatTSMatAdd.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/sparse matrix addition
cat >> Makefile <<EOF

tsmatsmatadd: \$(BINARY_PATH)/tsmatsmatadd
\$(BINARY_PATH)/tsmatsmatadd: $TSMATSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmatsmatadd $TSMATSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatSMatAdd.o:
	@echo
	@echo "Building transpose sparse matrix/sparse matrix addition (tsmatsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatSMatAdd.o \$(INSTALL_PATH)/src/blaze/TSMatSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatSMatAdd.o \$(INSTALL_PATH)/src/boost/TSMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatSMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatSMatAdd.o \$(INSTALL_PATH)/src/gmm/TSMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatSMatAdd.o \$(INSTALL_PATH)/src/mtl/TSMatSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatSMatAdd.o \$(INSTALL_PATH)/src/main/TSMatSMatAdd.cpp \$(INCLUDES)
EOF


# Transpose parse matrix/transpose sparse matrix addition
cat >> Makefile <<EOF

tsmattsmatadd: \$(BINARY_PATH)/tsmattsmatadd
\$(BINARY_PATH)/tsmattsmatadd: $TSMATTSMATADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmattsmatadd $TSMATTSMATADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatTSMatAdd.o:
	@echo
	@echo "Building transpose sparse matrix/transpose sparse matrix addition (tsmattsmatadd) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatTSMatAdd.o \$(INSTALL_PATH)/src/blaze/TSMatTSMatAdd.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatTSMatAdd.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatTSMatAdd.o \$(INSTALL_PATH)/src/boost/TSMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatTSMatAdd.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatTSMatAdd.o \$(INSTALL_PATH)/src/gmm/TSMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatTSMatAdd.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatTSMatAdd.o \$(INSTALL_PATH)/src/mtl/TSMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TSMatTSMatAdd.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TSMatTSMatAdd.o \$(INSTALL_PATH)/src/eigen/TSMatTSMatAdd.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatTSMatAdd.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatTSMatAdd.o \$(INSTALL_PATH)/src/main/TSMatTSMatAdd.cpp \$(INCLUDES)
EOF


# Dense matrix/dense matrix subtraction
cat >> Makefile <<EOF

dmatdmatsub: \$(BINARY_PATH)/dmatdmatsub
\$(BINARY_PATH)/dmatdmatsub: $DMATDMATSUB
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatdmatsub $DMATDMATSUB \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DMatDMatSub.o:
	@echo
	@echo "Building dense matrix/dense matrix subtraction (dmatdmatsub) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DMatDMatSub.o \$(INSTALL_PATH)/src/classic/DMatDMatSub.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DMatDMatSub.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatDMatSub.o \$(INSTALL_PATH)/src/blaze/DMatDMatSub.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatDMatSub.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatDMatSub.o \$(INSTALL_PATH)/src/boost/DMatDMatSub.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DMatDMatSub.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DMatDMatSub.o \$(INSTALL_PATH)/src/blitz/DMatDMatSub.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatDMatSub.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatDMatSub.o \$(INSTALL_PATH)/src/flens/DMatDMatSub.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatDMatSub.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatDMatSub.o \$(INSTALL_PATH)/src/mtl/DMatDMatSub.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatDMatSub.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatDMatSub.o \$(INSTALL_PATH)/src/eigen/DMatDMatSub.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatDMatSub.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatDMatSub.o \$(INSTALL_PATH)/src/main/DMatDMatSub.cpp \$(INCLUDES)
EOF


# Dense matrix/scalar multiplication
cat >> Makefile <<EOF

dmatscalarmult: \$(BINARY_PATH)/dmatscalarmult
\$(BINARY_PATH)/dmatscalarmult: $DMATSCALARMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatscalarmult $DMATSCALARMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DMatScalarMult.o:
	@echo
	@echo "Building dense matrix/scalar multiplication (dmatscalarmult) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DMatScalarMult.o \$(INSTALL_PATH)/src/classic/DMatScalarMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DMatScalarMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatScalarMult.o \$(INSTALL_PATH)/src/blaze/DMatScalarMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatScalarMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatScalarMult.o \$(INSTALL_PATH)/src/boost/DMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DMatScalarMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DMatScalarMult.o \$(INSTALL_PATH)/src/blitz/DMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_DMatScalarMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_DMatScalarMult.o \$(INSTALL_PATH)/src/gmm/DMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_DMatScalarMult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_DMatScalarMult.o \$(INSTALL_PATH)/src/armadillo/DMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatScalarMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatScalarMult.o \$(INSTALL_PATH)/src/flens/DMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatScalarMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatScalarMult.o \$(INSTALL_PATH)/src/mtl/DMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatScalarMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatScalarMult.o \$(INSTALL_PATH)/src/eigen/DMatScalarMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatScalarMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatScalarMult.o \$(INSTALL_PATH)/src/main/DMatScalarMult.cpp \$(INCLUDES)
EOF


# Sparse matrix/scalar multiplication
cat >> Makefile <<EOF

smatscalarmult: \$(BINARY_PATH)/smatscalarmult
\$(BINARY_PATH)/smatscalarmult: $SMATSCALARMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smatscalarmult $SMATSCALARMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatScalarMult.o:
	@echo
	@echo "Building sparse matrix/scalar multiplication (smatscalarmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatScalarMult.o \$(INSTALL_PATH)/src/blaze/SMatScalarMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatScalarMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatScalarMult.o \$(INSTALL_PATH)/src/boost/SMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatScalarMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatScalarMult.o \$(INSTALL_PATH)/src/gmm/SMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatScalarMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatScalarMult.o \$(INSTALL_PATH)/src/mtl/SMatScalarMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatScalarMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatScalarMult.o \$(INSTALL_PATH)/src/eigen/SMatScalarMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatScalarMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatScalarMult.o \$(INSTALL_PATH)/src/main/SMatScalarMult.cpp \$(INCLUDES)
EOF


# Dense matrix/dense matrix multiplication
cat >> Makefile <<EOF

dmatdmatmult: \$(BINARY_PATH)/dmatdmatmult
\$(BINARY_PATH)/dmatdmatmult: $DMATDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatdmatmult $DMATDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_DMatDMatMult.o:
	@echo
	@echo "Building dense matrix/dense matrix multiplication (dmatdmatmult) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_DMatDMatMult.o \$(INSTALL_PATH)/src/classic/DMatDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_DMatDMatMult.o:
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_DMatDMatMult.o \$(INSTALL_PATH)/src/blas/DMatDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_DMatDMatMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatDMatMult.o \$(INSTALL_PATH)/src/blaze/DMatDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatDMatMult.o \$(INSTALL_PATH)/src/boost/DMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_DMatDMatMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_DMatDMatMult.o \$(INSTALL_PATH)/src/blitz/DMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatDMatMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatDMatMult.o \$(INSTALL_PATH)/src/flens/DMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatDMatMult.o \$(INSTALL_PATH)/src/mtl/DMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatDMatMult.o \$(INSTALL_PATH)/src/eigen/DMatDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatDMatMult.o \$(INSTALL_PATH)/src/main/DMatDMatMult.cpp \$(INCLUDES)
EOF


# Dense matrix/transpose dense matrix multiplication
cat >> Makefile <<EOF

dmattdmatmult: \$(BINARY_PATH)/dmattdmatmult
\$(BINARY_PATH)/dmattdmatmult: $DMATTDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmattdmatmult $DMATTDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_DMatTDMatMult.o:
	@echo
	@echo "Building dense matrix/transpose dense matrix multiplication (dmattdmatmult) binary..."
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_DMatTDMatMult.o \$(INSTALL_PATH)/src/blas/DMatTDMatMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_DMatTDMatMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatTDMatMult.o \$(INSTALL_PATH)/src/blaze/DMatTDMatMult.cpp \$(INCLUDES)
EOF
else
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_DMatTDMatMult.o:
	@echo
	@echo "Building dense matrix/transpose dense matrix multiplication (dmattdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatTDMatMult.o \$(INSTALL_PATH)/src/blaze/DMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatTDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatTDMatMult.o \$(INSTALL_PATH)/src/boost/DMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_DMatTDMatMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_DMatTDMatMult.o \$(INSTALL_PATH)/src/flens/DMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatTDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatTDMatMult.o \$(INSTALL_PATH)/src/mtl/DMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatTDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatTDMatMult.o \$(INSTALL_PATH)/src/eigen/DMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatTDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatTDMatMult.o \$(INSTALL_PATH)/src/main/DMatTDMatMult.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/dense matrix multiplication
cat >> Makefile <<EOF

tdmatdmatmult: \$(BINARY_PATH)/tdmatdmatmult
\$(BINARY_PATH)/tdmatdmatmult: $TDMATDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmatdmatmult $TDMATDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_TDMatDMatMult.o:
	@echo
	@echo "Building transpose dense matrix/dense matrix multiplication (tdmatdmatmult) binary..."
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_TDMatDMatMult.o \$(INSTALL_PATH)/src/blas/TDMatDMatMult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_TDMatDMatMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatDMatMult.o \$(INSTALL_PATH)/src/blaze/TDMatDMatMult.cpp \$(INCLUDES)
EOF
else
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_TDMatDMatMult.o:
	@echo
	@echo "Building transpose dense matrix/dense matrix multiplication (tdmatdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatDMatMult.o \$(INSTALL_PATH)/src/blaze/TDMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatDMatMult.o \$(INSTALL_PATH)/src/boost/TDMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TDMatDMatMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TDMatDMatMult.o \$(INSTALL_PATH)/src/flens/TDMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatDMatMult.o \$(INSTALL_PATH)/src/mtl/TDMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDMatDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDMatDMatMult.o \$(INSTALL_PATH)/src/eigen/TDMatDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatDMatMult.o \$(INSTALL_PATH)/src/main/TDMatDMatMult.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/transpose dense matrix multiplication
cat >> Makefile <<EOF

tdmattdmatmult: \$(BINARY_PATH)/tdmattdmatmult
\$(BINARY_PATH)/tdmattdmatmult: $TDMATTDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmattdmatmult $TDMATTDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_TDMatTDMatMult.o:
	@echo
	@echo "Building transpose dense matrix/transpose dense matrix multiplication (tdmattdmatmult) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_TDMatTDMatMult.o \$(INSTALL_PATH)/src/classic/TDMatTDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BLAS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAS_TDMatTDMatMult.o:
	@echo "  Building the BLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAS_TDMatTDMatMult.o \$(INSTALL_PATH)/src/blas/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLAZE_TDMatTDMatMult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatTDMatMult.o \$(INSTALL_PATH)/src/blaze/TDMatTDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatTDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatTDMatMult.o \$(INSTALL_PATH)/src/boost/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TDMatTDMatMult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TDMatTDMatMult.o \$(INSTALL_PATH)/src/blitz/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatTDMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatTDMatMult.o \$(INSTALL_PATH)/src/gmm/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TDMatTDMatMult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TDMatTDMatMult.o \$(INSTALL_PATH)/src/armadillo/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TDMatTDMatMult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TDMatTDMatMult.o \$(INSTALL_PATH)/src/flens/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatTDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatTDMatMult.o \$(INSTALL_PATH)/src/mtl/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDMatTDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDMatTDMatMult.o \$(INSTALL_PATH)/src/eigen/TDMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatTDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatTDMatMult.o \$(INSTALL_PATH)/src/main/TDMatTDMatMult.cpp \$(INCLUDES)
EOF


# Dense matrix/sparse matrix multiplication
cat >> Makefile <<EOF

dmatsmatmult: \$(BINARY_PATH)/dmatsmatmult
\$(BINARY_PATH)/dmatsmatmult: $DMATSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmatsmatmult $DMATSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatSMatMult.o:
	@echo
	@echo "Building dense matrix/sparse matrix multiplication (dmatsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatSMatMult.o \$(INSTALL_PATH)/src/blaze/DMatSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatSMatMult.o \$(INSTALL_PATH)/src/boost/DMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatSMatMult.o \$(INSTALL_PATH)/src/mtl/DMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatSMatMult.o \$(INSTALL_PATH)/src/eigen/DMatSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatSMatMult.o \$(INSTALL_PATH)/src/main/DMatSMatMult.cpp \$(INCLUDES)
EOF


# Dense matrix/transpose sparse matrix multiplication
cat >> Makefile <<EOF

dmattsmatmult: \$(BINARY_PATH)/dmattsmatmult
\$(BINARY_PATH)/dmattsmatmult: $DMATTSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/dmattsmatmult $DMATTSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_DMatTSMatMult.o:
	@echo
	@echo "Building dense matrix/transpose sparse matrix multiplication (dmattsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_DMatTSMatMult.o \$(INSTALL_PATH)/src/blaze/DMatTSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_DMatTSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_DMatTSMatMult.o \$(INSTALL_PATH)/src/boost/DMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_DMatTSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_DMatTSMatMult.o \$(INSTALL_PATH)/src/mtl/DMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_DMatTSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_DMatTSMatMult.o \$(INSTALL_PATH)/src/eigen/DMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_DMatTSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_DMatTSMatMult.o \$(INSTALL_PATH)/src/main/DMatTSMatMult.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/sparse matrix multiplication
cat >> Makefile <<EOF

tdmatsmatmult: \$(BINARY_PATH)/tdmatsmatmult
\$(BINARY_PATH)/tdmatsmatmult: $TDMATSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmatsmatmult $TDMATSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDMatSMatMult.o:
	@echo
	@echo "Building transpose dense matrix/sparse matrix multiplication (tdmatsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatSMatMult.o \$(INSTALL_PATH)/src/blaze/TDMatSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatSMatMult.o \$(INSTALL_PATH)/src/boost/TDMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatSMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatSMatMult.o \$(INSTALL_PATH)/src/gmm/TDMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatSMatMult.o \$(INSTALL_PATH)/src/mtl/TDMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDMatSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDMatSMatMult.o \$(INSTALL_PATH)/src/eigen/TDMatSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatSMatMult.o \$(INSTALL_PATH)/src/main/TDMatSMatMult.cpp \$(INCLUDES)
EOF


# Transpose dense matrix/transpose sparse matrix multiplication
cat >> Makefile <<EOF

tdmattsmatmult: \$(BINARY_PATH)/tdmattsmatmult
\$(BINARY_PATH)/tdmattsmatmult: $TDMATTSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tdmattsmatmult $TDMATTSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TDMatTSMatMult.o:
	@echo
	@echo "Building transpose dense matrix/transpose sparse matrix multiplication (tdmattsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TDMatTSMatMult.o \$(INSTALL_PATH)/src/blaze/TDMatTSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TDMatTSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TDMatTSMatMult.o \$(INSTALL_PATH)/src/boost/TDMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TDMatTSMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TDMatTSMatMult.o \$(INSTALL_PATH)/src/gmm/TDMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TDMatTSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TDMatTSMatMult.o \$(INSTALL_PATH)/src/mtl/TDMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TDMatTSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TDMatTSMatMult.o \$(INSTALL_PATH)/src/eigen/TDMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TDMatTSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TDMatTSMatMult.o \$(INSTALL_PATH)/src/main/TDMatTSMatMult.cpp \$(INCLUDES)
EOF


# Sparse matrix/dense matrix multiplication
cat >> Makefile <<EOF

smatdmatmult: \$(BINARY_PATH)/smatdmatmult
\$(BINARY_PATH)/smatdmatmult: $SMATDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smatdmatmult $SMATDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatDMatMult.o:
	@echo
	@echo "Building sparse matrix/dense matrix multiplication (smatdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatDMatMult.o \$(INSTALL_PATH)/src/blaze/SMatDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatDMatMult.o \$(INSTALL_PATH)/src/boost/SMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatDMatMult.o \$(INSTALL_PATH)/src/mtl/SMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatDMatMult.o \$(INSTALL_PATH)/src/eigen/SMatDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatDMatMult.o \$(INSTALL_PATH)/src/main/SMatDMatMult.cpp \$(INCLUDES)
EOF


# Sparse matrix/transpose dense matrix multiplication
cat >> Makefile <<EOF

smattdmatmult: \$(BINARY_PATH)/smattdmatmult
\$(BINARY_PATH)/smattdmatmult: $SMATTDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smattdmatmult $SMATTDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatTDMatMult.o:
	@echo
	@echo "Building sparse matrix/transpose dense matrix multiplication (smattdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatTDMatMult.o \$(INSTALL_PATH)/src/blaze/SMatTDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatTDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatTDMatMult.o \$(INSTALL_PATH)/src/boost/SMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatTDMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatTDMatMult.o \$(INSTALL_PATH)/src/gmm/SMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatTDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatTDMatMult.o \$(INSTALL_PATH)/src/mtl/SMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatTDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatTDMatMult.o \$(INSTALL_PATH)/src/eigen/SMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatTDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatTDMatMult.o \$(INSTALL_PATH)/src/main/SMatTDMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/dense matrix multiplication
cat >> Makefile <<EOF

tsmatdmatmult: \$(BINARY_PATH)/tsmatdmatmult
\$(BINARY_PATH)/tsmatdmatmult: $TSMATDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmatdmatmult $TSMATDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatDMatMult.o:
	@echo
	@echo "Building transpose sparse matrix/dense matrix multiplication (tsmatdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatDMatMult.o \$(INSTALL_PATH)/src/blaze/TSMatDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatDMatMult.o \$(INSTALL_PATH)/src/boost/TSMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatDMatMult.o \$(INSTALL_PATH)/src/mtl/TSMatDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TSMatDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TSMatDMatMult.o \$(INSTALL_PATH)/src/eigen/TSMatDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatDMatMult.o \$(INSTALL_PATH)/src/main/TSMatDMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/transpose dense matrix multiplication
cat >> Makefile <<EOF

tsmattdmatmult: \$(BINARY_PATH)/tsmattdmatmult
\$(BINARY_PATH)/tsmattdmatmult: $TSMATTDMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmattdmatmult $TSMATTDMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatTDMatMult.o:
	@echo
	@echo "Building transpose sparse matrix/transpose dense matrix multiplication (tsmattdmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatTDMatMult.o \$(INSTALL_PATH)/src/blaze/TSMatTDMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatTDMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatTDMatMult.o \$(INSTALL_PATH)/src/boost/TSMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatTDMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatTDMatMult.o \$(INSTALL_PATH)/src/gmm/TSMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatTDMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatTDMatMult.o \$(INSTALL_PATH)/src/mtl/TSMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TSMatTDMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TSMatTDMatMult.o \$(INSTALL_PATH)/src/eigen/TSMatTDMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatTDMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatTDMatMult.o \$(INSTALL_PATH)/src/main/TSMatTDMatMult.cpp \$(INCLUDES)
EOF


# Sparse matrix/sparse matrix multiplication
cat >> Makefile <<EOF

smatsmatmult: \$(BINARY_PATH)/smatsmatmult
\$(BINARY_PATH)/smatsmatmult: $SMATSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smatsmatmult $SMATSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatSMatMult.o:
	@echo
	@echo "Building sparse matrix/sparse matrix multiplication (smatsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatSMatMult.o \$(INSTALL_PATH)/src/blaze/SMatSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatSMatMult.o \$(INSTALL_PATH)/src/boost/SMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatSMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatSMatMult.o \$(INSTALL_PATH)/src/gmm/SMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatSMatMult.o \$(INSTALL_PATH)/src/mtl/SMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatSMatMult.o \$(INSTALL_PATH)/src/eigen/SMatSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatSMatMult.o \$(INSTALL_PATH)/src/main/SMatSMatMult.cpp \$(INCLUDES)
EOF


# Sparse matrix/transpose sparse matrix multiplication
cat >> Makefile <<EOF

smattsmatmult: \$(BINARY_PATH)/smattsmatmult
\$(BINARY_PATH)/smattsmatmult: $SMATTSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/smattsmatmult $SMATTSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_SMatTSMatMult.o:
	@echo
	@echo "Building sparse matrix/transpose sparse matrix multiplication (smattsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_SMatTSMatMult.o \$(INSTALL_PATH)/src/blaze/SMatTSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_SMatTSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_SMatTSMatMult.o \$(INSTALL_PATH)/src/boost/SMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_SMatTSMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_SMatTSMatMult.o \$(INSTALL_PATH)/src/gmm/SMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_SMatTSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_SMatTSMatMult.o \$(INSTALL_PATH)/src/mtl/SMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_SMatTSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_SMatTSMatMult.o \$(INSTALL_PATH)/src/eigen/SMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_SMatTSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_SMatTSMatMult.o \$(INSTALL_PATH)/src/main/SMatTSMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/sparse matrix multiplication
cat >> Makefile <<EOF

tsmatsmatmult: \$(BINARY_PATH)/tsmatsmatmult
\$(BINARY_PATH)/tsmatsmatmult: $TSMATSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmatsmatmult $TSMATSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatSMatMult.o:
	@echo
	@echo "Building transpose sparse matrix/sparse matrix multiplication (tsmatsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatSMatMult.o \$(INSTALL_PATH)/src/blaze/TSMatSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatSMatMult.o \$(INSTALL_PATH)/src/boost/TSMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatSMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatSMatMult.o \$(INSTALL_PATH)/src/gmm/TSMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatSMatMult.o \$(INSTALL_PATH)/src/mtl/TSMatSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TSMatSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TSMatSMatMult.o \$(INSTALL_PATH)/src/eigen/TSMatSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatSMatMult.o \$(INSTALL_PATH)/src/main/TSMatSMatMult.cpp \$(INCLUDES)
EOF


# Transpose sparse matrix/transpose sparse matrix multiplication
cat >> Makefile <<EOF

tsmattsmatmult: \$(BINARY_PATH)/tsmattsmatmult
\$(BINARY_PATH)/tsmattsmatmult: $TSMATTSMATMULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tsmattsmatmult $TSMATTSMATMULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TSMatTSMatMult.o:
	@echo
	@echo "Building transpose sparse matrix/transpose sparse matrix multiplication (tsmattsmatmult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TSMatTSMatMult.o \$(INSTALL_PATH)/src/blaze/TSMatTSMatMult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TSMatTSMatMult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TSMatTSMatMult.o \$(INSTALL_PATH)/src/boost/TSMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TSMatTSMatMult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TSMatTSMatMult.o \$(INSTALL_PATH)/src/gmm/TSMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TSMatTSMatMult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TSMatTSMatMult.o \$(INSTALL_PATH)/src/mtl/TSMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TSMatTSMatMult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TSMatTSMatMult.o \$(INSTALL_PATH)/src/eigen/TSMatTSMatMult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TSMatTSMatMult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TSMatTSMatMult.o \$(INSTALL_PATH)/src/main/TSMatTSMatMult.cpp \$(INCLUDES)
EOF


# 3-dimensional vector/vector addition
cat >> Makefile <<EOF

vec3vec3add: \$(BINARY_PATH)/vec3vec3add
\$(BINARY_PATH)/vec3vec3add: $VEC3VEC3ADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/vec3vec3add $VEC3VEC3ADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Vec3Vec3Add.o:
	@echo
	@echo "Building 3-dimensional vector/vector addition (vec3vec3add) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Vec3Vec3Add.o \$(INSTALL_PATH)/src/blaze/Vec3Vec3Add.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Vec3Vec3Add.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Vec3Vec3Add.o \$(INSTALL_PATH)/src/boost/Vec3Vec3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Vec3Vec3Add.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Vec3Vec3Add.o \$(INSTALL_PATH)/src/blitz/Vec3Vec3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Vec3Vec3Add.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Vec3Vec3Add.o \$(INSTALL_PATH)/src/gmm/Vec3Vec3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Vec3Vec3Add.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Vec3Vec3Add.o \$(INSTALL_PATH)/src/armadillo/Vec3Vec3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Vec3Vec3Add.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Vec3Vec3Add.o \$(INSTALL_PATH)/src/flens/Vec3Vec3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Vec3Vec3Add.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Vec3Vec3Add.o \$(INSTALL_PATH)/src/mtl/Vec3Vec3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Vec3Vec3Add.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Vec3Vec3Add.o \$(INSTALL_PATH)/src/eigen/Vec3Vec3Add.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Vec3Vec3Add.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Vec3Vec3Add.o \$(INSTALL_PATH)/src/main/Vec3Vec3Add.cpp \$(INCLUDES)
EOF


# 6-dimensional vector/vector addition
cat >> Makefile <<EOF

vec6vec6add: \$(BINARY_PATH)/vec6vec6add
\$(BINARY_PATH)/vec6vec6add: $VEC6VEC6ADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/vec6vec6add $VEC6VEC6ADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Vec6Vec6Add.o:
	@echo
	@echo "Building 6-dimensional vector/vector addition (vec6vec6add) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Vec6Vec6Add.o \$(INSTALL_PATH)/src/blaze/Vec6Vec6Add.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Vec6Vec6Add.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Vec6Vec6Add.o \$(INSTALL_PATH)/src/boost/Vec6Vec6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Vec6Vec6Add.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Vec6Vec6Add.o \$(INSTALL_PATH)/src/blitz/Vec6Vec6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Vec6Vec6Add.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Vec6Vec6Add.o \$(INSTALL_PATH)/src/gmm/Vec6Vec6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Vec6Vec6Add.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Vec6Vec6Add.o \$(INSTALL_PATH)/src/armadillo/Vec6Vec6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Vec6Vec6Add.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Vec6Vec6Add.o \$(INSTALL_PATH)/src/flens/Vec6Vec6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Vec6Vec6Add.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Vec6Vec6Add.o \$(INSTALL_PATH)/src/mtl/Vec6Vec6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Vec6Vec6Add.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Vec6Vec6Add.o \$(INSTALL_PATH)/src/eigen/Vec6Vec6Add.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Vec6Vec6Add.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Vec6Vec6Add.o \$(INSTALL_PATH)/src/main/Vec6Vec6Add.cpp \$(INCLUDES)
EOF


# 3-dimensional matrix/vector multiplication
cat >> Makefile <<EOF

mat3vec3mult: \$(BINARY_PATH)/mat3vec3mult
\$(BINARY_PATH)/mat3vec3mult: $MAT3VEC3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat3vec3mult $MAT3VEC3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_Mat3Vec3Mult.o:
	@echo
	@echo "Building 3-dimensional matrix/vector multiplication (mat3vec3mult) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/clike/Mat3Vec3Mult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Mat3Vec3Mult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/blaze/Mat3Vec3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat3Vec3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/boost/Mat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat3Vec3Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/blitz/Mat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat3Vec3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/flens/Mat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat3Vec3Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/mtl/Mat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat3Vec3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/eigen/Mat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat3Vec3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat3Vec3Mult.o \$(INSTALL_PATH)/src/main/Mat3Vec3Mult.cpp \$(INCLUDES)
EOF


# 3-dimensional transpose matrix/vector multiplication
cat >> Makefile <<EOF

tmat3vec3mult: \$(BINARY_PATH)/tmat3vec3mult
\$(BINARY_PATH)/tmat3vec3mult: $TMAT3VEC3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat3vec3mult $TMAT3VEC3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLIKE_TMat3Vec3Mult.o:
	@echo
	@echo "Building 3-dimensional transpose matrix/vector multiplication (tmat3vec3mult) binary..."
	@echo "  Building the C-like kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLIKE_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/clike/TMat3Vec3Mult.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_TMat3Vec3Mult.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/blaze/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat3Vec3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/boost/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TMat3Vec3Mult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/gmm/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TMat3Vec3Mult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/armadillo/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat3Vec3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/flens/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat3Vec3Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/mtl/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat3Vec3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/eigen/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat3Vec3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat3Vec3Mult.o \$(INSTALL_PATH)/src/main/TMat3Vec3Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional matrix/vector multiplication
cat >> Makefile <<EOF

mat6vec6mult: \$(BINARY_PATH)/mat6vec6mult
\$(BINARY_PATH)/mat6vec6mult: $MAT6VEC6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat6vec6mult $MAT6VEC6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Mat6Vec6Mult.o:
	@echo
	@echo "Building 6-dimensional matrix/vector multiplication (mat6vec6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat6Vec6Mult.o \$(INSTALL_PATH)/src/blaze/Mat6Vec6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat6Vec6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat6Vec6Mult.o \$(INSTALL_PATH)/src/boost/Mat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat6Vec6Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat6Vec6Mult.o \$(INSTALL_PATH)/src/blitz/Mat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat6Vec6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat6Vec6Mult.o \$(INSTALL_PATH)/src/flens/Mat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat6Vec6Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat6Vec6Mult.o \$(INSTALL_PATH)/src/mtl/Mat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat6Vec6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat6Vec6Mult.o \$(INSTALL_PATH)/src/eigen/Mat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat6Vec6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat6Vec6Mult.o \$(INSTALL_PATH)/src/main/Mat6Vec6Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional transpose matrix/vector multiplication
cat >> Makefile <<EOF

tmat6vec6mult: \$(BINARY_PATH)/tmat6vec6mult
\$(BINARY_PATH)/tmat6vec6mult: $TMAT6VEC6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat6vec6mult $TMAT6VEC6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TMat6Vec6Mult.o:
	@echo
	@echo "Building 6-dimensional transpose matrix/vector multiplication (tmat6vec6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/blaze/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat6Vec6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/boost/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TMat6Vec6Mult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/gmm/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TMat6Vec6Mult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/armadillo/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat6Vec6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/flens/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat6Vec6Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/mtl/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat6Vec6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/eigen/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat6Vec6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat6Vec6Mult.o \$(INSTALL_PATH)/src/main/TMat6Vec6Mult.cpp \$(INCLUDES)
EOF


# 3-dimensional transpose vector/matrix multiplication
cat >> Makefile <<EOF

tvec3mat3mult: \$(BINARY_PATH)/tvec3mat3mult
\$(BINARY_PATH)/tvec3mat3mult: $TVEC3MAT3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tvec3mat3mult $TVEC3MAT3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TVec3Mat3Mult.o:
	@echo
	@echo "Building 3-dimensional transpose vector/matrix multiplication (tvec3mat3mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TVec3Mat3Mult.o \$(INSTALL_PATH)/src/blaze/TVec3Mat3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TVec3Mat3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TVec3Mat3Mult.o \$(INSTALL_PATH)/src/boost/TVec3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TVec3Mat3Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TVec3Mat3Mult.o \$(INSTALL_PATH)/src/blitz/TVec3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TVec3Mat3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TVec3Mat3Mult.o \$(INSTALL_PATH)/src/flens/TVec3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TVec3Mat3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TVec3Mat3Mult.o \$(INSTALL_PATH)/src/eigen/TVec3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TVec3Mat3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TVec3Mat3Mult.o \$(INSTALL_PATH)/src/main/TVec3Mat3Mult.cpp \$(INCLUDES)
EOF


# 3-dimensional transpose vector/transpose matrix multiplication
cat >> Makefile <<EOF

tvec3tmat3mult: \$(BINARY_PATH)/tvec3tmat3mult
\$(BINARY_PATH)/tvec3tmat3mult: $TVEC3TMAT3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tvec3tmat3mult $TVEC3TMAT3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TVec3TMat3Mult.o:
	@echo
	@echo "Building 3-dimensional transpose vector/transpose matrix multiplication (tvec3tmat3mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TVec3TMat3Mult.o \$(INSTALL_PATH)/src/blaze/TVec3TMat3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TVec3TMat3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TVec3TMat3Mult.o \$(INSTALL_PATH)/src/boost/TVec3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TVec3TMat3Mult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TVec3TMat3Mult.o \$(INSTALL_PATH)/src/armadillo/TVec3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TVec3TMat3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TVec3TMat3Mult.o \$(INSTALL_PATH)/src/flens/TVec3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TVec3TMat3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TVec3TMat3Mult.o \$(INSTALL_PATH)/src/eigen/TVec3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TVec3TMat3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TVec3TMat3Mult.o \$(INSTALL_PATH)/src/main/TVec3TMat3Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional transpose vector/matrix multiplication
cat >> Makefile <<EOF

tvec6mat6mult: \$(BINARY_PATH)/tvec6mat6mult
\$(BINARY_PATH)/tvec6mat6mult: $TVEC6MAT6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tvec6mat6mult $TVEC6MAT6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TVec6Mat6Mult.o:
	@echo
	@echo "Building 6-dimensional transpose vector/matrix multiplication (tvec6mat6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TVec6Mat6Mult.o \$(INSTALL_PATH)/src/blaze/TVec6Mat6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TVec6Mat6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TVec6Mat6Mult.o \$(INSTALL_PATH)/src/boost/TVec6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TVec6Mat6Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TVec6Mat6Mult.o \$(INSTALL_PATH)/src/blitz/TVec6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TVec6Mat6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TVec6Mat6Mult.o \$(INSTALL_PATH)/src/flens/TVec6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TVec6Mat6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TVec6Mat6Mult.o \$(INSTALL_PATH)/src/eigen/TVec6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TVec6Mat6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TVec6Mat6Mult.o \$(INSTALL_PATH)/src/main/TVec6Mat6Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional transpose vector/transpose matrix multiplication
cat >> Makefile <<EOF

tvec6tmat6mult: \$(BINARY_PATH)/tvec6tmat6mult
\$(BINARY_PATH)/tvec6tmat6mult: $TVEC6TMAT6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tvec6tmat6mult $TVEC6TMAT6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TVec6TMat6Mult.o:
	@echo
	@echo "Building 6-dimensional transpose vector/transpose matrix multiplication (tvec6tmat6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TVec6TMat6Mult.o \$(INSTALL_PATH)/src/blaze/TVec6TMat6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TVec6TMat6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TVec6TMat6Mult.o \$(INSTALL_PATH)/src/boost/TVec6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TVec6TMat6Mult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TVec6TMat6Mult.o \$(INSTALL_PATH)/src/armadillo/TVec6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TVec6TMat6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TVec6TMat6Mult.o \$(INSTALL_PATH)/src/flens/TVec6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TVec6TMat6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TVec6TMat6Mult.o \$(INSTALL_PATH)/src/eigen/TVec6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TVec6TMat6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TVec6TMat6Mult.o \$(INSTALL_PATH)/src/main/TVec6TMat6Mult.cpp \$(INCLUDES)
EOF


# 3-dimensional matrix/matrix addition
cat >> Makefile <<EOF

mat3mat3add: \$(BINARY_PATH)/mat3mat3add
\$(BINARY_PATH)/mat3mat3add: $MAT3MAT3ADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat3mat3add $MAT3MAT3ADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Mat3Mat3Add.o:
	@echo
	@echo "Building 3-dimensional matrix/matrix addition (mat3mat3add) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat3Mat3Add.o \$(INSTALL_PATH)/src/blaze/Mat3Mat3Add.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat3Mat3Add.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat3Mat3Add.o \$(INSTALL_PATH)/src/boost/Mat3Mat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat3Mat3Add.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat3Mat3Add.o \$(INSTALL_PATH)/src/blitz/Mat3Mat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat3Mat3Add.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat3Mat3Add.o \$(INSTALL_PATH)/src/flens/Mat3Mat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat3Mat3Add.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat3Mat3Add.o \$(INSTALL_PATH)/src/mtl/Mat3Mat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat3Mat3Add.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat3Mat3Add.o \$(INSTALL_PATH)/src/eigen/Mat3Mat3Add.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat3Mat3Add.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat3Mat3Add.o \$(INSTALL_PATH)/src/main/Mat3Mat3Add.cpp \$(INCLUDES)
EOF


# 3-dimensional transpose matrix/transpose matrix addition
cat >> Makefile <<EOF

tmat3tmat3add: \$(BINARY_PATH)/tmat3tmat3add
\$(BINARY_PATH)/tmat3tmat3add: $TMAT3TMAT3ADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat3tmat3add $TMAT3TMAT3ADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TMat3TMat3Add.o:
	@echo
	@echo "Building 3-dimensional matrix/matrix addition (tmat3tmat3add) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat3TMat3Add.o \$(INSTALL_PATH)/src/blaze/TMat3TMat3Add.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat3TMat3Add.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat3TMat3Add.o \$(INSTALL_PATH)/src/boost/TMat3TMat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TMat3TMat3Add.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TMat3TMat3Add.o \$(INSTALL_PATH)/src/blitz/TMat3TMat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TMat3TMat3Add.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TMat3TMat3Add.o \$(INSTALL_PATH)/src/gmm/TMat3TMat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TMat3TMat3Add.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TMat3TMat3Add.o \$(INSTALL_PATH)/src/armadillo/TMat3TMat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat3TMat3Add.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat3TMat3Add.o \$(INSTALL_PATH)/src/flens/TMat3TMat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat3TMat3Add.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat3TMat3Add.o \$(INSTALL_PATH)/src/mtl/TMat3TMat3Add.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat3TMat3Add.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat3TMat3Add.o \$(INSTALL_PATH)/src/eigen/TMat3TMat3Add.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat3TMat3Add.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat3TMat3Add.o \$(INSTALL_PATH)/src/main/TMat3TMat3Add.cpp \$(INCLUDES)
EOF


# 6-dimensional matrix/matrix addition
cat >> Makefile <<EOF

mat6mat6add: \$(BINARY_PATH)/mat6mat6add
\$(BINARY_PATH)/mat6mat6add: $MAT6MAT6ADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat6mat6add $MAT6MAT6ADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Mat6Mat6Add.o:
	@echo
	@echo "Building 6-dimensional matrix/matrix addition (mat6mat6add) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat6Mat6Add.o \$(INSTALL_PATH)/src/blaze/Mat6Mat6Add.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat6Mat6Add.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat6Mat6Add.o \$(INSTALL_PATH)/src/boost/Mat6Mat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat6Mat6Add.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat6Mat6Add.o \$(INSTALL_PATH)/src/blitz/Mat6Mat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat6Mat6Add.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat6Mat6Add.o \$(INSTALL_PATH)/src/flens/Mat6Mat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat6Mat6Add.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat6Mat6Add.o \$(INSTALL_PATH)/src/mtl/Mat6Mat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat6Mat6Add.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat6Mat6Add.o \$(INSTALL_PATH)/src/eigen/Mat6Mat6Add.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat6Mat6Add.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat6Mat6Add.o \$(INSTALL_PATH)/src/main/Mat6Mat6Add.cpp \$(INCLUDES)
EOF


# 6-dimensional transpose matrix/transpose matrix addition
cat >> Makefile <<EOF

tmat6tmat6add: \$(BINARY_PATH)/tmat6tmat6add
\$(BINARY_PATH)/tmat6tmat6add: $TMAT6TMAT6ADD
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat6tmat6add $TMAT6TMAT6ADD \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TMat6TMat6Add.o:
	@echo
	@echo "Building 6-dimensional matrix/matrix addition (tmat6tmat6add) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat6TMat6Add.o \$(INSTALL_PATH)/src/blaze/TMat6TMat6Add.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat6TMat6Add.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat6TMat6Add.o \$(INSTALL_PATH)/src/boost/TMat6TMat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TMat6TMat6Add.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TMat6TMat6Add.o \$(INSTALL_PATH)/src/blitz/TMat6TMat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TMat6TMat6Add.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TMat6TMat6Add.o \$(INSTALL_PATH)/src/gmm/TMat6TMat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TMat6TMat6Add.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TMat6TMat6Add.o \$(INSTALL_PATH)/src/armadillo/TMat6TMat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat6TMat6Add.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat6TMat6Add.o \$(INSTALL_PATH)/src/flens/TMat6TMat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat6TMat6Add.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat6TMat6Add.o \$(INSTALL_PATH)/src/mtl/TMat6TMat6Add.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat6TMat6Add.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat6TMat6Add.o \$(INSTALL_PATH)/src/eigen/TMat6TMat6Add.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat6TMat6Add.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat6TMat6Add.o \$(INSTALL_PATH)/src/main/TMat6TMat6Add.cpp \$(INCLUDES)
EOF


# 3-dimensional matrix/matrix multiplication
cat >> Makefile <<EOF

mat3mat3mult: \$(BINARY_PATH)/mat3mat3mult
\$(BINARY_PATH)/mat3mat3mult: $MAT3MAT3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat3mat3mult $MAT3MAT3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Mat3Mat3Mult.o:
	@echo
	@echo "Building 3-dimensional matrix/matrix multiplication (mat3mat3mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat3Mat3Mult.o \$(INSTALL_PATH)/src/blaze/Mat3Mat3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat3Mat3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat3Mat3Mult.o \$(INSTALL_PATH)/src/boost/Mat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat3Mat3Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat3Mat3Mult.o \$(INSTALL_PATH)/src/blitz/Mat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat3Mat3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat3Mat3Mult.o \$(INSTALL_PATH)/src/flens/Mat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat3Mat3Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat3Mat3Mult.o \$(INSTALL_PATH)/src/mtl/Mat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat3Mat3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat3Mat3Mult.o \$(INSTALL_PATH)/src/eigen/Mat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat3Mat3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat3Mat3Mult.o \$(INSTALL_PATH)/src/main/Mat3Mat3Mult.cpp \$(INCLUDES)
EOF


# 3-dimensional matrix/transpose matrix multiplication
cat >> Makefile <<EOF

mat3tmat3mult: \$(BINARY_PATH)/mat3tmat3mult
\$(BINARY_PATH)/mat3tmat3mult: $MAT3TMAT3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat3tmat3mult $MAT3TMAT3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Mat3TMat3Mult.o:
	@echo
	@echo "Building 3-dimensional matrix/transpose matrix multiplication (mat3tmat3mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat3TMat3Mult.o \$(INSTALL_PATH)/src/blaze/Mat3TMat3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat3TMat3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat3TMat3Mult.o \$(INSTALL_PATH)/src/boost/Mat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat3TMat3Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat3TMat3Mult.o \$(INSTALL_PATH)/src/blitz/Mat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat3TMat3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat3TMat3Mult.o \$(INSTALL_PATH)/src/flens/Mat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat3TMat3Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat3TMat3Mult.o \$(INSTALL_PATH)/src/mtl/Mat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat3TMat3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat3TMat3Mult.o \$(INSTALL_PATH)/src/eigen/Mat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat3TMat3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat3TMat3Mult.o \$(INSTALL_PATH)/src/main/Mat3TMat3Mult.cpp \$(INCLUDES)
EOF


# 3-dimensional transpose matrix/matrix multiplication
cat >> Makefile <<EOF

tmat3mat3mult: \$(BINARY_PATH)/tmat3mat3mult
\$(BINARY_PATH)/tmat3mat3mult: $TMAT3MAT3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat3mat3mult $TMAT3MAT3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TMat3Mat3Mult.o:
	@echo
	@echo "Building 3-dimensional transpose matrix/matrix multiplication (tmat3mat3mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat3Mat3Mult.o \$(INSTALL_PATH)/src/blaze/TMat3Mat3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat3Mat3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat3Mat3Mult.o \$(INSTALL_PATH)/src/boost/TMat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TMat3Mat3Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TMat3Mat3Mult.o \$(INSTALL_PATH)/src/blitz/TMat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat3Mat3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat3Mat3Mult.o \$(INSTALL_PATH)/src/flens/TMat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat3Mat3Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat3Mat3Mult.o \$(INSTALL_PATH)/src/mtl/TMat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat3Mat3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat3Mat3Mult.o \$(INSTALL_PATH)/src/eigen/TMat3Mat3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat3Mat3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat3Mat3Mult.o \$(INSTALL_PATH)/src/main/TMat3Mat3Mult.cpp \$(INCLUDES)
EOF


# 3-dimensional transpose matrix/transpose matrix multiplication
cat >> Makefile <<EOF

tmat3tmat3mult: \$(BINARY_PATH)/tmat3tmat3mult
\$(BINARY_PATH)/tmat3tmat3mult: $TMAT3TMAT3MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat3tmat3mult $TMAT3TMAT3MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TMat3TMat3Mult.o:
	@echo
	@echo "Building 3-dimensional transpose matrix/transpose matrix multiplication (tmat3tmat3mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/blaze/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat3TMat3Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/boost/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TMat3TMat3Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/blitz/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TMat3TMat3Mult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/gmm/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TMat3TMat3Mult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/armadillo/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat3TMat3Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/flens/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat3TMat3Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/mtl/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat3TMat3Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/eigen/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat3TMat3Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat3TMat3Mult.o \$(INSTALL_PATH)/src/main/TMat3TMat3Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional matrix/matrix multiplication
cat >> Makefile <<EOF

mat6mat6mult: \$(BINARY_PATH)/mat6mat6mult
\$(BINARY_PATH)/mat6mat6mult: $MAT6MAT6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat6mat6mult $MAT6MAT6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Mat6Mat6Mult.o:
	@echo
	@echo "Building 6-dimensional matrix/matrix multiplication (mat6mat6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat6Mat6Mult.o \$(INSTALL_PATH)/src/blaze/Mat6Mat6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat6Mat6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat6Mat6Mult.o \$(INSTALL_PATH)/src/boost/Mat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat6Mat6Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat6Mat6Mult.o \$(INSTALL_PATH)/src/blitz/Mat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat6Mat6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat6Mat6Mult.o \$(INSTALL_PATH)/src/flens/Mat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat6Mat6Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat6Mat6Mult.o \$(INSTALL_PATH)/src/mtl/Mat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat6Mat6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat6Mat6Mult.o \$(INSTALL_PATH)/src/eigen/Mat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat6Mat6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat6Mat6Mult.o \$(INSTALL_PATH)/src/main/Mat6Mat6Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional matrix/transpose matrix multiplication
cat >> Makefile <<EOF

mat6tmat6mult: \$(BINARY_PATH)/mat6tmat6mult
\$(BINARY_PATH)/mat6tmat6mult: $MAT6TMAT6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/mat6tmat6mult $MAT6TMAT6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Mat6TMat6Mult.o:
	@echo
	@echo "Building 6-dimensional matrix/transpose matrix multiplication (mat6tmat6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Mat6TMat6Mult.o \$(INSTALL_PATH)/src/blaze/Mat6TMat6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Mat6TMat6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Mat6TMat6Mult.o \$(INSTALL_PATH)/src/boost/Mat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Mat6TMat6Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Mat6TMat6Mult.o \$(INSTALL_PATH)/src/blitz/Mat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Mat6TMat6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Mat6TMat6Mult.o \$(INSTALL_PATH)/src/flens/Mat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Mat6TMat6Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Mat6TMat6Mult.o \$(INSTALL_PATH)/src/mtl/Mat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Mat6TMat6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Mat6TMat6Mult.o \$(INSTALL_PATH)/src/eigen/Mat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Mat6TMat6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Mat6TMat6Mult.o \$(INSTALL_PATH)/src/main/Mat6TMat6Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional transpose matrix/matrix multiplication
cat >> Makefile <<EOF

tmat6mat6mult: \$(BINARY_PATH)/tmat6mat6mult
\$(BINARY_PATH)/tmat6mat6mult: $TMAT6MAT6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat6mat6mult $TMAT6MAT6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TMat6Mat6Mult.o:
	@echo
	@echo "Building 6-dimensional transpose matrix/matrix multiplication (tmat6mat6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat6Mat6Mult.o \$(INSTALL_PATH)/src/blaze/TMat6Mat6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat6Mat6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat6Mat6Mult.o \$(INSTALL_PATH)/src/boost/TMat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TMat6Mat6Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TMat6Mat6Mult.o \$(INSTALL_PATH)/src/blitz/TMat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat6Mat6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat6Mat6Mult.o \$(INSTALL_PATH)/src/flens/TMat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat6Mat6Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat6Mat6Mult.o \$(INSTALL_PATH)/src/mtl/TMat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat6Mat6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat6Mat6Mult.o \$(INSTALL_PATH)/src/eigen/TMat6Mat6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat6Mat6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat6Mat6Mult.o \$(INSTALL_PATH)/src/main/TMat6Mat6Mult.cpp \$(INCLUDES)
EOF


# 6-dimensional transpose matrix/transpose matrix multiplication
cat >> Makefile <<EOF

tmat6tmat6mult: \$(BINARY_PATH)/tmat6tmat6mult
\$(BINARY_PATH)/tmat6tmat6mult: $TMAT6TMAT6MULT
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/tmat6tmat6mult $TMAT6TMAT6MULT \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_TMat6TMat6Mult.o:
	@echo
	@echo "Building 6-dimensional matrix/matrix multiplication (tmat6tmat6mult) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/blaze/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_TMat6TMat6Mult.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/boost/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_TMat6TMat6Mult.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/blitz/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_TMat6TMat6Mult.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/gmm/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_TMat6TMat6Mult.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/armadillo/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_TMat6TMat6Mult.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/flens/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_TMat6TMat6Mult.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/mtl/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_TMat6TMat6Mult.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/eigen/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_TMat6TMat6Mult.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_TMat6TMat6Mult.o \$(INSTALL_PATH)/src/main/TMat6TMat6Mult.cpp \$(INCLUDES)
EOF


# Complex expression d = A * ( a + b ) (complex1)
cat >> Makefile <<EOF

complex1: \$(BINARY_PATH)/complex1
\$(BINARY_PATH)/complex1: $COMPLEX1
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex1 $COMPLEX1 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex1.o:
	@echo
	@echo "Building complex expression ( c = A * ( a + b ) ) (complex1) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex1.o \$(INSTALL_PATH)/src/classic/Complex1.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex1.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex1.o \$(INSTALL_PATH)/src/blaze/Complex1.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex1.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex1.o \$(INSTALL_PATH)/src/boost/Complex1.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex1.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex1.o \$(INSTALL_PATH)/src/blitz/Complex1.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex1.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex1.o \$(INSTALL_PATH)/src/gmm/Complex1.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex1.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex1.o \$(INSTALL_PATH)/src/armadillo/Complex1.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex1.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex1.o \$(INSTALL_PATH)/src/flens/Complex1.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex1.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex1.o \$(INSTALL_PATH)/src/mtl/Complex1.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex1.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex1.o \$(INSTALL_PATH)/src/eigen/Complex1.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex1.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex1.o \$(INSTALL_PATH)/src/main/Complex1.cpp \$(INCLUDES)
EOF


# Complex expression d = A * ( a + b + c ) (complex2)
cat >> Makefile <<EOF

complex2: \$(BINARY_PATH)/complex2
\$(BINARY_PATH)/complex2: $COMPLEX2
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex2 $COMPLEX2 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex2.o:
	@echo
	@echo "Building complex expression ( d = A * ( a + b + c ) ) (complex2) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex2.o \$(INSTALL_PATH)/src/classic/Complex2.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex2.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex2.o \$(INSTALL_PATH)/src/blaze/Complex2.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex2.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex2.o \$(INSTALL_PATH)/src/boost/Complex2.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex2.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex2.o \$(INSTALL_PATH)/src/blitz/Complex2.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex2.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex2.o \$(INSTALL_PATH)/src/gmm/Complex2.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex2.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex2.o \$(INSTALL_PATH)/src/armadillo/Complex2.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex2.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex2.o \$(INSTALL_PATH)/src/flens/Complex2.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex2.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex2.o \$(INSTALL_PATH)/src/mtl/Complex2.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex2.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex2.o \$(INSTALL_PATH)/src/eigen/Complex2.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex2.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex2.o \$(INSTALL_PATH)/src/main/Complex2.cpp \$(INCLUDES)
EOF


# Complex expression c = A * B * ( a + b ) (complex3)
cat >> Makefile <<EOF

complex3: \$(BINARY_PATH)/complex3
\$(BINARY_PATH)/complex3: $COMPLEX3
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex3 $COMPLEX3 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex3.o:
	@echo
	@echo "Building complex expression ( c = A * B * ( a + b ) ) (complex3) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex3.o \$(INSTALL_PATH)/src/classic/Complex3.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex3.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex3.o \$(INSTALL_PATH)/src/blaze/Complex3.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex3.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex3.o \$(INSTALL_PATH)/src/boost/Complex3.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex3.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex3.o \$(INSTALL_PATH)/src/blitz/Complex3.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex3.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex3.o \$(INSTALL_PATH)/src/gmm/Complex3.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex3.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex3.o \$(INSTALL_PATH)/src/armadillo/Complex3.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex3.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex3.o \$(INSTALL_PATH)/src/flens/Complex3.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex3.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex3.o \$(INSTALL_PATH)/src/mtl/Complex3.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex3.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex3.o \$(INSTALL_PATH)/src/eigen/Complex3.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex3.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex3.o \$(INSTALL_PATH)/src/main/Complex3.cpp \$(INCLUDES)
EOF


# Complex expression b += s * A * a (complex4)
cat >> Makefile <<EOF

complex4: \$(BINARY_PATH)/complex4
\$(BINARY_PATH)/complex4: $COMPLEX4
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex4 $COMPLEX4 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex4.o:
	@echo
	@echo "Building complex expression ( b += s * A * a ) (complex4) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex4.o \$(INSTALL_PATH)/src/classic/Complex4.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex4.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex4.o \$(INSTALL_PATH)/src/blaze/Complex4.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex4.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex4.o \$(INSTALL_PATH)/src/boost/Complex4.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex4.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex4.o \$(INSTALL_PATH)/src/blitz/Complex4.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex4.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex4.o \$(INSTALL_PATH)/src/gmm/Complex4.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex4.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex4.o \$(INSTALL_PATH)/src/armadillo/Complex4.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex4.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex4.o \$(INSTALL_PATH)/src/flens/Complex4.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex4.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex4.o \$(INSTALL_PATH)/src/mtl/Complex4.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex4.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex4.o \$(INSTALL_PATH)/src/eigen/Complex4.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex4.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex4.o \$(INSTALL_PATH)/src/main/Complex4.cpp \$(INCLUDES)
EOF


# Complex expression D = ( A * B ) + C (complex5)
cat >> Makefile <<EOF

complex5: \$(BINARY_PATH)/complex5
\$(BINARY_PATH)/complex5: $COMPLEX5
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex5 $COMPLEX5 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex5.o:
	@echo
	@echo "Building complex expression ( D = ( A * B ) + C ) (complex5) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex5.o \$(INSTALL_PATH)/src/classic/Complex5.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex5.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex5.o \$(INSTALL_PATH)/src/blaze/Complex5.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex5.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex5.o \$(INSTALL_PATH)/src/boost/Complex5.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex5.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex5.o \$(INSTALL_PATH)/src/blitz/Complex5.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex5.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex5.o \$(INSTALL_PATH)/src/gmm/Complex5.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex5.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex5.o \$(INSTALL_PATH)/src/armadillo/Complex5.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex5.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex5.o \$(INSTALL_PATH)/src/flens/Complex5.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex5.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex5.o \$(INSTALL_PATH)/src/mtl/Complex5.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex5.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex5.o \$(INSTALL_PATH)/src/eigen/Complex5.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex5.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex5.o \$(INSTALL_PATH)/src/main/Complex5.cpp \$(INCLUDES)
EOF


# Complex expression D = A * B * C (complex6)
cat >> Makefile <<EOF

complex6: \$(BINARY_PATH)/complex6
\$(BINARY_PATH)/complex6: $COMPLEX6
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex6 $COMPLEX6 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex6.o:
	@echo
	@echo "Building complex expression ( D = A * B * C ) (complex6) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex6.o \$(INSTALL_PATH)/src/classic/Complex6.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex6.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex6.o \$(INSTALL_PATH)/src/blaze/Complex6.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex6.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex6.o \$(INSTALL_PATH)/src/boost/Complex6.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex6.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex6.o \$(INSTALL_PATH)/src/blitz/Complex6.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex6.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex6.o \$(INSTALL_PATH)/src/gmm/Complex6.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex6.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex6.o \$(INSTALL_PATH)/src/armadillo/Complex6.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex6.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex6.o \$(INSTALL_PATH)/src/flens/Complex6.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex6.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex6.o \$(INSTALL_PATH)/src/mtl/Complex6.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex6.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex6.o \$(INSTALL_PATH)/src/eigen/Complex6.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex6.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex6.o \$(INSTALL_PATH)/src/main/Complex6.cpp \$(INCLUDES)
EOF


# Complex expression E = ( A + B ) * ( C - D ) (complex7)
cat >> Makefile <<EOF

complex7: \$(BINARY_PATH)/complex7
\$(BINARY_PATH)/complex7: $COMPLEX7
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex7 $COMPLEX7 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex7.o:
	@echo
	@echo "Building complex expression ( E = ( A + B ) * ( C - D ) ) (complex7) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex7.o \$(INSTALL_PATH)/src/classic/Complex7.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex7.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex7.o \$(INSTALL_PATH)/src/blaze/Complex7.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex7.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex7.o \$(INSTALL_PATH)/src/boost/Complex7.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex7.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex7.o \$(INSTALL_PATH)/src/blitz/Complex7.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex7.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex7.o \$(INSTALL_PATH)/src/gmm/Complex7.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex7.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex7.o \$(INSTALL_PATH)/src/armadillo/Complex7.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex7.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex7.o \$(INSTALL_PATH)/src/flens/Complex7.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex7.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex7.o \$(INSTALL_PATH)/src/mtl/Complex7.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex7.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex7.o \$(INSTALL_PATH)/src/eigen/Complex7.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex7.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex7.o \$(INSTALL_PATH)/src/main/Complex7.cpp \$(INCLUDES)
EOF


# Complex expression C += s * A * B (complex8)
cat >> Makefile <<EOF

complex8: \$(BINARY_PATH)/complex8
\$(BINARY_PATH)/complex8: $COMPLEX8
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/complex8 $COMPLEX8 \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/CLASSIC_Complex8.o:
	@echo
	@echo "Building complex expression ( C += s * A * B ) (complex8) binary..."
	@echo "  Building the classic kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/CLASSIC_Complex8.o \$(INSTALL_PATH)/src/classic/Complex8.cpp \$(INCLUDES)
\$(OBJECT_PATH)/BLAZE_Complex8.o:
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Complex8.o \$(INSTALL_PATH)/src/blaze/Complex8.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Complex8.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Complex8.o \$(INSTALL_PATH)/src/boost/Complex8.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Complex8.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Complex8.o \$(INSTALL_PATH)/src/blitz/Complex8.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Complex8.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Complex8.o \$(INSTALL_PATH)/src/gmm/Complex8.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Complex8.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Complex8.o \$(INSTALL_PATH)/src/armadillo/Complex8.cpp \$(INCLUDES)
EOF
fi

if [ "$FLENS" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/FLENS_Complex8.o:
	@echo "  Building the FLENS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/FLENS_Complex8.o \$(INSTALL_PATH)/src/flens/Complex8.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Complex8.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Complex8.o \$(INSTALL_PATH)/src/mtl/Complex8.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Complex8.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Complex8.o \$(INSTALL_PATH)/src/eigen/Complex8.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Complex8.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Complex8.o \$(INSTALL_PATH)/src/main/Complex8.cpp \$(INCLUDES)
EOF


# Conjugate gradient (cg)
cat >> Makefile <<EOF

cg: \$(BINARY_PATH)/cg
\$(BINARY_PATH)/cg: $CG
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/cg $CG \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_CG.o:
	@echo
	@echo "Building conjugate gradient (cg) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_CG.o \$(INSTALL_PATH)/src/blaze/CG.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_CG.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_CG.o \$(INSTALL_PATH)/src/boost/CG.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_CG.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_CG.o \$(INSTALL_PATH)/src/gmm/CG.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_CG.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_CG.o \$(INSTALL_PATH)/src/mtl/CG.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_CG.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_CG.o \$(INSTALL_PATH)/src/eigen/CG.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_CG.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_CG.o \$(INSTALL_PATH)/src/main/CG.cpp \$(INCLUDES)
EOF


# Custom expressions (custom)
cat >> Makefile <<EOF

custom: \$(BINARY_PATH)/custom
\$(BINARY_PATH)/custom: $CUSTOM
	${SILENT}\$(CXX) \$(CXXFLAGS) -o \$(BINARY_PATH)/custom $CUSTOM \$(LIBRARIES)
	@echo "... finished"
	@echo
\$(OBJECT_PATH)/BLAZE_Custom.o:
	@echo
	@echo "Building custom expression (custom) binary..."
	@echo "  Building the Blaze kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLAZE_Custom.o \$(INSTALL_PATH)/src/blaze/Custom.cpp \$(INCLUDES)
EOF

if [ "$BOOST" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BOOST_Custom.o:
	@echo "  Building the Boost uBLAS kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BOOST_Custom.o \$(INSTALL_PATH)/src/boost/Custom.cpp \$(INCLUDES)
EOF
fi

if [ "$BLITZ" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/BLITZ_Custom.o:
	@echo "  Building the Blitz++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/BLITZ_Custom.o \$(INSTALL_PATH)/src/blitz/Custom.cpp \$(INCLUDES)
EOF
fi

if [ "$GMM" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/GMM_Custom.o:
	@echo "  Building the GMM++ kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/GMM_Custom.o \$(INSTALL_PATH)/src/gmm/Custom.cpp \$(INCLUDES)
EOF
fi

if [ "$ARMADILLO" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/ARMADILLO_Custom.o:
	@echo "  Building the Armadillo kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/ARMADILLO_Custom.o \$(INSTALL_PATH)/src/armadillo/Custom.cpp \$(INCLUDES)
EOF
fi

if [ "$MTL" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/MTL_Custom.o:
	@echo "  Building the MTL kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/MTL_Custom.o \$(INSTALL_PATH)/src/mtl/Custom.cpp \$(INCLUDES)
EOF
fi

if [ "$EIGEN" = "yes" ]; then
cat >> Makefile <<EOF
\$(OBJECT_PATH)/EIGEN_Custom.o:
	@echo "  Building the Eigen kernel..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -c -o \$(OBJECT_PATH)/EIGEN_Custom.o \$(INSTALL_PATH)/src/eigen/Custom.cpp \$(INCLUDES)
EOF
fi

cat >> Makefile <<EOF
\$(OBJECT_PATH)/MAIN_Custom.o:
	@echo "  Building the benchmark..."
	${SILENT}\$(CXX) \$(CXXFLAGS) -DINSTALL_PATH='"\$(INSTALL_PATH)"' -c -o \$(OBJECT_PATH)/MAIN_Custom.o \$(INSTALL_PATH)/src/main/Custom.cpp \$(INCLUDES)


# Clean up rules
clean:
	@echo "Cleaning up..."
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/clike clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/classic clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/blas clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/blaze clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/boost clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/blitz clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/gmm clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/armadillo clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/flens clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/mtl clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/eigen clean
	${SILENT}\$(MAKE) --no-print-directory -C \$(INSTALL_PATH)/src/main clean
	@\$(RM) bin/* obj/*.o


# Setting the independent commands
.PHONY: default clean \\
        bin/dvecdvecadd $DVECDVECADD \\
        bin/dvecsvecadd $DVECSVECADD \\
        bin/svecdvecadd $SVECDVECADD \\
        bin/svecsvecadd $SVECSVECADD \\
        bin/dvecdvecsub $DVECDVECSUB \\
        bin/dvecscalarmult $DVECSCALARMULT \\
        bin/svecscalarmult $SVECSCALARMULT \\
        bin/dvecdvecmult $DVECDVECMULT \\
        bin/dvecsvecmult $DVECSVECMULT \\
        bin/svecdvecmult $SVECDVECMULT \\
        bin/svecsvecmult $SVECSVECMULT \\
        bin/daxpy $DAXPY \\
        bin/dvecdveccross $DVECDVECCROSS \\
        bin/dvecsveccross $DVECSVECCROSS \\
        bin/svecdveccross $SVECDVECCROSS \\
        bin/svecsveccross $SVECSVECCROSS \\
        bin/dvecnorm $DVECNORM \\
        bin/dvecdvecinner $DVECDVECINNER \\
        bin/dvecsvecinner $DVECSVECINNER \\
        bin/svecdvecinner $SVECDVECINNER \\
        bin/svecsvecinner $SVECSVECINNER \\
        bin/dvecdvecouter $DVECDVECOUTER \\
        bin/dvecsvecouter $DVECSVECOUTER \\
        bin/svecdvecouter $SVECDVECOUTER \\
        bin/svecsvecouter $SVECSVECOUTER \\
        bin/dmatdvecmult $DMATDVECMULT \\
        bin/tdmatdvecmult $TDMATDVECMULT \\
        bin/dmatsvecmult $DMATSVECMULT \\
        bin/tdmatsvecmult $TDMATSVECMULT \\
        bin/smatdvecmult $SMATDVECMULT \\
        bin/tsmatdvecmult $TSMATDVECMULT \\
        bin/smatsvecmult $SMATSVECMULT \\
        bin/tsmatsvecmult $TSMATSVECMULT \\
        bin/tdvecdmatmult $TDVECDMATMULT \\
        bin/tdvectdmatmult $TDVECTDMATMULT \\
        bin/tsvecdmatmult $TSVECDMATMULT \\
        bin/tsvectdmatmult $TSVECTDMATMULT \\
        bin/tdvecsmatmult $TDVECSMATMULT \\
        bin/tdvectsmatmult $TDVECTSMATMULT \\
        bin/tsvecsmatmult $TSVECSMATMULT \\
        bin/tsvectsmatmult $TSVECTSMATMULT \\
        bin/dmattrans $DMATTRANS \\
        bin/smattrans $SMATTRANS \\
        bin/dmatinv $DMATINV \\
        bin/dmatdmatadd $DMATDMATADD \\
        bin/dmattdmatadd $DMATTDMATADD \\
        bin/tdmatdmatadd $TDMATDMATADD \\
        bin/tdmattdmatadd $TDMATTDMATADD \\
        bin/dmatsmatadd $DMATSMATADD \\
        bin/dmattsmatadd $DMATTSMATADD \\
        bin/tdmatsmatadd $TDMATSMATADD \\
        bin/tdmattsmatadd $TDMATTSMATADD \\
        bin/smatdmatadd $SMATDMATADD \\
        bin/smattdmatadd $SMATTDMATADD \\
        bin/tsmatdmatadd $TSMATDMATADD \\
        bin/tsmattdmatadd $TSMATTDMATADD \\
        bin/smatsmatadd $SMATSMATADD \\
        bin/smattsmatadd $SMATTSMATADD \\
        bin/tsmatsmatadd $TSMATSMATADD \\
        bin/tsmattsmatadd $TSMATTSMATADD \\
        bin/dmatdmatsub $DMATDMATSUB \\
        bin/dmatscalarmult $DMATSCALARMULT \\
        bin/smatscalarmult $SMATSCALARMULT \\
        bin/dmatdmatmult $DMATDMATMULT \\
        bin/dmattdmatmult $DMATTDMATMULT \\
        bin/tdmatdmatmult $TDMATDMATMULT \\
        bin/tdmattdmatmult $TDMATTDMATMULT \\
        bin/dmatsmatmult $DMATSMATMULT \\
        bin/dmattsmatmult $DMATTSMATMULT \\
        bin/tdmatsmatmult $TDMATSMATMULT \\
        bin/tdmattsmatmult $TDMATTSMATMULT \\
        bin/smatdmatmult $SMATDMATMULT \\
        bin/smattdmatmult $SMATTDMATMULT \\
        bin/tsmatdmatmult $TSMATDMATMULT \\
        bin/tsmattdmatmult $TSMATTDMATMULT \\
        bin/smatsmatmult $SMATSMATMULT \\
        bin/smattsmatmult $SMATTSMATMULT \\
        bin/tsmatsmatmult $TSMATSMATMULT \\
        bin/tsmattsmatmult $TSMATTSMATMULT \\
        bin/vec3vec3add $VEC3VEC3ADD \\
        bin/vec6vec6add $VEC6VEC6ADD \\
        bin/mat3vec3mult $MAT3VEC3MULT \\
        bin/tmat3vec3mult $TMAT3VEC3MULT \\
        bin/mat6vec6mult $MAT6VEC6MULT \\
        bin/tmat6vec6mult $TMAT6VEC6MULT \\
        bin/tvec3mat3mult $TVEC3MAT3MULT \\
        bin/tvec3tmat3mult $TVEC3TMAT3MULT \\
        bin/tvec6mat6mult $TVEC6MAT6MULT \\
        bin/tvec6tmat6mult $TVEC6TMAT6MULT \\
        bin/mat3mat3add $MAT3MAT3ADD \\
        bin/tmat3tmat3add $TMAT3TMAT3ADD \\
        bin/mat6mat6add $MAT6MAT6ADD \\
        bin/tmat6tmat6add $TMAT6TMAT6ADD \\
        bin/mat3mat3mult $MAT3MAT3MULT \\
        bin/mat3tmat3mult $MAT3TMAT3MULT \\
        bin/tmat3mat3mult $TMAT3MAT3MULT \\
        bin/tmat3tmat3mult $TMAT3TMAT3MULT \\
        bin/mat6mat6mult $MAT6MAT6MULT \\
        bin/mat6tmat6mult $MAT6TMAT6MULT \\
        bin/tmat6mat6mult $TMAT6MAT6MULT \\
        bin/tmat6tmat6mult $TMAT6TMAT6MULT \\
        bin/complex1 $COMPLEX1 \\
        bin/complex2 $COMPLEX2 \\
        bin/complex3 $COMPLEX3 \\
        bin/complex4 $COMPLEX4 \\
        bin/complex5 $COMPLEX5 \\
        bin/complex6 $COMPLEX6 \\
        bin/complex7 $COMPLEX7 \\
        bin/complex8 $COMPLEX8 \\
        bin/cg $CG \\
        bin/custom $CUSTOM

EOF


########################################
# Generating the 'BLAS.h' header file

cat > ./blazemark/system/BLAS.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/BLAS.h
//  \brief System settings for the BLAS performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_BLAS_H_
#define _BLAZEMARK_SYSTEM_BLAS_H_


//=================================================================================================
//
//  BLAS CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the BLAS performance benchmarks.
//
// This compilation switch enables/disables the BLAS performance benchmarks.
//
// Possible settings for the BLAS switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$BLAS" = "yes" ]; then
cat >> ./blazemark/system/BLAS.h <<EOF
#define BLAZEMARK_BLAS_MODE 1
EOF
else
cat >> ./blazemark/system/BLAS.h <<EOF
#define BLAZEMARK_BLAS_MODE 0
EOF
fi

cat >> ./blazemark/system/BLAS.h <<EOF
//*************************************************************************************************
EOF

if [ "$BLAS" = "yes" ]; then
cat >> ./blazemark/system/BLAS.h <<EOF




//=================================================================================================
//
//  BLAS INCLUDE FILE CONFIGURATION
//
//=================================================================================================

#if BLAZEMARK_BLAS_MODE
extern "C" {
#include <$BLAS_INCLUDE_FILE>
}
#endif

#endif
EOF
else
cat >> ./blazemark/system/BLAS.h <<EOF

#endif
EOF
fi


#########################################
# Generating the 'Boost.h' header file

cat > ./blazemark/system/Boost.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/Boost.h
//  \brief System settings for the Boost performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_BOOST_H_
#define _BLAZEMARK_SYSTEM_BOOST_H_


//=================================================================================================
//
//  BOOST CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the Boost performance benchmarks.
//
// This compilation switch enables/disables the Boost library performance benchmarks.
//
// Possible settings for the Boost switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$BOOST" = "yes" ]; then
cat >> ./blazemark/system/Boost.h <<EOF
#define BLAZEMARK_BOOST_MODE 1
EOF
else
cat >> ./blazemark/system/Boost.h <<EOF
#define BLAZEMARK_BOOST_MODE 0
EOF
fi

cat >> ./blazemark/system/Boost.h <<EOF
//*************************************************************************************************

#endif
EOF


#########################################
# Generating the 'Blitz.h' header file

cat > ./blazemark/system/Blitz.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/Blitz.h
//  \brief System settings for the Blitz++ performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_BLITZ_H_
#define _BLAZEMARK_SYSTEM_BLITZ_H_


//=================================================================================================
//
//  BLITZ CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the Blitz++ performance benchmarks.
//
// This compilation switch enables/disables the Blitz++ library performance benchmarks.
//
// Possible settings for the Blitz switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$BLITZ" = "yes" ]; then
cat >> ./blazemark/system/Blitz.h <<EOF
#define BLAZEMARK_BLITZ_MODE 1
EOF
else
cat >> ./blazemark/system/Blitz.h <<EOF
#define BLAZEMARK_BLITZ_MODE 0
EOF
fi

cat >> ./blazemark/system/Blitz.h <<EOF
//*************************************************************************************************

#endif
EOF


#######################################
# Generating the 'GMM.h' header file

cat > ./blazemark/system/GMM.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/GMM.h
//  \brief System settings for the GMM++ performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_GMM_H_
#define _BLAZEMARK_SYSTEM_GMM_H_


//=================================================================================================
//
//  GMM CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the GMM++ performance benchmarks.
//
// This compilation switch enables/disables the GMM++ library performance benchmarks.
//
// Possible settings for the GMM switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$GMM" = "yes" ]; then
cat >> ./blazemark/system/GMM.h <<EOF
#define BLAZEMARK_GMM_MODE 1
EOF
else
cat >> ./blazemark/system/GMM.h <<EOF
#define BLAZEMARK_GMM_MODE 0
EOF
fi

cat >> ./blazemark/system/GMM.h <<EOF
//*************************************************************************************************

#endif
EOF


#############################################
# Generating the 'Armadillo.h' header file

cat > ./blazemark/system/Armadillo.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/Armadillo.h
//  \brief System settings for the Armadillo performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_ARMADILLO_H_
#define _BLAZEMARK_SYSTEM_ARMADILLO_H_


//=================================================================================================
//
//  ARMADILLO CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the Armadillo performance benchmarks.
//
// This compilation switch enables/disables the Armadillo library performance benchmarks.
//
// Possible settings for the Armadillo switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$ARMADILLO" = "yes" ]; then
cat >> ./blazemark/system/Armadillo.h <<EOF
#define BLAZEMARK_ARMADILLO_MODE 1
EOF
else
cat >> ./blazemark/system/Armadillo.h <<EOF
#define BLAZEMARK_ARMADILLO_MODE 0
EOF
fi

cat >> ./blazemark/system/Armadillo.h <<EOF
//*************************************************************************************************

#endif
EOF


#########################################
# Generating the 'FLENS.h' header file

cat > ./blazemark/system/FLENS.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/FLENS.h
//  \brief System settings for the FLENS performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_FLENS_H_
#define _BLAZEMARK_SYSTEM_FLENS_H_


//=================================================================================================
//
//  FLENS CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the FLENS performance benchmarks.
//
// This compilation switch enables/disables the FLENS library performance benchmarks.
//
// Possible settings for the FLENS switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$FLENS" = "yes" ]; then
cat >> ./blazemark/system/FLENS.h <<EOF
#define BLAZEMARK_FLENS_MODE 1
EOF
else
cat >> ./blazemark/system/FLENS.h <<EOF
#define BLAZEMARK_FLENS_MODE 0
EOF
fi

cat >> ./blazemark/system/FLENS.h <<EOF
//*************************************************************************************************

#endif
EOF


#######################################
# Generating the 'MTL.h' header file

cat > ./blazemark/system/MTL.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/MTL.h
//  \brief System settings for the MTL performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_MTL_H_
#define _BLAZEMARK_SYSTEM_MTL_H_


//=================================================================================================
//
//  MTL CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the MTL performance benchmarks.
//
// This compilation switch enables/disables the MTL library performance benchmarks.
//
// Possible settings for the MTL switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$MTL" = "yes" ]; then
cat >> ./blazemark/system/MTL.h <<EOF
#define BLAZEMARK_MTL_MODE 1
EOF
else
cat >> ./blazemark/system/MTL.h <<EOF
#define BLAZEMARK_MTL_MODE 0
EOF
fi

cat >> ./blazemark/system/MTL.h <<EOF
//*************************************************************************************************

#endif
EOF


#########################################
# Generating the 'Eigen.h' header file

cat > ./blazemark/system/Eigen.h <<EOF
//=================================================================================================
/*!
//  \file blazemark/system/Eigen.h
//  \brief System settings for the Eigen performance benchmarks
//
//  Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
//  This file is part of the Blaze library. You can redistribute it and/or modify it under
//  the terms of the New (Revised) BSD License. Redistribution and use in source and binary
//  forms, with or without modification, are permitted provided that the following conditions
//  are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of
//     conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright notice, this list
//     of conditions and the following disclaimer in the documentation and/or other materials
//     provided with the distribution.
//  3. Neither the names of the Blaze development group nor the names of its contributors
//     may be used to endorse or promote products derived from this software without specific
//     prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
//  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
//  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
//  DAMAGE.
*/
//=================================================================================================

#ifndef _BLAZEMARK_SYSTEM_EIGEN_H_
#define _BLAZEMARK_SYSTEM_EIGEN_H_


//=================================================================================================
//
//  EIGEN CONFIGURATION
//
//=================================================================================================

//*************************************************************************************************
/*!\brief Compilation switch for the Eigen performance benchmarks.
//
// This compilation switch enables/disables the Eigen library performance benchmarks.
//
// Possible settings for the Eigen switch:
//  - Deactivated: \b 0
//  - Activated  : \b 1
//
// Note that changing this setting requires a recompilation of the Blaze benchmark suite. Also
// note that this switch is automatically set by the configuration script of the Blaze benchmark
// suite.
*/
EOF

if [ "$EIGEN" = "yes" ]; then
cat >> ./blazemark/system/Eigen.h <<EOF
#define BLAZEMARK_EIGEN_MODE 1
EOF
else
cat >> ./blazemark/system/Eigen.h <<EOF
#define BLAZEMARK_EIGEN_MODE 0
EOF
fi

cat >> ./blazemark/system/Eigen.h <<EOF
//*************************************************************************************************

#endif
EOF
