qt 6.5.3

2025-07-04 08:25:25 +08:00 · 2023-11-01 21:39:10 +01:00
parent 5c4154eda2
commit 94b1c5907b
3387 changed files with 0 additions and 0 deletions
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP-C.cmake
@ -0,0 +1,11 @@
+include(Compiler/CMakeCommonCompilerMacros)
+include(Compiler/ADSP)
+
+__compiler_adsp(C)
+
+set(CMAKE_C90_STANDARD_COMPILE_OPTION -c89)
+set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+
+__compiler_check_default_language_standard(C 8.0.0.0 99)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP-CXX.cmake
@ -0,0 +1,16 @@
+include(Compiler/CMakeCommonCompilerMacros)
+include(Compiler/ADSP)
+
+__compiler_adsp(CXX)
+
+set(CMAKE_CXX98_STANDARD_COMPILE_OPTION -c++)
+set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -g++)
+set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.3.0.0)
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION -c++11)
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -c++11 -g++)
+  set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+__compiler_check_default_language_standard(CXX 8.0.0.0 98)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP-DetermineCompiler.cmake
@ -0,0 +1,11 @@
+
+set(_compiler_id_pp_test "defined(_ADI_COMPILER)")
+
+set(_compiler_id_version_compute "
+#if defined(__VERSIONNUM__)
+  /* __VERSIONNUM__ = 0xVVRRPPTT */
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__VERSIONNUM__ >> 24 & 0xFF)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__VERSIONNUM__ >> 16 & 0xFF)
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__VERSIONNUM__ >> 8 & 0xFF)
+#  define @PREFIX@COMPILER_VERSION_TWEAK @MACRO_DEC@(__VERSIONNUM__ & 0xFF)
+#endif")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ADSP.cmake
@ -0,0 +1,26 @@
+include_guard()
+
+set(CMAKE_EXECUTABLE_SUFFIX ".dxe")
+
+macro(__compiler_adsp lang)
+  set(CMAKE_${lang}_OUTPUT_EXTENSION ".doj")
+
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-flags-link" " ")
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",")
+
+  set(_CMAKE_${lang}_ADSP_FLAGS "-proc=${CMAKE_ADSP_PROCESSOR}")
+
+  set(CMAKE_${lang}_COMPILE_OBJECT
+    "<CMAKE_${lang}_COMPILER> ${_CMAKE_${lang}_ADSP_FLAGS} <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>")
+
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY
+    "<CMAKE_${lang}_COMPILER> ${_CMAKE_${lang}_ADSP_FLAGS} -build-lib -o <TARGET> <CMAKE_${lang}_LINK_FLAGS> <OBJECTS>")
+
+  set(CMAKE_${lang}_LINK_EXECUTABLE
+    "<CMAKE_${lang}_COMPILER> ${_CMAKE_${lang}_ADSP_FLAGS} <FLAGS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
+
+  unset(_CMAKE_${lang}_ADSP_FLAGS)
+
+  set(CMAKE_${lang}_CREATE_SHARED_LIBRARY)
+  set(CMAKE_${lang}_CREATE_MODULE_LIBRARY)
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-ASM.cmake
@ -0,0 +1,7 @@
+include(Compiler/ARMCC)
+
+set(CMAKE_ASM_OUTPUT_EXTENSION ".o")
+set(CMAKE_ASM_OUTPUT_EXTENSION_REPLACE 1)
+
+set(CMAKE_ASM_COMPILE_OBJECT       "<CMAKE_ASM_COMPILER> <INCLUDES> <FLAGS> -o <OBJECT> <SOURCE>")
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS S;s;asm;msa)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-C.cmake
@ -0,0 +1,2 @@
+include(Compiler/ARMCC)
+__compiler_armcc(C)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-CXX.cmake
@ -0,0 +1,2 @@
+include(Compiler/ARMCC)
+__compiler_armcc(CXX)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC-DetermineCompiler.cmake
@ -0,0 +1,16 @@
+# ARMCC Toolchain
+set(_compiler_id_pp_test "defined(__ARMCC_VERSION) && !defined(__clang__)")
+
+set(_compiler_id_version_compute "
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__ARMCC_VERSION/1000000)
+  # define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__ARMCC_VERSION/10000 % 100)
+  # define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__ARMCC_VERSION/100000)
+  # define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__ARMCC_VERSION/10000 % 10)
+  # define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__ARMCC_VERSION    % 10000)
+#endif
+")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMCC.cmake
@ -0,0 +1,39 @@
+if(_ARMCC_CMAKE_LOADED)
+  return()
+endif()
+set(_ARMCC_CMAKE_LOADED TRUE)
+
+# See ARM Compiler documentation at:
+# http://infocenter.arm.com/help/topic/com.arm.doc.set.swdev/index.html
+
+get_filename_component(_CMAKE_C_TOOLCHAIN_LOCATION "${CMAKE_C_COMPILER}" PATH)
+get_filename_component(_CMAKE_CXX_TOOLCHAIN_LOCATION "${CMAKE_CXX_COMPILER}" PATH)
+
+set(CMAKE_EXECUTABLE_SUFFIX ".elf")
+
+find_program(CMAKE_ARMCC_LINKER armlink HINTS "${_CMAKE_C_TOOLCHAIN_LOCATION}" "${_CMAKE_CXX_TOOLCHAIN_LOCATION}" )
+find_program(CMAKE_ARMCC_AR     armar   HINTS "${_CMAKE_C_TOOLCHAIN_LOCATION}" "${_CMAKE_CXX_TOOLCHAIN_LOCATION}" )
+
+set(CMAKE_LINKER "${CMAKE_ARMCC_LINKER}" CACHE FILEPATH "The ARMCC linker" FORCE)
+mark_as_advanced(CMAKE_ARMCC_LINKER)
+set(CMAKE_AR "${CMAKE_ARMCC_AR}" CACHE FILEPATH "The ARMCC archiver" FORCE)
+mark_as_advanced(CMAKE_ARMCC_AR)
+
+macro(__compiler_armcc lang)
+  string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+  string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g")
+  string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Ospace -DNDEBUG")
+  string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -Otime -DNDEBUG")
+  string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+
+  set(CMAKE_${lang}_OUTPUT_EXTENSION ".o")
+  set(CMAKE_${lang}_OUTPUT_EXTENSION_REPLACE 1)
+  set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "--via=")
+
+  set(CMAKE_${lang}_LINK_EXECUTABLE      "<CMAKE_LINKER> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> <OBJECTS> -o <TARGET> --list <TARGET_BASE>.map")
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY  "<CMAKE_AR> --create -cr <TARGET> <LINK_FLAGS> <OBJECTS>")
+
+  set(CMAKE_DEPFILE_FLAGS_${lang} "--depend=<DEP_FILE> --depend_single_line --no_depend_system_headers")
+
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Xlinker" " ")
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-ASM.cmake
@ -0,0 +1,9 @@
+include(Compiler/ARMClang)
+
+set(CMAKE_ASM_OUTPUT_EXTENSION ".o")
+set(CMAKE_ASM_OUTPUT_EXTENSION_REPLACE 1)
+
+set(CMAKE_ASM_COMPILE_OBJECT       "<CMAKE_ASM_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -c -o <OBJECT> <SOURCE>")
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS S;s;asm;msa)
+
+__compiler_armclang(ASM)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-C-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-C-FeatureTests.cmake
@ -0,0 +1 @@
+include(Compiler/Clang-C-FeatureTests)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-C.cmake
@ -0,0 +1,23 @@
+include(Compiler/Clang-C)
+include(Compiler/ARMClang)
+__compiler_armclang(C)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_C)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_C_DEPFILE_FORMAT gcc)
+  set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
+set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
+set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
+set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-CXX-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-CXX-FeatureTests.cmake
@ -0,0 +1 @@
+include(Compiler/Clang-CXX-FeatureTests)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-CXX.cmake
@ -0,0 +1,11 @@
+include(Compiler/Clang-CXX)
+include(Compiler/ARMClang)
+__compiler_armclang(CXX)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_CXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang-DetermineCompiler.cmake
@ -0,0 +1,10 @@
+# ARMClang Toolchain
+set(_compiler_id_pp_test "defined(__clang__) && defined(__ARMCOMPILER_VERSION)")
+
+set(_compiler_id_version_compute "
+  # define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__ARMCOMPILER_VERSION/1000000)
+  # define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__ARMCOMPILER_VERSION/10000 % 100)
+  # define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__ARMCOMPILER_VERSION/100   % 100)")
+
+string(APPEND _compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__ARMCOMPILER_VERSION)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/ARMClang.cmake
@ -0,0 +1,146 @@
+if(_ARMClang_CMAKE_LOADED)
+  return()
+endif()
+
+# This file requires CMAKE_LINKER and CMAKE_AR set by CMakeFindBinUtils.cmake.
+if(NOT (DEFINED CMAKE_LINKER AND DEFINED CMAKE_AR))
+  return()
+endif()
+
+set(_ARMClang_CMAKE_LOADED TRUE)
+
+# Save the CMP0123 setting in a variable used both below and by try_compile.
+cmake_policy(GET CMP0123 CMAKE_ARMClang_CMP0123)
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0057 NEW) # if IN_LIST
+
+set(CMAKE_EXECUTABLE_SUFFIX ".elf")
+
+if (CMAKE_LINKER MATCHES "armlink")
+  set(__CMAKE_ARMClang_USING_armlink TRUE)
+  set(CMAKE_LIBRARY_PATH_FLAG "--userlibpath=")
+else()
+  set(__CMAKE_ARMClang_USING_armlink FALSE)
+endif()
+
+# get compiler supported cpu list
+function(__armclang_set_processor_list lang out_var)
+  execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" --target=${CMAKE_${lang}_COMPILER_TARGET} -mcpu=list
+    OUTPUT_VARIABLE processor_list
+    ERROR_VARIABLE processor_list)
+  string(REGEX MATCHALL "-mcpu=([^ \n]*)" processor_list "${processor_list}")
+  string(REGEX REPLACE "-mcpu=" "" processor_list "${processor_list}")
+  set(${out_var} "${processor_list}" PARENT_SCOPE)
+endfunction()
+
+# check processor is in list
+function(__armclang_check_processor processor list out_var)
+  string(TOLOWER "${processor}" processor)
+  if(processor IN_LIST list)
+    set(${out_var} TRUE PARENT_SCOPE)
+  else()
+    set(${out_var} FALSE PARENT_SCOPE)
+  endif()
+endfunction()
+
+# get compiler supported arch list
+function(__armclang_set_arch_list lang out_var)
+  execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" --target=${CMAKE_${lang}_COMPILER_TARGET} -march=list
+    OUTPUT_VARIABLE arch_list
+    ERROR_VARIABLE arch_list)
+  string(REGEX MATCHALL "-march=([^ \n]*)" arch_list "${arch_list}")
+  string(REGEX REPLACE "-march=" "" arch_list "${arch_list}")
+  set(${out_var} "${arch_list}" PARENT_SCOPE)
+endfunction()
+
+# get linker supported cpu list
+function(__armlink_set_cpu_list lang out_var)
+  if(__CMAKE_ARMClang_USING_armlink)
+    set(__linker_wrapper_flags "")
+  else()
+    set(__linker_wrapper_flags --target=${CMAKE_${lang}_COMPILER_TARGET} -Xlinker)
+  endif()
+
+  execute_process(COMMAND "${CMAKE_LINKER}" ${__linker_wrapper_flags} --cpu=list
+    OUTPUT_VARIABLE cpu_list
+    ERROR_VARIABLE cpu_list)
+  string(REGEX MATCHALL "--cpu=([^ \n]*)" cpu_list "${cpu_list}")
+  string(REGEX REPLACE "--cpu=" "" cpu_list "${cpu_list}")
+  set(${out_var} "${cpu_list}" PARENT_SCOPE)
+endfunction()
+
+macro(__compiler_armclang lang)
+  if(NOT CMAKE_${lang}_COMPILER_TARGET)
+    set(CMAKE_${lang}_COMPILER_TARGET arm-arm-none-eabi)
+  endif()
+  if(NOT CMAKE_${lang}_COMPILER_PROCESSOR_LIST)
+    __armclang_set_processor_list(${lang} CMAKE_${lang}_COMPILER_PROCESSOR_LIST)
+  endif()
+  if(NOT CMAKE_${lang}_COMPILER_ARCH_LIST)
+    __armclang_set_arch_list(${lang} CMAKE_${lang}_COMPILER_ARCH_LIST)
+  endif()
+
+  # CMAKE_SYSTEM_PROCESSOR and CMAKE_SYSTEM_ARCH are not sufficient because they provide no
+  # information of additional CPU features needed in `-mcpu=<name>[+[no]<feature>+...]`.
+  # The automatic setting of compile and link options is deprecated and projects should specify their own.
+  cmake_policy(GET CMP0123 policy_CMP0123)
+  if(NOT "x${CMAKE_ARMClang_CMP0123}x" STREQUAL "xNEWx")
+    if(NOT "x${CMAKE_ARMClang_CMP0123}x" STREQUAL "xOLDx")
+      cmake_policy(GET_WARNING CMP0123 _cmp0123_warning)
+      message(AUTHOR_WARNING
+        "${_cmp0123_warning}\n"
+        "For compatibility, CMake will automatically add cpu/arch flags based "
+        "on the CMAKE_SYSTEM_PROCESSOR and/or CMAKE_SYSTEM_ARCH variables."
+        )
+    endif()
+
+    if(NOT CMAKE_SYSTEM_PROCESSOR AND NOT CMAKE_SYSTEM_ARCH)
+      message(FATAL_ERROR "  CMAKE_SYSTEM_PROCESSOR or CMAKE_SYSTEM_ARCH must be set for ARMClang\n"
+        "  Supported processor: ${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}\n"
+        "  Supported Architecture: ${CMAKE_${lang}_COMPILER_ARCH_LIST}")
+    else()
+      __armclang_check_processor("${CMAKE_SYSTEM_ARCH}" "${CMAKE_${lang}_COMPILER_ARCH_LIST}" _CMAKE_${lang}_CHECK_ARCH_RESULT)
+      if( _CMAKE_${lang}_CHECK_ARCH_RESULT)
+        string(APPEND CMAKE_${lang}_FLAGS_INIT " -march=${CMAKE_SYSTEM_ARCH}")
+        set(__march_flag_set TRUE)
+      endif()
+      __armclang_check_processor("${CMAKE_SYSTEM_PROCESSOR}" "${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}" _CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
+      if(_CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
+        string(APPEND CMAKE_${lang}_FLAGS_INIT " -mcpu=${CMAKE_SYSTEM_PROCESSOR}")
+        set(__mcpu_flag_set TRUE)
+      endif()
+      if(NOT __march_flag_set AND NOT __mcpu_flag_set)
+        message(FATAL_ERROR "At least one of the variables CMAKE_SYSTEM_PROCESSOR or CMAKE_SYSTEM_ARCH must be set for ARMClang\n"
+                            "Supported processor: ${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}\n"
+                            "  Supported Architecture: ${CMAKE_${lang}_COMPILER_ARCH_LIST}")
+      endif()
+      unset(_CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
+      unset(_CMAKE_${lang}_CHECK_ARCH_RESULT)
+    endif()
+
+    #check if CMAKE_SYSTEM_PROCESSOR belongs to supported cpu list for armlink
+    __armlink_set_cpu_list( ${lang} CMAKE_LINKER_CPU_LIST)
+    list(TRANSFORM CMAKE_LINKER_CPU_LIST TOLOWER)
+    __armclang_check_processor("${CMAKE_SYSTEM_PROCESSOR}" "${CMAKE_LINKER_CPU_LIST}" _CMAKE_CHECK_LINK_CPU_RESULT)
+    if(_CMAKE_CHECK_LINK_CPU_RESULT)
+      string(APPEND CMAKE_${lang}_LINK_FLAGS " --cpu=${CMAKE_SYSTEM_PROCESSOR}")
+    endif()
+
+  endif()
+
+  if(__CMAKE_ARMClang_USING_armlink)
+    unset(CMAKE_${lang}_LINKER_WRAPPER_FLAG)
+    set(__CMAKE_ARMClang_USING_armlink_WRAPPER "")
+  else()
+    set(__CMAKE_ARMClang_USING_armlink_WRAPPER "-Xlinker")
+  endif()
+  set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> <OBJECTS> -o <TARGET> ${__CMAKE_ARMClang_USING_armlink_WRAPPER} --list=<TARGET_BASE>.map")
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY  "<CMAKE_AR> --create -cr <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_CREATE         "<CMAKE_AR> --create -cr <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "${__CMAKE_ARMClang_USING_armlink_WRAPPER} --via=")
+  set(CMAKE_${lang}_OUTPUT_EXTENSION ".o")
+  set(CMAKE_${lang}_OUTPUT_EXTENSION_REPLACE 1)
+endmacro()
+
+cmake_policy(POP)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Absoft-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Absoft-Fortran.cmake
@ -0,0 +1,13 @@
+string(APPEND CMAKE_Fortran_FLAGS_INIT " ")
+string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT " -g")
+string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " ")
+string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3")
+string(APPEND CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+set(CMAKE_Fortran_MODDIR_FLAG "-YMOD_OUT_DIR=")
+set(CMAKE_Fortran_MODPATH_FLAG "-p")
+set(CMAKE_Fortran_VERBOSE_FLAG "-v")
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree")
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-X")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-no-cpp")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-ASM.cmake
@ -0,0 +1 @@
+include(Compiler/Clang-ASM)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-C-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-C-FeatureTests.cmake
@ -0,0 +1,11 @@
+
+set(_cmake_oldestSupported "((__clang_major__ * 100) + __clang_minor__) >= 400")
+
+set(AppleClang_C11 "${_cmake_oldestSupported} && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L")
+set(_cmake_feature_test_c_static_assert "${AppleClang_C11}")
+set(AppleClang_C99 "${_cmake_oldestSupported} && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L")
+set(_cmake_feature_test_c_restrict "${AppleClang_C99}")
+set(_cmake_feature_test_c_variadic_macros "${AppleClang_C99}")
+
+set(AppleClang_C90 "${_cmake_oldestSupported}")
+set(_cmake_feature_test_c_function_prototypes "${AppleClang_C90}")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-C.cmake
@ -0,0 +1,41 @@
+include(Compiler/Clang)
+__compiler_clang(C)
+
+
+if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles"
+      AND CMAKE_DEPFILE_FLAGS_C)
+    # dependencies are computed by the compiler itself
+    set(CMAKE_C_DEPFILE_FORMAT gcc)
+    set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+  endif()
+endif()
+
+set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c)
+
+if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.0)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
+  set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+  set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
+  set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17")
+  set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0.3)
+  set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x")
+  set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
+endif()
+
+__compiler_check_default_language_standard(C 4.0 99 9.1 11 12.0.5 17)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-CXX-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-CXX-FeatureTests.cmake
@ -0,0 +1,52 @@
+
+# No known reference for AppleClang versions.
+# Generic reference: http://clang.llvm.org/cxx_status.html
+# http://clang.llvm.org/docs/LanguageExtensions.html
+
+# Note: CXX compiler in Xcode 4.3 does not set __apple_build_version__ and so is
+# not recognized as AppleClang.
+# Xcode_43 - Apple clang version 3.1 (tags/Apple/clang-318.0.61) (based on LLVM 3.1svn)
+# Xcode_44 - Apple clang version 4.0 (tags/Apple/clang-421.0.60) (based on LLVM 3.1svn)
+# Xcode_45 - Apple clang version 4.1 (tags/Apple/clang-421.11.66) (based on LLVM 3.1svn)
+# Xcode_46 - Apple LLVM version 4.2 (clang-425.0.28) (based on LLVM 3.2svn)
+# Xcode_50 - Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
+# Xcode_51 - Apple LLVM version 5.1 (clang-503.0.38) (based on LLVM 3.4svn)
+# Xcode_60 - Apple LLVM version 6.0 (clang-600.0.51) (based on LLVM 3.5svn)
+# Xcode_61 - Apple LLVM version 6.0 (clang-600.0.56) (based on LLVM 3.5svn)
+
+# There is some non-correspondance. __has_feature(cxx_user_literals) is
+# false for AppleClang 4.0 and 4.1, although it is reported as
+# supported in the reference link for Clang 3.1.  The compiler does not pass
+# the CompileFeatures/cxx_user_literals.cpp test.
+# cxx_attributes is listed as not supported until Clang 3.3. It works without
+# warning with AppleClang 5.0, but issues a gcc-compat warning for
+# AppleClang 4.0-4.2.
+# cxx_alignof and cxx_alignas tests work for early AppleClang versions, though
+# they are listed as supported for Clang 3.3 and later.
+
+set(_cmake_oldestSupported "((__clang_major__ * 100) + __clang_minor__) >= 400")
+
+include("${CMAKE_CURRENT_LIST_DIR}/Clang-CXX-TestableFeatures.cmake")
+
+set(AppleClang51_CXX14 "((__clang_major__ * 100) + __clang_minor__) >= 501 && __cplusplus > 201103L")
+# http://llvm.org/bugs/show_bug.cgi?id=19242
+set(_cmake_feature_test_cxx_attribute_deprecated "${AppleClang51_CXX14}")
+# http://llvm.org/bugs/show_bug.cgi?id=19698
+set(_cmake_feature_test_cxx_decltype_auto "${AppleClang51_CXX14}")
+set(_cmake_feature_test_cxx_digit_separators "${AppleClang51_CXX14}")
+# http://llvm.org/bugs/show_bug.cgi?id=19674
+set(_cmake_feature_test_cxx_generic_lambdas "${AppleClang51_CXX14}")
+
+set(AppleClang40_CXX11 "${_cmake_oldestSupported} && __cplusplus >= 201103L")
+set(_cmake_feature_test_cxx_enum_forward_declarations "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_sizeof_member "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_extended_friend_declarations "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_extern_templates "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_func_identifier "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_inline_namespaces "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_long_long_type "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_right_angle_brackets "${AppleClang40_CXX11}")
+set(_cmake_feature_test_cxx_variadic_macros "${AppleClang40_CXX11}")
+
+set(AppleClang_CXX98 "${_cmake_oldestSupported} && __cplusplus >= 199711L")
+set(_cmake_feature_test_cxx_template_template_parameters "${AppleClang_CXX98}")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-CXX.cmake
@ -0,0 +1,63 @@
+include(Compiler/Clang)
+__compiler_clang(CXX)
+
+set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+
+if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles"
+      AND CMAKE_DEPFILE_FLAGS_CXX)
+    # dependencies are computed by the compiler itself
+    set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+    set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+  endif()
+
+  set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+endif()
+
+if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98")
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+endif()
+
+if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+  set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
+  # AppleClang 5.0 knows this flag, but does not set a __cplusplus macro greater than 201103L
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+  set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+    set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
+elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+  set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std=c++2b")
+  set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std=gnu++2b")
+endif()
+
+__compiler_check_default_language_standard(CXX 4.0 98)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-DetermineCompiler.cmake
@ -0,0 +1,7 @@
+
+set(_compiler_id_pp_test "defined(__clang__) && defined(__apple_build_version__)")
+
+include("${CMAKE_CURRENT_LIST_DIR}/Clang-DetermineCompilerInternal.cmake")
+
+string(APPEND _compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_TWEAK @MACRO_DEC@(__apple_build_version__)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-OBJC.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-OBJC.cmake
@ -0,0 +1,40 @@
+include(Compiler/Clang-OBJC)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles"
+    AND CMAKE_DEPFILE_FLAGS_OBJC)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJC_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJC_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+
+if(NOT CMAKE_OBJC_COMPILER_VERSION VERSION_LESS 4.0)
+  set(CMAKE_OBJC90_STANDARD_COMPILE_OPTION "-std=c90")
+  set(CMAKE_OBJC90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+  set(CMAKE_OBJC90_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_OBJC99_STANDARD_COMPILE_OPTION "-std=c99")
+  set(CMAKE_OBJC99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+  set(CMAKE_OBJC99_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_OBJC11_STANDARD_COMPILE_OPTION "-std=c11")
+  set(CMAKE_OBJC11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+  set(CMAKE_OBJC11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+# AppleClang 10.0 was the oldest compiler available to test C17 support
+if(NOT CMAKE_OBJC_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_OBJC17_STANDARD_COMPILE_OPTION "-std=c17")
+  set(CMAKE_OBJC17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+  set(CMAKE_OBJC17_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if(NOT CMAKE_OBJC_COMPILER_VERSION VERSION_LESS 11.0)
+  set(CMAKE_OBJC23_STANDARD_COMPILE_OPTION "-std=c2x")
+  set(CMAKE_OBJC23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
+  set(CMAKE_OBJC23_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+# AppleClang 10.0 was the oldest compiler available to test default C11 support
+__compiler_check_default_language_standard(OBJC 4.0 99 10.0 11)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-OBJCXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/AppleClang-OBJCXX.cmake
@ -0,0 +1,52 @@
+include(Compiler/Clang-OBJCXX)
+
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles"
+    AND CMAKE_DEPFILE_FLAGS_OBJCXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJCXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJCXX_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+
+set(CMAKE_OBJCXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+
+if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 4.0)
+  set(CMAKE_OBJCXX98_STANDARD_COMPILE_OPTION "-std=c++98")
+  set(CMAKE_OBJCXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+  set(CMAKE_OBJCXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_OBJCXX11_STANDARD_COMPILE_OPTION "-std=c++11")
+  set(CMAKE_OBJCXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+endif()
+
+if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_OBJCXX14_STANDARD_COMPILE_OPTION "-std=c++14")
+  set(CMAKE_OBJCXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+  set(CMAKE_OBJCXX14_STANDARD__HAS_FULL_SUPPORT ON)
+elseif(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 5.1)
+  # AppleClang 5.0 knows this flag, but does not set a __cplusplus macro greater than 201103L
+  set(CMAKE_OBJCXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
+  set(CMAKE_OBJCXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+  set(CMAKE_OBJCXX14_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std=c++17")
+  set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+elseif (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 6.1)
+  set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
+  set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
+endif()
+
+if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 8.0)
+    set(CMAKE_OBJCXX11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 10.0)
+  set(CMAKE_OBJCXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
+  set(CMAKE_OBJCXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
+endif()
+
+__compiler_check_default_language_standard(OBJCXX 4.0 98)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Borland-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Borland-DetermineCompiler.cmake
@ -0,0 +1,7 @@
+
+set(_compiler_id_pp_test "defined(__BORLANDC__)")
+
+set(_compiler_id_version_compute "
+  /* __BORLANDC__ = 0xVRR */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_HEX@(__BORLANDC__>>8)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_HEX@(__BORLANDC__ & 0xFF)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Bruce-C-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Bruce-C-DetermineCompiler.cmake
@ -0,0 +1 @@
+set(_compiler_id_pp_test "defined(__BCC__)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Bruce-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Bruce-C.cmake
@ -0,0 +1,9 @@
+# Bruce C Compiler ignores "-g" flag and optimization cannot be
+# enabled here (it is implemented only for 8086 target).
+string(APPEND CMAKE_C_FLAGS_INIT " -D__CLASSIC_C__")
+string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " -g")
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG")
+string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO_INIT " -g -DNDEBUG")
+
+set(CMAKE_C_LINKER_WRAPPER_FLAG "-X")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CCur-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CCur-Fortran.cmake
@ -0,0 +1 @@
+include(Compiler/GNU-Fortran)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CMakeCommonCompilerMacros.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CMakeCommonCompilerMacros.cmake
@ -0,0 +1,194 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This module is shared by multiple languages and compilers; use include guard
+if (__COMPILER_CMAKE_COMMON_COMPILER_MACROS)
+  return()
+endif ()
+set(__COMPILER_CMAKE_COMMON_COMPILER_MACROS 1)
+
+
+# Check that a compiler's language standard is properly detected
+# Parameters:
+#   lang   - Language to check
+#   stdver1 - Minimum version to set a given default for
+#   std1    - Default to use for compiler ver >= stdver1
+#   stdverN - Minimum version to set a given default for
+#   stdN    - Default to use for compiler ver >= stdverN
+#
+#   The order of stdverN stdN pairs passed as arguments is expected to be in
+#   monotonically increasing version order.
+#
+# Note:
+#   This macro can be called with multiple version / std pairs to convey that
+#   newer compiler versions may use a newer standard default.
+#
+# Example:
+#   To specify that compiler version 6.1 and newer defaults to C++11 while
+#   4.8 <= ver < 6.1 default to C++98, you would call:
+#
+# __compiler_check_default_language_standard(CXX 4.8 98 6.1 11)
+#
+macro(__compiler_check_default_language_standard lang stdver1 std1)
+  set(__std_ver_pairs "${stdver1};${std1};${ARGN}")
+  string(REGEX REPLACE " *; *" " " __std_ver_pairs "${__std_ver_pairs}")
+  string(REGEX MATCHALL "[^ ]+ [^ ]+" __std_ver_pairs "${__std_ver_pairs}")
+
+  # If the compiler version is below the threshold of even having CMake
+  # support for language standards, then don't bother.
+  if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL "${stdver1}")
+    if (NOT CMAKE_${lang}_COMPILER_FORCED)
+      if (NOT CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT OR NOT DEFINED CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT)
+        message(FATAL_ERROR "CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT and CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT should be set for ${CMAKE_${lang}_COMPILER_ID} (${CMAKE_${lang}_COMPILER}) version ${CMAKE_${lang}_COMPILER_VERSION}")
+      endif ()
+      set(CMAKE_${lang}_STANDARD_DEFAULT ${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT})
+      set(CMAKE_${lang}_EXTENSIONS_DEFAULT ${CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT})
+    else ()
+      list(REVERSE __std_ver_pairs)
+      foreach (__std_ver_pair IN LISTS __std_ver_pairs)
+        string(REGEX MATCH "([^ ]+) (.+)" __std_ver_pair "${__std_ver_pair}")
+        set(__stdver ${CMAKE_MATCH_1})
+        set(__std ${CMAKE_MATCH_2})
+        # Compiler id was forced so just guess the defaults.
+        if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL __stdver)
+          if(NOT DEFINED CMAKE_${lang}_EXTENSIONS_DEFAULT)
+            # Currently known compilers default to enabling extensions.
+            set(CMAKE_${lang}_EXTENSIONS_DEFAULT ON)
+          endif()
+          if(NOT DEFINED CMAKE_${lang}_STANDARD_DEFAULT)
+            set(CMAKE_${lang}_STANDARD_DEFAULT ${__std})
+          endif()
+        endif ()
+        unset(__std)
+        unset(__stdver)
+      endforeach ()
+    endif ()
+  endif ()
+  unset(__std_ver_pairs)
+endmacro()
+
+# Define to allow compile features to be automatically determined
+macro(cmake_record_c_compile_features)
+  set(_result 0)
+  if(_result EQUAL 0 AND DEFINED CMAKE_C23_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_c(23)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_C17_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_c(17)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_C11_STANDARD_COMPILE_OPTION)
+    if(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_c(11)
+    else()
+      _record_compiler_features_c(11)
+    endif()
+    unset(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_C99_STANDARD_COMPILE_OPTION)
+    if(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_c(99)
+    else()
+      _record_compiler_features_c(99)
+    endif()
+    unset(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_C90_STANDARD_COMPILE_OPTION)
+    if(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_c(90)
+    else()
+      _record_compiler_features_c(90)
+    endif()
+    unset(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+endmacro()
+
+# Define to allow compile features to be automatically determined
+macro(cmake_record_cxx_compile_features)
+  set(_result 0)
+  if(_result EQUAL 0 AND DEFINED CMAKE_CXX23_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_cxx(23)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CXX20_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_cxx(20)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CXX17_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_cxx(17)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CXX14_STANDARD_COMPILE_OPTION)
+    if(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_cxx(14)
+    else()
+      _record_compiler_features_cxx(14)
+    endif()
+    unset(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CXX11_STANDARD_COMPILE_OPTION)
+    if(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_cxx(11)
+    else()
+      _record_compiler_features_cxx(11)
+    endif()
+    unset(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CXX98_STANDARD_COMPILE_OPTION)
+    if(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_cxx(98)
+    else()
+      _record_compiler_features_cxx(98)
+    endif()
+    unset(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+endmacro()
+
+macro(cmake_record_cuda_compile_features)
+  set(_result 0)
+  if(_result EQUAL 0 AND DEFINED CMAKE_CUDA23_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_cuda(23)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CUDA20_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_cuda(20)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CUDA17_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_cuda(17)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CUDA14_STANDARD_COMPILE_OPTION)
+    if(CMAKE_CUDA14_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_cuda(14)
+    else()
+      _record_compiler_features_cuda(14)
+    endif()
+    unset(CMAKE_CUDA14_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CUDA11_STANDARD_COMPILE_OPTION)
+    if(CMAKE_CUDA11_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_cuda(11)
+    else()
+      _record_compiler_features_cuda(11)
+    endif()
+    unset(CMAKE_CUDA11_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_CUDA03_STANDARD_COMPILE_OPTION)
+    if(CMAKE_CUDA03_STANDARD__HAS_FULL_SUPPORT)
+      _has_compiler_features_cuda(03)
+    else()
+      _record_compiler_features_cuda(03)
+    endif()
+    unset(CMAKE_CUDA03_STANDARD__HAS_FULL_SUPPORT)
+  endif()
+endmacro()
+
+macro(cmake_record_hip_compile_features)
+  set(_result 0)
+  if(_result EQUAL 0 AND DEFINED CMAKE_HIP23_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_hip(23)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_HIP20_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_hip(20)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_HIP17_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_hip(17)
+  endif()
+  _has_compiler_features_hip(14)
+  _has_compiler_features_hip(11)
+  _has_compiler_features_hip(98)
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-ASM.cmake
@ -0,0 +1,5 @@
+include(Compiler/Clang)
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S;asm)
+
+__compiler_clang(ASM)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-C-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-C-FeatureTests.cmake
@ -0,0 +1,11 @@
+
+set(_cmake_oldestSupported "((__clang_major__ * 100) + __clang_minor__) >= 304")
+
+set(Clang_C11 "${_cmake_oldestSupported} && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L")
+set(_cmake_feature_test_c_static_assert "${Clang_C11}")
+set(Clang_C99 "${_cmake_oldestSupported} && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L")
+set(_cmake_feature_test_c_restrict "${Clang_C99}")
+set(_cmake_feature_test_c_variadic_macros "${Clang_C99}")
+
+set(Clang_C90 "${_cmake_oldestSupported}")
+set(_cmake_feature_test_c_function_prototypes "${Clang_C90}")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-C.cmake
@ -0,0 +1,88 @@
+include(Compiler/Clang)
+__compiler_clang(C)
+
+cmake_policy(GET CMP0025 appleClangPolicy)
+if(APPLE AND NOT appleClangPolicy STREQUAL NEW)
+  return()
+endif()
+
+if("x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC")
+  set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -TC)
+  set(CMAKE_C_CLANG_TIDY_DRIVER_MODE "cl")
+  set(CMAKE_C_INCLUDE_WHAT_YOU_USE_DRIVER_MODE "cl")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+      AND CMAKE_DEPFILE_FLAGS_C)
+    set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+  endif()
+elseif("x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
+  set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c)
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+      AND CMAKE_DEPFILE_FLAGS_C)
+    # dependencies are computed by the compiler itself
+    set(CMAKE_C_DEPFILE_FORMAT gcc)
+    set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+  endif()
+endif()
+
+if("x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 2.1)
+    set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
+    set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+
+    set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
+    set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+  endif()
+
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.1)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+  elseif(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.0)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c1x")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu1x")
+  endif()
+
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
+    set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17")
+    set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+  endif()
+
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 18.0)
+    set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c23")
+    set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu23")
+  elseif(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
+    set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x")
+    set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
+  endif()
+else()
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION "")
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION "")
+
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 13.0)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "/std:c11")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "/std:c11")
+
+    set(CMAKE_C17_STANDARD_COMPILE_OPTION "/std:c17")
+    set(CMAKE_C17_EXTENSION_COMPILE_OPTION "/std:c17")
+  else()
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "")
+
+    set(CMAKE_C17_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_C17_EXTENSION_COMPILE_OPTION "")
+  endif()
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 2.1)
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.0)
+  set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+__compiler_check_default_language_standard(C 2.1 99 3.5.2 11 11.0 17)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CUDA.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CUDA.cmake
@ -0,0 +1,44 @@
+include(Compiler/Clang)
+__compiler_clang(CUDA)
+
+# Set explicitly, because __compiler_clang() doesn't set this if we're simulating MSVC.
+set(CMAKE_DEPFILE_FLAGS_CUDA "-MD -MT <DEP_TARGET> -MF <DEP_FILE>")
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake")
+  # dependencies are computed by the compiler itself
+  set(CMAKE_CUDA_DEPFILE_FORMAT gcc)
+  set(CMAKE_CUDA_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+# C++03 isn't supported for CXX, but is for CUDA, so we need to set these manually.
+# Do this before __compiler_clang_cxx_standards() since that adds the feature.
+set(CMAKE_CUDA03_STANDARD_COMPILE_OPTION "-std=c++03")
+set(CMAKE_CUDA03_EXTENSION_COMPILE_OPTION "-std=gnu++03")
+__compiler_clang_cxx_standards(CUDA)
+
+set(CMAKE_CUDA_COMPILER_HAS_DEVICE_LINK_PHASE TRUE)
+set(_CMAKE_COMPILE_AS_CUDA_FLAG "-x cuda")
+set(_CMAKE_CUDA_WHOLE_FLAG "-c")
+set(_CMAKE_CUDA_RDC_FLAG "-fgpu-rdc")
+set(_CMAKE_CUDA_PTX_FLAG "--cuda-device-only -S")
+
+# Device linking is just regular linking so these are the same.
+set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG ${CMAKE_CUDA_LINKER_WRAPPER_FLAG})
+set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG_SEP ${CMAKE_CUDA_LINKER_WRAPPER_FLAG_SEP})
+
+# RulePlaceholderExpander expands crosscompile variables like sysroot and target only for CMAKE_<LANG>_COMPILER. Override the default.
+set(CMAKE_CUDA_LINK_EXECUTABLE "<CMAKE_CUDA_COMPILER> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
+set(CMAKE_CUDA_CREATE_SHARED_LIBRARY "<CMAKE_CUDA_COMPILER> <CMAKE_SHARED_LIBRARY_CUDA_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
+
+set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "STATIC")
+set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "cudadevrt;cudart_static")
+set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_SHARED "cudadevrt;cudart")
+set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_NONE   "")
+
+# Clang doesn't support CUDA device LTO
+set(_CMAKE_CUDA_IPO_SUPPORTED_BY_CMAKE NO)
+set(_CMAKE_CUDA_IPO_MAY_BE_SUPPORTED_BY_COMPILER NO)
+
+if(UNIX)
+  list(APPEND CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "rt" "pthread" "dl")
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CXX-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CXX-FeatureTests.cmake
@ -0,0 +1,33 @@
+
+# Reference: http://clang.llvm.org/cxx_status.html
+# http://clang.llvm.org/docs/LanguageExtensions.html
+
+set(_cmake_oldestSupported "((__clang_major__ * 100) + __clang_minor__) >= 301")
+
+include("${CMAKE_CURRENT_LIST_DIR}/Clang-CXX-TestableFeatures.cmake")
+
+set(Clang34_CXX14 "((__clang_major__ * 100) + __clang_minor__) >= 304 && __cplusplus > 201103L")
+# http://llvm.org/bugs/show_bug.cgi?id=19242
+set(_cmake_feature_test_cxx_attribute_deprecated "${Clang34_CXX14}")
+# http://llvm.org/bugs/show_bug.cgi?id=19698
+set(_cmake_feature_test_cxx_decltype_auto "${Clang34_CXX14}")
+set(_cmake_feature_test_cxx_digit_separators "${Clang34_CXX14}")
+# http://llvm.org/bugs/show_bug.cgi?id=19674
+set(_cmake_feature_test_cxx_generic_lambdas "${Clang34_CXX14}")
+
+set(Clang31_CXX11 "${_cmake_oldestSupported} && __cplusplus >= 201103L")
+set(_cmake_feature_test_cxx_enum_forward_declarations "${Clang31_CXX11}")
+set(_cmake_feature_test_cxx_sizeof_member "${Clang31_CXX11}")
+# TODO: Should be supported by Clang 2.9
+set(Clang29_CXX11 "${_cmake_oldestSupported} && __cplusplus >= 201103L")
+set(_cmake_feature_test_cxx_extended_friend_declarations "${Clang29_CXX11}")
+set(_cmake_feature_test_cxx_extern_templates "${Clang29_CXX11}")
+set(_cmake_feature_test_cxx_func_identifier "${Clang29_CXX11}")
+set(_cmake_feature_test_cxx_inline_namespaces "${Clang29_CXX11}")
+set(_cmake_feature_test_cxx_long_long_type "${Clang29_CXX11}")
+set(_cmake_feature_test_cxx_right_angle_brackets "${Clang29_CXX11}")
+set(_cmake_feature_test_cxx_variadic_macros "${Clang29_CXX11}")
+
+# TODO: Should be supported forever?
+set(Clang_CXX98 "${_cmake_oldestSupported} && __cplusplus >= 199711L")
+set(_cmake_feature_test_cxx_template_template_parameters "${Clang_CXX98}")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CXX-TestableFeatures.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CXX-TestableFeatures.cmake
@ -0,0 +1,56 @@
+
+set(testable_features
+  cxx_alias_templates
+  cxx_alignas
+  cxx_attributes
+  cxx_auto_type
+  cxx_binary_literals
+  cxx_constexpr
+  cxx_contextual_conversions
+  cxx_decltype
+  cxx_default_function_template_args
+  cxx_defaulted_functions
+  cxx_delegating_constructors
+  cxx_deleted_functions
+  cxx_explicit_conversions
+  cxx_generalized_initializers
+  cxx_inheriting_constructors
+  cxx_lambdas
+  cxx_local_type_template_args
+  cxx_noexcept
+  cxx_nonstatic_member_init
+  cxx_nullptr
+  cxx_range_for
+  cxx_raw_string_literals
+  cxx_reference_qualified_functions
+  cxx_relaxed_constexpr
+  cxx_return_type_deduction
+  cxx_rvalue_references
+  cxx_static_assert
+  cxx_strong_enums
+  cxx_thread_local
+  cxx_unicode_literals
+  cxx_unrestricted_unions
+  cxx_user_literals
+  cxx_variable_templates
+  cxx_variadic_templates
+)
+if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
+  list(APPEND testable_features cxx_decltype_incomplete_return_types)
+endif()
+
+foreach(feature ${testable_features})
+  set(_cmake_feature_test_${feature} "${_cmake_oldestSupported} && __has_feature(${feature})")
+endforeach()
+
+unset(testable_features)
+
+set(_cmake_feature_test_cxx_aggregate_default_initializers "${_cmake_oldestSupported} && __has_feature(cxx_aggregate_nsdmi)")
+
+set(_cmake_feature_test_cxx_trailing_return_types "${_cmake_oldestSupported} && __has_feature(cxx_trailing_return)")
+set(_cmake_feature_test_cxx_alignof "${_cmake_oldestSupported} && __has_feature(cxx_alignas)")
+set(_cmake_feature_test_cxx_final "${_cmake_oldestSupported} && __has_feature(cxx_override_control)")
+set(_cmake_feature_test_cxx_override "${_cmake_oldestSupported} && __has_feature(cxx_override_control)")
+set(_cmake_feature_test_cxx_uniform_initialization "${_cmake_oldestSupported} && __has_feature(cxx_generalized_initializers)")
+set(_cmake_feature_test_cxx_defaulted_move_initializers "${_cmake_oldestSupported} && __has_feature(cxx_defaulted_functions)")
+set(_cmake_feature_test_cxx_lambda_init_captures "${_cmake_oldestSupported} && __has_feature(cxx_init_captures)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-CXX.cmake
@ -0,0 +1,47 @@
+include(Compiler/Clang)
+__compiler_clang(CXX)
+__compiler_clang_cxx_standards(CXX)
+
+if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+      AND CMAKE_DEPFILE_FLAGS_CXX)
+    # dependencies are computed by the compiler itself
+    set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+    set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+  endif()
+
+  set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+  set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+endif()
+
+cmake_policy(GET CMP0025 appleClangPolicy)
+if(APPLE AND NOT appleClangPolicy STREQUAL NEW)
+  return()
+endif()
+
+if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC")
+  set(CMAKE_CXX_CLANG_TIDY_DRIVER_MODE "cl")
+  set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE_DRIVER_MODE "cl")
+  if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+      AND CMAKE_GENERATOR MATCHES "Makefiles"
+      AND CMAKE_DEPFILE_FLAGS_CXX)
+    set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+  endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
+  if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
+    string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
+      "\"${CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS}\""
+      " -format=p1689"
+      " --"
+      " <CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS>"
+      " -x c++ <SOURCE> -c -o <OBJECT>"
+      " -MT <DYNDEP_FILE>"
+      " -MD -MF <DEP_FILE>"
+      " > <DYNDEP_FILE>")
+    set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "clang")
+    set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
+  endif()
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-DetermineCompiler.cmake
@ -0,0 +1,4 @@
+
+set(_compiler_id_pp_test "defined(__clang__)")
+
+include("${CMAKE_CURRENT_LIST_DIR}/Clang-DetermineCompilerInternal.cmake")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-DetermineCompilerInternal.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-DetermineCompilerInternal.cmake
@ -0,0 +1,15 @@
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__clang_major__)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__clang_minor__)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(_MSC_VER / 100)
+#  define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(_MSC_VER % 100)
+# endif")
+
+set(_compiler_id_simulate "
+# if defined(_MSC_VER)
+#  define @PREFIX@SIMULATE_ID \"MSVC\"
+# endif")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-FindBinUtils.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-FindBinUtils.cmake
@ -0,0 +1,59 @@
+if(NOT DEFINED _CMAKE_PROCESSING_LANGUAGE OR _CMAKE_PROCESSING_LANGUAGE STREQUAL "")
+  message(FATAL_ERROR "Internal error: _CMAKE_PROCESSING_LANGUAGE is not set")
+endif()
+
+# Ubuntu:
+# * /usr/bin/llvm-ar-9
+# * /usr/bin/llvm-ranlib-9
+string(REGEX MATCH "^([0-9]+)" __version_x
+    "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}")
+
+# Debian:
+# * /usr/bin/llvm-ar-4.0
+# * /usr/bin/llvm-ranlib-4.0
+string(REGEX MATCH "^([0-9]+\\.[0-9]+)" __version_x_y
+    "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}")
+
+# Try to find tools in the same directory as Clang itself
+get_filename_component(__clang_hint_1 "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER}" REALPATH)
+get_filename_component(__clang_hint_1 "${__clang_hint_1}" DIRECTORY)
+
+get_filename_component(__clang_hint_2 "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER}" DIRECTORY)
+
+set(__clang_hints ${__clang_hint_1} ${__clang_hint_2})
+
+# http://manpages.ubuntu.com/manpages/precise/en/man1/llvm-ar.1.html
+find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR NAMES
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ar-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ar-${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ar${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ar"
+    HINTS ${__clang_hints}
+    NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH
+    DOC "LLVM archiver"
+)
+mark_as_advanced(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR)
+
+# http://manpages.ubuntu.com/manpages/precise/en/man1/llvm-ranlib.1.html
+find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB NAMES
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ranlib-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ranlib-${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ranlib${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}llvm-ranlib"
+    HINTS ${__clang_hints}
+    NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH
+    DOC "Generate index for LLVM archive"
+)
+mark_as_advanced(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB)
+
+# clang-scan-deps
+find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_CLANG_SCAN_DEPS NAMES
+    "${_CMAKE_TOOLCHAIN_PREFIX}clang-scan-deps-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}clang-scan-deps-${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}clang-scan-deps${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}clang-scan-deps"
+    HINTS ${__clang_hints}
+    NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH
+    DOC "`clang-scan-deps` dependency scanner"
+)
+mark_as_advanced(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_CLANG_SCAN_DEPS)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-HIP.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-HIP.cmake
@ -0,0 +1,21 @@
+include(Compiler/Clang)
+
+__compiler_clang(HIP)
+__compiler_clang_cxx_standards(HIP)
+
+set(_CMAKE_COMPILE_AS_HIP_FLAG "-x hip")
+set(_CMAKE_HIP_RDC_FLAG "-fgpu-rdc")
+
+if(NOT "x${CMAKE_HIP_SIMULATE_ID}" STREQUAL "xMSVC")
+  set(CMAKE_HIP_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+
+  string(APPEND CMAKE_HIP_FLAGS_DEBUG_INIT " -O")
+endif()
+
+set(CMAKE_HIP_RUNTIME_LIBRARY_DEFAULT "SHARED")
+set(CMAKE_HIP_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC  "")
+set(CMAKE_HIP_RUNTIME_LIBRARY_LINK_OPTIONS_SHARED  "")
+
+# Populated by CMakeHIPInformation.cmake
+set(CMAKE_HIP_RUNTIME_LIBRARIES_STATIC "")
+set(CMAKE_HIP_RUNTIME_LIBRARIES_SHARED "")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-OBJC.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-OBJC.cmake
@ -0,0 +1,39 @@
+include(Compiler/Clang)
+__compiler_clang(OBJC)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_OBJC)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJC_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJC_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+
+if(NOT CMAKE_OBJC_COMPILER_VERSION VERSION_LESS 3.4)
+  set(CMAKE_OBJC90_STANDARD_COMPILE_OPTION "-std=c90")
+  set(CMAKE_OBJC90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+  set(CMAKE_OBJC90_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_OBJC99_STANDARD_COMPILE_OPTION "-std=c99")
+  set(CMAKE_OBJC99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+  set(CMAKE_OBJC99_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_OBJC11_STANDARD_COMPILE_OPTION "-std=c11")
+  set(CMAKE_OBJC11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+  set(CMAKE_OBJC11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if(NOT CMAKE_OBJC_COMPILER_VERSION VERSION_LESS 6.0)
+  set(CMAKE_OBJC17_STANDARD_COMPILE_OPTION "-std=c17")
+  set(CMAKE_OBJC17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+  set(CMAKE_OBJC17_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if(NOT CMAKE_OBJC_COMPILER_VERSION VERSION_LESS 9.0)
+  set(CMAKE_OBJC23_STANDARD_COMPILE_OPTION "-std=c2x")
+  set(CMAKE_OBJC23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
+  set(CMAKE_OBJC23_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+__compiler_check_default_language_standard(OBJC 3.4 99 3.6 11)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-OBJCXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang-OBJCXX.cmake
@ -0,0 +1,11 @@
+include(Compiler/Clang)
+__compiler_clang(OBJCXX)
+__compiler_clang_cxx_standards(OBJCXX)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_OBJCXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJCXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJCXX_DEPENDS_USE_COMPILER TRUE)
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Clang.cmake
@ -0,0 +1,275 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_CLANG)
+  return()
+endif()
+set(__COMPILER_CLANG 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+set(__pch_header_C "c-header")
+set(__pch_header_CXX "c++-header")
+set(__pch_header_OBJC "objective-c-header")
+set(__pch_header_OBJCXX "objective-c++-header")
+
+if("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC"
+    OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC"
+    OR "x${CMAKE_Fortran_SIMULATE_ID}" STREQUAL "xMSVC")
+  macro(__compiler_clang lang)
+  endmacro()
+else()
+  include(Compiler/GNU)
+
+  macro(__compiler_clang lang)
+    __compiler_gnu(${lang})
+    set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE")
+    # Link options for PIE are already set in 'Compiler/GNU.cmake'
+    # but clang may require alternate syntax on some platforms
+    if (APPLE)
+      set(CMAKE_${lang}_LINK_OPTIONS_PIE ${CMAKE_${lang}_COMPILE_OPTIONS_PIE} -Xlinker -pie)
+      set(CMAKE_${lang}_LINK_OPTIONS_NO_PIE -Xlinker -no_pie)
+    endif()
+    set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ")
+    set(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY "-fvisibility=")
+    if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.4.0)
+      set(CMAKE_${lang}_COMPILE_OPTIONS_TARGET "-target ")
+      set(CMAKE_${lang}_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN "-gcc-toolchain ")
+    else()
+      set(CMAKE_${lang}_COMPILE_OPTIONS_TARGET "--target=")
+      set(CMAKE_${lang}_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN "--gcc-toolchain=")
+    endif()
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Xlinker" " ")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP)
+
+    if(CMAKE_${lang}_COMPILER_TARGET AND "${lang}" STREQUAL "CXX")
+      if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.4.0)
+        list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "-target" "${CMAKE_${lang}_COMPILER_TARGET}")
+      else()
+        list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "--target=${CMAKE_${lang}_COMPILER_TARGET}")
+      endif()
+    endif()
+
+    set(_CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE YES)
+    set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES)
+
+    string(COMPARE EQUAL "${CMAKE_${lang}_COMPILER_ID}" "AppleClang" __is_apple_clang)
+    string(COMPARE EQUAL "${CMAKE_${lang}_COMPILER_ID}" "FujitsuClang" __is_fujitsu_clang)
+
+    # '-flto=thin' available since Clang 3.9 and Xcode 8
+    # * http://clang.llvm.org/docs/ThinLTO.html#clang-llvm
+    # * https://trac.macports.org/wiki/XcodeVersionInfo
+    set(_CMAKE_LTO_THIN TRUE)
+    if(__is_apple_clang)
+      if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 8.0)
+        set(_CMAKE_LTO_THIN FALSE)
+      endif()
+    elseif(__is_fujitsu_clang)
+      set(_CMAKE_LTO_THIN FALSE)
+    else()
+      if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.9)
+        set(_CMAKE_LTO_THIN FALSE)
+      endif()
+    endif()
+
+    if(_CMAKE_LTO_THIN)
+      set(CMAKE_${lang}_COMPILE_OPTIONS_IPO "-flto=thin")
+    else()
+      set(CMAKE_${lang}_COMPILE_OPTIONS_IPO "-flto")
+    endif()
+
+    if(ANDROID AND NOT CMAKE_ANDROID_NDK_VERSION VERSION_GREATER_EQUAL "22")
+      # https://github.com/android-ndk/ndk/issues/242
+      set(CMAKE_${lang}_LINK_OPTIONS_IPO "-fuse-ld=gold")
+    endif()
+
+    if(ANDROID OR __is_apple_clang)
+      set(__ar "${CMAKE_AR}")
+      set(__ranlib "${CMAKE_RANLIB}")
+    else()
+      set(__ar "${CMAKE_${lang}_COMPILER_AR}")
+      set(__ranlib "${CMAKE_${lang}_COMPILER_RANLIB}")
+    endif()
+
+    set(CMAKE_${lang}_ARCHIVE_CREATE_IPO
+      "\"${__ar}\" cr <TARGET> <LINK_FLAGS> <OBJECTS>"
+    )
+
+    set(CMAKE_${lang}_ARCHIVE_APPEND_IPO
+      "\"${__ar}\" r <TARGET> <LINK_FLAGS> <OBJECTS>"
+    )
+
+    set(CMAKE_${lang}_ARCHIVE_FINISH_IPO
+      "\"${__ranlib}\" <TARGET>"
+    )
+
+    set(CMAKE_PCH_EXTENSION .pch)
+    if (NOT CMAKE_GENERATOR MATCHES "Xcode")
+      set(CMAKE_PCH_PROLOGUE "#pragma clang system_header")
+    endif()
+    if(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0.0 AND NOT __is_apple_clang)
+      set(CMAKE_${lang}_COMPILE_OPTIONS_INSTANTIATE_TEMPLATES_PCH -fpch-instantiate-templates)
+    endif()
+    set(CMAKE_${lang}_COMPILE_OPTIONS_USE_PCH -Xclang -include-pch -Xclang <PCH_FILE> -Xclang -include -Xclang <PCH_HEADER>)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_CREATE_PCH -Xclang -emit-pch -Xclang -include -Xclang <PCH_HEADER> -x ${__pch_header_${lang}})
+
+    # '-fcolor-diagnostics' introduced since Clang 2.6
+    if(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 2.6)
+      set(CMAKE_${lang}_COMPILE_OPTIONS_COLOR_DIAGNOSTICS "-fcolor-diagnostics")
+      set(CMAKE_${lang}_COMPILE_OPTIONS_COLOR_DIAGNOSTICS_OFF "-fno-color-diagnostics")
+    endif()
+  endmacro()
+endif()
+
+macro(__compiler_clang_cxx_standards lang)
+  if("x${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 2.1)
+      set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "-std=c++98")
+      set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+    endif()
+
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.1)
+      set(CMAKE_${lang}98_STANDARD__HAS_FULL_SUPPORT ON)
+      set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "-std=c++11")
+      set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+      set(CMAKE_${lang}11_STANDARD__HAS_FULL_SUPPORT ON)
+    elseif(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 2.1)
+      set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "-std=c++0x")
+      set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "-std=gnu++0x")
+    endif()
+
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.5)
+      set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std=c++14")
+      set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+      set(CMAKE_${lang}14_STANDARD__HAS_FULL_SUPPORT ON)
+    elseif(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.4)
+      set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std=c++1y")
+      set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+      set(CMAKE_${lang}14_STANDARD__HAS_FULL_SUPPORT ON)
+    endif()
+
+    set(_clang_version_std17 5.0)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Android")
+      set(_clang_version_std17 6.0)
+    endif()
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std=c++17")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+    elseif (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.5)
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std=c++1z")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
+    endif()
+
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 11.0)
+      set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std=c++20")
+      set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
+    elseif(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
+      set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std=c++2a")
+      set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
+    endif()
+
+    unset(_clang_version_std17)
+
+    set(_clang_version_std23 17.0)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Android")
+      set(_clang_version_std23 18.0)
+    endif()
+
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS "${_clang_version_std23}")
+      set(CMAKE_${lang}23_STANDARD_COMPILE_OPTION "-std=c++23")
+      set(CMAKE_${lang}23_EXTENSION_COMPILE_OPTION "-std=gnu++23")
+      set(CMAKE_${lang}26_STANDARD_COMPILE_OPTION "-std=c++26")
+      set(CMAKE_${lang}26_EXTENSION_COMPILE_OPTION "-std=gnu++26")
+    elseif(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 12.0)
+      set(CMAKE_${lang}23_STANDARD_COMPILE_OPTION "-std=c++2b")
+      set(CMAKE_${lang}23_EXTENSION_COMPILE_OPTION "-std=gnu++2b")
+    endif()
+
+    unset(_clang_version_std23)
+
+    if("x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC")
+      # The MSVC standard library requires C++14, and MSVC itself has no
+      # notion of operating in a mode not aware of at least that standard.
+      set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "-std=c++14")
+      set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+      set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "-std=c++14")
+      set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+
+      # This clang++ is missing some features because of MSVC compatibility.
+      unset(CMAKE_${lang}11_STANDARD__HAS_FULL_SUPPORT)
+      unset(CMAKE_${lang}14_STANDARD__HAS_FULL_SUPPORT)
+    endif()
+
+    __compiler_check_default_language_standard(${lang} 2.1 98)
+  elseif(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 3.9
+      AND CMAKE_${lang}_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.0)
+    # This version of clang-cl and the MSVC version it simulates have
+    # support for -std: flags.
+    set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}98_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std:c++14")
+    set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std:c++14")
+
+    if(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std:c++17")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std:c++17")
+    else()
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std:c++latest")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std:c++latest")
+    endif()
+
+    if(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 13.0)
+      set(CMAKE_${lang}23_STANDARD_COMPILE_OPTION "-std:c++latest")
+      set(CMAKE_${lang}23_EXTENSION_COMPILE_OPTION "-std:c++latest")
+      set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std:c++20")
+      set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std:c++20")
+    elseif(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
+      set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std:c++latest")
+      set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std:c++latest")
+    endif()
+
+    __compiler_check_default_language_standard(${lang} 3.9 14)
+  else()
+    # This version of clang-cl, or the MSVC version it simulates, does not have
+    # language standards.  Set these options as empty strings so the feature
+    # test infrastructure can at least check to see if they are defined.
+    set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}23_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}23_EXTENSION_COMPILE_OPTION "")
+
+    # There is no meaningful default for this
+    set(CMAKE_${lang}_STANDARD_DEFAULT "")
+
+    # There are no compiler modes so we only need to test features once.
+    # Override the default macro for this special case.  Pretend that
+    # all language standards are available so that at least compilation
+    # can be attempted.
+    macro(cmake_record_${lang}_compile_features)
+      list(APPEND CMAKE_${lang}_COMPILE_FEATURES
+        cxx_std_98
+        cxx_std_11
+        cxx_std_14
+        cxx_std_17
+        cxx_std_20
+        cxx_std_23
+        cxx_std_26
+        )
+      _record_compiler_features(${lang} "" CMAKE_${lang}_COMPILE_FEATURES)
+    endmacro()
+  endif()
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake
@ -0,0 +1,7 @@
+
+set(_compiler_id_pp_test "defined(__COMO__)")
+
+set(_compiler_id_version_compute "
+  /* __COMO_VERSION__ = VRR */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__COMO_VERSION__ / 100)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__COMO_VERSION__ % 100)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Compaq-C-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Compaq-C-DetermineCompiler.cmake
@ -0,0 +1,8 @@
+
+set(_compiler_id_pp_test "defined(__DECC)")
+
+set(_compiler_id_version_compute "
+  /* __DECC_VER = VVRRTPPPP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__DECC_VER/10000000)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__DECC_VER/100000  % 100)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__DECC_VER         % 10000)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake
@ -0,0 +1,8 @@
+
+set(_compiler_id_pp_test "defined(__DECCXX)")
+
+set(_compiler_id_version_compute "
+  /* __DECCXX_VER = VVRRTPPPP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__DECCXX_VER/10000000)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__DECCXX_VER/100000  % 100)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__DECCXX_VER         % 10000)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-C.cmake
@ -0,0 +1,24 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+__compiler_cray(C)
+
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION  -h noc99,conform)
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION -h noc99,gnu)
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION  -h c99,conform)
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION -h c99,gnu)
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+  if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.5)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION  -h std=c11,conform)
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION -h std=c11,gnu)
+    set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+  endif ()
+endif ()
+
+__compiler_check_default_language_standard(C 8.1 99)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-CXX.cmake
@ -0,0 +1,26 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+__compiler_cray(CXX)
+
+string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION  -h conform)
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -h gnu)
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.4)
+    set(CMAKE_CXX11_STANDARD_COMPILE_OPTION  -h std=c++11)
+    set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -h std=c++11,gnu)
+    set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+  endif()
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.6)
+    set(CMAKE_CXX14_STANDARD_COMPILE_OPTION  -h std=c++14)
+    set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION -h std=c++14,gnu)
+    set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+  endif ()
+endif ()
+
+__compiler_check_default_language_standard(CXX 8.1 98)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-DetermineCompiler.cmake
@ -0,0 +1,6 @@
+
+set(_compiler_id_pp_test "defined(_CRAYC)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(_RELEASE_MAJOR)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(_RELEASE_MINOR)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray-Fortran.cmake
@ -0,0 +1,25 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+__compiler_cray(Fortran)
+
+set(CMAKE_Fortran_SUBMODULE_SEP "")
+set(CMAKE_Fortran_SUBMODULE_EXT ".mod")
+set(CMAKE_Fortran_MODOUT_FLAG -em)
+set(CMAKE_Fortran_MODDIR_FLAG -J)
+set(CMAKE_Fortran_MODDIR_DEFAULT .)
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-f fixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-f free")
+
+if (NOT CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 8.5)
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-eT")
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-dT")
+else()
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-eZ")
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-dZ")
+endif()
+
+if (NOT CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 11.0)
+  set(CMAKE_Fortran_PREPROCESS_SOURCE "<CMAKE_Fortran_COMPILER> -o <PREPROCESSED_SOURCE> <DEFINES> <INCLUDES> <FLAGS> -eP <SOURCE>")
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Cray.cmake
@ -0,0 +1,17 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_CRAY)
+  return()
+endif()
+set(__COMPILER_CRAY 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+macro(__compiler_cray lang)
+  set(CMAKE_${lang}_VERBOSE_FLAG "-v")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_PIC -h PIC)
+  set(CMAKE_${lang}_COMPILE_OPTIONS_PIE -h PIC)
+  set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "-h PIC")
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv-C.cmake
@ -0,0 +1,7 @@
+if(__craylinux_crayprgenv_c)
+  return()
+endif()
+set(__craylinux_crayprgenv_c 1)
+
+include(Compiler/CrayPrgEnv)
+__CrayPrgEnv_setup(C)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv-CXX.cmake
@ -0,0 +1,7 @@
+if(__craylinux_crayprgenv_cxx)
+  return()
+endif()
+set(__craylinux_crayprgenv_cxx 1)
+
+include(Compiler/CrayPrgEnv)
+__CrayPrgEnv_setup(CXX)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv-Fortran.cmake
@ -0,0 +1,7 @@
+if(__craylinux_crayprgenv_fortran)
+  return()
+endif()
+set(__craylinux_crayprgenv_fortran 1)
+
+include(Compiler/CrayPrgEnv)
+__CrayPrgEnv_setup(Fortran)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/CrayPrgEnv.cmake
@ -0,0 +1,136 @@
+# Guard against multiple inclusions
+if(__cmake_craype_crayprgenv)
+  return()
+endif()
+set(__cmake_craype_crayprgenv 1)
+
+# CrayPrgEnv: loaded when compiling through the Cray compiler wrapper.
+# The compiler wrapper can run on a front-end node or a compute node.
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0057 NEW)  # if IN_LIST
+
+# One-time setup of the craype environment.  First, check the wrapper config.
+# The wrapper's selection of a compiler (gcc, clang, intel, etc.) and
+# default include/library paths is selected using the "module" command.
+# The CRAYPE_LINK_TYPE environment variable partly controls if static
+# or dynamic binaries are generated (see __cmake_craype_linktype below).
+# Running cmake and then changing module and/or linktype configuration
+# may cause build problems (since the data in the cmake cache may no
+# longer be correct after the change).  We can look for this and warn
+# the user about it.  Second, use the "module" provided PKG_CONFIG_PATH-like
+# environment variable to add additional prefixes to the system prefix
+# path.
+function(__cmake_craype_setupenv)
+  if(NOT DEFINED __cmake_craype_setupenv_done)  # only done once per run
+    set(__cmake_craype_setupenv_done 1 PARENT_SCOPE)
+    unset(__cmake_check)
+    set(CMAKE_CRAYPE_LINKTYPE "$ENV{CRAYPE_LINK_TYPE}" CACHE STRING
+        "saved value of CRAYPE_LINK_TYPE environment variable")
+    set(CMAKE_CRAYPE_LOADEDMODULES "$ENV{LOADEDMODULES}" CACHE STRING
+        "saved value of LOADEDMODULES environment variable")
+    mark_as_advanced(CMAKE_CRAYPE_LINKTYPE CMAKE_CRAYPE_LOADEDMODULES)
+    if (NOT "${CMAKE_CRAYPE_LINKTYPE}" STREQUAL "$ENV{CRAYPE_LINK_TYPE}")
+      string(APPEND __cmake_check "CRAYPE_LINK_TYPE ")
+    endif()
+    if (NOT "${CMAKE_CRAYPE_LOADEDMODULES}" STREQUAL "$ENV{LOADEDMODULES}")
+      string(APPEND __cmake_check "LOADEDMODULES ")
+    endif()
+    if(DEFINED __cmake_check)
+      message(STATUS "NOTE: ${__cmake_check}changed since initial config!")
+      message(STATUS "NOTE: this may cause unexpected build errors.")
+    endif()
+    # loop over variables of interest
+    foreach(pkgcfgvar PKG_CONFIG_PATH PKG_CONFIG_PATH_DEFAULT
+            PE_PKG_CONFIG_PATH)
+      file(TO_CMAKE_PATH "$ENV{${pkgcfgvar}}" pkgcfg)
+      foreach(path ${pkgcfg})
+        string(REGEX REPLACE "(.*)/lib[^/]*/pkgconfig$" "\\1" path "${path}")
+        if(NOT "${path}" STREQUAL "" AND
+           NOT "${path}" IN_LIST CMAKE_SYSTEM_PREFIX_PATH)
+          list(APPEND CMAKE_SYSTEM_PREFIX_PATH "${path}")
+        endif()
+      endforeach()
+    endforeach()
+    # push it up out of this function into the parent scope
+    set(CMAKE_SYSTEM_PREFIX_PATH "${CMAKE_SYSTEM_PREFIX_PATH}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+# The wrapper disables dynamic linking by default.  Dynamic linking is
+# enabled either by setting $ENV{CRAYPE_LINK_TYPE} to "dynamic" or by
+# specifying "-dynamic" to the wrapper when linking.  Specifying "-static"
+# to the wrapper when linking takes priority over $ENV{CRAYPE_LINK_TYPE}.
+# Furthermore, if you specify multiple "-dynamic" and "-static" flags to
+# the wrapper when linking, the last one will win.  In this case, the
+# wrapper will also print a warning like:
+#  Warning: -dynamic was already seen on command line, overriding with -static.
+#
+# note that cmake applies both CMAKE_${lang}_FLAGS and CMAKE_EXE_LINKER_FLAGS
+# (in that order) to the linking command, so -dynamic can appear in either
+# variable.
+#
+# Note: As of CrayPE v19.06 (which translates to the craype/2.6.0 module)
+# the default has changed and is now dynamic by default.  This is handled
+# accordingly
+function(__cmake_craype_linktype lang rv)
+  # start with ENV, but allow flags to override
+  if(("$ENV{CRAYPE_VERSION}" STREQUAL "") OR
+     ("$ENV{CRAYPE_VERSION}" VERSION_LESS "2.6"))
+    if("$ENV{CRAYPE_LINK_TYPE}" STREQUAL "dynamic")
+      set(linktype dynamic)
+    else()
+      set(linktype static)
+    endif()
+  else()
+    if("$ENV{CRAYPE_LINK_TYPE}" STREQUAL "static")
+      set(linktype static)
+    else()
+      set(linktype dynamic)
+    endif()
+  endif()
+
+  # combine flags and convert to a list so we can apply the flags in order
+  set(linkflags "${CMAKE_${lang}_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}")
+  string(REPLACE " " ";" linkflags "${linkflags}")
+  foreach(flag IN LISTS linkflags)
+    if("${flag}" STREQUAL "-dynamic")
+      set(linktype dynamic)
+    elseif("${flag}" STREQUAL "-static")
+      set(linktype static)
+    endif()
+  endforeach()
+  set(${rv} ${linktype} PARENT_SCOPE)
+endfunction()
+
+macro(__CrayPrgEnv_setup lang)
+  if(DEFINED ENV{CRAYPE_VERSION})
+    message(STATUS "Cray Programming Environment $ENV{CRAYPE_VERSION} ${lang}")
+  elseif(DEFINED ENV{ASYNCPE_VERSION})
+    message(STATUS "Cray XT Programming Environment $ENV{ASYNCPE_VERSION} ${lang}")
+  else()
+    message(STATUS "Cray Programming Environment (unknown version) ${lang}")
+  endif()
+
+  # setup the craype environment
+  __cmake_craype_setupenv()
+
+  # Flags for the Cray wrappers
+  set(CMAKE_STATIC_LIBRARY_LINK_${lang}_FLAGS "-static")
+  set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared")
+  set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS "-dynamic")
+
+  # determine linktype from environment and compiler flags
+  __cmake_craype_linktype(${lang} __cmake_craype_${lang}_linktype)
+
+  # switch off shared libs if we get a static linktype
+  if("${__cmake_craype_${lang}_linktype}" STREQUAL "static")
+    set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS FALSE)
+    set(BUILD_SHARED_LIBS FALSE CACHE BOOL "")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
+    set(CMAKE_LINK_SEARCH_START_STATIC TRUE)
+  endif()
+
+endmacro()
+
+cmake_policy(POP)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Embarcadero-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Embarcadero-DetermineCompiler.cmake
@ -0,0 +1,7 @@
+
+set(_compiler_id_pp_test "defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_HEX@(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_HEX@(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__CODEGEARC_VERSION__     & 0xFFFF)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Flang-FindBinUtils.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Flang-FindBinUtils.cmake
@ -0,0 +1 @@
+include(Compiler/Clang-FindBinUtils)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Flang-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Flang-Fortran.cmake
@ -0,0 +1,16 @@
+include(Compiler/Clang)
+__compiler_clang(Fortran)
+
+set(CMAKE_Fortran_SUBMODULE_SEP "-")
+set(CMAKE_Fortran_SUBMODULE_EXT ".mod")
+
+set(CMAKE_Fortran_PREPROCESS_SOURCE
+    "<CMAKE_Fortran_COMPILER> -cpp <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed-form")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree-form")
+
+set(CMAKE_Fortran_MODDIR_FLAG "-J")
+
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-nocpp")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-C.cmake
@ -0,0 +1,20 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+include(Compiler/Fujitsu)
+__compiler_fujitsu(C)
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 4)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION  -std=c89)
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION -std=gnu89)
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION  -std=c99)
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION -std=gnu99)
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C11_STANDARD_COMPILE_OPTION  -std=c11)
+  set(CMAKE_C11_EXTENSION_COMPILE_OPTION -std=gnu11)
+  set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+__compiler_check_default_language_standard(C 4 11)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-CXX.cmake
@ -0,0 +1,47 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+include(Compiler/Fujitsu)
+__compiler_fujitsu(CXX)
+
+#set(CMAKE_PCH_EXTENSION .pch)
+#set(CMAKE_PCH_EPILOGUE "#pragma hdrstop")
+#set(CMAKE_CXX_COMPILE_OPTIONS_USE_PCH --no_pch_messages -include <PCH_HEADER> --use_pch <PCH_FILE>)
+#set(CMAKE_CXX_COMPILE_OPTIONS_CREATE_PCH --no_pch_messages -include <PCH_HEADER> --create_pch <PCH_FILE>)
+
+# The Fujitsu compiler offers both a 98 and 03 mode.  These two are
+# essentially interchangeable as 03 simply provides clarity to some 98
+# ambiguyity.
+#
+# Re: Stroustrup's C++ FAQ:
+#   What is the difference between C++98 and C++03?
+#     From a programmer's view there is none. The C++03 revision of the
+#     standard was a bug fix release for implementers to ensure greater
+#     consistency and portability. In particular, tutorial and reference
+#     material describing C++98 and C++03 can be used interchangeably by all
+#     except compiler writers and standards gurus.
+#
+# Since CMake doesn't actually have an 03 mode and they're effectively
+# interchangeable then we're just going to explicitly use 03 mode in the
+# compiler when 98 is requested.
+
+# The version matching is messy here.  The std support seems to be related to
+# the compiler tweak version derived from the patch id in the version string.
+
+if(CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 4)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION  -std=c++03)
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -std=gnu++03)
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION  -std=c++11)
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -std=gnu++11)
+  set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION  -std=c++14)
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION -std=gnu++14)
+  set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION  -std=c++17)
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION -std=gnu++17)
+endif()
+
+__compiler_check_default_language_standard(CXX 4 14)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-DetermineCompiler.cmake
@ -0,0 +1,17 @@
+
+set(_compiler_id_pp_test "defined(__FUJITSU)")
+
+set(_compiler_id_version_compute "
+# if defined(__FCC_version__)
+#   define @PREFIX@COMPILER_VERSION __FCC_version__
+# elif defined(__FCC_major__)
+#   define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__FCC_major__)
+#   define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__FCC_minor__)
+#   define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__FCC_patchlevel__)
+# endif
+# if defined(__fcc_version)
+#   define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__fcc_version)
+# elif defined(__FCC_VERSION)
+#   define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__FCC_VERSION)
+# endif
+")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu-Fortran.cmake
@ -0,0 +1,16 @@
+include(Compiler/Fujitsu)
+__compiler_fujitsu(Fortran)
+
+set(CMAKE_Fortran_SUBMODULE_SEP ".")
+set(CMAKE_Fortran_SUBMODULE_EXT ".smod")
+
+set(CMAKE_Fortran_PREPROCESS_SOURCE
+  "<CMAKE_Fortran_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -Cpp -P <SOURCE> -o <PREPROCESSED_SOURCE>")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-Cpp")
+
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-Fixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-Free")
+
+string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT "")
+
+set(CMAKE_Fortran_MODDIR_FLAG "-M ")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/Fujitsu.cmake
@ -0,0 +1,44 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_FUJITSU)
+  return()
+endif()
+set(__COMPILER_FUJITSU 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+macro(__compiler_fujitsu lang)
+  set(CMAKE_${lang}_VERBOSE_FLAG "-###")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-cwno")
+
+  # Initial configuration flags
+  string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+  string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g -O0")
+  string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3 -DNDEBUG")
+  string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
+
+  # PIC flags
+  set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "-fPIC")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE")
+
+  # Passing link options to the compiler
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Wl,")
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",")
+
+  # IPO flag
+  set(_CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE YES)
+  if ("${lang}" STREQUAL "Fortran")
+    # Supported by Fortran compiler only
+    set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_IPO "-Klto")
+  else()
+    set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER NO)
+  endif()
+
+  # How to actually call the compiler
+  set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE
+  "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E $<$<COMPILE_LANGUAGE:Fortran>:-Cpp> <SOURCE> > <PREPROCESSED_SOURCE>")
+  set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-C.cmake
@ -0,0 +1,6 @@
+include(Compiler/FujitsuClang)
+
+set(_fjclang_ver "${CMAKE_C_COMPILER_VERSION_INTERNAL}")
+set(CMAKE_C_COMPILER_VERSION "${CMAKE_C_COMPILER_VERSION_INTERNAL}")
+include(Compiler/Clang-C)
+set(CMAKE_C_COMPILER_VERSION "${_fjclang_ver}")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-CXX.cmake
@ -0,0 +1,6 @@
+include(Compiler/FujitsuClang)
+
+set(_fjclang_ver "${CMAKE_CXX_COMPILER_VERSION_INTERNAL}")
+set(CMAKE_CXX_COMPILER_VERSION "${CMAKE_CXX_COMPILER_VERSION_INTERNAL}")
+include(Compiler/Clang-CXX)
+set(CMAKE_CXX_COMPILER_VERSION "${_fjclang_ver}")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake
@ -0,0 +1,9 @@
+
+set(_compiler_id_pp_test "defined(__CLANG_FUJITSU)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__FCC_major__)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__FCC_minor__)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__FCC_patchlevel__)
+# define @PREFIX@COMPILER_VERSION_INTERNAL_STR __clang_version__
+")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-FindBinUtils.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang-FindBinUtils.cmake
@ -0,0 +1,6 @@
+if(NOT DEFINED _CMAKE_PROCESSING_LANGUAGE OR _CMAKE_PROCESSING_LANGUAGE STREQUAL "")
+  message(FATAL_ERROR "Internal error: _CMAKE_PROCESSING_LANGUAGE is not set")
+endif()
+
+set(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR ar)
+set(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB ranlib)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/FujitsuClang.cmake
@ -0,0 +1,11 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_FUJITSUCLANG)
+  return()
+endif()
+set(__COMPILER_FUJITSUCLANG 1)
+
+include(Compiler/Clang)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/G95-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/G95-Fortran.cmake
@ -0,0 +1,13 @@
+string(APPEND CMAKE_Fortran_FLAGS_INIT " ")
+string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT " -g")
+string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " -Os")
+string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3")
+string(APPEND CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+set(CMAKE_Fortran_MODDIR_FLAG "-fmod=")
+set(CMAKE_Fortran_VERBOSE_FLAG "-v")
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed-form")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree-form")
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-Wl,")
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG_SEP ",")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-no-cpp")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS-C.cmake
@ -0,0 +1,10 @@
+include(Compiler/GHS)
+
+set(CMAKE_C_VERBOSE_FLAG "-v")
+set(CMAKE_C_OUTPUT_EXTENSION ".o")
+
+string(APPEND CMAKE_C_FLAGS_INIT " ")
+string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " -Odebug -g")
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -Ospace")
+string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -O")
+string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO_INIT " -O -g")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS-CXX.cmake
@ -0,0 +1,10 @@
+include(Compiler/GHS)
+
+set(CMAKE_CXX_VERBOSE_FLAG "-v")
+set(CMAKE_CXX_OUTPUT_EXTENSION ".o")
+
+string(APPEND CMAKE_CXX_FLAGS_INIT " ")
+string(APPEND CMAKE_CXX_FLAGS_DEBUG_INIT " -Odebug -g")
+string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -Ospace")
+string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -O")
+string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT " -O -g")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS-DetermineCompiler.cmake
@ -0,0 +1,9 @@
+set(_compiler_id_pp_test "defined(__ghs__)")
+
+set(_compiler_id_version_compute "
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__GHS_VERSION_NUMBER / 100)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__GHS_VERSION_NUMBER / 10 % 10)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__GHS_VERSION_NUMBER      % 10)
+# endif")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GHS.cmake
@ -0,0 +1,8 @@
+if(__COMPILER_GHS)
+  return()
+endif()
+set(__COMPILER_GHS 1)
+
+set(CMAKE_EXECUTABLE_SUFFIX "")
+set(CMAKE_LIBRARY_PATH_TERMINATOR "")
+set(CMAKE_LIBRARY_PATH_FLAG "")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-ASM.cmake
@ -0,0 +1,13 @@
+# This file is loaded when gcc/g++ is used for assembler files (the "ASM" cmake language)
+include(Compiler/GNU)
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S;asm)
+
+__compiler_gnu(ASM)
+
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_MATCH STREQUAL "GNU assembler")
+  set(CMAKE_DEPFILE_FLAGS_ASM${ASM_DIALECT} "--MD <DEP_FILE>")
+  set(CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE
+    "<CMAKE_LINKER> <FLAGS> <CMAKE_ASM${ASM_DIALECT}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
+  set(CMAKE_ASM_DEFINE_FLAG "--defsym ")
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-C-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-C-DetermineCompiler.cmake
@ -0,0 +1,11 @@
+
+set(_compiler_id_pp_test "defined(__GNUC__)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__GNUC__)
+# if defined(__GNUC_MINOR__)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__GNUC_PATCHLEVEL__)
+# endif")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-C-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-C-FeatureTests.cmake
@ -0,0 +1,17 @@
+
+set(_cmake_oldestSupported "(__GNUC__ * 100 + __GNUC_MINOR__) >= 304")
+
+# GNU 4.7 correctly sets __STDC_VERSION__ to 201112L, but GNU 4.6 sets it
+# to 201000L.  As the former is strictly greater than the latter, test only
+# for the latter.  If in the future CMake learns about a C feature which was
+# introduced with GNU 4.7, that should test for the correct version, similar
+# to the distinction between __cplusplus and __GXX_EXPERIMENTAL_CXX0X__ tests.
+set(GNU46_C11 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201000L")
+set(_cmake_feature_test_c_static_assert "${GNU46_C11}")
+# Since 3.4 at least:
+set(GNU34_C99 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 304 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L")
+set(_cmake_feature_test_c_restrict "${GNU34_C99}")
+set(_cmake_feature_test_c_variadic_macros "${GNU34_C99}")
+
+set(GNU_C90 "${_cmake_oldestSupported}")
+set(_cmake_feature_test_c_function_prototypes "${GNU_C90}")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-C.cmake
@ -0,0 +1,49 @@
+include(Compiler/GNU)
+__compiler_gnu(C)
+
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_C)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_C_DEPFILE_FORMAT gcc)
+  set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c)
+
+if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.5)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+elseif (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c89")
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu89")
+endif()
+
+if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4)
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.7)
+  set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
+  set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+  set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+elseif (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.6)
+  set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c1x")
+  set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu1x")
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+  set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17")
+  set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 9.1)
+  set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x")
+  set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
+endif()
+
+__compiler_check_default_language_standard(C 3.4 90 5.0 11 8.1 17)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake
@ -0,0 +1,15 @@
+
+set(_compiler_id_pp_test "defined(__GNUC__) || defined(__GNUG__)")
+
+set(_compiler_id_version_compute "
+# if defined(__GNUC__)
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__GNUC__)
+# else
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__GNUC_PATCHLEVEL__)
+# endif")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX-FeatureTests.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX-FeatureTests.cmake
@ -0,0 +1,109 @@
+
+# Reference: http://gcc.gnu.org/projects/cxx0x.html
+# http://gcc.gnu.org/projects/cxx1y.html
+
+set(_cmake_oldestSupported "(__GNUC__ * 100 + __GNUC_MINOR__) >= 404")
+
+set(GNU50_CXX14 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 500 && __cplusplus >= 201402L")
+set(_cmake_feature_test_cxx_variable_templates "${GNU50_CXX14}")
+set(_cmake_feature_test_cxx_relaxed_constexpr "${GNU50_CXX14}")
+set(_cmake_feature_test_cxx_aggregate_default_initializers "${GNU50_CXX14}")
+
+# GNU 4.9 in c++14 mode sets __cplusplus to 201300L, so don't test for the
+# correct value of it below.
+# https://patchwork.ozlabs.org/patch/382470/
+set(GNU49_CXX14 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L")
+set(_cmake_feature_test_cxx_contextual_conversions "${GNU49_CXX14}")
+set(_cmake_feature_test_cxx_attribute_deprecated "${GNU49_CXX14}")
+set(_cmake_feature_test_cxx_decltype_auto "${GNU49_CXX14}")
+set(_cmake_feature_test_cxx_digit_separators "${GNU49_CXX14}")
+set(_cmake_feature_test_cxx_generic_lambdas "${GNU49_CXX14}")
+# GNU 4.3 supports binary literals as an extension, but may warn about
+# use of extensions prior to GNU 4.9
+# http://stackoverflow.com/questions/16334024/difference-between-gcc-binary-literals-and-c14-ones
+set(_cmake_feature_test_cxx_binary_literals "${GNU49_CXX14}")
+# The features below are documented as available in GNU 4.8 (by implementing an
+# earlier draft of the standard paper), but that version of the compiler
+# does not set __cplusplus to a value greater than 201103L until GNU 4.9:
+# http://gcc.gnu.org/onlinedocs/gcc-4.8.2/cpp/Standard-Predefined-Macros.html#Standard-Predefined-Macros
+# http://gcc.gnu.org/onlinedocs/gcc-4.9.0/cpp/Standard-Predefined-Macros.html#Standard-Predefined-Macros
+# So, CMake only reports availability for it with GNU 4.9 or later.
+set(_cmake_feature_test_cxx_return_type_deduction "${GNU49_CXX14}")
+set(_cmake_feature_test_cxx_lambda_init_captures "${GNU49_CXX14}")
+
+# Introduced in GCC 4.8.1
+set(GNU481_CXX11 "((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40801) && __cplusplus >= 201103L")
+set(_cmake_feature_test_cxx_decltype_incomplete_return_types "${GNU481_CXX11}")
+set(_cmake_feature_test_cxx_reference_qualified_functions "${GNU481_CXX11}")
+set(GNU48_CXX11 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L")
+set(_cmake_feature_test_cxx_alignas "${GNU48_CXX11}")
+# The alignof feature works with GNU 4.7 and -std=c++11, but it is documented
+# as available with GNU 4.8, so treat that as true.
+set(_cmake_feature_test_cxx_alignof "${GNU48_CXX11}")
+set(_cmake_feature_test_cxx_attributes "${GNU48_CXX11}")
+set(_cmake_feature_test_cxx_inheriting_constructors "${GNU48_CXX11}")
+set(_cmake_feature_test_cxx_thread_local "${GNU48_CXX11}")
+set(GNU47_CXX11 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L")
+set(_cmake_feature_test_cxx_alias_templates "${GNU47_CXX11}")
+set(_cmake_feature_test_cxx_delegating_constructors "${GNU47_CXX11}")
+set(_cmake_feature_test_cxx_extended_friend_declarations "${GNU47_CXX11}")
+set(_cmake_feature_test_cxx_final "${GNU47_CXX11}")
+set(_cmake_feature_test_cxx_nonstatic_member_init "${GNU47_CXX11}")
+set(_cmake_feature_test_cxx_override "${GNU47_CXX11}")
+set(_cmake_feature_test_cxx_user_literals "${GNU47_CXX11}")
+# NOTE: C++11 was ratified in September 2011. GNU 4.7 is the first minor
+# release following that (March 2012), and the first minor release to
+# support -std=c++11. Prior to that, support for C++11 features is technically
+# experiemental and possibly incomplete (see for example the note below about
+# cxx_variadic_template_template_parameters)
+# GNU does not define __cplusplus correctly before version 4.7.
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=1773
+# __GXX_EXPERIMENTAL_CXX0X__ is defined in prior versions, but may not be
+# defined in the future.
+set(GNU_CXX0X_DEFINED "(__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__))")
+set(GNU46_CXX11 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && ${GNU_CXX0X_DEFINED}")
+set(_cmake_feature_test_cxx_constexpr "${GNU46_CXX11}")
+set(_cmake_feature_test_cxx_defaulted_move_initializers "${GNU46_CXX11}")
+set(_cmake_feature_test_cxx_enum_forward_declarations "${GNU46_CXX11}")
+set(_cmake_feature_test_cxx_noexcept "${GNU46_CXX11}")
+set(_cmake_feature_test_cxx_nullptr "${GNU46_CXX11}")
+set(_cmake_feature_test_cxx_range_for "${GNU46_CXX11}")
+set(_cmake_feature_test_cxx_unrestricted_unions "${GNU46_CXX11}")
+set(GNU45_CXX11 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && ${GNU_CXX0X_DEFINED}")
+set(_cmake_feature_test_cxx_explicit_conversions "${GNU45_CXX11}")
+set(_cmake_feature_test_cxx_lambdas "${GNU45_CXX11}")
+set(_cmake_feature_test_cxx_local_type_template_args "${GNU45_CXX11}")
+set(_cmake_feature_test_cxx_raw_string_literals "${GNU45_CXX11}")
+set(GNU44_CXX11 "(__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && ${GNU_CXX0X_DEFINED}")
+set(_cmake_feature_test_cxx_auto_type "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_defaulted_functions "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_deleted_functions "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_generalized_initializers "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_inline_namespaces "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_sizeof_member "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_strong_enums "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_trailing_return_types "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_unicode_literals "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_uniform_initialization "${GNU44_CXX11}")
+set(_cmake_feature_test_cxx_variadic_templates "${GNU44_CXX11}")
+# TODO: If features are ever recorded for GNU 4.3, there should possibly
+# be a new feature added like cxx_variadic_template_template_parameters,
+# which is implemented by GNU 4.4, but not 4.3. cxx_variadic_templates is
+# actually implemented by GNU 4.3, but variadic template template parameters
+# 'completes' it, so that is the version we record as having the variadic
+# templates capability in CMake. See
+# http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
+# TODO: Should be supported by GNU 4.3
+set(GNU43_CXX11 "${_cmake_oldestSupported} && ${GNU_CXX0X_DEFINED}")
+set(_cmake_feature_test_cxx_decltype "${GNU43_CXX11}")
+set(_cmake_feature_test_cxx_default_function_template_args "${GNU43_CXX11}")
+set(_cmake_feature_test_cxx_long_long_type "${GNU43_CXX11}")
+set(_cmake_feature_test_cxx_right_angle_brackets "${GNU43_CXX11}")
+set(_cmake_feature_test_cxx_rvalue_references "${GNU43_CXX11}")
+set(_cmake_feature_test_cxx_static_assert "${GNU43_CXX11}")
+# TODO: Should be supported since GNU 3.4?
+set(_cmake_feature_test_cxx_extern_templates "${_cmake_oldestSupported} && ${GNU_CXX0X_DEFINED}")
+# TODO: Should be supported forever?
+set(_cmake_feature_test_cxx_func_identifier "${_cmake_oldestSupported} && ${GNU_CXX0X_DEFINED}")
+set(_cmake_feature_test_cxx_variadic_macros "${_cmake_oldestSupported} && ${GNU_CXX0X_DEFINED}")
+set(_cmake_feature_test_cxx_template_template_parameters "${_cmake_oldestSupported} && __cplusplus")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX.cmake
@ -0,0 +1,74 @@
+include(Compiler/GNU)
+__compiler_gnu(CXX)
+
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_CXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
+
+if (WIN32)
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
+    set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fno-keep-inline-dllexport")
+  endif()
+else()
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0)
+    set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+  endif()
+endif()
+
+if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98")
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4)
+  # 4.3 supports 0x variants
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++0x")
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++0x")
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8.1)
+  set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+  set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
+endif()
+
+if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11.1)
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
+  set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std=c++23")
+  set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std=gnu++23")
+elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0)
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
+endif()
+
+__compiler_check_default_language_standard(CXX 3.4 98 6.0 14 11.1 17)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-FindBinUtils.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-FindBinUtils.cmake
@ -0,0 +1,39 @@
+if(NOT DEFINED _CMAKE_PROCESSING_LANGUAGE OR _CMAKE_PROCESSING_LANGUAGE STREQUAL "")
+  message(FATAL_ERROR "Internal error: _CMAKE_PROCESSING_LANGUAGE is not set")
+endif()
+
+# Ubuntu 16.04:
+# * /usr/bin/gcc-ar-5
+# * /usr/bin/gcc-ranlib-5
+string(REGEX MATCH "^([0-9]+)" __version_x
+    "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}")
+
+string(REGEX MATCH "^([0-9]+\\.[0-9]+)" __version_x_y
+    "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}")
+
+# Try to find tools in the same directory as GCC itself
+get_filename_component(__gcc_hints "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER}" DIRECTORY)
+
+# http://manpages.ubuntu.com/manpages/wily/en/man1/gcc-ar.1.html
+find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR NAMES
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar${_CMAKE_COMPILER_SUFFIX}"
+    HINTS ${__gcc_hints}
+    NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH
+    DOC "A wrapper around 'ar' adding the appropriate '--plugin' option for the GCC compiler"
+)
+mark_as_advanced(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR)
+
+# http://manpages.ubuntu.com/manpages/wily/en/man1/gcc-ranlib.1.html
+find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB NAMES
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib${_CMAKE_COMPILER_SUFFIX}"
+    HINTS ${__gcc_hints}
+    NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH
+    DOC "A wrapper around 'ranlib' adding the appropriate '--plugin' option for the GCC compiler"
+)
+mark_as_advanced(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-Fortran.cmake
@ -0,0 +1,28 @@
+include(Compiler/GNU)
+__compiler_gnu(Fortran)
+
+set(CMAKE_Fortran_SUBMODULE_SEP "@")
+set(CMAKE_Fortran_SUBMODULE_EXT ".smod")
+
+set(CMAKE_Fortran_PREPROCESS_SOURCE
+  "<CMAKE_Fortran_COMPILER> -cpp <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> -o <PREPROCESSED_SOURCE>")
+
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed-form")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree-form")
+
+if (NOT CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 4.4)
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+  set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-nocpp")
+endif()
+
+set(CMAKE_Fortran_POSTPROCESS_FLAG "-fpreprocessed")
+
+# No -DNDEBUG for Fortran.
+string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " -Os")
+string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3")
+
+# No -isystem for Fortran because it will not find .mod files.
+unset(CMAKE_INCLUDE_SYSTEM_FLAG_Fortran)
+
+# Fortran-specific feature flags.
+set(CMAKE_Fortran_MODDIR_FLAG -J)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-OBJC.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-OBJC.cmake
@ -0,0 +1,11 @@
+include(Compiler/GNU)
+__compiler_gnu(OBJC)
+
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_OBJC)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJC_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJC_DEPENDS_USE_COMPILER TRUE)
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-OBJCXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU-OBJCXX.cmake
@ -0,0 +1,19 @@
+include(Compiler/GNU)
+__compiler_gnu(OBJCXX)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_OBJCXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_OBJCXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_OBJCXX_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+
+if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 4.2)
+  set(CMAKE_OBJCXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
+endif()
+
+if(NOT CMAKE_OBJCXX_LINK_FLAGS)
+  set(CMAKE_OBCXX_LINK_FLAGS "-lstdc++")
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/GNU.cmake
@ -0,0 +1,196 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_GNU)
+  return()
+endif()
+set(__COMPILER_GNU 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+set(__pch_header_C "c-header")
+set(__pch_header_CXX "c++-header")
+set(__pch_header_OBJC "objective-c-header")
+set(__pch_header_OBJCXX "objective-c++-header")
+
+macro(__compiler_gnu lang)
+  # Feature flags.
+  set(CMAKE_${lang}_VERBOSE_FLAG "-v")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_WARNING_AS_ERROR "-Werror")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "-fPIC")
+  set (_CMAKE_${lang}_PIE_MAY_BE_SUPPORTED_BY_LINKER NO)
+  if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.4)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE")
+    # Support of PIE at link stage depends on various elements : platform, compiler, linker
+    # so to activate it, module CheckPIESupported must be used.
+    set (_CMAKE_${lang}_PIE_MAY_BE_SUPPORTED_BY_LINKER YES)
+    set(CMAKE_${lang}_LINK_OPTIONS_PIE ${CMAKE_${lang}_COMPILE_OPTIONS_PIE} "-pie")
+    set(CMAKE_${lang}_LINK_OPTIONS_NO_PIE "-no-pie")
+  endif()
+  if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4.0)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY "-fvisibility=")
+  endif()
+  set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "-fPIC")
+  set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_SYSROOT "--sysroot=")
+
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Wl,")
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",")
+
+  # Older versions of gcc (< 4.5) contain a bug causing them to report a missing
+  # header file as a warning if depfiles are enabled, causing check_header_file
+  # tests to always succeed.  Work around this by disabling dependency tracking
+  # in try_compile mode.
+  get_property(_IN_TC GLOBAL PROPERTY IN_TRY_COMPILE)
+  if(CMAKE_${lang}_COMPILER_ID STREQUAL "GNU" AND _IN_TC AND NOT CMAKE_FORCE_DEPFILES)
+  else()
+    # distcc does not transform -o to -MT when invoking the preprocessor
+    # internally, as it ought to.  Work around this bug by setting -MT here
+    # even though it isn't strictly necessary.
+    set(CMAKE_DEPFILE_FLAGS_${lang} "-MD -MT <DEP_TARGET> -MF <DEP_FILE>")
+  endif()
+
+  # define flags for linker depfile generation
+  set(CMAKE_${lang}_LINKER_DEPFILE_FLAGS "LINKER:--dependency-file,<DEP_FILE>")
+  set(CMAKE_${lang}_LINKER_DEPFILE_FORMAT gcc)
+
+  if(NOT DEFINED CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED)
+    ## Ensure ninja tool is recent enough...
+    if(CMAKE_GENERATOR MATCHES "^Ninja")
+      # Ninja 1.10 or upper is required
+      execute_process(COMMAND "${CMAKE_MAKE_PROGRAM}" --version
+        OUTPUT_VARIABLE _ninja_version
+        ERROR_VARIABLE _ninja_version)
+      if (_ninja_version MATCHES "[0-9]+(\\.[0-9]+)*")
+        set (_ninja_version "${CMAKE_MATCH_0}")
+      endif()
+      if (_ninja_version VERSION_LESS "1.10")
+        set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED FALSE)
+      endif()
+      unset(_ninja_version)
+    endif()
+
+    if (NOT DEFINED CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED)
+      ## check if this feature is supported by the linker
+      execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -Wl,--help
+        OUTPUT_VARIABLE _linker_capabilities
+        ERROR_VARIABLE _linker_capabilities)
+      if(_linker_capabilities MATCHES "--dependency-file")
+        set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED TRUE)
+      else()
+        set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED FALSE)
+      endif()
+      unset(_linker_capabilities)
+    endif()
+  endif()
+  if (CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED)
+    set(CMAKE_${lang}_LINK_DEPENDS_USE_LINKER TRUE)
+  else()
+    unset(CMAKE_${lang}_LINK_DEPENDS_USE_LINKER)
+  endif()
+
+  # For now, due to GNU binutils ld bug when LTO is enabled (see GNU bug
+    # `30568 <https://sourceware.org/bugzilla/show_bug.cgi?id=30568>`_),
+  # deactivate this feature.
+  if (NOT DEFINED CMAKE_LINK_DEPENDS_USE_LINKER)
+    set(CMAKE_LINK_DEPENDS_USE_LINKER FALSE)
+  endif()
+
+  # Initial configuration flags.
+  string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+  string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g")
+  string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Os -DNDEBUG")
+  string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3 -DNDEBUG")
+  string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
+  set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+  set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+  if(NOT APPLE OR NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4) # work around #4462
+    set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ")
+  endif()
+
+  set(_CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE YES)
+  set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER NO)
+
+  # '-flto' introduced since GCC 4.5:
+  # * https://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/Option-Summary.html (no)
+  # * https://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc/Option-Summary.html (yes)
+  if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4.5)
+    set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES)
+
+    set(__lto_flags "")
+
+    # '-flto=auto' introduced since GCC 10.1:
+    # * https://gcc.gnu.org/onlinedocs/gcc-9.5.0/gcc/Optimize-Options.html#Optimize-Options (no)
+    # * https://gcc.gnu.org/onlinedocs/gcc-10.1.0/gcc/Optimize-Options.html#Optimize-Options (yes)
+    # Since GCC 12.1, the abundance of a parameter produces a warning if compiling multiple targets.
+    # FIXME: What version of GCC for Windows added support for -flto=auto?  10.3 does not have it.
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 11.0)
+      list(APPEND __lto_flags -flto=auto)
+    elseif(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 10.1)
+      if (CMAKE_HOST_WIN32)
+        list(APPEND __lto_flags -flto=1)
+      else()
+        list(APPEND __lto_flags -flto=auto)
+      endif()
+    else()
+      list(APPEND __lto_flags -flto)
+    endif()
+
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4.7)
+      # '-ffat-lto-objects' introduced since GCC 4.7:
+      # * https://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/Option-Summary.html (no)
+      # * https://gcc.gnu.org/onlinedocs/gcc-4.7.4/gcc/Option-Summary.html (yes)
+      list(APPEND __lto_flags -fno-fat-lto-objects)
+    endif()
+
+    set(CMAKE_${lang}_COMPILE_OPTIONS_IPO ${__lto_flags})
+
+    # Need to use version of 'ar'/'ranlib' with plugin support.
+    # Quote from [documentation][1]:
+    #
+    #   To create static libraries suitable for LTO,
+    #   use gcc-ar and gcc-ranlib instead of ar and ranlib
+    #
+    # [1]: https://gcc.gnu.org/onlinedocs/gcc-4.9.4/gcc/Optimize-Options.html
+    set(CMAKE_${lang}_ARCHIVE_CREATE_IPO
+      "\"${CMAKE_${lang}_COMPILER_AR}\" cr <TARGET> <LINK_FLAGS> <OBJECTS>"
+    )
+
+    set(CMAKE_${lang}_ARCHIVE_APPEND_IPO
+      "\"${CMAKE_${lang}_COMPILER_AR}\" r <TARGET> <LINK_FLAGS> <OBJECTS>"
+    )
+
+    set(CMAKE_${lang}_ARCHIVE_FINISH_IPO
+      "\"${CMAKE_${lang}_COMPILER_RANLIB}\" <TARGET>"
+    )
+  endif()
+
+  if("${lang}" STREQUAL "CXX")
+    set(CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "${CMAKE_${lang}_COMPILER}")
+    if(CMAKE_${lang}_COMPILER_ARG1)
+      separate_arguments(_COMPILER_ARGS NATIVE_COMMAND "${CMAKE_${lang}_COMPILER_ARG1}")
+      list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND ${_COMPILER_ARGS})
+      unset(_COMPILER_ARGS)
+    endif()
+    list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "-dM" "-E" "-c" "${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp")
+  endif()
+
+  if(NOT "x${lang}" STREQUAL "xFortran")
+    set(CMAKE_PCH_EXTENSION .gch)
+    if (NOT CMAKE_GENERATOR MATCHES "Xcode")
+      set(CMAKE_PCH_PROLOGUE "#pragma GCC system_header")
+    endif()
+    set(CMAKE_${lang}_COMPILE_OPTIONS_INVALID_PCH -Winvalid-pch)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_USE_PCH -include <PCH_HEADER>)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_CREATE_PCH -x ${__pch_header_${lang}} -include <PCH_HEADER>)
+  endif()
+
+  # '-fdiagnostics-color=always' introduced since GCC 4.9
+  # https://gcc.gnu.org/gcc-4.9/changes.html
+  if(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 4.9)
+    set(CMAKE_${lang}_COMPILE_OPTIONS_COLOR_DIAGNOSTICS "-fdiagnostics-color=always")
+    set(CMAKE_${lang}_COMPILE_OPTIONS_COLOR_DIAGNOSTICS_OFF "-fno-diagnostics-color")
+  endif()
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-ASM.cmake
@ -0,0 +1,3 @@
+set(CMAKE_ASM_VERBOSE_FLAG "-v")
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s )
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-C-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-C-DetermineCompiler.cmake
@ -0,0 +1,8 @@
+
+set(_compiler_id_pp_test "defined(__HP_cc)")
+
+set(_compiler_id_version_compute "
+  /* __HP_cc = VVRRPP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__HP_cc/10000)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__HP_cc/100 % 100)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__HP_cc     % 100)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-C.cmake
@ -0,0 +1,7 @@
+set(CMAKE_C_VERBOSE_FLAG "-v")
+
+set(CMAKE_C_CREATE_ASSEMBLY_SOURCE "<CMAKE_C_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+set(CMAKE_C_CREATE_PREPROCESSED_SOURCE "<CMAKE_C_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+
+set(CMAKE_C_LINKER_WRAPPER_FLAG "-Wl,")
+set(CMAKE_C_LINKER_WRAPPER_FLAG_SEP ",")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-CXX-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-CXX-DetermineCompiler.cmake
@ -0,0 +1,8 @@
+
+set(_compiler_id_pp_test "defined(__HP_aCC)")
+
+set(_compiler_id_version_compute "
+  /* __HP_aCC = VVRRPP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__HP_aCC/10000)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__HP_aCC/100 % 100)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__HP_aCC     % 100)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-CXX.cmake
@ -0,0 +1,16 @@
+set(CMAKE_CXX_VERBOSE_FLAG "-v")
+
+set(CMAKE_CXX_CREATE_ASSEMBLY_SOURCE "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+set(CMAKE_CXX_CREATE_PREPROCESSED_SOURCE "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+
+set(CMAKE_CXX_LINKER_WRAPPER_FLAG "-Wl,")
+set(CMAKE_CXX_LINKER_WRAPPER_FLAG_SEP ",")
+
+# HP aCC since version 3.80 supports the flag +hpxstd98 to get ANSI C++98
+# template support. It is known that version 6.25 doesn't need that flag.
+# Current assumption: the flag is needed for every version from 3.80 to 4
+# to get it working.
+if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4 AND
+   NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.80)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "+hpxstd98")
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-Fortran.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/HP-Fortran.cmake
@ -0,0 +1,12 @@
+set(CMAKE_Fortran_VERBOSE_FLAG "-v")
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "+source=fixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "+source=free")
+
+set(CMAKE_Fortran_CREATE_ASSEMBLY_SOURCE "<CMAKE_Fortran_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+set(CMAKE_Fortran_CREATE_PREPROCESSED_SOURCE "<CMAKE_Fortran_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-Wl,")
+set(CMAKE_Fortran_LINKER_WRAPPER_FLAG ",")
+
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "+cpp=yes")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "+cpp=no")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-ASM.cmake
@ -0,0 +1,79 @@
+# This file is processed when the IAR Assembler is used
+
+include(Compiler/IAR)
+
+# Architecture specific
+if("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
+  __compiler_iar_ilink(ASM)
+  __assembler_iar_deps("-y" 9.30)
+  set(_CMAKE_IAR_SILENCER_FLAG " -S")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;asm;msa;S)
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "RX")
+  __compiler_iar_ilink(ASM)
+  __assembler_iar_deps("--dependencies=ns" 2.50.1)
+  set(_CMAKE_IAR_SILENCER_FLAG " --silent")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;asm;msa;S)
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "RH850")
+  __compiler_iar_ilink(ASM)
+  __assembler_iar_deps("--dependencies=ns" 2)
+  set(_CMAKE_IAR_SILENCER_FLAG " --silent")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;asm;msa;S)
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "RL78")
+  __compiler_iar_ilink(ASM)
+  __assembler_iar_deps("--dependencies=ns" 2)
+  set(_CMAKE_IAR_SILENCER_FLAG " --silent")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;asm;msa;S)
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" MATCHES "(RISCV|RISC-V)")
+  __compiler_iar_ilink(ASM)
+  __assembler_iar_deps("--dependencies=ns" 1)
+  set(_CMAKE_IAR_SILENCER_FLAG " --silent")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;asm;msa;S)
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
+  __compiler_iar_xlink(ASM)
+  __assembler_iar_deps("-y" 8)
+  set(_CMAKE_IAR_SILENCER_FLAG " -S")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s90;asm;msa)
+  set(CMAKE_ASM_OUTPUT_EXTENSION ".r90")
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "MSP430")
+  __compiler_iar_xlink(ASM)
+  __assembler_iar_deps("-y" 8)
+  set(_CMAKE_IAR_SILENCER_FLAG " -S")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s43;asm;msa)
+  set(CMAKE_ASM_OUTPUT_EXTENSION ".r43")
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "V850")
+  __compiler_iar_xlink(ASM)
+  set(_CMAKE_IAR_SILENCER_FLAG " -S")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s85;asm;msa)
+  set(CMAKE_ASM_OUTPUT_EXTENSION ".r85")
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "8051")
+  __compiler_iar_xlink(ASM)
+  set(_CMAKE_IAR_SILENCER_FLAG " -S")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s51;asm;msa)
+  set(CMAKE_ASM_OUTPUT_EXTENSION ".r51")
+
+elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "STM8")
+  __compiler_iar_ilink(ASM)
+  __assembler_iar_deps("--dependencies=ns" 2)
+  set(_CMAKE_IAR_SILENCER_FLAG " --silent")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;asm;msa;S)
+
+else()
+  message(FATAL_ERROR "CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID not detected. This should be automatic." )
+endif()
+
+string(APPEND CMAKE_ASM_FLAGS_DEBUG_INIT " -r")
+string(APPEND CMAKE_ASM_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_ASM_FLAGS_RELEASE_INIT " -DNDEBUG")
+string(APPEND CMAKE_ASM_FLAGS_RELWITHDEBINFO_INIT " -r -DNDEBUG")
+
+set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> ${_CMAKE_IAR_SILENCER_FLAG} <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT>")
+
+unset(_CMAKE_IAR_SILENCER_FLAG)
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-C.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-C.cmake
@ -0,0 +1,86 @@
+# This file is processed when the IAR C Compiler is used
+#
+# C Language Specification support
+#  - Newer versions of the IAR C Compiler require the --c89 flag to build a file under the C90 standard.
+#  - Earlier versions of the compiler had C90 by default, not requiring the backward-compatibility flag.
+#
+# The IAR Language Extensions
+#  - The IAR Language Extensions can be enabled by -e flag
+#
+include(Compiler/IAR)
+include(Compiler/CMakeCommonCompilerMacros)
+
+if(NOT DEFINED CMAKE_C_COMPILER_VERSION)
+  message(FATAL_ERROR "CMAKE_C_COMPILER_VERSION not detected.  This should be automatic.")
+endif()
+
+# Unused after CMP0128
+set(CMAKE_C_EXTENSION_COMPILE_OPTION -e)
+
+if(CMAKE_C_COMPILER_VERSION_INTERNAL VERSION_GREATER 7)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION --c89)
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION --c89 -e)
+else()
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION "")
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION -e)
+endif()
+
+set(CMAKE_C${CMAKE_C_STANDARD_COMPUTED_DEFAULT}_STANDARD_COMPILE_OPTION "")
+set(CMAKE_C${CMAKE_C_STANDARD_COMPUTED_DEFAULT}_EXTENSION_COMPILE_OPTION -e)
+
+# Architecture specific
+if("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
+  if (CMAKE_C_COMPILER_VERSION VERSION_LESS 5)
+    # IAR C Compiler for Arm prior version 5.xx uses XLINK. Support in CMake is not implemented.
+    message(FATAL_ERROR "IAR C Compiler for Arm version ${CMAKE_C_COMPILER_VERSION} not supported by CMake.")
+  endif()
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 5.10 90 6.10 99 8.10 11 8.40 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RX")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 1.10 90 2.10 99 4.10 11 4.20 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RH850")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 1.10 90 1.10 99 2.10 11 2.21 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RL78")
+  if(CMAKE_C_COMPILER_VERSION VERSION_LESS 2)
+    # IAR C Compiler for RL78 prior version 2.xx uses XLINK. Support in CMake is not implemented.
+    message(FATAL_ERROR "IAR C Compiler for RL78 version ${CMAKE_C_COMPILER_VERSION} not supported by CMake.")
+  endif()
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 2.10 90 2.10 99 4.10 11 4.20 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "RISCV")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 1.10 90 1.10 99 1.10 11 1.21 17)
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 7.10 99 8.10 17)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r90")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "MSP430")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 1.10 90 5.10 99)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r43")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "V850")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 1.10 90 4.10 99)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r85")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "8051")
+  __compiler_iar_xlink(C)
+  __compiler_check_default_language_standard(C 6.10 90 8.10 99)
+  set(CMAKE_C_OUTPUT_EXTENSION ".r51")
+
+elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "STM8")
+  __compiler_iar_ilink(C)
+  __compiler_check_default_language_standard(C 3.11 90 3.11 99)
+
+else()
+  message(FATAL_ERROR "CMAKE_C_COMPILER_ARCHITECTURE_ID not detected. This should be automatic.")
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-CXX.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-CXX.cmake
@ -0,0 +1,95 @@
+# This file is processed when the IAR C++ Compiler is used
+#
+# C++ Language Specification support
+#  - Newer versions of the IAR C++ Compiler require the --c++ flag to build a C++ file.
+#    Earlier versions for non-ARM architectures provided Embedded C++, enabled with the --eec++ flag.
+#
+# The IAR Language Extensions
+#  - The IAR Language Extensions can be enabled by -e flag
+#
+include(Compiler/IAR)
+include(Compiler/CMakeCommonCompilerMacros)
+
+if(NOT DEFINED CMAKE_CXX_COMPILER_VERSION)
+  message(FATAL_ERROR "CMAKE_CXX_COMPILER_VERSION not detected. This should be automatic.")
+endif()
+
+# Whenever needed, override this default behavior using CMAKE_IAR_CXX_FLAG in your toolchain file.
+if(NOT CMAKE_IAR_CXX_FLAG)
+  cmake_policy(PUSH)
+  cmake_policy(SET CMP0057 NEW) # if IN_LIST
+
+  set(_CMAKE_IAR_MODERNCXX_LIST 14 17)
+  if(${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT} IN_LIST _CMAKE_IAR_MODERNCXX_LIST OR
+     ("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM" AND ${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT} EQUAL 98))
+    set(CMAKE_IAR_CXX_FLAG --c++)
+  else()
+    set(CMAKE_IAR_CXX_FLAG --eec++)
+  endif()
+  unset(_CMAKE_IAR_MODERNCXX_LIST)
+
+  cmake_policy(POP)
+endif()
+
+set(CMAKE_CXX_STANDARD_COMPILE_OPTION "")
+set(CMAKE_CXX_EXTENSION_COMPILE_OPTION -e) # Unused after CMP0128
+
+set(CMAKE_CXX${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT}_STANDARD_COMPILE_OPTION "")
+set(CMAKE_CXX${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT}_EXTENSION_COMPILE_OPTION -e)
+
+# Architecture specific
+if("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
+    # IAR C++ Compiler for Arm prior version 5.xx uses XLINK. Support in CMake is not implemented.
+    message(FATAL_ERROR "IAR C++ Compiler for Arm version ${CMAKE_CXX_COMPILER_VERSION} not supported by CMake.")
+  endif()
+  __compiler_iar_ilink(CXX)
+  __compiler_check_default_language_standard(CXX 5.10 98 8.10 14 8.40 17)
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "RX")
+  __compiler_iar_ilink(CXX)
+  __compiler_check_default_language_standard(CXX 2.10 98 4.10 14 4.20 17)
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "RH850")
+  __compiler_iar_ilink(CXX)
+  __compiler_check_default_language_standard(CXX 1.10 98 2.10 14 2.21 17)
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "RL78")
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 2)
+    # # IAR C++ Compiler for RL78 prior version 2.xx uses XLINK. Support in CMake is not implemented.
+    message(FATAL_ERROR "IAR C++ Compiler for RL78 version ${CMAKE_CXX_COMPILER_VERSION} not supported by CMake.")
+  endif()
+  __compiler_iar_ilink(CXX)
+  __compiler_check_default_language_standard(CXX 2.10 98 4.10 14 4.20 17)
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "RISCV")
+  __compiler_iar_ilink(CXX)
+  __compiler_check_default_language_standard(CXX 1.10 98 1.10 14 1.21 17)
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
+  __compiler_iar_xlink(CXX)
+  __compiler_check_default_language_standard(CXX 7.10 98 8.10 17)
+  set(CMAKE_CXX_OUTPUT_EXTENSION ".r90")
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "MSP430")
+  __compiler_iar_xlink(CXX)
+  __compiler_check_default_language_standard(CXX 5.10 98)
+  set(CMAKE_CXX_OUTPUT_EXTENSION ".r43")
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "V850")
+  __compiler_iar_xlink(CXX)
+  __compiler_check_default_language_standard(CXX 1.10 98)
+  set(CMAKE_CXX_OUTPUT_EXTENSION ".r85")
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "8051")
+  __compiler_iar_xlink(CXX)
+  __compiler_check_default_language_standard(CXX 6.10 98)
+  set(CMAKE_CXX_OUTPUT_EXTENSION ".r51")
+
+elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "STM8")
+  __compiler_iar_ilink(CXX)
+  __compiler_check_default_language_standard(CXX 3.11 98)
+
+else()
+  message(FATAL_ERROR "CMAKE_CXX_COMPILER_ARCHITECTURE_ID not detected. This should be automatic." )
+endif()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-DetermineCompiler.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR-DetermineCompiler.cmake
@ -0,0 +1,37 @@
+# IAR C/C++ Compiler (https://www.iar.com)
+# CPU <arch> supported in CMake: 8051, Arm, AVR, MSP430, RH850, RISC-V, RL78, RX and V850
+#
+# IAR C/C++ Compiler for <arch> internal integer symbols used in CMake:
+#
+# __IAR_SYSTEMS_ICC__
+#           Provides the compiler internal platform version
+# __ICC<arch>__
+#           Provides 1 for the current <arch> in use
+# __VER__
+#           Provides the current version in use
+#            The semantic version of the compiler is architecture-dependent
+#            When <arch> is ARM:
+#               CMAKE_<LANG>_COMPILER_VERSION_MAJOR = (__VER__ / 1E6)
+#               CMAKE_<LANG>_COMPILER_VERSION_MINOR = (__VER__ / 1E3) % 1E3
+#               CMAKE_<LANG>_COMPILER_VERSION_PATCH = (__VER__ % 1E3)
+#            When <arch> is non-ARM:
+#               CMAKE_<LANG>_COMPILER_VERSION_MAJOR = (__VER__ / 1E2)
+#               CMAKE_<LANG>_COMPILER_VERSION_MINOR = (__VER__ - ((__VER__/ 1E2) * 1E2))
+#               CMAKE_<LANG>_COMPILER_VERSION_PATCH = (__SUBVERSION__)
+# __SUBVERSION__
+#           Provides the version's patch level for non-ARM <arch>
+#
+set(_compiler_id_pp_test "defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)")
+
+set(_compiler_id_version_compute "
+# if defined(__VER__) && defined(__ICCARM__)
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@((__VER__) / 1000000)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(((__VER__) / 1000) % 1000)
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@((__VER__) % 1000)
+#  define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
+#  define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@((__VER__) / 100)
+#  define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@((__VER__) - (((__VER__) / 100)*100))
+#  define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__SUBVERSION__)
+#  define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__IAR_SYSTEMS_ICC__)
+# endif")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IAR.cmake
@ -0,0 +1,66 @@
+# This file is processed when the IAR C/C++ Compiler is used
+#
+# CPU <arch> supported in CMake: 8051, Arm, AVR, MSP430, RH850, RISC-V, RL78, RX, STM8 and V850
+#
+# The compiler user documentation is architecture-dependent
+# and it can found with the product installation under <arch>/doc/{EW,BX}<arch>_DevelopmentGuide.ENU.pdf
+#
+#
+include_guard()
+
+macro(__compiler_iar_common lang)
+  if ("x${lang}" MATCHES "^x(C|CXX)$")
+    set(CMAKE_${lang}_COMPILE_OBJECT             "<CMAKE_${lang}_COMPILER> ${CMAKE_IAR_${lang}_FLAG} --silent <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT>")
+    set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> ${CMAKE_IAR_${lang}_FLAG} --silent <SOURCE> <DEFINES> <INCLUDES> <FLAGS> --preprocess=cnl <PREPROCESSED_SOURCE>")
+    set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE     "<CMAKE_${lang}_COMPILER> ${CMAKE_IAR_${lang}_FLAG} --silent <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -lAH <ASSEMBLY_SOURCE> -o <OBJECT>.dummy")
+
+    set(CMAKE_DEPFILE_FLAGS_${lang} "--dependencies=ns <DEP_FILE>")
+
+    string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+    string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -r")
+    string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -Oh -DNDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Ohz -DNDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -Oh -r -DNDEBUG")
+  endif()
+
+  set(CMAKE_${lang}_OUTPUT_EXTENSION_REPLACE 1)
+  set(CMAKE_${lang}_RESPONSE_FILE_FLAG "-f ")
+  set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "-f ")
+
+  set(CMAKE_${lang}_ARCHIVE_FINISH "")
+endmacro()
+
+macro(__compiler_iar_ilink lang)
+  set(CMAKE_EXECUTABLE_SUFFIX ".elf")
+  set(CMAKE_${lang}_OUTPUT_EXTENSION ".o")
+
+  __compiler_iar_common(${lang})
+
+  string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " --silent")
+  set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_LINKER> <OBJECTS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> -o <TARGET>")
+
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "<CMAKE_AR> <TARGET> --create <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> <TARGET> --create <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_APPEND "<CMAKE_AR> <TARGET> --replace <LINK_FLAGS> <OBJECTS>")
+endmacro()
+
+macro(__compiler_iar_xlink lang)
+  set(CMAKE_EXECUTABLE_SUFFIX ".bin")
+
+  __compiler_iar_common(${lang})
+
+  string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " -S")
+  set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_LINKER> <OBJECTS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> -o <TARGET>")
+
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "<CMAKE_AR> <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_APPEND "")
+
+  set(CMAKE_LIBRARY_PATH_FLAG "-I")
+endmacro()
+
+macro(__assembler_iar_deps flag min_version)
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL ${min_version})
+    set(CMAKE_DEPFILE_FLAGS_ASM "${flag} <DEP_FILE>")
+  endif()
+endmacro()
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake
@ -0,0 +1,6 @@
+
+set(_compiler_id_version_compute "
+  /* __IBMC__ = VRP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__IBMC__/100)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__IBMC__/10 % 10)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__IBMC__    % 10)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake
@ -0,0 +1,6 @@
+
+set(_compiler_id_version_compute "
+  /* __IBMCPP__ = VRP */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__IBMCPP__/100)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__IBMCPP__/10 % 10)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__IBMCPP__    % 10)")
--- a/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IBMClang-ASM.cmake
+++ b/6.5.3/_tools/cmake/share/cmake-3.27/Modules/Compiler/IBMClang-ASM.cmake
@ -0,0 +1,5 @@
+include(Compiler/IBMClang)
+
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S;asm)
+
+__compiler_ibmclang(ASM)
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`set(_compiler_id_pp_test "defined(__BCC__)")`