ADD_CUSTOM_COMMAND(
  TARGET copy_scripts
  POST_BUILD
  COMMAND ${CMAKE_CXX_COMPILER} --version | head -n 1 > ${CMAKE_CURRENT_BINARY_DIR}/compiler_version.txt
  ARGS
)

EXEC_PROGRAM(
    	${CMAKE_CXX_COMPILER}  
        ARGS 	${CMAKE_CXX_COMPILER_ARG1} -dumpversion 
        OUTPUT_VARIABLE gcc_compiler_version)

add_test(NAME compile_simple_C_example 
	     COMMAND ${CMAKE_C_COMPILER} ${CMAKE_CURRENT_SOURCE_DIR}/C/example.c -L../../lib/ -Wl,--whole-archive -l${WB_TARGET} -Wl,--no-whole-archive -I${CMAKE_SOURCE_DIR}/include/ ${WB_COMPILER_OPTIONS_PRIVATE_COVERAGE_NEW} -o example${CMAKE_EXECUTABLE_SUFFIX} ${WB_COMPILER_OPTIONS_PRIVATE_COVERAGE_NEW} -lstdc++ -lm  -L${MPI_C_LIBRARIES} -L${MPI_CXX_LIBRARIES}
	     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/tests/C/)

CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )

execute_process (COMMAND ${CMAKE_C_COMPILER} ${ARCH_FLAGS} -E -dM -xc ${NULL_DEVICE${EMCC_FIX}} RESULT_VARIABLE CC_EXIT_STATUS OUTPUT_VARIABLE NATIVE_PREDEFINED_MACROS ERROR_QUIET)

ExternalProject_Add(${SUITESPARSE_TARGET}
        URL https://github.com/DrTimothyAldenDavis/SuiteSparse/archive/v7.3.0.tar.gz
        URL_HASH MD5=6ff86003a85d73eb383d82db04af7373
        DOWNLOAD_DIR ${BUILD_DIR}/download/suitesparse
        PREFIX ${BUILD_DIR}
        BUILD_IN_SOURCE 0
        BUILD_ALWAYS 0
        UPDATE_COMMAND ""
        SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/suitesparse
        BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/suitesparse
        INSTALL_DIR ${CMAKE_INSTALL_PREFIX}
        CONFIGURE_COMMAND ""
        BUILD_COMMAND   cd <BINARY_DIR> && ${SUITESPARSE_INTERNAL_MAKE_CMD} library CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} CMAKE_OPTIONS=-DBLAS_LIBRARIES=${BLAS_LIBRARIES}\ -DLAPACK_LIBRARIES=${LAPACK_LIBRARIES}\ -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
        INSTALL_COMMAND cd <BINARY_DIR> && ${SUITESPARSE_INTERNAL_MAKE_CMD} install library INSTALL=<INSTALL_DIR> CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} CMAKE_OPTIONS=-DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
        DEPENDS ${LAPACK_TARGET} mpfr
    )

ExternalProject_Add(
        dep_${projectname}
        INSTALL_DIR         ${${PROJECT_NAME}_DEP_INSTALL_PREFIX}
        DOWNLOAD_DIR        ${${PROJECT_NAME}_DEP_DOWNLOAD_DIR}/${projectname}
        BINARY_DIR          ${CMAKE_CURRENT_BINARY_DIR}/builds/${projectname}
        CMAKE_ARGS
            -DCMAKE_INSTALL_PREFIX:STRING=${${PROJECT_NAME}_DEP_INSTALL_PREFIX}
            -DCMAKE_MODULE_PATH:STRING=${CMAKE_MODULE_PATH}
            -DCMAKE_PREFIX_PATH:STRING=${${PROJECT_NAME}_DEP_INSTALL_PREFIX}
            -DCMAKE_DEBUG_POSTFIX:STRING=${CMAKE_DEBUG_POSTFIX}
            -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
            -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
            -DCMAKE_CXX_FLAGS_${_build_type_upper}:STRING=${CMAKE_CXX_FLAGS_${_build_type_upper}}
            -DCMAKE_C_FLAGS_${_build_type_upper}:STRING=${CMAKE_C_FLAGS_${_build_type_upper}}
            -DCMAKE_TOOLCHAIN_FILE:STRING=${CMAKE_TOOLCHAIN_FILE}
            -DBUILD_SHARED_LIBS:BOOL=${BUILD_SHARED_LIBS}
            "${_configs_line}"
            ${DEP_CMAKE_OPTS}
            ${P_ARGS_CMAKE_ARGS}
       ${P_ARGS_UNPARSED_ARGUMENTS}
       BUILD_COMMAND ${CMAKE_COMMAND} --build . --config ${CMAKE_BUILD_TYPE} -- ${_build_j} ${_verbose_switch}
       INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install --config ${CMAKE_BUILD_TYPE}
    )

EXEC_PROGRAM(${CMAKE_CXX_COMPILER} ARGS --version OUTPUT_VARIABLE CXX_COMPILER_VERSION)

find_program(CMAKE_C_COMPILER NAMES i686-w64-mingw32-gcc)

ExternalProject_Add(
        dep_${projectname}
        EXCLUDE_FROM_ALL    ON
        INSTALL_DIR         ${DESTDIR}/usr/local
        DOWNLOAD_DIR        ${DEP_DOWNLOAD_DIR}/${projectname}
        ${_gen}
        CMAKE_ARGS
            -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}/usr/local
            -DCMAKE_MODULE_PATH:STRING=${PROJECT_SOURCE_DIR}/../cmake/modules
            -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}/usr/local
            -DCMAKE_DEBUG_POSTFIX:STRING=d
            -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
            -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
            -DCMAKE_TOOLCHAIN_FILE:STRING=${CMAKE_TOOLCHAIN_FILE}
            -DBUILD_SHARED_LIBS:BOOL=OFF
            ${_cmake_osx_arch}
            "${_configs_line}"
            ${DEP_CMAKE_OPTS}
            ${P_ARGS_CMAKE_ARGS}
       ${P_ARGS_UNPARSED_ARGUMENTS}
       BUILD_COMMAND ${CMAKE_COMMAND} --build . --config Release -- ${_build_j}
       INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install --config Release
    )

set(CMAKE_CXX_COMPILER "${LLVM_NATIVE_TOOLCHAIN}/bin/clang-cl.exe" CACHE FILEPATH "")

ExternalProject_Add(
        dep_${projectname}
        EXCLUDE_FROM_ALL    ON
        INSTALL_DIR         ${DESTDIR}
        DOWNLOAD_DIR        ${DEP_DOWNLOAD_DIR}/${projectname}
        ${_gen}
        CMAKE_ARGS
            -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}
            -DCMAKE_MODULE_PATH:STRING=${PROJECT_SOURCE_DIR}/../cmake/modules
            -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}
            -DCMAKE_DEBUG_POSTFIX:STRING=d
            -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
            -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
            -DCMAKE_TOOLCHAIN_FILE:STRING=${CMAKE_TOOLCHAIN_FILE}
            -DBUILD_SHARED_LIBS:BOOL=OFF
            ${_cmake_osx_arch}
            "${_configs_line}"
            ${DEP_CMAKE_OPTS}
            ${P_ARGS_CMAKE_ARGS}
       ${P_ARGS_UNPARSED_ARGUMENTS}
       BUILD_COMMAND ${CMAKE_COMMAND} --build . --config Release -- ${_build_j}
       INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install --config Release
    )

execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version
                    COMMAND head -n 1
                    OUTPUT_VARIABLE eigen_cxx_compiler_version_string OUTPUT_STRIP_TRAILING_WHITESPACE)

set(CMAKE_CXX_COMPILER "/usr/bin/c++")

EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)

find_program(CMAKE_CXX_COMPILER NAMES i686-w64-mingw32-g++)

get_filename_component(GCC_PATH ${CMAKE_C_COMPILER} PATH)

CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )

cmake_path(GET CMAKE_CXX_COMPILER STEM LAST_ONLY ZENO_CXX_COMPILER_BINARY)

ExternalProject_Add(${proj}
  ${${proj}_EP_ARGS}
  DOWNLOAD_COMMAND ""
  INSTALL_COMMAND ""
  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
  BINARY_DIR ${EXTENSION_BUILD_SUBDIRECTORY}
  CMAKE_CACHE_ARGS
    # Compiler settings
    -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
    -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
    -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
    -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
    -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
    -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
    -DCMAKE_CXX_EXTENSIONS:BOOL=${CMAKE_CXX_EXTENSIONS}
    # Output directories
    -DCMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
    -DCMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
    -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
    # Packaging
    -DMIDAS_PACKAGE_EMAIL:STRING=${MIDAS_PACKAGE_EMAIL}
    -DMIDAS_PACKAGE_API_KEY:STRING=${MIDAS_PACKAGE_API_KEY}
    # Superbuild
    -D${EXTENSION_NAME}_SUPERBUILD:BOOL=OFF
    -DEXTENSION_SUPERBUILD_BINARY_DIR:PATH=${${EXTENSION_NAME}_BINARY_DIR}
  DEPENDS
    ${${proj}_DEPENDS}
  )

execute_process(
      COMMAND ${CMAKE_CXX_COMPILER} --version
      COMMAND grep -c Cray
      OUTPUT_VARIABLE INTERNAL_HAVE_CRAY_COMPILER
      OUTPUT_STRIP_TRAILING_WHITESPACE
    )

execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
                        OUTPUT_VARIABLE GCC_VERSION)

execute_process(COMMAND "${CMAKE_C_COMPILER}" --version
        OUTPUT_VARIABLE _version ERROR_VARIABLE _version)

execute_process (COMMAND ${CMAKE_CXX_COMPILER} "-dumpversion" OUTPUT_VARIABLE GCC_VERSION)

exec_program(${CMAKE_CXX_COMPILER} ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion OUTPUT_VARIABLE GCC_VERSION)

execute_process(
                COMMAND ${CMAKE_CXX_COMPILER} --version
                OUTPUT_VARIABLE _gcc_version_info
                OUTPUT_STRIP_TRAILING_WHITESPACE
        )

message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++17 support. Please use a different C++ compiler.")

execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version COMMAND head -n 1 OUTPUT_VARIABLE EIGEN_CXX_VERSION_STRING OUTPUT_STRIP_TRAILING_WHITESPACE)

separate_arguments(CMD
              UNIX_COMMAND
              "${CMAKE_CXX_COMPILER} ${compile_options_str}
${include_options_str} -x c++ -fsyntax-only \
${compute_deps_extra_args} \
${CMAKE_CURRENT_SOURCE_DIR}/../${package}/include/${header}"
              # The header Algebraic_kernel_rs_gmpz_d_1.h is skipped on purpose: it
              # depends on RS.
              )

exec_program(${CMAKE_CXX_COMPILER} ARGS --version OUTPUT_VARIABLE _gcc_version_info)

ExternalProject_Add(
    extern_gflags
    ${EXTERNAL_PROJECT_LOG_ARGS}
    GIT_REPOSITORY  "https://github.com/gflags/gflags.git"
    PREFIX          ${GFLAGS_SOURCES_DIR}
    UPDATE_COMMAND  ""
    CMAKE_ARGS      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
    CMAKE_ARGS      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
    CMAKE_ARGS      -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
    CMAKE_ARGS      -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
    CMAKE_ARGS      -DCMAKE_INSTALL_PREFIX=${GFLAGS_INSTALL_DIR}
    CMAKE_ARGS      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
    CMAKE_ARGS      -DBUILD_TESTING=OFF
    CMAKE_ARGS      -DCMAKE_BUILD_TYPE=Release
    CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${GFLAGS_INSTALL_DIR}
    -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
    -DCMAKE_BUILD_TYPE:STRING=Release
    )

ExternalProject_Add(nvshmem_device_project
                    SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/device
                    BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/device
                    CMAKE_ARGS  -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                                -DNVSHMEM_PREFIX=${NVSHMEM_PREFIX}
                                -DNVSHMEM_DEBUG=${NVSHMEM_DEBUG}
                                -DNVSHMEM_DEVICELIB_CUDA_HOME=${NVSHMEM_DEVICELIB_CUDA_HOME}
                                -DNVSHMEM_ENABLE_ALL_DEVICE_INLINING=${NVSHMEM_ENABLE_ALL_DEVICE_INLINING}
                                -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
                                -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                                -DCMAKE_CUDA_HOST_COMPILER=${CMAKE_CUDA_HOST_COMPILER}
                                -DPROJECT_VERSION=${PROJECT_VERSION}
				$ENV{CMAKE_CCACHE_FLAGS}
                    CMAKE_CACHE_ARGS ${my_cmake_cache_args}
                    STEP_TARGETS build install
                    BUILD_ALWAYS TRUE
                    BUILD_BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/lib/libnvshmem_device.a
                    )

get_filename_component(compiler_prefix "${CMAKE_CXX_COMPILER}" DIRECTORY)

message(WARNING "\nCannot determine the version of the compiler selected to build GNSS-SDR (${APPLE_STR}Clang : ${CMAKE_CXX_COMPILER}). This build may or not work. We highly recommend using Apple Clang version ${APPLECLANG_MIN_VERSION} or more recent, or Clang version ${CLANG_MIN_VERSION} or more recent.")

message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")

add_custom_command(
        OUTPUT ${_source_output}
        COMMAND ${CMAKE_CXX_COMPILER} --std=c++17 ${_us_resource_cxx_flags} -c ${US_CMAKE_RESOURCE_DEPENDENCIES_CPP} -o stub.o
        COMMAND ${CMAKE_LINKER} -r -sectcreate __TEXT us_resources ${_zip_archive_name} stub.o -o ${_source_output}
        DEPENDS ${_zip_archive}
        WORKING_DIRECTORY ${_zip_archive_path}
        COMMENT "Linking resources zip file ${_zip_archive} for ${US_RESOURCE_TARGET}"
        VERBATIM
       )

add_custom_target(jsimdcfg COMMAND
  ${CMAKE_C_COMPILER} -E -I${CMAKE_BINARY_DIR} -I${CMAKE_CURRENT_BINARY_DIR}
    -I${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/nasm/jsimdcfg.inc.h |
  ${GREP} -E '^[\;%]|^\ %' | sed 's%_cpp_protection_%%' |
  sed 's@% define@%define@g' >${CMAKE_CURRENT_SOURCE_DIR}/nasm/jsimdcfg.inc)

ExternalProject_Add(psi4-core
   DEPENDS lapack_external
           hdf5_external
           ambit_external
           bse_external
           chemps2_external
           cppe_external
           dkh_external
           ecpint_external
           libefp_external
           einsums_external
           gau2grid_external
           gdma_external
           libint2_external
           pcmsolver_external
           ddx_external
           pybind11_external
           pylibefp_external
           qcelemental_external
           qcengine_external
           qcmanybody_external
           openorbitaloptimizer_external
           optking_external
           simint_external
           libxc_external
           mdi_external
           brianqc_external
           integratorxx_external
           gauxc_external
 
   SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/psi4
   CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${STAGED_INSTALL_PREFIX}
              -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
              -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
              -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
              -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
              -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
              -DCMAKE_CXX_STANDARD=${psi4_CXX_STANDARD}
              -Dpsi4_CXX_STANDARD_Libint2=${psi4_CXX_STANDARD_Libint2}
              -DCMAKE_CXX_STANDARD_REQUIRED=ON
              -DCMAKE_CXX_EXTENSIONS=OFF
              -DFORCE_PEDANTIC=${FORCE_PEDANTIC}
              -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
              -DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE}
              -DCMAKE_Fortran_COMPILER=${CMAKE_Fortran_COMPILER}
              -DCMAKE_Fortran_FLAGS=${CMAKE_Fortran_FLAGS}
              -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR}
              -DCMAKE_INSTALL_BINDIR=${CMAKE_INSTALL_BINDIR}
              -DCMAKE_INSTALL_DATADIR=${CMAKE_INSTALL_DATADIR}
              -DCMAKE_INSTALL_INCLUDEDIR=${CMAKE_INSTALL_INCLUDEDIR}
              -Dpsi4_INSTALL_CMAKEDIR=${psi4_INSTALL_CMAKEDIR}
              -DCMAKE_INSTALL_MESSAGE=${CMAKE_INSTALL_MESSAGE}
              -DPYMOD_INSTALL_LIBDIR=${PYMOD_INSTALL_LIBDIR}
              -DMAX_AM_ERI=${MAX_AM_ERI}
              -DPython_EXECUTABLE=${Python_EXECUTABLE}
              -DPython_INCLUDE_DIR=${Python_INCLUDE_DIRS}
              -DPython_LIBRARY=${Python_LIBRARIES}
              -DPython_NumPy_INCLUDE_DIR=${Python_NumPy_INCLUDE_DIR}
              -DPSI4_ROOT=${CMAKE_CURRENT_SOURCE_DIR}
              -DENABLE_ambit=${ENABLE_ambit}
              -DENABLE_CheMPS2=${ENABLE_CheMPS2}
              -DENABLE_cppe=${ENABLE_cppe}
              -DENABLE_dkh=${ENABLE_dkh}
              -DENABLE_IntegratorXX=${ENABLE_IntegratorXX}
              -DENABLE_gauxc=${ENABLE_gauxc}
              -DENABLE_ecpint=${ENABLE_ecpint}
              -DENABLE_libefp=${ENABLE_libefp}
              -DENABLE_Einsums=${ENABLE_Einsums}
              -DENABLE_simint=${ENABLE_simint}
              -DENABLE_gdma=${ENABLE_gdma}
              -DENABLE_PCMSolver=${ENABLE_PCMSolver}
              -DENABLE_ddx=${ENABLE_ddx}
              -DENABLE_mdi=${ENABLE_mdi}
              -DENABLE_BrianQC=${ENABLE_BrianQC}
              -DENABLE_OpenOrbitalOptimizer=${ENABLE_OpenOrbitalOptimizer}
              -DENABLE_OPENMP=${ENABLE_OPENMP}
              -DTargetLAPACK_DIR=${TargetLAPACK_DIR}
              -DTargetHDF5_DIR=${TargetHDF5_DIR}
              -DEigen3_DIR=${Eigen3_DIR}
              -Dambit_DIR=${ambit_DIR}
              -DCheMPS2_DIR=${CheMPS2_DIR}
              -Ddkh_DIR=${dkh_DIR}
              -Decpint_DIR=${ecpint_DIR}
              -Dlibefp_DIR=${libefp_DIR}
              -DEinsums_DIR=${Einsums_DIR}
              -Dgau2grid_DIR=${gau2grid_DIR}
              -Dgdma_DIR=${gdma_DIR}
              -DLibint2_DIR=${Libint2_DIR}
              -DOpenOrbitalOptimizer_DIR=${OpenOrbitalOptimizer_DIR}
              -DPCMSolver_DIR=${PCMSolver_DIR}
              -Dmdi_DIR=${mdi_DIR}
              -Dpybind11_DIR=${pybind11_DIR}
              -DIntegratorXX_DIR=${IntegratorXX_DIR}
              -Dgauxc_DIR=${gauxc_DIR}
              -Dpylibefp_DIR=${pylibefp_DIR}
              -Dsimint_DIR=${simint_DIR}
              -DLibxc_DIR=${Libxc_DIR}
              -DBrianQC_DIR=${BrianQC_DIR}
              -DFortran_ENABLED=${Fortran_ENABLED}
              -DLIBC_INTERJECT=${LIBC_INTERJECT}
              -DRESTRICT_KEYWORD=${RESTRICT_KEYWORD}
              -DFC_SYMBOL=${FC_SYMBOL}
              -DOpenMP_LIBRARY_DIRS=${OpenMP_LIBRARY_DIRS}
              -DOpenMP_C_FLAGS=${OpenMP_C_FLAGS}
              -DOpenMP_CXX_FLAGS=${OpenMP_CXX_FLAGS}
              -DOpenMP_omp_LIBRARY=${OpenMP_omp_LIBRARY}
              -DOpenMP_gomp_LIBRARY=${OpenMP_gomp_LIBRARY}
              -DOpenMP_libiomp5md_LIBRARY=${OpenMP_libiomp5md_LIBRARY}
              -DOpenMP_pthread_LIBRARY=${OpenMP_pthread_LIBRARY}
              -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
              -DENABLE_CYTHONIZE=${ENABLE_CYTHONIZE}
              -Dpsi4_SHGSHELL_ORDERING=${psi4_SHGSHELL_ORDERING}
   CMAKE_CACHE_ARGS -DCMAKE_PREFIX_PATH:PATH=${_cmake_CMAKE_PREFIX_PATH}
              -DCMAKE_C_COMPILER_ARG1:STRING=${CMAKE_C_COMPILER_ARG1}
              -DCMAKE_CXX_COMPILER_ARG1:STRING=${CMAKE_CXX_COMPILER_ARG1}
              -DCMAKE_Fortran_COMPILER_ARG1:STRING=${CMAKE_Fortran_COMPILER_ARG1}
               # CMAKE_<lang>_COMPILER_ARG1 vars pass args thru when CMAKE_<lang>_COMPILER set as "compiler --vital-args"
              -DOpenMP_C_LIB_NAMES:STRING=${OpenMP_C_LIB_NAMES}
              -DOpenMP_CXX_LIB_NAMES:STRING=${OpenMP_CXX_LIB_NAMES}
   USES_TERMINAL_BUILD 1
   BUILD_ALWAYS 1)

add_custom_command(OUTPUT elf_app
        COMMAND ${CMAKE_C_COMPILER} ${cflags} ${elf_libs} -o ${elf_app}
        COMMAND ${CMAKE_STRIP} ${strip_flags} ${elf_app}
        DEPENDS ${elf_dependeces}
        COMMENT "Build ELF: ${elf_app}"
        )

execute_process(
        COMMAND ${CMAKE_COMMAND}
            "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}"
            "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
            "-DCOMPILER_CACHE=${COMPILER_CACHE}"
            # Avoid overriding .cargo/config.toml with native toolchain.
            "-DENABLE_RUST=OFF"
            "-DENABLE_CLICKHOUSE_SELF_EXTRACTING=${ENABLE_CLICKHOUSE_SELF_EXTRACTING}"
        ${PROJECT_SOURCE_DIR}
        WORKING_DIRECTORY "${NATIVE_BUILD_DIR}"
        COMMAND_ECHO STDOUT
        COMMAND_ERROR_IS_FATAL ANY
    )

exec_program(${CMAKE_CXX_COMPILER}
                    ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
                    OUTPUT_VARIABLE CMAKE_CXX_COMPILER_VERSION)

CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )

message("WARNING: Requested optimized build, but -march=native flag not supported by"
            "${CMAKE_CXX_COMPILER}"
            "${CMAKE_C_COMPILER}")

GET_FILENAME_COMPONENT(LLVM_COMPILER_DIR "${CMAKE_C_COMPILER}" DIRECTORY)

ExternalProject_Add(gmp
    SOURCE_DIR           "${PROJECT_SOURCE_DIR}/external/gmp"
    BINARY_DIR           "${CMAKE_BINARY_DIR}/gmp"
    CONFIGURE_COMMAND    CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} ${PROJECT_SOURCE_DIR}/external/gmp/configure --enable-cxx --enable-shared=no --enable-static=yes --with-readline=no --with-pic --prefix=${CMAKE_BINARY_DIR}/gmp-prefix
    DOWNLOAD_COMMAND     ""
    UPDATE_COMMAND       ""
    BUILD_BYPRODUCTS     "${GMP_LIBRARY};${GMPXX_LIBRARY}"
    #LOG_CONFIGURE         1
    #LOG_OUTPUT_ON_FAILURE 1
    )

ExternalProject_Add(Externals
  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Externals
  BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Externals-build
  DOWNLOAD_COMMAND ""
  UPDATE_COMMAND ""
  INSTALL_COMMAND ""
  CMAKE_CACHE_ARGS
    -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
    -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
    -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}
    -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
    -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
    -DCMAKE_MACOSX_RPATH:BOOL=ON
    -DBUILD_TESTING:BOOL=OFF
    -DBUILD_EXAMPLES:BOOL=OFF
    -DSV_USE_MITK:BOOL=${SV_CMAKE_DOWLOAD_MITK_EXTERNAL}
    -DSV_GIT_PULL_SUBMODULES:BOOL=${SV_GIT_PULL_SUBMODULES}
    -DSV_EXTERNALS_VERSION_NUMBER:STRING=${SV_EXTERNALS_VERSION_NUMBER}
    # External packages directories
    -DSV_FREETYPE_DIR:PATH=${SV_FREETYPE_DIR}
    -DSV_GDCM_DIR:PATH=${SV_GDCM_DIR}
    -DSV_HDF5_DIR:PATH=${SV_HDF5_DIR}
    -DSV_ITK_DIR:PATH=${SV_ITK_DIR}
    -DSV_MMG_DIR:PATH=${SV_MMG_DIR}
    -DSV_MITK_DIR:PATH=${SV_MITK_DIR}
    -DSV_ML_DIR:PATH=${SV_ML_DIR}
    -DSV_OpenCASCADE_DIR:PATH=${SV_OpenCASCADE_DIR}
    -DSV_PYTHON_DIR:PATH=${SV_PYTHON_DIR}
    -DSV_TINYXML2_DIR:PATH=${SV_TINYXML2_DIR}
    -DSV_Qt6_DIR:PATH=${SV_Qt6_DIR}
    -DSV_VTK_DIR:PATH=${SV_VTK_DIR}
    #
    -DSV_EXTERNALS_USE_PREBUILT_QT:BOOL=${SV_EXTERNALS_USE_PREBUILT_QT}
    -DSV_EXTERNALS_PREBUILT_QT_PATH:PATH=${SV_EXTERNALS_PREBUILT_QT_PATH}
    -DQt6_DIR:PATH=${SV_EXTERNALS_PREBUILT_QT_PATH}
    -DSV_EXTERNALS_TOPLEVEL_BIN_DIR:PATH=${SV_EXTERNALS_TOPLEVEL_BIN_DIR}
    ${SV_EXTERNALS_ADDITIONAL_CMAKE_ARGS}
    )

execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang++
   OUTPUT_VARIABLE CMAKE_CXX_COMPILER
   ERROR_QUIET
   OUTPUT_STRIP_TRAILING_WHITESPACE)

ExternalProject_Add(Boost
    ${source_dir}
    CONFIGURE_COMMAND CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} ${configure_command}
    BUILD_COMMAND CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} ${build_command}
    BUILD_IN_SOURCE 1
    BUILD_BYPRODUCTS ${Boost_LIBRARIES}
    INSTALL_COMMAND ${install_command}
    PREFIX "${root_dir}")

execute_process(COMMAND echo "#include <string>"
    COMMAND ${CMAKE_CXX_COMPILER} "-x" "c++" "-E" "-dM" "-"
    COMMAND grep "-F" "_GLIBCXX_USE_CXX11_ABI"
    TIMEOUT 10
    RESULT_VARIABLE QUERIED_GCC_CXX11_ABI_SUCCESS
    OUTPUT_VARIABLE _GCC_CXX11_ABI)

cmake_print_variables(CMAKE_CXX_COMPILER)

execute_process(
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles
        COMMAND ${CMAKE_CXX_COMPILER} dummy.mm
        RESULT_VARIABLE result
        ERROR_QUIET
        OUTPUT_QUIET
    )

execute_process(
    COMMAND ${CMAKE_CXX_COMPILER} -dumpfullversion -dumpversion OUTPUT_VARIABLE GCC_VERSION)

find_program(CMAKE_CXX_COMPILER NAMES ${COMPILER_PREFIX}-g++)

execute_process(
  COMMAND ${CMAKE_C_COMPILER} -print-prog-name=llvm-objcopy
  OUTPUT_VARIABLE CMAKE_LLVM_OBJCOPY
  OUTPUT_STRIP_TRAILING_WHITESPACE)

exec_program(${CMAKE_CXX_COMPILER}
    ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
    OUTPUT_VARIABLE _boost_COMPILER_VERSION
  )

ExternalProject_Add(DAVIX
  URL ${DAVIX_URL}/davix-${DAVIX_VERSION}.tar.gz
  URL_HASH ${DAVIX_URLHASH}
  CMAKE_CACHE_ARGS
    -DCMAKE_PREFIX_PATH:STRING=${OPENSSL_PREFIX}
    -DUUID_INCLUDE_DIR:STRING=${UUID_INCLUDE_DIR}
    -DUUID_LIBRARY:STRING=${UUID_LIBRARY}
    -DLIBXML2_INCLUDE_DIR:PATH=${LIBXML2_INCLUDE_DIR}
    -DLIBXML2_INCLUDE_DIRS:STRING=${LIBXML2_INCLUDE_DIRS}
    -DLIBXML2_LIBRARY:PATH=${LIBXML2_LIBRARY}
    -DLIBXML2_LIBRARIES:STRING=${LIBXML2_LIBRARIES}
  CMAKE_ARGS
    -DCMAKE_POLICY_VERSION_MINIMUM=3.5
    -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
    -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
    -DENABLE_HTML_DOCS=OFF
    -DENABLE_IPV6=OFF
    -DSTATIC_LIBRARY=ON
    -DSHARED_LIBRARY=OFF
    -DENABLE_TOOLS=OFF
    -DDAVIX_TESTS=OFF
    -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
    -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
    -DCMAKE_CXX_FLAGS=${DAVIX_CXX_FLAGS}\ -fPIC
    -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
    -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}
    -DLIB_SUFFIX=
  LOG_BUILD 1 LOG_CONFIGURE 1 LOG_DOWNLOAD 1 LOG_INSTALL 1
  BUILD_BYPRODUCTS ${DAVIX_LIBRARIES}
  TIMEOUT 600)

add_test(compile-error-test ${CMAKE_CTEST_COMMAND}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test"
    "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DFMT_DIR=${CMAKE_SOURCE_DIR}"
    "-DSUPPORTS_USER_DEFINED_LITERALS=${SUPPORTS_USER_DEFINED_LITERALS}")

execute_process(
    COMMAND ${CMAKE_C_COMPILER} "-###" /dev/null -o t
    ERROR_VARIABLE driver_command_line
    ERROR_STRIP_TRAILING_WHITESPACE)

add_test(
      NAME find-package-testsA
      COMMAND
        ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" -A "${CMAKE_GENERATOR_PLATFORM}"
        "-DCLI11_DIR=${CMAKE_INSTALL_PREFIX}" "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
        "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
        "-DCMAKE_RUNTIME_OUTPUT_DIRECTORY=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
        "${CMAKE_CURRENT_SOURCE_DIR}/find_package_tests"
      WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/find_package_tests")

ExternalProject_Add(${proj}
  ${${proj}_EP_ARGS}
  DEPENDS ${Slicer_DEPENDENCIES} ${Slicer_REMOTE_DEPENDENCIES}
  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
  BINARY_DIR ${CMAKE_BINARY_DIR}/${Slicer_BINARY_INNER_SUBDIR}
  DOWNLOAD_COMMAND ""
  UPDATE_COMMAND ""
  CMAKE_CACHE_ARGS
    -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
    -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
    -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
    -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
    -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
    -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
    -DCMAKE_CXX_EXTENSIONS:BOOL=${CMAKE_CXX_EXTENSIONS}
    -DADDITIONAL_C_FLAGS:STRING=${ADDITIONAL_C_FLAGS}
    -DADDITIONAL_CXX_FLAGS:STRING=${ADDITIONAL_CXX_FLAGS}
    -DSlicer_REQUIRED_C_FLAGS:STRING=${Slicer_REQUIRED_C_FLAGS}
    -DSlicer_REQUIRED_CXX_FLAGS:STRING=${Slicer_REQUIRED_CXX_FLAGS}
    -DSlicer_SUPERBUILD:BOOL=OFF
    -DSlicer_SUPERBUILD_DIR:PATH=${CMAKE_BINARY_DIR}
    -D${Slicer_MAIN_PROJECT}_APPLICATION_NAME:STRING=${${Slicer_MAIN_PROJECT}_APPLICATION_NAME}
    -DSlicer_EXTENSION_SOURCE_DIRS:STRING=${Slicer_EXTENSION_SOURCE_DIRS}
    -DSlicer_EXTENSION_INSTALL_DIRS:STRING=${Slicer_EXTENSION_INSTALL_DIRS}
    -DExternalData_OBJECT_STORES:PATH=${ExternalData_OBJECT_STORES}
    ${EXTERNAL_PROJECT_OPTIONAL_ARGS}
  INSTALL_COMMAND ""
  )

add_custom_command(
      OUTPUT ${of_e_h_expanded}
      COMMAND ${CMAKE_C_COMPILER} ARGS -E -I"${PROJECT_SOURCE_DIR}" -I"${PROJECT_BINARY_DIR}" -o
              "${of_e_h_expanded}" "${oneflow_hdr_to_be_expanded}"
      DEPENDS ${oneflow_hdr_to_be_expanded}
      COMMENT "Expanding macros in ${oneflow_hdr_to_be_expanded}")

ExternalProject_Add(
            googletest
            DOWNLOAD_COMMAND ""
            SOURCE_DIR ${GOOGLETEST_ROOT}
            BINARY_DIR ${GOOGLETEST_BINARY_DIR}
            CMAKE_CACHE_ARGS "-DBUILD_GTEST:bool=ON" "-DBUILD_GMOCK:bool=OFF"
                            "-Dgtest_force_shared_crt:bool=ON"
                            "-DCMAKE_CXX_COMPILER:path=${CMAKE_CXX_COMPILER}"
            INSTALL_COMMAND ""
        )

execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang
    OUTPUT_VARIABLE CMAKE_C_COMPILER
    ERROR_QUIET
    OUTPUT_STRIP_TRAILING_WHITESPACE)

ExternalProject_Add(googletest
      ${EXCLUDE_FROM_ALL_OPT} ${EXCLUDE_FROM_ALL_VALUE}
      GIT_REPOSITORY https://github.com/google/googletest.git
      GIT_TAG master
      PREFIX "${CMAKE_BINARY_DIR}/googletest"
      INSTALL_DIR "${CMAKE_BINARY_DIR}/googletest"
      CMAKE_CACHE_ARGS
        -DCMAKE_BUILD_TYPE:STRING=${GTEST_BUILD_TYPE}
        -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
        -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
        -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
        -DCMAKE_INSTALL_LIBDIR:PATH=<INSTALL_DIR>/lib
        -DCMAKE_CXX_FLAGS:STRING=${GTEST_FLAGS}
        -Dgtest_force_shared_crt:BOOL=ON
      )

ExternalProject_Add(project_mpich
    PREFIX ${CMAKE_INSTALL_PREFIX}
    URL ${MPICH_URL}
    STAMP_DIR ${MPICH_BINARY_DIR}/stamp
    BUILD_IN_SOURCE 1
    SOURCE_DIR ${MPICH_SOURCE_DIR}
    TMP_DIR    ${MPICH_BINARY_DIR}/tmp
    INSTALL_DIR ${CMAKE_INSTALL_PREFIX}
    CONFIGURE_COMMAND ${MPICH_SOURCE_DIR}/configure --prefix=<INSTALL_DIR> --CC=${CMAKE_C_COMPILER} --CXX=${CMAKE_CXX_COMPILER} ${TRY_TO_PASS_FC}
    UPDATE_COMMAND "" 
    BUILD_COMMAND ${CMAKE_MAKE_PROGRAM}
    INSTALL_COMMAND ${CMAKE_MAKE_PROGRAM} install
  )

GET_FILENAME_COMPONENT(ASAN_LIB_DIR ${CMAKE_CXX_COMPILER} DIRECTORY)

SET(CMAKE_C_COMPILER     "x86_64-w64-mingw32-clang")

get_filename_component(
		MY_COMPILER_DIR
		${CMAKE_CXX_COMPILER} DIRECTORY
	)

ExternalProject_Add(OMomp
    DOWNLOAD_DIR "."
    SOURCE_DIR "."
    BINARY_DIR "."
    INSTALL_DIR "."
    STAMP_DIR "."
    TMP_DIR "tmp"

    DOWNLOAD_COMMAND ""
    # Build with LIBOMP_ENABLE_SHARED=OFF so that libomp.a can be embedded
    # into model.so
    CONFIGURE_COMMAND sh -c "CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} \
                             cmake -G Ninja ${LLVM_BUILD_MAIN_SRC_DIR} \
                                   -DLLVM_ENABLE_PROJECTS=\"clang\" \
                                   -DLLVM_ENABLE_RUNTIMES=\"openmp\" \
                                   -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \
                                   -DLIBOMP_ENABLE_SHARED=OFF"
    BUILD_COMMAND sh -c "cmake --build . --target omp -- ${MAKEFLAGS}"
    INSTALL_COMMAND ""
    )

message(STATUS "  CXX Compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION} (${CMAKE_CXX_COMPILER})")

execute_process(
    COMMAND printf
      "#include <new>\nint main(){(::operator delete)(0,256);return 0;}\n"
    COMMAND ${CMAKE_CXX_COMPILER}
      -x c++ -fsized-deallocation -O0 -fno-builtin
      -L${SIZED_DEALLOCATION_TEST_TCMALLOC_LIBDIR} -ltcmalloc -o /dev/null -
    RESULT_VARIABLE SIZED_DEALLOCATION_TEST_RESULT OUTPUT_QUIET ERROR_QUIET)

unset(CMAKE_CXX_COMPILER CACHE)

execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion
    OUTPUT_VARIABLE CMAKE_CXX_COMPILER_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)

EXECUTE_PROCESS( COMMAND ${CMAKE_CXX_COMPILER} --version OUTPUT_VARIABLE clang_full_version_string )

get_filename_component ( DIRHINT ${CMAKE_CXX_COMPILER} DIRECTORY )

string(REGEX MATCH "\/cl(.exe)?$" matched_cl ${CMAKE_CXX_COMPILER})

ExternalProject_Add(
    ext_intel_hexl
    PREFIX ext_intel_hexl
    GIT_REPOSITORY ${INTEL_HEXL_GIT_REPO_URL}
    GIT_TAG ${INTEL_HEXL_GIT_LABEL}
    CMAKE_ARGS
        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
        -DHEXL_SHARED_LIB=ON
        -DHEXL_EXPERIMENTAL=ON
        -DHEXL_DEBUG=OFF
        -DHEXL_BENCHMARK=OFF
        -DHEXL_COVERAGE=OFF
        -DHEXL_TESTING=OFF
        -DCMAKE_INSTALL_INCLUDEDIR=include
        -DCMAKE_INSTALL_LIBDIR=lib
        -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/hexl-install
    EXCLUDE_FROM_ALL TRUE
    # Skip updates
    UPDATE_COMMAND "")

add_custom_command (
      OUTPUT ${dpdk_object_path}
      COMMAND ${CMAKE_CXX_COMPILER}
        -r # create a relocatable object
        -o ${dpdk_object_path}
        -Wl,--whole-archive ${_dpdk_linker_files}
      DEPENDS
        ${_dpdk_linker_files})

execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
                  OUTPUT_VARIABLE GCC_VERSION)

ExternalProject_Add(fletch
  PREFIX ${TELESCULPTOR_BINARY_DIR}
  GIT_REPOSITORY "https://github.com/Kitware/fletch.git"
  GIT_TAG 94870a290a06db845e80816863bb6d1b9cb12085
  #GIT_SHALLOW 1
  SOURCE_DIR ${TELESCULPTOR_EXTERNAL_DIR}/fletch
  BINARY_DIR ${TELESCULPTOR_EXTERNAL_DIR}/fletch-build
  STAMP_DIR ${TELESCULPTOR_STAMP_DIR}
  CMAKE_CACHE_ARGS
    -DBUILD_SHARED_LIBS:BOOL=ON
    -Dfletch_BUILD_CXX11:BOOL=ON
    -Dfletch_BUILD_WITH_PYTHON:BOOL=${TELESCULPTOR_ENABLE_PYTHON}
    -Dfletch_ENABLE_Boost:BOOL=${TELESCULPTOR_ENABLE_FLETCH_BOOST}
    -DBoost_SELECT_VERSION:STRING=1.65.1
    -Dfletch_ENABLE_Caffe:BOOL=OFF
    -Dfletch_ENABLE_Caffe_Segnet:BOOL=OFF
    -Dfletch_ENABLE_Ceres:BOOL=${TELESCULPTOR_ENABLE_FLETCH_CERES}
    -Dfletch_ENABLE_CppDB:BOOL=OFF
    -Dfletch_ENABLE_Darknet:BOOL=OFF
    -Dfletch_ENABLE_Darknet_OpenCV:BOOL=OFF
    -Dfletch_ENABLE_Eigen:BOOL=${TELESCULPTOR_ENABLE_FLETCH_EIGEN}
    -Dfletch_ENABLE_FFmpeg:BOOL=${TELESCULPTOR_ENABLE_FLETCH_FFMPEG}
    -DFFmpeg_SELECT_VERSION:STRING=3.3.3
    -Dfletch_ENABLE_GDAL:BOOL=${TELESCULPTOR_ENABLE_FLETCH_GDAL}
    -Dfletch_ENABLE_GEOS:BOOL=${TELESCULPTOR_ENABLE_FLETCH_GEOS}
    -Dfletch_ENABLE_GFlags:BOOL=OFF
    -Dfletch_ENABLE_GLog:BOOL=${TELESCULPTOR_ENABLE_FLETCH_CERES}
    -Dfletch_ENABLE_GTest:BOOL=${TELESCULPTOR_ENABLE_TESTING}
    -Dfletch_ENABLE_GeographicLib:BOOL=OFF
    -Dfletch_ENABLE_HDF5:BOOL=OFF
    -Dfletch_ENABLE_ITK:BOOL=OFF
    -Dfletch_ENABLE_LMDB:BOOL=OFF
    -Dfletch_ENABLE_LevelDB:BOOL=OFF
    -Dfletch_ENABLE_OpenBLAS:BOOL=OFF
    -Dfletch_ENABLE_OpenCV:BOOL=${TELESCULPTOR_ENABLE_FLETCH_OPENCV}
    -DOpenCV_SELECT_VERSION:STRING=4.5.1
    -Dfletch_ENABLE_OpenCV_FFmpeg:BOOL=ON
    -Dfletch_ENABLE_OpenCV_contrib:BOOL=ON
    -Dfletch_ENABLE_OpenCV_highgui:BOOL=ON
    -Dfletch_ENABLE_PDAL:BOOL=${TELESCULPTOR_ENABLE_FLETCH_PDAL}
    -Dfletch_ENABLE_PNG:BOOL=${TELESCULPTOR_ENABLE_FLETCH_PNG}
    -Dfletch_ENABLE_PROJ:BOOL=${TELESCULPTOR_ENABLE_FLETCH_PROJ}
    -Dfletch_ENABLE_PostGIS:BOOL=OFF
    -Dfletch_ENABLE_PostgresSQL:BOOL=OFF
    -Dfletch_ENABLE_Protobuf:BOOL=OFF
    -Dfletch_ENABLE_Qt:BOOL=${TELESCULPTOR_ENABLE_FLETCH_QT}
    -DBUILD_Qt_MINIMAL:BOOL=ON
    -DQt_SELECT_VERSION:STRING=5.12.8
    -Dfletch_ENABLE_Snappy:BOOL=OFF
    -Dfletch_ENABLE_SQLite3:BOOL=${TELESCULPTOR_ENABLE_FLETCH_PROJ}
    -Dfletch_ENABLE_SuiteSparse:BOOL=${TELESCULPTOR_ENABLE_FLETCH_CERES}
    -Dfletch_ENABLE_TinyXML:BOOL=OFF
    -Dfletch_ENABLE_VTK:BOOL=${TELESCULPTOR_ENABLE_FLETCH_VTK}
    -DVTK_SELECT_VERSION:STRING=9.0
    -Dfletch_ENABLE_VXL:BOOL=ON
    -Dfletch_ENABLE_YAMLcpp:BOOL=OFF
    -Dfletch_ENABLE_ZLib:BOOL=${TELESCULPTOR_ENABLE_FLETCH_ZLIB}
    -Dfletch_ENABLE_libgeotiff:BOOL=${TELESCULPTOR_ENABLE_FLETCH_GEOTIFF}
    -Dfletch_ENABLE_libjpeg-turbo:BOOL=${TELESCULPTOR_ENABLE_FLETCH_JPEG}
    -Dfletch_ENABLE_libjson:BOOL=OFF
    -Dfletch_ENABLE_libkml:BOOL=OFF
    -Dfletch_ENABLE_libtiff:BOOL=${TELESCULPTOR_ENABLE_FLETCH_TIFF}
    -Dfletch_ENABLE_log4cplus:BOOL=ON
    -Dfletch_ENABLE_openjpeg:BOOL=OFF
    -Dfletch_ENABLE_qtExtensions:BOOL=ON
    -Dfletch_ENABLE_pybind11:BOOL=${TELESCULPTOR_ENABLE_PYTHON}
    -Dfletch_ENABLE_shapelib:BOOL=OFF
    -Dfletch_BUILD_WITH_CUDA:BOOL=${TELESCULPTOR_ENABLE_CUDA}
    -DCUDA_TOOLKIT_ROOT_DIR:PATH=${CUDA_TOOLKIT_ROOT_DIR}
    -Dfletch_PYTHON_MAJOR_VERSION:STRING=3
    -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
    -DCMAKE_CONFIGURATION_TYPES:STRING=${CMAKE_CONFIGURATION_TYPES}
    -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
    -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}
    -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
    -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
    ${CMAKE_CXX_COMPILER_LAUNCHER_FLAG}
    ${CMAKE_C_COMPILER_LAUNCHER_FLAG}
    -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
    -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
    -DADDITIONAL_C_FLAGS:STRING=${ADDITIONAL_C_FLAGS}
    -DADDITIONAL_CXX_FLAGS:STRING=${ADDITIONAL_CXX_FLAGS}
    ${FLETCH_ADDITIONAL_OPTIONS}
  INSTALL_COMMAND ${CMAKE_COMMAND} -E echo "Skipping install step."
  USES_TERMINAL_BUILD 1
)

set(CMAKE_C_COMPILER "/usr/tce/packages/cce-tce/cce-18.0.0/bin/craycc" CACHE PATH "")

message(STATUS "== CMAKE_CXX_COMPILER:" ${CMAKE_CXX_COMPILER})

exec_program(${CMAKE_CXX_COMPILER}
		ARGS
		${CMAKE_CXX_COMPILER_ARG1}
		-dumpversion
		OUTPUT_VARIABLE
		_compilerinfo_COMPILER_VERSION)

set(CMAKE_CXX_COMPILER "/usr/tce/packages/gcc/gcc-10.3.1/bin/g++" CACHE PATH "")

execute_process(COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)

add_custom_target(single_header
            ALL
            cat ${CMAKE_CURRENT_LIST_DIR}/header.h > ${SINGLE_HEADER_OUTPUT}
            COMMAND ${CMAKE_CXX_COMPILER} ${FLAGS} ${CMAKE_CURRENT_LIST_DIR}/single_header.cpp | grep "^[^#]" | grep --after-context=1000000 single_header_delimiter | tail -n +2 >> ${SINGLE_HEADER_OUTPUT}
            COMMAND cat ${CMAKE_CURRENT_LIST_DIR}/footer.h >> ${SINGLE_HEADER_OUTPUT}
            )

set(CC                      "${CMAKE_C_COMPILER}")

CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )

execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang
    OUTPUT_VARIABLE CMAKE_C_COMPILER
    ERROR_QUIET
    OUTPUT_STRIP_TRAILING_WHITESPACE)

EXECUTE_PROCESS(
      COMMAND ${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}  --version
      OUTPUT_VARIABLE out)

get_filename_component(immer_compiler_name "${CMAKE_CXX_COMPILER}" NAME)

execute_process(COMMAND xcrun -sdk iphoneos -find clang++
   OUTPUT_VARIABLE CMAKE_CXX_COMPILER
   ERROR_QUIET
   OUTPUT_STRIP_TRAILING_WHITESPACE)

exec_program(${CMAKE_CXX_COMPILER}
    ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
    OUTPUT_VARIABLE _boost_COMPILER_VERSION
  )

ExternalProject_Add(${name}_project
    DOWNLOAD_DIR ${_DIR}
    SOURCE_DIR ${_DIR}
    INSTALL_DIR ${INSTALL_ROOT}
    UPDATE_COMMAND ""

    BUILD_COMMAND ${parsed_BUILD_COMMAND}

    INSTALL_COMMAND ${parsed_INSTALL_COMMAND}

    # Wrap download, configure and build steps in a script to log output
    LOG_INSTALL ON
    LOG_DOWNLOAD ON
    LOG_CONFIGURE ON
    LOG_BUILD ON
    LOG_PATCH ON
    LOG_UPDATE ON

    CMAKE_GENERATOR "Unix Makefiles"
    BUILD_BYPRODUCTS ${LIB_FILES}
    # LIST_SEPARATOR | # Use the alternate list separator.
    # Can not use | because we use it inside sh/install_cmd

    # we need those CMAKE_ARGS for cmake based 3rd party projects.
    # CMAKE_ARCHIVE_OUTPUT_DIRECTORY is for static libs
    # CMAKE_LIBRARY_OUTPUT_DIRECTORY is for shared libs
    CMAKE_ARGS -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${INSTALL_ROOT}/lib
        -DCMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${INSTALL_ROOT}/lib
        -DCMAKE_BUILD_TYPE:STRING=Release
        -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
        -DBUILD_TESTING=OFF
        "-DCMAKE_C_FLAGS:STRING=-O3" -DCMAKE_CXX_FLAGS=${THIRD_PARTY_CXX_FLAGS}
        -DCMAKE_INSTALL_PREFIX:PATH=${INSTALL_ROOT}
        ${piped_CMAKE_ARGS}
    ${parsed_UNPARSED_ARGUMENTS}
  )

exec_program(${CMAKE_CXX_COMPILER}
		ARGS
		${CMAKE_CXX_COMPILER_ARG1}
		-dumpversion
		OUTPUT_VARIABLE
		_compilerinfo_COMPILER_VERSION)

set(__qt_initial_c_compiler \"${CMAKE_C_COMPILER}\")

exec_program(${CMAKE_CXX_COMPILER} ARGS --version OUTPUT_VARIABLE _gcc_version_info)

EXECUTE_PROCESS(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE CLANG_VERSION)

execute_process(COMMAND xcrun -sdk ${SDKROOT} -find clang
   OUTPUT_VARIABLE CMAKE_C_COMPILER
   ERROR_QUIET
   OUTPUT_STRIP_TRAILING_WHITESPACE)

execute_process(COMMAND ${CMAKE_C_COMPILER} ${CMAKE_CURRENT_LIST_DIR}/parse-compile-commands.c -o ${BINARY_DIR}/parse-compile-commands${CMAKE_EXECUTABLE_SUFFIX})