add_custom_target(copy_ncine_dll_benchmarks ALL
			COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:ncine> ${CMAKE_BINARY_DIR}/benchmarks
			DEPENDS ncine
			COMMENT "Copying nCine DLL..."
		)

try_compile(GOOGLEHASH_COMPILE ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}/googlehash_test.cpp OUTPUT_VARIABLE GOOGLEHASH_COMPILE_RESULT)

target_include_directories(${TARGET_EXE_RELEASE} PRIVATE "${CMAKE_BINARY_DIR}/world_builder_release/include/")

execute_process (COMMAND ${CMAKE_COMMAND} -E create_symlink ${CCACHE} ${CMAKE_BINARY_DIR}/${COMPILER_PREFIX}${TOOL})

try_compile (URHO3D_COMPILE_RESULT ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_LIST_DIR}/CheckUrhoLibrary.cpp
                                    CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${COMPILER_FLAGS} -DLINK_LIBRARIES:STRING=${CANDIDATE_URHO3D_LIBRARY} -DINCLUDE_DIRECTORIES:STRING=${URHO3D_INCLUDE_DIRS} ${COMPILER_STATIC_DEFINE} ${COMPILER_STATIC_RUNTIME_FLAGS}
                                    OUTPUT_VARIABLE TRY_COMPILE_OUT)

export(EXPORT Imath
    FILE "${CMAKE_BINARY_DIR}/config/PyBindImathTargets.cmake"
    NAMESPACE Imath::
  )

set_target_properties(
            ${target}
            PROPERTIES
            CXX_STANDARD 17
            CXX_STANDARD_REQUIRED ON
            CXX_EXTENSIONS ON
            DEBUG_POSTFIX -d
            ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
            ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib
            ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib
            LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
            LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib
            LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib
            EXPORT_NAME ${name}
    )

add_custom_command(TARGET copy
        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_SOURCE_DIR}/src/${header} ${CMAKE_BINARY_DIR}/include/SFCGAL/${header} DEPENDS ${CMAKE_SOURCE_DIR}/src/${header})

add_custom_command(
		OUTPUT "${_joinedFile}"
		COMMAND ${_prefixCmd}
		DEPENDS ${_files}
		COMMENT "${_comment}"
		WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
		VERBATIM)

cmake_path(SET _screenshot_path ${CMAKE_BINARY_DIR}/Testing/Temporary/ss)

cmake_path(ABSOLUTE_PATH CMAKE_BINARY_DIR NORMALIZE OUTPUT_VARIABLE cmake_binary_dir_normalized)

try_compile(
  RESULT_VAR
    ${CMAKE_BINARY_DIR}
  SOURCES
    ${CMAKE_BINARY_DIR}/backtrace.cpp
)

add_custom_command(TARGET ${EXE} POST_BUILD
			COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/Binaries
			COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${EXE}> ${CMAKE_BINARY_DIR}/Binaries)

target_link_options(${target} PRIVATE -fdebug-prefix-map=${CMAKE_BINARY_DIR}=)

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
       # HACK: save space after each compile job, because CI
       # reasoning: cmake changes directory after this command, so just keep only the folders
       # so that it can navigate out
       COMMAND find "${CMAKE_BINARY_DIR}/dep_${projectname}-prefix/" -type f -delete
    )

configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake.in ${CMAKE_BINARY_DIR}/CTestCustom.cmake)

file (MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${PATH})

add_custom_command(TARGET "${PROJECT_NAME}" POST_BUILD
			COMMAND ${CMAKE_COMMAND} -E copy_directory
				"${CMAKE_BINARY_DIR}/deps/bin/win.x86_64.vc142.md/$<CONFIGURATION>"
				"$<TARGET_FILE_DIR:${PROJECT_NAME}>/$<CONFIGURATION>")

add_custom_command (TARGET ${_target} POST_BUILD
                        COMMAND ${CMAKE_COMMAND} -E
                        copy_if_different
                          ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${_target}
                          ${CMAKE_BINARY_DIR}/Build/${ACG_PROJECT_BINDIR}/${_target})

ADD_CUSTOM_TARGET(${_targetname}
		
		# Cleanup lcov
		${LCOV_PATH} --directory . --zerocounters
		
		# Run tests
		COMMAND ${_testrunner} ${ARGV3}
		
		# Capturing lcov counters and generating report
		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info
		COMMAND ${LCOV_PATH} --remove ${_outputname}.info 'tests/*' '/usr/*' --output-file ${_outputname}.info.cleaned
		COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned
		COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned
		
		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
	)

target_include_directories(pioneer-core PRIVATE ${CMAKE_BINARY_DIR})

include(${CMAKE_BINARY_DIR}/cmake/ConanToolsDirs.cmake)

configure_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/../Resources/Gamma_ColorTable.ctbl
  ${CMAKE_BINARY_DIR}/${Slicer_QTLOADABLEMODULES_SHARE_DIR}/${MODULE_NAME}/Gamma_ColorTable.ctbl
  COPYONLY)

add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD 
		COMMAND ${CMAKE_COMMAND} -E copy_if_different
		${CMAKE_BINARY_DIR}/bin/${librarylocation}/${CMAKE_SHARED_LIBRARY_PREFIX}input_lite${CMAKE_SHARED_LIBRARY_SUFFIX}          
		$<TARGET_FILE_DIR:${PROJECT_NAME}>)

ExternalProject_Add(
    cmocka_cloned
    GIT_REPOSITORY    https://gitlab.com/cmocka/cmocka.git
    GIT_TAG           cmocka-1.1.5
    SOURCE_DIR        "${CMAKE_BINARY_DIR}/cmocka-src"
    BINARY_DIR        "${CMAKE_BINARY_DIR}/cmocka-build"
    CMAKE_ARGS        "${CMOCKA_ARGS}"
    INSTALL_COMMAND   ""
    STEP_TARGETS build
    EXCLUDE_FROM_ALL TRUE
  )

file(READ ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckPrototypeDefinition.c _SOURCE)

find_program(PATCHELF_COMMAND NAMES ${CMAKE_BINARY_DIR}/PATCHELF/src/patchelf/src/)

export(TARGETS ${CROSS_EXPORTS} FILE "${CMAKE_BINARY_DIR}/ImportExecutables.cmake" )

find_library(SPARKLE_FRAMEWORK Sparkle "${CMAKE_BINARY_DIR}/frameworks/Sparkle")

link_directories(${CMAKE_BINARY_DIR}/gme)

set(SHELLANYTHING_RESOURCE_RC ${CMAKE_BINARY_DIR}/src/resource.rc)

configure_file("${CMAKE_SOURCE_DIR}/src/config.hh.in" "${CMAKE_BINARY_DIR}/config/config.hh")

execute_process(COMMAND chmod a+rx
                     "${CMAKE_BINARY_DIR}/launch-c"
                     "${CMAKE_BINARY_DIR}/launch-cxx"
                     "${CMAKE_BINARY_DIR}/launch-cuda"
    )

configure_file(src/build-scripts/oslexec.pc.in "${CMAKE_BINARY_DIR}/oslexec.pc" @ONLY)

try_compile( ${suffix}_COMPILES ${CMAKE_BINARY_DIR}/try/${prj_name} ${prj_dir} ${prj_name} )

try_compile(${CURL_TEST}
      ${CMAKE_BINARY_DIR}
      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
      "${CURL_TEST_ADD_LIBRARIES}"
      OUTPUT_VARIABLE OUTPUT)

try_compile(CHRONO_HAS_TIMEZONES_AND_CALENDERS
            ${CMAKE_BINARY_DIR}
            ${PROJECT_SOURCE_DIR}/cpp-feature-tests/chrono_feature_test.cpp
            CXX_STANDARD 20
            CXX_STANDARD_REQUIRED ON
            CXX_EXTENSIONS OFF)

try_compile(_jpeglib_version_compile_result ${CMAKE_BINARY_DIR} ${_jpeglib_version_source_file}
                CMAKE_FLAGS "${_jpeglib_version_include_dirs}"
                COMPILE_OUTPUT_VARIABLE _jpeglib_version_compile_output_var)

configure_file(${CMAKE_CURRENT_BINARY_DIR}/DartConfiguration.tcl ${CMAKE_BINARY_DIR}/DartConfiguration.tcl)

try_compile(VITAL_USE_${NAME}
    ${CMAKE_BINARY_DIR}
    ${CMAKE_CURRENT_LIST_DIR}/configcheck/${TEST}
    CMAKE_FLAGS
      -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}
      -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD})

configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake.in ${CMAKE_BINARY_DIR}/CTestCustom.cmake)

configure_file(${CGAL_INSTALLATION_PACKAGE_DIR}/config/version.h.in ${CMAKE_BINARY_DIR}/include/CGAL/version.h @ONLY)

ExternalProject_Add(
    project_catch
    PREFIX ${CMAKE_BINARY_DIR}/catch
    GIT_REPOSITORY https://github.com/catchorg/Catch2.git
    GIT_TAG v2.13.7
    TIMEOUT 10
    UPDATE_COMMAND "" # ${GIT_EXECUTABLE} pull
    CONFIGURE_COMMAND ""
    BUILD_COMMAND ""
    INSTALL_COMMAND ""
    LOG_DOWNLOAD ON
   )

add_custom_target(install-mtkahypar-cli
      ${CMAKE_COMMAND}
      -DBUILD_TYPE=${CMAKE_BUILD_TYPE}
      -DCMAKE_INSTALL_COMPONENT=MtKaHyPar_CLI
      -P ${CMAKE_BINARY_DIR}/cmake_install.cmake
      DEPENDS MtKaHyPar-CLI)

add_custom_target("${tidy_target}"
                    DEPENDS "${src}"
                    COMMAND "${CMAKE_COMMAND}" #
                            -DROOT_DIR="${root_dir}" #
                            -DBUILD_DIR="${build_dir}" #
                            -DCLANG_TIDY="${BASE_CLANG_TIDY_COMMAND}" #
                            -DSOURCES="${absolute_sources}" #
                            -DSED="${LEGATE_SED}" #
                            -DLEGATE_BUILD_DIR="${CMAKE_BINARY_DIR}" #
                            -P "${LEGATE_CMAKE_DIR}/scripts/external_clang_tidy.cmake" #
                    COMMENT "clang-tidy ${rel_root_dir}")

set_target_properties(${BINARY_NAME}
  PROPERTIES
  RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
)

export(TARGETS ${CROSS_EXPORTS} FILE "${CMAKE_BINARY_DIR}/ImportExecutables.cmake" )

file(WRITE "${CMAKE_BINARY_DIR}/cpm-packages.yaml"
     "# List of packages provided by CPM\n" "---\n"
)

set_target_properties(libfenestra PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})

ExternalProject_Add(
      boost_${Component}
      PREFIX ${CMAKE_BINARY_DIR}/${BoostFolderName}
      SOURCE_DIR ${BoostSourceDir}
      BINARY_DIR ${BoostSourceDir}
      CONFIGURE_COMMAND ""
      BUILD_COMMAND "${b2Args}" --with-${Component}
      INSTALL_COMMAND ""
      LOG_BUILD ON
      )

ExternalProject_Add(libjpeg-src
    GIT_REPOSITORY      https://github.com/libjpeg-turbo/libjpeg-turbo.git
    GIT_TAG             3.0.1
    SOURCE_DIR          "${libjpeg_dir}"
    BINARY_DIR          "${libjpeg_dir}"
    CMAKE_ARGS          "-DCMAKE_TOOLCHAIN_FILE:FILEPATH=${CMAKE_TOOLCHAIN_FILE}"
                        "-DCMAKE_INSTALL_PREFIX=${libjpeg_dir}/install" # unused, have to specify
                        "-DCMAKE_C_FLAGS=${universal_cflags}"
                        "-DENABLE_SHARED=FALSE"
                        "-DWITH_TURBOJPEG=FALSE"
                        "-Wno-dev"

    INSTALL_COMMAND     ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/include/jpeg/;
    COMMAND             ${CMAKE_COMMAND} -E copy ${libjpeg_dir}/jpeglib.h
                                                 ${libjpeg_dir}/jerror.h
                                                 ${libjpeg_dir}/jconfig.h
                                                 ${libjpeg_dir}/jmorecfg.h
                                                 ${libjpeg_dir}/jpegint.h
                                            ${CMAKE_BINARY_DIR}/include/jpeg/
    BUILD_BYPRODUCTS    "${libjpeg_dir}/${libjpeg_binary}"
                        "${CMAKE_BINARY_DIR}/include/jpeg/jpeglib.h"
                        "${CMAKE_BINARY_DIR}/include/jpeg/jerror.h"
    USES_TERMINAL_DOWNLOAD TRUE
    USES_TERMINAL_UPDATE TRUE
    USES_TERMINAL_CONFIGURE TRUE
    USES_TERMINAL_BUILD TRUE
    UPDATE_DISCONNECTED TRUE
)

link_directories(
        ${CMAKE_BINARY_DIR}/ui
        ${CMAKE_BINARY_DIR}/ui/gtk
        ${CMAKE_BINARY_DIR}/ui/qt
        ${CMAKE_BINARY_DIR}/codecs
        ${CMAKE_BINARY_DIR}/epan
        ${CMAKE_BINARY_DIR}/wiretap
        ${CMAKE_BINARY_DIR}/wsutil
)

file(ARCHIVE_EXTRACT INPUT ${CMAKE_BINARY_DIR}/Sparkle.tar.xz DESTINATION ${CMAKE_BINARY_DIR}/frameworks/Sparkle)

ADD_CUSTOM_COMMAND(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc"
             "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h"
      COMMAND  ${Protobuf_PROTOC_EXECUTABLE}
      ARGS "--cpp_out=${DLL_EXPORT_DECL}${CMAKE_BINARY_DIR}" ${_protobuf_include_path} ${ABS_FIL}
      DEPENDS ${ABS_FIL} ${Protobuf_PROTOC_EXECUTABLE}
      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
      VERBATIM )

install(FILES ${CMAKE_BINARY_DIR}/NVSHMEMConfig.cmake
        DESTINATION lib/cmake/nvshmem
	)

add_custom_command(
    OUTPUT
      ${generated_headers}
      ${generated_sources}
    COMMAND_EXPAND_LISTS
    COMMAND
      "${CMAKE_COMMAND}" -E make_directory "${output_dir}"
    COMMAND
      "${FBTHRIFT_COMPILER}"
      --legacy-strict
      --gen "mstch_cpp2:${GEN_ARG_STR}"
      "${thrift_include_options}"
      -I "${FBTHRIFT_INCLUDE_DIR}"
      -o "${output_dir}"
      "${CMAKE_CURRENT_SOURCE_DIR}/${THRIFT_FILE}"
    WORKING_DIRECTORY
      "${CMAKE_BINARY_DIR}"
    MAIN_DEPENDENCY
      "${THRIFT_FILE}"
    DEPENDS
      ${ARG_DEPENDS}
      "${FBTHRIFT_COMPILER}"
  )

add_custom_target(dist
    COMMAND ${CMAKE_CPACK_COMMAND} -G TGZ --config ${CMAKE_BINARY_DIR}/CPackSourceConfig.cmake
    COMMENT "Building source tarball" VERBATIM)

export(TARGETS ${_OPENVINO_DEVELOPER_PACKAGE_TARGETS} NAMESPACE openvino::
           APPEND FILE "${CMAKE_BINARY_DIR}/openvino_developer_package_targets.cmake")

file(APPEND ${CMAKE_BINARY_DIR}/Tests.txt "${TARGET_NAME}|${HWA_VALUE}|0\n")

set_target_properties(fpectl PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/tests)

try_compile(
    HAVE_RVV_INTRINSICS
    ${CMAKE_BINARY_DIR}
    ${CMAKE_SOURCE_DIR}/cmake/Checks/check-rvv-intrinsics.c
)

configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/opencv_run_all_tests_unix.sh.in"
                   "${CMAKE_BINARY_DIR}/unix-install/opencv_run_all_tests.sh" @ONLY)

set_target_properties(suil_x11 PROPERTIES
  LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/suil-0"
)

file(APPEND ${CMAKE_BINARY_DIR}/valgrind-suppressions.txt ${vgs})

configure_file(
    cmake/gtest.pc.in
    "${CMAKE_BINARY_DIR}/gtest.pc"
    @ONLY)

ExternalProject_Add(
  build32 
  SOURCE_DIR "${CMAKE_SOURCE_DIR}"
  STAMP_DIR "${CMAKE_BINARY_DIR}/stamp32"
  BINARY_DIR "${CMAKE_BINARY_DIR}/build32"
  INSTALL_DIR "${CMAKE_BINARY_DIR}/install32"
  BUILD_ALWAYS ON
  EXCLUDE_FROM_ALL ON
  DOWNLOAD_COMMAND ""
  CONFIGURE_COMMAND
  "${CMAKE_COMMAND}"
  -S "<SOURCE_DIR>"
  -B "<BINARY_DIR>"
  -G "${CMAKE_GENERATOR}"
  "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
  -A Win32
  "-DBUILD_OUT_PREFIX=${BUILD_OUT_PREFIX}"
  -DWITH_ASAN=${WITH_ASAN}
  BUILD_COMMAND
  "${CMAKE_COMMAND}"
  --build "<BINARY_DIR>"
  --config "$<CONFIG>"
  --target build32
  --parallel
  INSTALL_COMMAND
  ""
)

file(DOWNLOAD
          ${PCKG_URL}
          ${CMAKE_BINARY_DIR}/${PCKG_DIR_NAME}.zip
          INACTIVITY_TIMEOUT 15
          SHOW_PROGRESS
          STATUS DOWNLOAD_STATUS
          EXPECTED_MD5 ${ARGV3})

execute_process(COMMAND git checkout 9174634e9dcc1b21a63668969406897aad650f35 WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/lvgl_image_converter" OUTPUT_QUIET)

file(WRITE "${CMAKE_BINARY_DIR}/CMakeGraphVizOptions.cmake" "
    set(GRAPHVIZ_GRAPH_NAME \"MMEX build dependency graph\")
    set(GRAPHVIZ_GENERATE_PER_TARGET FALSE)
    set(GRAPHVIZ_GENERATE_DEPENDERS FALSE)
")

add_custom_command(TARGET clickhouse POST_BUILD
        COMMAND "${CMAKE_SOURCE_DIR}/utils/check-style/check-large-objects.sh" "${CMAKE_BINARY_DIR}")

install(FILES ${CMAKE_BINARY_DIR}/include/version_config.h DESTINATION include)

configure_package_config_file(
    ${ZEP_ROOT}/cmake/zep-config.cmake.in
    ${CMAKE_BINARY_DIR}/cmake/zep-config.cmake
    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/zep
)

try_compile(${lang}_ABI_COMPILED
        "${CMAKE_BINARY_DIR}/CMake${lang}ABI"
        "${CMAKE_ROOT}/Modules/CMake${lang}CompilerABI.cpp"
        CMAKE_FLAGS ${CMAKE_FLAGS}
                # Ignore unused flags when we are just determining the ABI.
                "--no-warn-unused-cli"
        COMPILE_DEFINITIONS ${COMPILE_DEFINITIONS}
        OUTPUT_VARIABLE OUTPUT
    )

ADD_TEST(
  NAME autotests
  # GitHub's Linux testers only have two cores
  COMMAND "${CMAKE_SOURCE_DIR}/attest"
    "-j2"
    "--verbose"
    "--test-timeout=120"
     -E
     "${disabled_test_regex}"
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR})

try_compile(GOOGLEHASH_COMPILE ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}/googlehash_test.cpp OUTPUT_VARIABLE GOOGLEHASH_COMPILE_RESULT)

add_custom_command(TARGET libmonosat
            POST_BUILD
            COMMAND
            "${Java_JAR_EXECUTABLE}" "cfM" "${CMAKE_BINARY_DIR}/monosat_src.zip" ${RELATIVE_JAVA_PATHS}  "||" "true" # do not quote RELATIVE_JAVA_PATHS, or else semicolons will be injected between items.
            #OUTPUT "${CMAKE_BINARY_DIR}/monosat_src.zip"
            WORKING_DIRECTORY  "${CMAKE_SOURCE_DIR}/src/monosat/api/java/"
            )

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

try_run(${VAR}_EXITCODE ${VAR}_COMPILED
      ${CMAKE_BINARY_DIR}
      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c
      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
      ${CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES}
      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
      -DCMAKE_SKIP_RPATH:BOOL=${CMAKE_SKIP_RPATH}
      "${CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}"
      COMPILE_OUTPUT_VARIABLE OUTPUT)

export(TARGETS libimpala impala FILE ${CMAKE_BINARY_DIR}/share/anydsl/cmake/impala-exports.cmake)

configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake.in ${CMAKE_BINARY_DIR}/CTestCustom.cmake)

add_custom_target(run-clang-tidy
                ${Python_EXECUTABLE} ${RUN_CLANG_TIDY} -p=${CMAKE_BINARY_DIR} -j ${NPROC} -quiet
                USES_TERMINAL
                VERBATIM)

export(
        EXPORT    VTKPython
        NAMESPACE VTK::
        FILE      "${CMAKE_BINARY_DIR}/${paraview_cmake_destination}/vtk/VTKPython-targets.cmake")

TRY_COMPILE(SUFFICIENT_TEMPLATE_DEPTH
                ${CMAKE_BINARY_DIR} ${PROJECT_SOURCE_DIR}/config/checkTemplateDepth.cxx
                COMPILE_DEFINITIONS "-DDEPTH=900")

configure_file(${CMAKE_SOURCE_DIR}/cmake_templates/hilti-cxx-include-dirs.in
               ${CMAKE_BINARY_DIR}/hilti-cxx-include-dirs @ONLY)

configure_file(${CMAKE_CURRENT_LIST_DIR}/${xmlFile} ${CMAKE_BINARY_DIR}/paraview/xmls/${xmlFile})

try_compile(${VARIABLE}
			${CMAKE_BINARY_DIR}
			"${SOURCEFILE}"
			COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
			${CHECK_CONSTANT_EXISTS_LIBS}
			CMAKE_FLAGS
			-DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_CONSTANT_EXISTS_FLAGS}
			"${CMAKE_CONSTANT_EXISTS_INCLUDES}"
			OUTPUT_VARIABLE OUTPUT)

ExternalProject_Add(SpecFilePreview
    BINARY_DIR   "${CMAKE_BINARY_DIR}/SpecFilePreview"
    URL ${CMAKE_CURRENT_SOURCE_DIR}/../macOsQuickLook/SpecFilePreview/SpecFilePreview/
    CMAKE_GENERATOR   "Unix Makefiles"
    CMAKE_CACHE_ARGS -DCMAKE_PREFIX_PATH:PATH=${CMAKE_PREFIX_PATH}
                     #-DWt_INCLUDE_DIR:PATH=${Wt_INCLUDE_DIR}
                     #-DBOOST_ROOT:PATH=${Boost_INCLUDE_DIR}/..
                     -DInterSpec_BASE_DIR:PATH=${CMAKE_CURRENT_SOURCE_DIR}/../../
                     #-DBOOST_INCLUDEDIR:PATH=${Boost_INCLUDE_DIR}
                     -DCMAKE_BUILD_TYPE:STRING=RELEASE
                     -DSpecUtils_ENABLE_D3_CHART:BOOL=OFF
                     INSTALL_COMMAND   ""
)

configure_file("${CMAKE_SOURCE_DIR}/version_defs.h.in" "${CMAKE_BINARY_DIR}/version_defs.h" @ONLY)

add_custom_target(copy_data_bin_dir ALL 
        COMMAND ${CMAKE_COMMAND} -E copy_directory
        ${CMAKE_CURRENT_SOURCE_DIR}/data
        ${CMAKE_BINARY_DIR}/data
        COMMENT "Copying test data into binary directory")

ExternalProject_Add(${proj}
      ${${proj}_EP_ARGS}
      URL https://github.com/commontk/AppLauncher/releases/download/v${launcher_version}/CTKAppLauncher-${launcher_version}-${CTKAPPLAUNCHER_OS}-${CTKAPPLAUNCHER_ARCHITECTURE}.tar.gz
      URL_MD5 ${md5}
      DOWNLOAD_DIR ${CMAKE_BINARY_DIR}
      SOURCE_DIR ${EP_BINARY_DIR}
      BUILD_IN_SOURCE 1
      CONFIGURE_COMMAND ""
      BUILD_COMMAND ""
      INSTALL_COMMAND ""
      DEPENDS
        ${${proj}_DEPENDENCIES}
      )

CONFIGURE_FILE(cmake/TULIPConfigVersion.cmake.in ${CMAKE_BINARY_DIR}/cmake/TULIPConfigVersion.cmake @ONLY)

configure_file(${PROJECT_SOURCE_DIR}/cmake/gismoConfig.cmake.in
              "${CMAKE_BINARY_DIR}/gismoConfig.cmake" @ONLY)

add_custom_command(
			TARGET ${TARGET} POST_BUILD
			COMMAND "${CMAKE_COMMAND}" "-DTARGET_FILE=$<TARGET_FILE:${TARGET}>"
			ARGS ${CMAKE_SOURCE_DIR}
			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
			VERBATIM
		)

export(TARGETS ${SV_TARGETS} FILE "${CMAKE_BINARY_DIR}/SimVascularTargets.cmake")

configure_file(${CMAKE_CURRENT_SOURCE_DIR}/hal.pc.in ${CMAKE_BINARY_DIR}/hal.pc @ONLY)

set_target_properties(${PROJECT_NAME} PROPERTIES
            LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/analyzers)

ExternalProject_Add(${name}
    DEPENDS ${ARG_DEPENDS} llvm-config
    ${name}-clobber
    PREFIX ${CMAKE_BINARY_DIR}/projects/${name}
    SOURCE_DIR ${source_dir}
    STAMP_DIR ${STAMP_DIR}
    BINARY_DIR ${BINARY_DIR}
    ${exclude}
    CMAKE_ARGS ${${nameCanon}_CMAKE_ARGS}
               ${compiler_args}
               -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
               ${sysroot_arg}
               -DLLVM_BINARY_DIR=${PROJECT_BINARY_DIR}
               -DLLVM_CONFIG_PATH=${llvm_config_path}
               -DLLVM_ENABLE_WERROR=${LLVM_ENABLE_WERROR}
               -DLLVM_HOST_TRIPLE=${LLVM_HOST_TRIPLE}
               -DLLVM_HAVE_LINK_VERSION_SCRIPT=${LLVM_HAVE_LINK_VERSION_SCRIPT}
               -DPACKAGE_VERSION=${PACKAGE_VERSION}
               -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
               -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
               -DCMAKE_EXPORT_COMPILE_COMMANDS=1
               ${ARG_CMAKE_ARGS}
               ${PASSTHROUGH_VARIABLES}
    INSTALL_COMMAND ""
    STEP_TARGETS configure build
    BUILD_ALWAYS 1
    USES_TERMINAL_CONFIGURE 1
    USES_TERMINAL_BUILD 1
    USES_TERMINAL_INSTALL 1
    LIST_SEPARATOR |
    )

configure_file(${CMAKE_CURRENT_SOURCE_DIR}/dist/DEBIAN/control.in ${CMAKE_BINARY_DIR}/DEBIAN/control)

set_property(
    TEST ${test_name}
    PROPERTY ENVIRONMENT
    CEPH_ROOT=${CMAKE_SOURCE_DIR}
    CEPH_BIN=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
    CEPH_LIB=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
    CEPH_BUILD_VIRTUALENV=${CEPH_BUILD_VIRTUALENV}
    LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/lib
    PATH=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}:${CMAKE_SOURCE_DIR}/src:${CMAKE_CURRENT_BINARY_DIR}:$ENV{PATH}
    PYTHONPATH=${CMAKE_SOURCE_DIR}/src/pybind)

target_include_directories(winvnc4 PUBLIC ${CMAKE_BINARY_DIR}/win)