#!/bin/bash
  
  # This configure script is hand-generated, not auto-generated.  It creates the
  # file kaldi.mk, which is %included by the Makefiles in the subdirectories.
  # The file kaldi.mk is editable by hand -- for example, you may want to
  # uncomment the options -O0 -DKALDI_PARANOID, or edit the DOUBLE_PRECISION
  # variable (to be 1 not 0).
  
  #  Example command lines:
  # ./configure
  # ./configure --shared                # Build shared Kaldi libraries.
  # ./configure --mathlib=OPENBLAS      # Build and use OpenBLAS.
  #        # Before doing this, cd to ../tools and type "make -j openblas".
  # ./configure --openblas-root=/usr    # Use system OpenBLAS.
  #        # Note: this is not working correctly on all platforms, do "make test"
  #        # and look out for segmentation faults.
  # ./configure --atlas-root=../tools/ATLAS/build
  # ./configure --use-cuda=no   # disable CUDA detection (will build cpu-only
  #                             # version of kaldi even on CUDA-enabled machine.
  # ./configure --use-cuda --cudatk-dir=/usr/local/cuda/ --cuda-arch=-arch=sm_70
  #        # Use cuda in /usr/local/cuda and set the arch to sm_70
  # ./configure --static --fst-root=/opt/cross/armv8hf \
  #   --atlas-root=/opt/cross/armv8hf --host=armv8-rpi3-linux-gnueabihf
  #        # Cross-compile for armv8hf. This assumes that you have OpenFST built
  #        # with the armv8-rpi3-linux-gnueabihf toolchain and installed to
  #        # /opt/cross/armv8hf. It also assumes that you have an ATLAS library
  #        # built for the target install to /opt/cross/armv8hf and that the
  #        # armv8-rpi3-linux-gnueabihf toolchain is available in your path.
  # ./configure --static --openblas-root=/opt/cross/arm-linux-androideabi \
  #   --fst-root=/opt/cross/arm-linux-androideabi --fst-version=1.6.9 \
  #   --android-incdir=/opt/cross/arm-linux-androideabi/sysroot/usr/include \
  #   --host=arm-linux-androideabi
  #        # Cross-compile for Android on arm. The only difference here is the
  #        # addition of the the --android-includes flag because the toolchains
  #        # produced by the Android NDK don't always include the C++ stdlib
  #        # headers in the normal cross-compile include path.
  #   --host=aarch64-linux-android
  #        # support for 64bit ARMv8 (AArch64) architecture in Android.
  
  # This should be incremented after any significant change to the configure
  # script, i.e. any change affecting kaldi.mk or the build system as a whole.
  CONFIGURE_VERSION=11
  
  # We support bash version 3.2 (Macs still ship with this version as of 2019)
  # and above.
  [[ $BASH_VERSION < '3.2' ]] && {
    echo >&2 "bash version ${BASH_VERSION} is too old, cannot continue." \
             "You won't be able to run Kaldi recipes with it anyway." \
             "Please upgrade. bash version 3.2 or higher is required."
    exit 1;
  }
  
  if ! [ -x "$PWD/configure" ]; then
    echo 'You must run "configure" from the src/ directory.'
    exit 1
  fi
  
  function usage {
    cat <<EOF
  'configure' configures Kaldi installation.
  
  Usage: [VAR=VALUE]... $0 [OPTION]...
  
  The default configuration is to build and link against static Kaldi libraries.
  OpenFst and Math libraries are linked dynamically.
  
  Configuration options:
    --help                Display this help message and exit
    --version             Display the version of 'configure' and exit
    --static              Build and link against static libraries [default=no]
    --shared              Build and link against shared libraries [default=no]
    --use-cuda            Build with CUDA [default=yes]
    --cudatk-dir=DIR      CUDA toolkit directory
    --cuda-arch=FLAGS     Override the default CUDA_ARCH flags. See:
           https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#nvcc-examples.
    --double-precision    Build with BaseFloat set to double if yes [default=no],
                          mostly useful for testing purposes.
    --static-fst          Build with static OpenFst libraries [default=no]
    --fst-root=DIR        OpenFst root directory [default=../tools/openfst/]
    --fst-version=STR     OpenFst version string
    --mathlib=LIB         Math library [default=MKL|OPENBLAS, based on platform]
                          Supported libraries: ATLAS, MKL, CLAPACK, OPENBLAS.
    --static-math         Build with static math libraries [default=no]
    --threaded-math       Build with multi-threaded math libraries [default=no]
    --threaded-atlas      Build with multi-threaded ATLAS libraries [default=no]
    --atlas-root=DIR      ATLAS root directory [default=../tools/ATLAS/]
    --openblas-root=DIR   OpenBLAS root directory
    --clapack-root=DIR    CLAPACK root directory
    --mkl-root=DIR        MKL root directory
    --mkl-libdir=DIR      MKL library directory
    --mkl-threading=LIB   MKL threading layer [default=sequential]
                          Supported layers: sequential, iomp, tbb, gomp.
    --omp-libdir=DIR      OpenMP directory
    --speex-root=DIR      SPEEX root directory
    --speex-libdir=DIR    SPEEX library directory
    --speex-incdir=DIR    SPEEX include directory
    --host=HOST           Host triple in the format 'cpu-vendor-os'
                          If provided, it is prepended to all toolchain programs.
    --android-incdir=DIR  Android include directory
  
  Following environment variables can be used to override the default toolchain.
    CXX         C++ compiler [default=g++]
    AR          Archive maintenance utility [default=ar]
    AS          Assembler [default=as]
    RANLIB      Archive indexing utility [default=ranlib]
  
  If a host triple is provided, it is prepended to CXX, AR, AS and RANLIB.
  
  Following environment variables can be used to provide additional flags to the
  compiler/linker.
    CXXFLAGS    Additional C++ compiler flags, e.g. -I<include-dir>
    LDFLAGS     Additional linker flags, e.g. -L<lib-dir>
    LDLIBS      Additional libraries to pass to the linker, e.g. -l<lib>
  
  EOF
  }
  
  # E.g. Die "Invalid switch --foobar"
  Die() { echo >&2 "$0: FATAL:" "$@"; exit 1; }
  
  # E.g. abspath=$(rel2abs "../tools") || exit 1
  #  - Set 'abspath' to existing absolute path of $1, return 0.
  #  - print empty string if path does not exist, return non-0.
  function rel2abs {
    [[ $1 ]] && cd -P "$1" 2>/dev/null && pwd
  }
  
  # E.g.: GetSwitchValue var --some-switch=foo
  # Assign variable named 'var' to 'foo'. Return 0 iff value is not empty.
  GetSwitchValue() {
    IFS='=' read -r -- _ $1 <<< "$2" && [[ ${!1} ]]
  }
  
  # E.g.: GetSwitchValueOrDie var --some-switch=foo
  # Assign variable named 'var' to 'foo'. Die with a fatal error if value is empty.
  GetSwitchValueOrDie() {
    GetSwitchValue "$@" ||
      Die "'$2': switch requires a value. See '$0 --help'."
  }
  
  # E.g.: GetSwitchExistingPathOrDie var --some-switch=../tools
  #  - Set 'var' to absolute path of '../tools' if exists, return 1.
  #  - Die with a fatal error if path does not exist or not given in switch.
  GetSwitchExistingPathOrDie() {
    GetSwitchValueOrDie "$@"  # Already sets variable named $1 to path.
    local path varname=$1
    path=$(rel2abs "${!varname}") && [[ -d $path ]] ||
      Die "'$2': switch must specify an existing directory. See '$0 --help'."
    builtin printf -v $varname %s "$path"  # Assign $path to variable '$varname'.
  }
  
  # TODO(kkm): Kill this. `[[ ${var-} ]]' is the idiomatic equivalent in bash.
  #   Even better, do not rely on uninitialized variables.
  function is_set {
    local myvar=${1:-notset}
    if [ "$myvar" == "notset" ]; then
      return 1
    else
      return 0
    fi
  }
  
  # Lowercase/uppercase argument. Only bash 4.2+ has internal faclilties for this,
  # and we support versions down to 3.2.
  lcase () { awk '{print tolower($0)}' <<<"$1" ; }
  ucase () { awk '{print toupper($0)}' <<<"$1" ; }
  
  function failure {
    echo "***configure failed: $* ***" >&2
    if [ -f kaldi.mk ]; then rm kaldi.mk; fi
    exit 1;
  }
  
  function check_exists {
    if [[ ! -f $1 ]]; then failure "$1 not found."; fi
  }
  
  function check_library {
    local libpath=$1
    local libname=$2
    local libext=$3
    local full_libname="$libpath/$libname.$libext"
    ##echo "Testing $full_libname" >&2
    test -f "$full_libname" && return ;
    return 1
  }
  
  function check_compiler {
    COMPILER=$1
    if ! which $COMPILER >&/dev/null; then
      failure "$COMPILER is not installed.
               You need g++ >= 4.7, Apple clang >= 5.0 or LLVM clang >= 3.3."
    else
      COMPILER_VER_INFO=$($COMPILER --version 2>/dev/null)
      if [[ $COMPILER_VER_INFO == *"g++"* ]]; then
        GCC_VER=$($COMPILER -dumpversion)
        GCC_VER_NUM=$(echo $GCC_VER | sed 's/\./ /g' | xargs printf "%d%02d%02d")
        if [ $GCC_VER_NUM -lt 40700 ]; then
          failure "$COMPILER (g++-$GCC_VER) is not supported.
                   You need g++ >= 4.7, Apple clang >= 5.0 or LLVM clang >= 3.3."
        elif [ $GCC_VER_NUM  == 40801 ] || [ $GCC_VER_NUM == 40802 ]; then
          failure "$COMPILER (g++-$GCC_VER) is not supported.
                   GCC 4.8.1 and 4.8.2 have a bug in the implementation of
                   the nth_element algorithm provided by the standard library.
                   This will cause Kaldi to crash (make test would fail).
                   Please use another C++ compiler with C++11 support.
                   You need g++ >= 4.7, Apple clang >= 5.0 or LLVM clang >= 3.3."
        fi
      elif [[ $COMPILER_VER_INFO == *"Apple"* ]]; then
        CLANG_VER=$(echo $COMPILER_VER_INFO | grep version | sed "s/.*version \([0-9\.]*\).*/\1/")
        CLANG_VER_NUM=$(echo $COMPILER_VER_INFO | grep version | sed "s/.*clang-\([0-9]*\).*/\1/")
        if [ $CLANG_VER_NUM -lt 500 ]; then
          failure "$COMPILER (Apple clang-$CLANG_VER) is not supported.
                   You need g++ >= 4.7, Apple clang >= 5.0 or LLVM clang >= 3.3."
        fi
      elif [[ $COMPILER_VER_INFO == *"LLVM"* ]]; then
        CLANG_VER=$(echo $COMPILER_VER_INFO | grep version | sed "s/.*version \([0-9\.]*\).*/\1/")
        CLANG_VER_NUM=$(echo $CLANG_VER | sed 's/\./ /g' | xargs printf "%d%02d")
        if [ $CLANG_VER_NUM -lt 303 ]; then
          failure "$COMPILER (LLVM clang-$CLANG_VER) is not supported.
                  You need g++ >= 4.7, Apple clang >= 5.0 or LLVM clang >= 3.3."
        fi
      fi
    fi
  }
  
  function check_for_slow_expf {
    # We cannot run this test if we are cross compiling.
    if [[ "$TARGET_ARCH" == "`uname -m`" ]] ; then
      cd probe
      rm -f exp-test
      make -f Makefile.slow_expf 1>/dev/null
      ./exp-test
      if [ $? -eq 1 ]; then
          echo "*** WARNING: expf() seems to be slower than exp() on your machine. This is a known bug in old versions of glibc. Please consider updating glibc. ***"
          echo "*** Kaldi will be configured to use exp() instead of expf() in base/kaldi-math.h Exp() routine for single-precision floats. ***"
          echo "CXXFLAGS += -DKALDI_NO_EXPF" >> ../kaldi.mk
      fi
      cd ..
    fi
  }
  
  # MKL functions
  function linux_configure_mkllibdir {
    local mklroot=$1
  
    if [ -d $mklroot/lib/em64t ]; then
      echo $mklroot/lib/em64t
    elif [ -d $mklroot/lib/intel64 ]; then
      echo $mklroot/lib/intel64
    else
      return 1;
    fi
  }
  
  function linux_configure_mkl_includes {
    test -d $1/include && echo "$1/include" && return;
    test -d $2/../../include && echo "$2/../../include" && return;
    failure "Could not find the MKL include directory"
  }
  
  function linux_configure_mkl_libraries {
    local mkllibdir=$1
    local static=$2
    local threaded=$3
    local mplib=$4
  
    declare -A mkl_libs
    mkl_libs=(
      [sequential]="mkl_intel_lp64 mkl_core mkl_sequential"
      [gomp]="mkl_intel_lp64 mkl_core mkl_gnu_thread"
      [iomp]="mkl_intel_lp64 mkl_core mkl_intel_thread "
      [tbb]="mkl_intel_lp64 mkl_core mkl_tbb_thread "
    )
  
    if [ -z "${mkl_libs[$threaded]}" ]; then
      echo >&2 "Unknown threading mode: $threaded"
      return 1;
    fi
  
    local linkline=""
    if  ! $static ; then
      linkline="-L$mkllibdir -Wl,-rpath=$mkllibdir"
      for file in ${mkl_libs[$threaded]}; do
        local libfile=$mkllibdir/lib$file.so
        check_exists $libfile
        linkline+=" -l$file "
      done
    else
      if [ $threaded == "sequential" ] ; then
        test -f "$mkllibdir/libmkl_solver_lp64.a" && \
          linkline="$linkline $mkllibdir/libmkl_solver_lp64.a"
      else
        test -f "$mkllibdir/libmkl_solver_lp64_sequential.a" && \
          linkline="$linkline $mkllibdir/libmkl_solver_lp64_sequential.a"
      fi
      linkline="$linkline -Wl,--start-group"
      for file in ${mkl_libs[$threaded]}; do
        local libfile=$mkllibdir/lib${file}.a
        check_exists $libfile
        linkline="$linkline $libfile"
      done
      linkline="$linkline -Wl,--end-group "
    fi
    echo "$linkline"
  }
  
  function linux_configure_mkl_extra {
    local static=$1
    local threaded=$2
  
    declare -A extra_libs
    extra_libs=(
      [sequential]="-ldl -lpthread -lm"
      [gomp]="-lgomp -ldl -lpthread -lm"
      [iomp]="-ldl -lpthread -lm"
      [tbb]=" -ldl -lpthread -lm "
    )
    echo "$linkline ${extra_libs[$threaded]}"
  }
  
  function linux_configure_mkl_threadinglibdir {
    local library=$1
    local mklroot=$2
    local mkllibdir=$3
    local libexts=$4
  
    ##First we try to use the library in the same directory
    ##where the mkl libraries reside
    ##Afterwards, just try some possibilities for different MKL layouts
    for libext in $libexts; do
      check_library $mkllibdir "lib$library" $libext \
      && echo `readlink -f $mkllibdir` && return 0
  
      local testdir=`(cd $mklroot; cd ..; cd lib/intel64;pwd)`
      test -d $testdir && check_library $testdir "lib$library" $libext && echo `readlink -f $testdir` && return 0;
      local testdir=`(cd $mklroot; cd ..; cd lib/em64t;pwd)`
      test -d $testdir && check_library $testdir "lib$library" $libext && echo `readlink -f $testdir` && return 0;
  
      local testdir=`(cd $mkllibdir; cd ../../..; cd lib/intel64;pwd)`
      test -d $testdir && check_library $testdir "lib$library" $libext && echo `readlink -f $testdir` && return 0;
      local testdir=`(cd $mklroot; cd ../../..; cd lib/em64t;pwd)`
      test -d $testdir && check_library $testdir "lib$library" $libext && echo `readlink -f $testdir` && return 0;
    done
  
    #failure "Could not find the library iomp5, use the configure switch --omp-libdir"
    return 1
  }
  
  function linux_configure_mkl_threading {
    local mklroot=$1
    local mkllibdir=$2
    local static=$3
    local threading=$4
  
    declare -A libs
    libs=(
      [sequential]=""
      [gomp]=""
      [iomp]="iomp5"
      [tbb]="tbb"
    )
  
    echo >&2 "Configuring MKL threading as $threading"
    library=${libs[$threading]}
    if [ -z "$library" ]; then
      return 0
    fi
  
    if ! is_set $OMPLIBDIR ; then
      if  $static ; then
        OMPLIBDIR=`linux_configure_mkl_threadinglibdir $library "$MKLROOT" "$MKLLIBDIR" "a"`
      else
        OMPLIBDIR=`linux_configure_mkl_threadinglibdir $library "$MKLROOT" "$MKLLIBDIR" "so"`
      fi
    fi
  
    check_library $OMPLIBDIR "lib$library" "a" || \
    check_library $OMPLIBDIR "lib$library" "so" || \
    failure "Could not find the $library library, have your tried the --omp-libdir switch?"
  
    OMP_LINK_LINE=''
    # TODO(arnab): in the following conditional, the $static_math test is
    # needed since the OpenMP library is assumed to be dynamic.
    if [ "$OMPLIBDIR" != "$MKLLIBDIR" ] ; then
      OMP_LINK_LINE="-L${OMPLIBDIR}"
    fi
    #if the libiomp5 library is dynamic, we add the rpath attribute
    if ! $static_math ; then
      OMP_LINK_LINE="$OMP_LINK_LINE -Wl,-rpath=$OMPLIBDIR -l$library"
    else
      OMP_LINK_LINE="$OMP_LINK_LINE -Wl,-Bstatic -l$library -Wl,-Bdynamic"
    fi
    echo "$OMP_LINK_LINE"
  }
  
  
  # CUDA is used only in selected directories including src/cudamatrix, src/nnet*
  # and src/chain*. It is used to accelerate the neural network training.
  # The rest of Kaldi runs on CPUs.
  
  function configure_cuda {
    # Check for CUDA toolkit in the system
    if [ ! -d  "$CUDATKDIR" ]; then
      for base in /usr/local/share/cuda /usr/local/cuda /usr/; do
        if [ -f $base/bin/nvcc ]; then
          CUDATKDIR=$base
        fi
      done
    fi
  
    if [ -d "$CUDATKDIR" ]; then
      if [ ! -f $CUDATKDIR/bin/nvcc ]; then
        failure "Cannnot find nvcc in CUDATKDIR=$CUDATKDIR"
      fi
  
      if [[ "$TARGET_ARCH" != "`uname -m`" ]] ; then
        failure "Cannot cross compile with CUDA support"
      fi
  
      # Determine 'CUDA_ARCH',
      CUDA_VERSION=$($CUDATKDIR/bin/nvcc -V | tr '.,' '_ ' | awk '/release/{sub(/.*release/,""); print $1;}') # MAJOR_MINOR,
      if [ -z "$CUDA_VERSION" ] ; then
        echo "Cannot figure out CUDA_VERSION from the nvcc output. Either your CUDA is too new or too old."
        exit 1
      fi
  
      COMPILER_VER_INFO=$($CXX --version 2>/dev/null)
      if [[ $COMPILER_VER_INFO == *"g++"* ]]; then
        GCC_VER=$($COMPILER -dumpversion)
        GCC_VER_NUM=$(echo $GCC_VER | sed 's/\./ /g' | xargs printf "%d%02d%02d")
        case $CUDA_VERSION in
          7_*)
            MIN_UNSUPPORTED_GCC_VER="5.0"
            MIN_UNSUPPORTED_GCC_VER_NUM=50000;
            CUSOLVER=false
          ;;
          8_*)
            MIN_UNSUPPORTED_GCC_VER="6.0"
            MIN_UNSUPPORTED_GCC_VER_NUM=60000;
            CUSOLVER=false
          ;;
          9_0)
            MIN_UNSUPPORTED_GCC_VER="7.0"
            MIN_UNSUPPORTED_GCC_VER_NUM=70000;
            CUSOLVER=false
          ;;
          9_1)
            MIN_UNSUPPORTED_GCC_VER="7.0"
            MIN_UNSUPPORTED_GCC_VER_NUM=70000;
            CUSOLVER=true
          ;;
          9_2 | 9_* | 10_0)
            MIN_UNSUPPORTED_GCC_VER="8.0"
            MIN_UNSUPPORTED_GCC_VER_NUM=80000;
            CUSOLVER=true
          ;;
          10_1 | 10_*)
            MIN_UNSUPPORTED_GCC_VER="9.0"
            MIN_UNSUPPORTED_GCC_VER_NUM=90000;
            CUSOLVER=true
          ;;
          *)
            echo "Unsupported CUDA_VERSION (CUDA_VERSION=$CUDA_VERSION), please report it to Kaldi mailing list, together with 'nvcc -h' or 'ptxas -h' which lists allowed -gencode values..."; exit 1;
          ;;
        esac
        if [ $GCC_VER_NUM -ge $MIN_UNSUPPORTED_GCC_VER_NUM ]; then
          failure "CUDA $CUDA_VERSION does not support $CXX (g++-$GCC_VER).
                   You need g++ < $MIN_UNSUPPORTED_GCC_VER."
        fi
      fi
  
      if [ -z "$CUDA_ARCH" ]; then
        case `uname -m` in
          x86_64|ppc64le)
            case $CUDA_VERSION in
              5_5) CUDA_ARCH="-gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35" ;;
              6_*) CUDA_ARCH="-gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50" ;;
              7_*) CUDA_ARCH="-gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52" ;;
              8_*) CUDA_ARCH="-gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61" ;;
              9_*) CUDA_ARCH="-gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61 -gencode arch=compute_70,code=sm_70" ;;
              10_*) CUDA_ARCH="-gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61 -gencode arch=compute_70,code=sm_70 -gencode arch=compute_75,code=sm_75" ;;
              *) echo "Unsupported CUDA_VERSION (CUDA_VERSION=$CUDA_VERSION), please report it to Kaldi mailing list, together with 'nvcc -h' or 'ptxas -h' which lists allowed -gencode values..."; exit 1 ;;
            esac
          ;;
          aarch64)
            case $CUDA_VERSION in
              7_*)     CUDA_ARCH="-gencode arch=compute_53,code=sm_53" ;;
              8_*|9_*) CUDA_ARCH="-gencode arch=compute_53,code=sm_53 -gencode arch=compute_62,code=sm_62" ;;
              10_*)    CUDA_ARCH="-gencode arch=compute_53,code=sm_53 -gencode arch=compute_62,code=sm_62 -gencode arch=compute_72,code=sm_72" ;;
              *) echo "Unsupported CUDA_VERSION (CUDA_VERSION=$CUDA_VERSION), please report it to Kaldi mailing list, together with 'nvcc -h' or 'ptxas -h' which lists allowed -gencode values..."; exit 1 ;;
            esac
          ;;
          *) echo "Unsupported architecture for use of Kaldi with CUDA.  Please report it to Kaldi mailing list."; exit 1 ;;
        esac
      fi
  
      echo "Using CUDA toolkit $CUDATKDIR (nvcc compiler and runtime libraries)"
      echo >> kaldi.mk
      echo "# CUDA configuration" >> kaldi.mk
      echo >> kaldi.mk
      echo CUDA = true >> kaldi.mk
      echo CUDATKDIR = $CUDATKDIR >> kaldi.mk
      echo "CUDA_ARCH = $CUDA_ARCH" >> kaldi.mk
      
      
      echo >> kaldi.mk
  
      # 64bit/32bit? We do not support cross compilation with CUDA so, use direct
      # calls to uname -m here
      if [ "`uname -m`" == "x86_64" ]; then
        if [ "`uname`" == "Darwin" ]; then
          sed 's/lib64/lib/g' < makefiles/cuda_64bit.mk >> kaldi.mk
        else
          cat makefiles/cuda_64bit.mk >> kaldi.mk
        fi
      elif [ "`uname -m`" == "aarch64" ]; then
        cat makefiles/cuda_64bit.mk >> kaldi.mk
      elif [ "`uname -m`" == "ppc64le" ]; then
        cat makefiles/cuda_64bit.mk >> kaldi.mk
      else
        echo "\
  WARNING: CUDA will not be used!
           CUDA is not supported with 32-bit builds."
        exit 1;
      fi
      
      #add cusolver flags for newer toolkits
      if [ "$CUSOLVER" == "true" ]; then
        echo "CUDA_LDLIBS += -lcusolver" >> kaldi.mk
      fi
  
    else
      echo "\
  WARNING: CUDA will not be used! If you have already installed cuda drivers
           and CUDA toolkit, try using the --cudatk-dir= option. A GPU and CUDA
           are required to run neural net experiments in a realistic time."
    fi
  }
  
  function linux_configure_speex {
    # Check whether the user has called tools/extras/install_speex.sh or not
    [ ! -z "$SPEEXROOT" ] || SPEEXROOT=`pwd`/../tools/speex
    [ ! -z "$SPEEXLIBDIR" ] || SPEEXLIBDIR="$SPEEXROOT"/lib
    [ ! -z "$SPEEXINCDIR" ] || SPEEXINCDIR="$SPEEXROOT"/include
    static_speex=$1
    if [ "foo"$static_speex == "foo" ]; then
      static_speex=false
    fi
  
    if $static_speex; then
      spx_type=a
    else
      spx_type=so
    fi
    if [ ! -f "$SPEEXLIBDIR/libspeex.${spx_type}" ];then
      echo "\
  INFO: Configuring Kaldi not to link with Speex. Don't worry, it's only needed if
        you intend to use 'compress-uncompress-speex', which is very unlikely."
      return
    fi
  
    if [ -f $SPEEXINCDIR/speex/speex.h ]; then
      echo >> kaldi.mk
      echo CXXFLAGS += -DHAVE_SPEEX -I${SPEEXINCDIR} >> kaldi.mk
  
      if $static_speex; then
        echo LDLIBS += $SPEEXLIBDIR/libspeex.a
      else
        echo LDLIBS += -L${SPEEXLIBDIR} -lspeex >> kaldi.mk
        echo LDFLAGS += -Wl,-rpath=${SPEEXLIBDIR} >> kaldi.mk
      fi
  
      echo "Successfully configured with Speex at $SPEEXROOT, (static=[$static_speex])"
    else
      echo "Speex will not be used. If you want to use it, run tools/extras/install_speex.sh first."
    fi
  }
  
  function linux_configure_atlas_failure {
    echo ATLASINC = $ATLASROOT/include >> kaldi.mk
    echo ATLASLIBS = [somewhere]/liblapack.a [somewhere]/libcblas.a [somewhere]/libatlas.a [somewhere]/libf77blas.a $ATLASLIBDIR >> kaldi.mk
    echo >> kaldi.mk
  
    echo "** $* ***"
    echo "**  ERROR   **"
    echo "** Configure cannot proceed automatically."
    echo "**  If you know that you have ATLAS installed somewhere on your machine, you"
    echo "** may be able to proceed by replacing [somewhere] in kaldi.mk with a directory."
    echo "**  If you have sudo (root) access you could install the ATLAS package on your"
    echo "** machine, e.g. 'sudo apt-get install libatlas-dev libatlas-base-dev' or"
    echo "** 'sudo yum install atlas.x86_64' or 'sudo zypper install libatlas3-devel',"
    echo "** or on cygwin, install atlas from the installer GUI; and then run ./configure"
    echo "** again."
    echo "**"
    echo "**  Otherwise (or if you prefer OpenBLAS for speed), you could go the OpenBLAS"
    echo "** route: cd to ../tools, type 'extras/install_openblas.sh', cd back to here,"
    echo "** and type './configure  --mathlib=OPENBLAS'"
    exit 1;
  }
  
  function linux_atlas_check_static {
    # will exit with success if $dir seems to contain ATLAS libraries with
    # right architecture (compatible with default "nm")
    echo "int main(void) { return 0; }" > test_linking.cc;
    if [ -f $dir/libatlas.a ]; then # candidate...
      # Note: on the next line, the variable assignment
      # LANG=en_US should apply just to the program called on that line.
      if LANG=en_US $CXX -o test_linking test_linking.cc -u ATL_flushcache $dir/libatlas.a 2>&1 | grep -i "incompatible" >/dev/null; then
        echo "Directory $dir may contain ATLAS libraries but seems to be wrong architecture";
        rm test_linking test_linking.cc 2>/dev/null
        return 1;
      fi
      rm test_linking test_linking.cc 2>/dev/null
      return 0;
    else
      rm test_linking.cc
      return 1;
    fi
  }
  
  function linux_configure_atlas_generic {
    # You pass in a directory (e.g. /usr/lib/atlas-base) and a suffix (e.g. so.3.0)
    # and it tries to find ATLAS libraries with that dir and suffix.  On success it
    # returns 0; on failure, it returns 1.
    dir=$1
    suffix=$2
    ATLASLIBS="$dir/libatlas.$suffix $dir/libf77blas.$suffix $dir/libcblas.$suffix $dir/liblapack_atlas.$suffix"
    for f in $ATLASLIBS; do
      [ ! -f $f ] && return 1;
    done
    lapacklib=$(echo $ATLASLIBS | awk '{print $NF}')
    if ! nm --dynamic $lapacklib | grep ATL_cgetrf >/dev/null; then
      echo "configure: failed to find symbol ATL_cgetrf in library $lapacklib"
      exit 1;
    fi
    libdir=$(dirname $(echo $ATLASLIBS | awk '{print $1}'))
    [ -z "$libdir" ] && echo "Error getting libdir in linux_configure_atlas_generic: dir=$dir,suffix=$suffix" && exit 1;
    echo ATLASINC = $ATLASROOT/include >> kaldi.mk
    echo ATLASLIBS = $ATLASLIBS -Wl,-rpath=$libdir >> kaldi.mk
    echo >> kaldi.mk
    echo "Successfully configured ATLAS with ATLASLIBS=$ATLASLIBS"
  }
  
  function linux_configure_atlas_redhat_fat {
    # This is for when only two so-called 'fat' ATLAS libs are provided:
    # libsatlas.so.3 and libtatlas.so.3.
    # See http://stackoverflow.com/questions/13439296/build-shared-libraries-in-atlas.
    m=$1  # 64 or empty.
    ATLASLIBS="/usr/lib$m/atlas/libsatlas.so.3 /usr/lib$m/atlas/libtatlas.so.3"
    for f in $ATLASLIBS; do
      [ ! -f $f ] && return 1;
    done
    libdir=$(dirname $(echo $ATLASLIBS | awk '{print $1}'))
    [ -z "$libdir" ] && echo "Error getting libdir in linux_configure_atlas_redhat_fat" && exit 1;
    echo ATLASINC = $ATLASROOT/include >> kaldi.mk
    echo ATLASLIBS = $ATLASLIBS -Wl,-rpath=$libdir >> kaldi.mk
    echo >> kaldi.mk
    echo "Successfully configured for red hat [dynamic libraries, fat] with ATLASLIBS =$ATLASLIBS"
  }
  
  function linux_configure_atlas_static {
    if $threaded_atlas; then pt=pt; else pt=""; fi
  
    if [ -z $ATLASLIBDIR ]; then # Note: it'll pick up the last one below.
      for dir in /usr{,/local}/lib{64,}{,/atlas,/atlas-sse2,/atlas-sse3} \
         /usr/local/atlas/lib{,64} `pwd`/../tools/ATLAS/build/install/lib/ $ATLASROOT/lib; do
       linux_atlas_check_static && ATLASLIBDIR=$dir
      done
      if [ -z $ATLASLIBDIR ]; then # Note: it'll pick up the last one below.
        echo "Could not find libatlas.a in any of the generic-Linux places, but we'll try other stuff..."
        return 1;
      fi
    elif [ ! -f $ATLASLIBDIR/libatlas.a ]; then
      echo "Could not find libatlas.a in '$ATLASLIBDIR'"
      return 1;
    fi
    echo "Validating presence of ATLAS libs in $ATLASLIBDIR"
    ATLASLIBS=
    # The Lapack part of ATLAS seems to appear under various different names.. but it
    # should always have symbols like ATL_cgetrf and clapack_cgetrf defined, so we test for this.
    for libname in liblapack liblapack_atlas  libclapack; do
      if [ -f $ATLASLIBDIR/${libname}.a -a "$ATLASLIBS" == "" ]; then
        if nm  $ATLASLIBDIR/${libname}.a  | grep ATL_cgetrf >/dev/null && \
  	 nm  $ATLASLIBDIR/${libname}.a  | grep clapack_cgetrf >/dev/null; then
           ATLASLIBS=$ATLASLIBDIR/${libname}.a
           echo "Using library $ATLASLIBS as ATLAS's CLAPACK library."
        fi
      fi
    done
    if [ "$ATLASLIBS" == "" ]; then
      echo Could not find any libraries $ATLASLIBDIR/{liblapack,liblapack_atlas,libclapack} that seem to be an ATLAS CLAPACK library.
      return 1;
    fi
  
    for x in lib${pt}cblas.a libatlas.a lib${pt}f77blas.a; do
      if [ ! -f $ATLASLIBDIR/$x ]; then
        echo "Configuring static ATLAS libraries failed: Could not find library $x in directory $ATLASLIBDIR"
        return 1;
      fi
      ATLASLIBS="$ATLASLIBS $ATLASLIBDIR/$x"
    done
    if $threaded_atlas; then ATLASLIBS="$ATLASLIBS"; fi
  
    echo ATLASINC = $ATLASROOT/include >> kaldi.mk
    echo ATLASLIBS = $ATLASLIBS >> kaldi.mk
    echo >> kaldi.mk
    echo "Successfully configured for Linux [static libraries] with ATLASLIBS =$ATLASLIBS"
  }
  
  #############################    CONFIGURATION    #############################
  
  # If configuration sets any of these variables, we will switch the external
  # math library. Here we unset them so that we can check later.
  #TODO(kkm): Maybe allow env vars to provide defaults?
  ATLASROOT=
  CLAPACKROOT=
  MATHLIB=
  MKLLIBDIR=
  MKLROOT=
  OPENBLASROOT=
  
  # This variable identifies the type of system where built programs and
  # libraries will run. It is set by the configure script when cross compiling.
  HOST=
  
  # These environment variables can be used to override the default toolchain.
  CXX=${CXX:-g++}
  AR=${AR:-ar}
  AS=${AS:-as}
  RANLIB=${RANLIB:-ranlib}
  
  # These environment variables can be used to provide additional flags to the
  # compiler/linker. We want these flags to override the flags determined by the
  # configure script, so we append them to the appropriate variables (CXXFLAGS,
  # LDFLAGS and LDLIBS) after those variables are set by the configure script.
  ENV_CXXFLAGS=$CXXFLAGS
  ENV_LDFLAGS=$LDFLAGS
  ENV_LDLIBS=$LDLIBS
  
  # Default configuration
  double_precision=false
  dynamic_kaldi=false
  use_cuda=true
  static_fst=false
  static_math=false
  threaded_atlas=false
  mkl_threading=sequential
  android=false
  
  FSTROOT=`rel2abs ../tools/openfst`
  CUBROOT=`rel2abs ../tools/cub`
  
  # Save the command line to include in kaldi.mk
  cmd_line="$0 $@"
  
  while [ $# -gt 0 ];
  do
    case "$1" in
    --help)
      usage; exit 0 ;;
    --version)
      echo $CONFIGURE_VERSION; exit 0 ;;
    --static)
      dynamic_kaldi=false;
      static_math=true;
      static_fst=true;
      shift ;;
    --shared)
      dynamic_kaldi=true;
      static_math=false;
      static_fst=false;
      shift ;;
    --double-precision)
      double_precision=true;
      shift ;;
    --double-precision=yes)
      double_precision=true;
      shift ;;
    --double-precision=no)
      double_precision=false;
      shift ;;
    --atlas-root=*)
      GetSwitchExistingPathOrDie ATLASROOT "$1"
      shift ;;
    --threaded-atlas)
      threaded_atlas=true;
      shift ;;
    --threaded-atlas=yes)
      threaded_atlas=true;
      shift ;;
    --threaded-atlas=no)
      threaded_atlas=false;
      shift ;;
    --threaded-math)
      threaded_atlas=true;
      mkl_threading=iomp
      shift ;;
    --threaded-math=yes)
      threaded_atlas=true;
      mkl_threading=iomp
      shift ;;
    --threaded-math=no)
      threaded_atlas=false;
      mkl_threading=sequential
      shift ;;
    --use-cuda)
      use_cuda=true;
      shift ;;
    --use-cuda=yes)
      use_cuda=true;
      shift ;;
    --use-cuda=no)
      use_cuda=false;
      shift ;;
    --static-math)
      static_math=true;
      shift ;;
    --static-math=yes)
      static_math=true;
      shift ;;
    --static-math=no)
      static_math=false;
      shift ;;
    --static-fst)
      static_fst=true;
      shift ;;
    --static-fst=yes)
      static_fst=true;
      shift ;;
    --static-fst=no)
      static_fst=false;
      shift ;;
    --mkl-threading=sequential)
      threaded_atlas=false;
      mkl_threading=sequential;
      shift ;;
    --mkl-threading=*)
      GetSwitchValueOrDie mkl_threading "$1"
      threaded_atlas=true;
      shift ;;
    --fst-root=*)
      GetSwitchExistingPathOrDie FSTROOT "$1"
      shift ;;
    --cub-root=*)
      GetSwitchExistingPathOrDie CUBROOT "$1"
      shift ;;
    --clapack-root=*)
      GetSwitchExistingPathOrDie CLAPACKROOT "$1"
      shift ;;
    --openblas-root=*)
      GetSwitchExistingPathOrDie OPENBLASROOT "$1"
      shift ;;
    --mkl-root=*)
      GetSwitchExistingPathOrDie MKLROOT "$1"
      shift ;;
    --mkl-libdir=*)
      GetSwitchExistingPathOrDie MKLLIBDIR "$1"
      shift ;;
    --speex-root=*)
      GetSwitchExistingPathOrDie SPEEXROOT "$1"
      shift ;;
    --speex-libdir=*)
      GetSwitchExistingPathOrDie SPEEXLIBDIR "$1"
      shift ;;
    --speex-incdir=*)
      GetSwitchExistingPathOrDie SPEEXINCDIR "$1"
      shift ;;
    --omp-libdir=*)
      GetSwitchExistingPathOrDie OMPLIBDIR "$1"
      shift ;;
    --mathlib=*)
      GetSwitchValueOrDie MATHLIB "$1"
      shift ;;
    --cudatk-dir=*)
      # CUDA is used in src/cudamatrix and src/nnet{,bin} only.
      GetSwitchExistingPathOrDie CUDATKDIR "$1"
      shift ;;
    --cuda-arch=*)
      GetSwitchValueOrDie CUDA_ARCH "$1"
      shift;;
    --fst-version=*)
      GetSwitchValueOrDie OPENFST_VER "$1"
      shift;;
    --host=*)
      # The type of system where built programs and libraries will run.
      # It should be in the format cpu-vendor-os. If specified, this script
      # will infer the target architecture from the specified host triple.
      GetSwitchValueOrDie HOST "$1"
      shift ;;
    --android-incdir=*)
      android=true;
      threaded_math=false;
      static_math=true;
      static_fst=true;
      dynamic_kaldi=false;
      MATHLIB='OPENBLAS';
      GetSwitchExistingPathOrDie ANDROIDINC "$1"
      shift;;
    *)  echo "Unknown argument: $1, exiting"; usage; exit 1 ;;
    esac
  done
  
  # The idea here is that if you change the configuration options from using
  # CUDA to not using it, or vice versa, we want to recompile all parts of the
  # code that may use a GPU. Touching this file is a way to force this.
  touch cudamatrix/cu-common.h 2>/dev/null
  
  if $android && [[ "$CXX" != *clang++*  ]] ; then
    failure "Android build requires clang++. Make sure you have clang++ installed
    on your system and then override the default compiler by setting CXX, e.g.
    CXX=clang++ ./configure"
  fi
  
  # If HOST is set
  # 1. We prepend it to CXX, AR, AS and RANLIB.
  # 2. We parse the target architecture from the HOST triple.
  # Otherwise we set the target architecture to the output of `uname -m`.
  if is_set $HOST; then
    CXX="$HOST-$CXX"
    AR="$HOST-$AR"
    AS="$HOST-$AS"
    RANLIB="$HOST-$RANLIB"
  
    # The host triple will be something like "armv8-rpi3-linux-gnueabihf". We
    # need the first field which is the target architecture for this build. The
    # following command will take the host triple "armv8-rpi3-linux-gnueabihf"
    # and return ["armv8", "rpi3", "linux", "gnueabihf"] in PARTS.
    IFS='-' read -ra PARTS <<< "$HOST"
    # The first field in the PARTS list is the target architecture.
    TARGET_ARCH="$PARTS"
    if [[ "$TARGET_ARCH" != aarch64* && "$TARGET_ARCH" != arm* && "$TARGET_ARCH" != ppc64le && \
          "$TARGET_ARCH" != x86* && "$TARGET_ARCH" != i686* ]] ; then
      # We currently only support building for x86[_64], arm*, aarch64* and ppc64le.
      # If TARGET_ARCH was read from the HOST variable, it must be one of these.
      failure "$TARGET_ARCH is not a supported architecture.
               Supported architectures: x86[_64], arm*, aarch64*, ppc64le."
    fi
  else
    TARGET_ARCH="`uname -m`"
  fi
  
  #------------------------------------------------------------------------------
  # Matrix algebra library selection and validation.
  #--------------
  
  declare -a mathlibs   # Contains e. g. 'atlas', 'mkl'
  declare -a incompat   # Contains mutually-inconsistent switches, if any.
  auto_lib=             # Deduced lib name, used when $MATHLIB is not set.
  
  # Validate the (optionally) provided MATHLIB value.
  case $MATHLIB in
    ''|ATLAS|CLAPACK|MKL|OPENBLAS) : ;;
    *) failure "Unknown --mathlib='${MATHLIB}'. Supported libs: ATLAS CLAPACK MKL OPENBLAS" ;;
  esac
  
  # See which library-root switches are set, what mathlib they imply, and whether
  # there are any conflicts betweeh the switches.
  [[ $MKLLIBDIR || $MKLROOT ]] && { mathlibs+=(mkl); auto_lib=MKL; }
  [[ $CLAPACKROOT  ]] && { mathlibs+=(clapack); auto_lib=CLAPACK; }
  [[ $OPENBLASROOT ]] && { mathlibs+=(openblas); auto_lib=OPENBLAS; }
  [[ $ATLASROOT    ]] && { mathlibs+=(atlas); auto_lib=ATLAS; }
  
  # When --mathlib= is explicitly provided, and some mathlib(s) deduced, but
  # MATHLIB is not among them, record a conflict for the --mathlib= value.
  shopt -s nocasematch
  [[ $MATHLIB && $mathlibs && ! " ${mathlibs[@]} " =~ " $MATHLIB " ]] &&
    incompat+=(--mathlib=$MATHLIB)
  shopt -u nocasematch
  
  # If more than one library specified, or a conflict has been recorded above
  # already, then add all deduced libraries as conflicting options (not all may
  # be conflicting sensu stricto, but let the user deal with it).
  if [[ ${#mathlibs[@]} -gt 1 || $incompat ]]; then
    for libpfx in "${mathlibs[@]}"; do
      # Handle --mkl-libdir out of common pattern.
      [[ $libpfx == mkl && $MKLLIBDIR ]] && incompat+=(--mkl-libdir=)
      # All other switches follow the pattern --$libpfx-root.
      incompat+=(--$(lcase $libpfx)-root=)
    done
    failure "Incompatible configuration switches: ${incompat[@]}"
  fi
  
  # When no library roots were provided, so that auto_lib is not deduced, and
  # MATHLIB is also not explicitly provided by the user, then default to MKL.
  [[ ! $auto_lib && ! $MATHLIB ]] &&
    case $TARGET_ARCH in
      x86_64) auto_lib=MKL ;;
      *) auto_lib=OPENBLAS ;;
    esac
  : ${MATHLIB:=$auto_lib}
  export MATHLIB  #TODO(kkm): Likely not needed. Briefly tested without,
                  #    but left in the hotfix. Remove when doing the #3192.
  
  # Define default library roots where known (others may be found by probing).
  case $MATHLIB in
    MKL) [[ ! $MKLLIBDIR && ! $MKLROOT ]] && MKLROOT=/opt/intel/mkl ;;
    ATLAS) : ${ATLASROOT:=$(rel2abs ../tools/ATLAS_headers/)} ;;
  esac
  
  unset auto_lib incompat libpfx mathlibs
  
  echo "Configuring KALDI to use ${MATHLIB}."
  
  # Back up the old kaldi.mk in case we modified it
  if [ -f kaldi.mk ]; then
    echo "Backing up kaldi.mk to kaldi.mk.bak ..."
    cp kaldi.mk kaldi.mk.bak
  fi
  
  # Generate the new kaldi.mk file
  echo "# This file was generated using the following command:" > kaldi.mk
  echo "# $cmd_line" >> kaldi.mk
  echo >> kaldi.mk
  echo "CONFIGURE_VERSION := $CONFIGURE_VERSION" >> kaldi.mk
  echo >> kaldi.mk
  
  echo "# Toolchain configuration" >> kaldi.mk
  echo >> kaldi.mk
  echo "CXX = $CXX" >> kaldi.mk
  echo "AR = $AR" >> kaldi.mk
  echo "AS = $AS" >> kaldi.mk
  echo "RANLIB = $RANLIB" >> kaldi.mk
  echo >> kaldi.mk
  
  echo "Checking compiler $CXX ..."
  check_compiler $CXX
  
  echo "# Base configuration" >> kaldi.mk
  echo >> kaldi.mk
  if $dynamic_kaldi ; then
    KALDILIBDIR=`pwd`/lib
    echo "KALDI_FLAVOR := dynamic" >> kaldi.mk
    echo "KALDILIBDIR := $KALDILIBDIR" >> kaldi.mk
  fi
  if $double_precision; then
    echo "DOUBLE_PRECISION = 1" >> kaldi.mk
  else
    echo "DOUBLE_PRECISION = 0" >> kaldi.mk
  fi
  echo "Checking OpenFst library in $FSTROOT ..."
  if [ ! -f $FSTROOT/include/fst/fst.h  ]; then
    failure "Could not find file $FSTROOT/include/fst/fst.h:
    you may not have installed OpenFst. See ../tools/INSTALL"
  fi
  OPENFST_VER=${OPENFST_VER:-$(grep 'PACKAGE_VERSION' $FSTROOT/Makefile | sed -e 's:.*= ::')}
  OPENFST_VER_NUM=$(echo $OPENFST_VER | sed 's/\./ /g' | xargs printf "%d%02d%02d")
  if [ $OPENFST_VER_NUM -lt 10600 ]; then
    failure "OpenFst-$OPENFST_VER is not supported. You need OpenFst >= 1.6.0.)"
  fi
  echo "OPENFSTINC = $FSTROOT/include" >> kaldi.mk
  if $static_fst ; then
    OPENFSTLIBS="$FSTROOT/lib/libfst.a"
  else
    if [ "`uname`" == "Darwin"  ]; then
      OPENFSTLIBS="$FSTROOT/lib/libfst.dylib"
      OPENFSTLDFLAGS="-Wl,-rpath -Wl,${FSTROOT}/lib"
    elif [ "`uname`" == "Linux" ]; then
      OPENFSTLIBS="$FSTROOT/lib/libfst.so"
      OPENFSTLDFLAGS="-Wl,-rpath=${FSTROOT}/lib"
    else
      failure "Dynamic libraries are not supported on this platform.
               Run configure with --static --static-fst flag."
    fi
  fi
  if [ ! -f "$OPENFSTLIBS" ]; then
    failure "Static=[$static_fst] OpenFST library not found:  See ../tools/INSTALL"
  fi
  echo "OPENFSTLIBS = $OPENFSTLIBS" >> kaldi.mk
  echo "OPENFSTLDFLAGS = $OPENFSTLDFLAGS" >> kaldi.mk
  echo >> kaldi.mk
  
  $use_cuda && echo "Checking cub library in $CUBROOT ..."
  if [[ "$use_cuda" = true  && ! -f $CUBROOT/cub/cub.cuh ]]; then
    failure "Could not find file $CUBROOT/cub/cub.cuh:
    you may not have installed cub.  Go to ../tools/ and type
    e.g. 'make cub'; cub is a new requirement."
  else
    echo "CUBROOT = $CUBROOT" >> kaldi.mk
  fi
  
  
  # OS-specific steps given below append to kaldi.mk
  echo "Doing OS specific configurations ..."
  
  if $android ; then
    if [ -z $ANDROIDINC ] ;  then
      failure "--android-incdir must be specified for android builds."
    fi
  
    if ! is_set $HOST; then
      failure "HOST must be specified for android builds."
    fi
  
    OPENBLASROOT=`rel2abs "$OPENBLASROOT"`
    if [ -z "$OPENBLASROOT" ]; then
      failure "The location of OPENBLAS must be specified for android builds
               using --openblas-root (and it must exist)"
    fi
    if [ ! -f $OPENBLASROOT/lib/libopenblas.a ]; then
      failure "Expected to find the file $OPENBLASROOT/lib/libopenblas.a"
    fi
    echo "Using OpenBLAS as the linear algebra library."
  
    OPENBLASLIBS="$OPENBLASROOT/lib/libopenblas.a $OPENBLASROOT/lib/libclapack.a $OPENBLASROOT/lib/liblapack.a $OPENBLASROOT/lib/libblas.a $OPENBLASROOT/lib/libf2c.a"
    echo "OPENBLASINC = $OPENBLASROOT/include" >> kaldi.mk
    echo "OPENBLASLIBS = $OPENBLASLIBS" >> kaldi.mk
    echo "ANDROIDINC = $ANDROIDINC" >> kaldi.mk
  
    cat makefiles/android_openblas.mk >> kaldi.mk
  
    echo "Successfully configured for Android with OpenBLAS from $OPENBLASROOT."
  
  elif [ "`uname`" == "Darwin" ]; then
    # Check for Darwin first, because we later call uname -o (for Cygwin)
    # which crashes on Darwin.
  
    echo "On Darwin: Checking for Accelerate framework ..."
    if [ ! -e /System/Library/Frameworks/Accelerate.framework ]; then
      failure "Need the Accelerate framework to compile on Darwin."
    fi
    OSX_VER=$(sw_vers | grep ProductVersion | awk '{print $2}' | awk '{split($0,a,"."); print a[1] "." a[2]; }')
    OSX_VER_NUM=$(echo $OSX_VER | sed 's/\./ /g' | xargs printf "%d%02d")
    echo "Configuring for OS X version $OSX_VER ..."
    if [ $OSX_VER_NUM -ge 1005 ]; then
      cat makefiles/darwin.mk >> kaldi.mk
    else
      failure "Mac OS X version '$OSX_VER' is not supported."
    fi
  
    if [ $OSX_VER_NUM == 1011 ]; then
      echo "**BAD WARNING**: You are using OS X El Capitan.  Some versions of this OS"
      echo "**BAD WARNING**: have a bug in the BLAS implementation that affects Kaldi."
      echo "**BAD WARNING**: After compiling, cd to matrix/ and type 'make test'.  The"
      echo "**BAD WARNING**: test will fail if the problem exists in your version. "
      echo "**BAD WARNING**: Eventually this issue will be fixed by system updates from"
      echo "**BAD WARNING**: Apple.  Unexplained crashes with reports of NaNs will"
      echo "**BAD WARNING**: be caused by this bug, but some recipes will (sometimes) work."
      sleep 1; echo -n .; sleep 1; echo -n .; sleep 1; echo .
    fi
    echo "Successfully configured for Darwin with Accelerate framework."
    $use_cuda && configure_cuda
  
  elif [ "`uname -o`" == "Cygwin"  ]; then
    echo "On Cygwin: Checking for linear algebra libraries ..."
    if [ ! -f ../tools/CLAPACK/clapack.h ]; then
        failure "could not find file ../tools/CLAPACK/clapack.h"
    fi
    if [ ! -f /usr/lib/lapack/cygblas-0.dll ]; then
       failure "please first install package liblapack0"
    fi
    cat makefiles/cygwin.mk >> kaldi.mk
    echo "Successfully configured for Cygwin with CLAPACK."
  
  elif [ "`uname`" == "Linux" ]; then
    echo "On Linux: Checking for linear algebra header files ..."
    if [ "$MATHLIB" == "ATLAS" ]; then
      if [ ! -f $ATLASROOT/include/cblas.h ] || [ ! -f $ATLASROOT/include/clapack.h ] ; then
        failure "Could not find required header files cblas.h or clapack.h in ATLAS dir '$ATLASROOT/include'"
      fi
      echo "Using ATLAS as the linear algebra library."
  
      # Finding out where the libraries are located:
      # First we look for the static libraries and then look for dynamic ones.
      # We're looking for four libraries, all in the same directory, named
      # libcblas.a, libatlas.a, libf77blas.a, and a library that's variously
      # named liblapack.a, libclapack.a, or liblapack_atlas.a, but which exports
      # the symbol ATL_cgetrf.
      # Note: there is a different type of ATLAS installation that is not
      # covered.  We saw a case where there was a directory called /usr/lib/atlas
      # containing {liblapack.a,libblas.a}, and linking against just these two
      # libraries worked.
  
      ( $static_math && linux_configure_atlas_static ) || \
        linux_configure_atlas_generic /usr/lib "so.3" || \
        linux_configure_atlas_generic /usr/lib/atlas-base "so.3gf" || \
        linux_configure_atlas_generic /usr/lib64/atlas-base "so.3gf" \
        linux_configure_atlas_generic /usr/lib/atlas "so.3" || \
        linux_configure_atlas_generic /usr/lib64/atlas "so.3" || \
        linux_configure_atlas_generic /usr/lib/x86_64-linux-gnu/ "so.3" || \
        linux_configure_atlas_generic /usr/lib/x86_64-linux-gnu/ "so" || \
        linux_configure_atlas_redhat_fat 64 || \
        linux_configure_atlas_redhat_fat || \
        linux_configure_atlas_static || \
        linux_configure_atlas_failure "Failed to configure ATLAS libraries";
  
      case $TARGET_ARCH in
        arm*)    cat makefiles/linux_atlas_arm.mk ;;
        ppc64le) cat makefiles/linux_atlas_ppc64le.mk ;;
        *)       cat makefiles/linux_atlas.mk ;;
      esac >> kaldi.mk
  
    elif [ "$MATHLIB" == "MKL" ]; then
      if [ "$TARGET_ARCH" != "x86_64" ]; then
        failure "MKL on Linux only supported for Intel(R) 64 architecture (x86_64).
        See makefiles/linux_64_mkl.mk to manually configure for other platforms."
      fi
  
      if  ( is_set "$MKLROOT" && ! is_set "$MKLLIBDIR" ); then
        echo -n "Configuring MKL library directory: "
        MKLLIBDIR=`linux_configure_mkllibdir $MKLROOT`
        if [ $? -ne 0 ]; then
          failure "MKL libraries could not be found. Please use the switch --mkl-libdir or try another math library, e.g. --mathlib=ATLAS (would be slower)"
        else
          echo "Found: $MKLLIBDIR"
        fi
      fi
  
      MKL_LINK_LINE=`linux_configure_mkl_libraries "$MKLLIBDIR" $static_math $mkl_threading` || exit 1
      echo "MKL configured with threading: $mkl_threading, libs: $MKL_LINK_LINE"
  
      MKL_COMPILE_LINE=`linux_configure_mkl_includes "$MKLROOT" "$MKLLIBDIR"` || exit 1
      echo "MKL include directory configured as: $MKL_COMPILE_LINE"
      MKL_COMPILE_LINE=" -I${MKL_COMPILE_LINE} "
  
      THREADING_LINE=`linux_configure_mkl_threading $MKLROOT $MKLLIBDIR $static_math $mkl_threading` || exit 1
      EXTRA_LIBS=`linux_configure_mkl_extra $static_math $mkl_threading` || exit 1
      if [ ! -z "$THREADING_LINE" ] || [ ! -z "$EXTRA_LIBS" ]; then
        echo "MKL threading libraries configured as $THREADING_LINE $EXTRA_LIBS"
      fi
  
      echo "Using Intel MKL as the linear algebra library."
      (
        cd probe; rm -f mkl-test;
        g++ mkl-test.cc -o mkl-test $MKL_COMPILE_LINE $MKL_LINK_LINE $THREADING_LINE $EXTRA_LIBS || exit 1
        test -f ./mkl-test || exit 1
        ./mkl-test || exit 1
        cd ..
      ) || failure "Cannot validate the MKL switches"
  
      echo MKLROOT = $MKLROOT >> kaldi.mk
      if [ ! -z $MKLLIBDIR ]; then
        echo MKLLIB = $MKLLIBDIR >> kaldi.mk
      fi
      echo >> kaldi.mk
      check_exists makefiles/linux_x86_64_mkl.mk
      cat makefiles/linux_x86_64_mkl.mk >> kaldi.mk
      echo "MKLFLAGS = ${MKL_LINK_LINE} ${THREADING_LINE} $EXTRA_LIBS " >> kaldi.mk
      echo "Successfully configured for Linux with MKL libs from $MKLROOT"
  
    elif [ "$MATHLIB" == "CLAPACK" ]; then
      if [ -z "$CLAPACKROOT" ]; then
        failure "Must specify the location of CLAPACK with --clapack-root option (and it must exist)"
      fi
      if [ ! -f ../tools/CLAPACK/clapack.h ]; then
        failure "could not find file ../tools/CLAPACK/clapack.h"
      fi
      if [ ! -d "$CLAPACKROOT" ]; then
        failure "The directory $CLAPACKROOT does not exist"
      fi
      # Also check for cblas.h and f2c.h
      echo "Using CLAPACK libs from $CLAPACKROOT as the linear algebra library."
      if [ ! -f makefiles/linux_clapack.mk ]; then
        failure "makefiles/linux_clapack.mk not found."
      fi
      if [[ "$TARGET_ARCH" == arm* ]]; then
        cat makefiles/linux_clapack_arm.mk >> kaldi.mk
      else
        cat makefiles/linux_clapack.mk >> kaldi.mk
      fi
      echo "Warning (CLAPACK): this part of the configure process is not properly tested and may not work."
      echo "Successfully configured for Linux with CLAPACK libs from $CLAPACKROOT"
  
    elif [ "$MATHLIB" == "OPENBLAS" ]; then
      if [[ ! $OPENBLASROOT ]]; then
        # Either the user specified --mathlib=OPENBLAS or we've autodetected the
        # system where OpenBLAS is the preferred option (the parser for
        # --openblas-root fails fatally if the path does not exist, so we trust
        # that if set, the variable contains the existing path, converted to
        # absolute form).
        OPENBLASROOT="$(rel2abs ../tools/OpenBLAS/install)" ||
          Die "OpenBLAS not found in '../tools/OpenBLAS/install'.
  ** This is the only place we look for it. The best option is to build OpenBLAS
  ** tuned for your system and CPU. To do that, run the following commands:
  **
  **   cd ../tools; extras/install_openblas.sh
  **
  ** Another option is to specify the location of existing OpenBLAS directory
  ** with the switch '--openblas-root='. However, even if a package is provided
  ** for your system, the packaged version is almost always significantly slower
  ** and often older than the above commands can fetch and build.
  **
  ** You can also use other matrix algebra libraries. For information, see:
  **   http://kaldi-asr.org/doc/matrixwrap.html"
      fi
      if [ -f $OPENBLASROOT/lib/libopenblas.so ]; then
        OPENBLASLIBDIR=$OPENBLASROOT/lib
      elif [ -f $OPENBLASROOT/lib64/libopenblas.so ]; then
        # in REDHAT/CentOS package installs, the library is located here
        OPENBLASLIBDIR=$OPENBLASROOT/lib64
      else
        failure "Expected to find the file $OPENBLASROOT/lib/libopenblas.so"
      fi
      if [ -f $OPENBLASROOT/include/cblas.h ] ; then
        OPENBLASINCDIR=$OPENBLASROOT/include
      elif [ -f $OPENBLASROOT/include/openblas/cblas.h ] ; then
        # in REDHAT/CentOS/Ubuntu package installs, the includes are located here
        OPENBLASINCDIR=$OPENBLASROOT/include/openblas
      else
        echo "$0: ***** Using OpenBLAS from $OPENBLASROOT but cblas.h is not found. "
        echo "** Assuming openblas is aleady in a default include path, but"
        echo "** if you get compilation messages about not finding files like cblas.h,"
        echo "** you should look into this (e.g. make sure to install the 'openblas-dev' package,"
        echo "** if it is a package-based install)."
        OPENBLASINCDIR="/usr/include"
      fi
      echo "Your math library seems to be OpenBLAS from $OPENBLASROOT.  Configuring appropriately."
      # TODO(kkm): Probably, OpenBLAS required libgfortran.so.3 at some point, but
      # no longer does. *My* linker does not complain about a missing library, but
      # is it safe to keep the reference if no longer required? Try to figure out
      # how long ago the dependency was dropped.
      if $static_math; then
        echo "Configuring static OpenBlas since --static-math=yes"
        OPENBLASLIBS="-L$OPENBLASLIBDIR -l:libopenblas.a -lgfortran"
      else
        echo "Configuring dynamically loaded OpenBlas since --static-math=no (the default)"
        OPENBLASLIBS="-L$OPENBLASLIBDIR -lopenblas -lgfortran -Wl,-rpath=$OPENBLASLIBDIR"
      fi
      echo "OPENBLASINC = $OPENBLASINCDIR" >> kaldi.mk
      echo "OPENBLASLIBS = $OPENBLASLIBS" >> kaldi.mk
      echo >> kaldi.mk
      case $TARGET_ARCH in
        aarch64*) cat makefiles/linux_openblas_aarch64.mk ;;
        arm*)     cat makefiles/linux_openblas_arm.mk ;;
        ppc64le)  cat makefiles/linux_openblas_ppc64le.mk ;;
        *)        cat makefiles/linux_openblas.mk ;;
      esac >> kaldi.mk
  
      echo "Successfully configured for Linux with OpenBLAS from $OPENBLASROOT"
    else
      failure "Unsupported linear algebra library '$MATHLIB'"
    fi
    $use_cuda && configure_cuda
    linux_configure_speex
  else
    failure "Could not detect the platform or we have not yet worked out the
    appropriate configuration for this platform. Please contact the developers."
  fi
  
  # Append the flags set by environment variables last so they can be used
  # to override the automatically generated configuration.
  echo >> kaldi.mk
  echo "# Environment configuration" >> kaldi.mk
  echo >> kaldi.mk
  if [ -n "$ENV_CXXFLAGS" ]; then echo "CXXFLAGS += $ENV_CXXFLAGS" >> kaldi.mk; fi
  if [ -n "$ENV_LDFLAGS" ]; then echo "LDFLAGS += $ENV_LDFLAGS" >> kaldi.mk; fi
  if [ -n "$ENV_LDLIBS" ]; then echo "LDLIBS += $ENV_LDLIBS" >> kaldi.mk; fi
  
  # We check for slow exp implementation just before we exit. This check uses
  # and possibly modifies the kaldi.mk file that we just generated.
  check_for_slow_expf;
  echo "Kaldi has been successfully configured. To compile:
  
    make -j clean depend; make -j <NCPU>
  
  where <NCPU> is the number of parallel builds you can afford to do. If unsure,
  use the smaller of the number of CPUs or the amount of RAM in GB divided by 2,
  to stay within safe limits. 'make -j' without the numeric value may not limit
  the number of parallel jobs at all, and overwhelm even a powerful workstation,
  since Kaldi build is highly parallelized."
  exit 0