Add files using upload-large-folder tool

.gitattributes

@@ -1257,3 +1257,4 @@ evalkit_tf449/lib/python3.10/lib-dynload/_codecs_jp.cpython-310-x86_64-linux-gnu
 infer_4_47_1/lib/python3.10/site-packages/triton/backends/nvidia/bin/ptxas filter=lfs diff=lfs merge=lfs -text
 falcon/bin/x86_64-conda-linux-gnu-ld filter=lfs diff=lfs merge=lfs -text
 falcon/lib/python3.10/tkinter/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+falcon/lib/python3.10/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in

@@ -0,0 +1,32 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+set(PACKAGE_VERSION "@CVF_VERSION@")
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  # Package version must be in the requested version range
+  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+      OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+else()
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+@CVF_ARCH_INDEPENDENT_CHECK@

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/BasicConfigVersion-ExactVersion.cmake.in

@@ -0,0 +1,72 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is equal to the requested version.
+# The tweak version component is ignored.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  message(AUTHOR_WARNING
+    "`find_package()` specify a version range but the version strategy "
+    "(ExactVersion) of the module `${PACKAGE_FIND_NAME}` is incompatible "
+    "with this request. Only the lower endpoint of the range will be used.")
+endif()
+
+set(PACKAGE_VERSION "@CVF_VERSION@")
+
+if("@CVF_VERSION@" MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version
+  set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+  set(CVF_VERSION_MINOR "${CMAKE_MATCH_2}")
+  set(CVF_VERSION_PATCH "${CMAKE_MATCH_3}")
+
+  if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+  endif()
+  if(NOT CVF_VERSION_MINOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_MINOR "${CVF_VERSION_MINOR}")
+  endif()
+  if(NOT CVF_VERSION_PATCH VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_PATCH "${CVF_VERSION_PATCH}")
+  endif()
+
+  set(CVF_VERSION_NO_TWEAK "${CVF_VERSION_MAJOR}.${CVF_VERSION_MINOR}.${CVF_VERSION_PATCH}")
+else()
+  set(CVF_VERSION_NO_TWEAK "@CVF_VERSION@")
+endif()
+
+if(PACKAGE_FIND_VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version
+  set(REQUESTED_VERSION_MAJOR "${CMAKE_MATCH_1}")
+  set(REQUESTED_VERSION_MINOR "${CMAKE_MATCH_2}")
+  set(REQUESTED_VERSION_PATCH "${CMAKE_MATCH_3}")
+
+  if(NOT REQUESTED_VERSION_MAJOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MAJOR "${REQUESTED_VERSION_MAJOR}")
+  endif()
+  if(NOT REQUESTED_VERSION_MINOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MINOR "${REQUESTED_VERSION_MINOR}")
+  endif()
+  if(NOT REQUESTED_VERSION_PATCH VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_PATCH "${REQUESTED_VERSION_PATCH}")
+  endif()
+
+  set(REQUESTED_VERSION_NO_TWEAK
+      "${REQUESTED_VERSION_MAJOR}.${REQUESTED_VERSION_MINOR}.${REQUESTED_VERSION_PATCH}")
+else()
+  set(REQUESTED_VERSION_NO_TWEAK "${PACKAGE_FIND_VERSION}")
+endif()
+
+if(REQUESTED_VERSION_NO_TWEAK STREQUAL CVF_VERSION_NO_TWEAK)
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+endif()
+
+if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+  set(PACKAGE_VERSION_EXACT TRUE)
+endif()
+
+@CVF_ARCH_INDEPENDENT_CHECK@

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeASM_MARMASMInformation.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.
+
+
+# support for the MS ARM assembler, marmasm and marmasm64
+
+set(ASM_DIALECT "_MARMASM")
+
+set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS asm)
+
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <INCLUDES> <FLAGS> -o <OBJECT> <SOURCE>")
+set(CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY "<CMAKE_AR> <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")
+
+# The ASM_MARMASM compiler id for this compiler is "MSVC", so fill out the runtime library table.
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded         "")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL      "")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug    "")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL "")
+
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_Embedded        "-g")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_ProgramDatabase "")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OPTIONS_MSVC_DEBUG_INFORMATION_FORMAT_EditAndContinue "")
+
+include(CMakeASMInformation)
+set(ASM_DIALECT)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeASM_NASMInformation.cmake

@@ -0,0 +1,66 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# support for the nasm assembler
+
+set(CMAKE_ASM_NASM_SOURCE_FILE_EXTENSIONS nasm asm)
+
+if(NOT CMAKE_ASM_NASM_OBJECT_FORMAT)
+  if(WIN32)
+    if(DEFINED CMAKE_C_SIZEOF_DATA_PTR AND CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
+    elseif(DEFINED CMAKE_CXX_SIZEOF_DATA_PTR AND CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
+    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
+    else()
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT win32)
+    endif()
+  elseif(APPLE)
+    if(DEFINED CMAKE_C_SIZEOF_DATA_PTR AND CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64)
+    elseif(DEFINED CMAKE_CXX_SIZEOF_DATA_PTR AND CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64)
+    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64)
+    else()
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT macho)
+    endif()
+  else()
+    if(DEFINED CMAKE_C_SIZEOF_DATA_PTR AND CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)
+    elseif(DEFINED CMAKE_CXX_SIZEOF_DATA_PTR AND CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)
+    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)
+    else()
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT elf)
+    endif()
+  endif()
+endif()
+
+if(NOT CMAKE_ASM_NASM_COMPILE_OBJECT)
+  set(CMAKE_ASM_NASM_COMPILE_OBJECT "<CMAKE_ASM_NASM_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -f ${CMAKE_ASM_NASM_OBJECT_FORMAT} -o <OBJECT> <SOURCE>")
+endif()
+
+if(NOT CMAKE_ASM_NASM_LINK_EXECUTABLE)
+  set(CMAKE_ASM_NASM_LINK_EXECUTABLE
+    "<CMAKE_LINKER> <CMAKE_ASM_NASM_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
+endif()
+
+if(CMAKE_ASM_NASM_COMPILER_ID STREQUAL "NASM")
+  set(CMAKE_DEPFILE_FLAGS_ASM_NASM "-MD <DEP_FILE> -MT <DEP_TARGET>")
+
+  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_ASM_NASM_DEPFILE_FORMAT gcc)
+    set(CMAKE_ASM_NASM_DEPENDS_USE_COMPILER TRUE)
+  endif()
+endif()
+
+# Load the generic ASMInformation file:
+set(ASM_DIALECT "_NASM")
+include(CMakeASMInformation)
+set(ASM_DIALECT)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeBackwardCompatibilityC.cmake

@@ -0,0 +1,76 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
+  # Old CMake versions did not support OS X universal binaries anyway,
+  # so just get through this with at least some size for the types.
+  list(LENGTH CMAKE_OSX_ARCHITECTURES NUM_ARCHS)
+  if(${NUM_ARCHS} GREATER 1)
+    if(NOT DEFINED CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+      message(WARNING "This module does not work with OS X universal binaries.")
+      set(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES 1)
+      list(GET CMAKE_OSX_ARCHITECTURES 0 CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+    endif()
+  endif()
+
+  include (CheckTypeSize)
+  CHECK_TYPE_SIZE(int      CMAKE_SIZEOF_INT)
+  CHECK_TYPE_SIZE(long     CMAKE_SIZEOF_LONG)
+  CHECK_TYPE_SIZE("void*"  CMAKE_SIZEOF_VOID_P)
+  CHECK_TYPE_SIZE(char     CMAKE_SIZEOF_CHAR)
+  CHECK_TYPE_SIZE(short    CMAKE_SIZEOF_SHORT)
+  CHECK_TYPE_SIZE(float    CMAKE_SIZEOF_FLOAT)
+  CHECK_TYPE_SIZE(double   CMAKE_SIZEOF_DOUBLE)
+
+  include (CheckIncludeFile)
+  CHECK_INCLUDE_FILE("limits.h"       CMAKE_HAVE_LIMITS_H)
+  CHECK_INCLUDE_FILE("unistd.h"       CMAKE_HAVE_UNISTD_H)
+  CHECK_INCLUDE_FILE("pthread.h"      CMAKE_HAVE_PTHREAD_H)
+
+  include (CheckIncludeFiles)
+  CHECK_INCLUDE_FILES("sys/types.h;sys/prctl.h"    CMAKE_HAVE_SYS_PRCTL_H)
+
+  include (TestBigEndian)
+  TEST_BIG_ENDIAN(CMAKE_WORDS_BIGENDIAN)
+  include (FindX11)
+
+  if("${X11_X11_INCLUDE_PATH}" STREQUAL "/usr/include")
+    set (CMAKE_X_CFLAGS "" CACHE STRING "X11 extra flags.")
+  else()
+    set (CMAKE_X_CFLAGS "-I${X11_X11_INCLUDE_PATH}" CACHE STRING
+         "X11 extra flags.")
+  endif()
+  set (CMAKE_X_LIBS "${X11_LIBRARIES}" CACHE STRING
+       "Libraries and options used in X11 programs.")
+  set (CMAKE_HAS_X "${X11_FOUND}" CACHE INTERNAL "Is X11 around.")
+
+  include (FindThreads)
+
+  set (CMAKE_THREAD_LIBS        "${CMAKE_THREAD_LIBS_INIT}" CACHE STRING
+    "Thread library used.")
+
+  set (CMAKE_USE_PTHREADS       "${CMAKE_USE_PTHREADS_INIT}" CACHE BOOL
+     "Use the pthreads library.")
+
+  set (CMAKE_USE_WIN32_THREADS  "${CMAKE_USE_WIN32_THREADS_INIT}" CACHE BOOL
+       "Use the win32 thread library.")
+
+  set (CMAKE_HP_PTHREADS        ${CMAKE_HP_PTHREADS_INIT} CACHE BOOL
+     "Use HP pthreads.")
+
+  if(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+    set(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+    set(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+  endif()
+endif()
+
+mark_as_advanced(
+CMAKE_HP_PTHREADS
+CMAKE_THREAD_LIBS
+CMAKE_USE_PTHREADS
+CMAKE_USE_WIN32_THREADS
+CMAKE_X_CFLAGS
+CMAKE_X_LIBS
+)
+

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeCCompiler.cmake.in

@@ -0,0 +1,81 @@
+set(CMAKE_C_COMPILER "@CMAKE_C_COMPILER@")
+set(CMAKE_C_COMPILER_ARG1 "@CMAKE_C_COMPILER_ARG1@")
+set(CMAKE_C_COMPILER_ID "@CMAKE_C_COMPILER_ID@")
+set(CMAKE_C_COMPILER_VERSION "@CMAKE_C_COMPILER_VERSION@")
+set(CMAKE_C_COMPILER_VERSION_INTERNAL "@CMAKE_C_COMPILER_VERSION_INTERNAL@")
+set(CMAKE_C_COMPILER_WRAPPER "@CMAKE_C_COMPILER_WRAPPER@")
+set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "@CMAKE_C_STANDARD_COMPUTED_DEFAULT@")
+set(CMAKE_C_EXTENSIONS_COMPUTED_DEFAULT "@CMAKE_C_EXTENSIONS_COMPUTED_DEFAULT@")
+set(CMAKE_C_STANDARD_LATEST "@CMAKE_C_STANDARD_LATEST@")
+set(CMAKE_C_COMPILE_FEATURES "@CMAKE_C_COMPILE_FEATURES@")
+set(CMAKE_C90_COMPILE_FEATURES "@CMAKE_C90_COMPILE_FEATURES@")
+set(CMAKE_C99_COMPILE_FEATURES "@CMAKE_C99_COMPILE_FEATURES@")
+set(CMAKE_C11_COMPILE_FEATURES "@CMAKE_C11_COMPILE_FEATURES@")
+set(CMAKE_C17_COMPILE_FEATURES "@CMAKE_C17_COMPILE_FEATURES@")
+set(CMAKE_C23_COMPILE_FEATURES "@CMAKE_C23_COMPILE_FEATURES@")
+
+set(CMAKE_C_PLATFORM_ID "@CMAKE_C_PLATFORM_ID@")
+set(CMAKE_C_SIMULATE_ID "@CMAKE_C_SIMULATE_ID@")
+set(CMAKE_C_COMPILER_FRONTEND_VARIANT "@CMAKE_C_COMPILER_FRONTEND_VARIANT@")
+set(CMAKE_C_SIMULATE_VERSION "@CMAKE_C_SIMULATE_VERSION@")
+@_SET_CMAKE_C_COMPILER_ARCHITECTURE_ID@
+@_SET_CMAKE_C_COMPILER_SYSROOT@
+@SET_MSVC_C_ARCHITECTURE_ID@
+@SET_CMAKE_XCODE_ARCHS@
+set(CMAKE_AR "@CMAKE_AR@")
+set(CMAKE_C_COMPILER_AR "@CMAKE_C_COMPILER_AR@")
+set(CMAKE_RANLIB "@CMAKE_RANLIB@")
+set(CMAKE_C_COMPILER_RANLIB "@CMAKE_C_COMPILER_RANLIB@")
+set(CMAKE_LINKER "@CMAKE_LINKER@")
+set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@")
+set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@")
+set(CMAKE_C_COMPILER_LINKER "@CMAKE_C_COMPILER_LINKER@")
+set(CMAKE_C_COMPILER_LINKER_ID "@CMAKE_C_COMPILER_LINKER_ID@")
+set(CMAKE_C_COMPILER_LINKER_VERSION @CMAKE_C_COMPILER_LINKER_VERSION@)
+set(CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT@)
+set(CMAKE_MT "@CMAKE_MT@")
+set(CMAKE_TAPI "@CMAKE_TAPI@")
+set(CMAKE_COMPILER_IS_GNUCC @CMAKE_COMPILER_IS_GNUCC@)
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS @CMAKE_C_COMPILER_WORKS@)
+set(CMAKE_C_ABI_COMPILED @CMAKE_C_ABI_COMPILED@)
+
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
+
+set(CMAKE_C_COMPILER_ID_RUN 1)
+set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
+set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_C_LINKER_PREFERENCE 10)
+set(CMAKE_C_LINKER_DEPFILE_SUPPORTED @CMAKE_C_LINKER_DEPFILE_SUPPORTED@)
+
+# Save compiler ABI information.
+set(CMAKE_C_SIZEOF_DATA_PTR "@CMAKE_C_SIZEOF_DATA_PTR@")
+set(CMAKE_C_COMPILER_ABI "@CMAKE_C_COMPILER_ABI@")
+set(CMAKE_C_BYTE_ORDER "@CMAKE_C_BYTE_ORDER@")
+set(CMAKE_C_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@")
+
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_C_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
+endif()
+
+if(CMAKE_C_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@")
+endif()
+
+set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "@CMAKE_C_CL_SHOWINCLUDES_PREFIX@")
+if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+@CMAKE_C_COMPILER_CUSTOM_CODE@
+@CMAKE_C_SYSROOT_FLAG_CODE@
+@CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG_CODE@
+
+set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "@CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES@")
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "@CMAKE_C_IMPLICIT_LINK_LIBRARIES@")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_DIRECTORIES@")
+set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES@")

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeCUDAInformation.cmake

@@ -0,0 +1,155 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+if(UNIX)
+  set(CMAKE_CUDA_OUTPUT_EXTENSION .o)
+else()
+  set(CMAKE_CUDA_OUTPUT_EXTENSION .obj)
+endif()
+set(CMAKE_INCLUDE_FLAG_CUDA "-I")
+
+# Set implicit links early so compiler-specific modules can use them.
+set(__IMPLICIT_LINKS)
+foreach(dir ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES})
+  string(APPEND __IMPLICIT_LINKS " -L\"${dir}\"")
+endforeach()
+foreach(lib ${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES})
+  if(${lib} MATCHES "/")
+    string(APPEND __IMPLICIT_LINKS " \"${lib}\"")
+  else()
+    string(APPEND __IMPLICIT_LINKS " -l${lib}")
+  endif()
+endforeach()
+
+# Load compiler-specific information.
+if(CMAKE_CUDA_COMPILER_ID)
+  include(Compiler/${CMAKE_CUDA_COMPILER_ID}-CUDA OPTIONAL)
+endif()
+
+# load the system- and compiler specific files
+if(CMAKE_CUDA_COMPILER_ID)
+  # load a hardware specific file, mostly useful for embedded compilers
+  if(CMAKE_SYSTEM_PROCESSOR)
+    include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CUDA_COMPILER_ID}-CUDA-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
+  endif()
+  include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CUDA_COMPILER_ID}-CUDA OPTIONAL)
+endif()
+
+
+# This should be included before the _INIT variables are
+# used to initialize the cache.  Since the rule variables
+# have if blocks on them, users can still define them here.
+# But, it should still be after the platform file so changes can
+# be made to those values.
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE)
+  # Save the full path of the file so try_compile can use it.
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
+endif()
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA)
+  # Save the full path of the file so try_compile can use it.
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA "${_override}")
+endif()
+
+
+
+# add the flags to the cache based
+# on the initial values computed in the platform/*.cmake files
+# use _INIT variables so that this only happens the first time
+# and you can set these flags in the cmake cache
+set(CMAKE_CUDA_FLAGS_INIT "$ENV{CUDAFLAGS} ${CMAKE_CUDA_FLAGS_INIT}")
+
+cmake_initialize_per_config_variable(CMAKE_CUDA_FLAGS "Flags used by the CUDA compiler")
+
+if(CMAKE_CUDA_STANDARD_LIBRARIES_INIT)
+  set(CMAKE_CUDA_STANDARD_LIBRARIES "${CMAKE_CUDA_STANDARD_LIBRARIES_INIT}"
+    CACHE STRING "Libraries linked by default with all CUDA applications.")
+  mark_as_advanced(CMAKE_CUDA_STANDARD_LIBRARIES)
+endif()
+
+if(NOT CMAKE_CUDA_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_CUDA_COMPILER_LAUNCHER})
+  set(CMAKE_CUDA_COMPILER_LAUNCHER "$ENV{CMAKE_CUDA_COMPILER_LAUNCHER}"
+    CACHE STRING "Compiler launcher for CUDA.")
+endif()
+
+include(CMakeCommonLanguageInclude)
+_cmake_common_language_platform_flags(CUDA)
+
+# now define the following rules:
+# CMAKE_CUDA_CREATE_SHARED_LIBRARY
+# CMAKE_CUDA_CREATE_SHARED_MODULE
+# CMAKE_CUDA_COMPILE_WHOLE_COMPILATION
+# CMAKE_CUDA_COMPILE_SEPARABLE_COMPILATION
+# CMAKE_CUDA_LINK_EXECUTABLE
+
+# create a shared library
+if(NOT CMAKE_CUDA_CREATE_SHARED_LIBRARY)
+  set(CMAKE_CUDA_CREATE_SHARED_LIBRARY
+      "<CMAKE_CUDA_HOST_LINK_LAUNCHER> <CMAKE_SHARED_LIBRARY_CUDA_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
+endif()
+
+# create a shared module copy the shared library rule by default
+if(NOT CMAKE_CUDA_CREATE_SHARED_MODULE)
+  set(CMAKE_CUDA_CREATE_SHARED_MODULE ${CMAKE_CUDA_CREATE_SHARED_LIBRARY})
+endif()
+
+# Create a static archive incrementally for large object file counts.
+if(NOT DEFINED CMAKE_CUDA_ARCHIVE_CREATE)
+  set(CMAKE_CUDA_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_CUDA_ARCHIVE_APPEND)
+  set(CMAKE_CUDA_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_CUDA_ARCHIVE_FINISH)
+  set(CMAKE_CUDA_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
+endif()
+
+if(NOT CMAKE_CUDA_COMPILE_OBJECT)
+  set(CMAKE_CUDA_COMPILE_OBJECT
+    "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_CUDA_FLAG} <CUDA_COMPILE_MODE> <SOURCE> -o <OBJECT>")
+endif()
+
+# compile a cu file into an executable
+if(NOT CMAKE_CUDA_LINK_EXECUTABLE)
+  set(CMAKE_CUDA_LINK_EXECUTABLE
+    "<CMAKE_CUDA_HOST_LINK_LAUNCHER> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
+endif()
+
+# Add implicit host link directories that contain device libraries
+# to the device link line.
+set(__IMPLICIT_DLINK_DIRS ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES})
+if(__IMPLICIT_DLINK_DIRS)
+  list(REMOVE_ITEM __IMPLICIT_DLINK_DIRS ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES})
+endif()
+set(__IMPLICIT_DLINK_FLAGS)
+foreach(dir ${__IMPLICIT_DLINK_DIRS})
+  if(EXISTS "${dir}/libcurand_static.a")
+    string(APPEND __IMPLICIT_DLINK_FLAGS " -L\"${dir}\"")
+  endif()
+endforeach()
+unset(__IMPLICIT_DLINK_DIRS)
+
+
+#These are used when linking relocatable (dc) cuda code
+if(NOT CMAKE_CUDA_DEVICE_LINK_LIBRARY)
+  set(CMAKE_CUDA_DEVICE_LINK_LIBRARY
+    "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> ${CMAKE_CUDA_COMPILE_OPTIONS_PIC} ${_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS} -shared -dlink <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_DLINK_FLAGS}")
+endif()
+if(NOT CMAKE_CUDA_DEVICE_LINK_EXECUTABLE)
+  set(CMAKE_CUDA_DEVICE_LINK_EXECUTABLE
+    "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> ${CMAKE_CUDA_COMPILE_OPTIONS_PIC} ${_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS} -shared -dlink <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_DLINK_FLAGS}")
+endif()
+
+# Used when device linking is handled by CMake.
+if(NOT CMAKE_CUDA_DEVICE_LINK_COMPILE)
+  set(CMAKE_CUDA_DEVICE_LINK_COMPILE "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <FLAGS> <LINK_FLAGS> -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -D__NV_EXTRA_INITIALIZATION=\"\" -D__NV_EXTRA_FINALIZATION=\"\" -DREGISTERLINKBINARYFILE=\\\"<REGISTER_FILE>\\\" -DFATBINFILE=\\\"<FATBINARY>\\\" ${_CMAKE_COMPILE_AS_CUDA_FLAG} -c \"${CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT}/bin/crt/link.stub\" -o <OBJECT>")
+endif()
+
+unset(__IMPLICIT_DLINK_FLAGS)
+
+set(CMAKE_CUDA_USE_LINKER_INFORMATION TRUE)
+
+set(CMAKE_CUDA_INFORMATION_LOADED 1)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp

@@ -0,0 +1,18 @@
+#ifndef __cplusplus
+#  error "A C compiler has been selected for C++."
+#endif
+
+#include "CMakeCompilerABI.h"
+
+int main(int argc, char* argv[])
+{
+  int require = 0;
+  require += info_sizeof_dptr[argc];
+  require += info_byte_order_big_endian[argc];
+  require += info_byte_order_little_endian[argc];
+#if defined(ABI_ID)
+  require += info_abi[argc];
+#endif
+  (void)argv;
+  return require;
+}

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeCompilerCUDAArch.h

@@ -0,0 +1,29 @@
+#include <cstdio>
+
+#include <cuda_runtime.h>
+
+static bool cmakeCompilerCUDAArch()
+{
+  int count = 0;
+  if (cudaGetDeviceCount(&count) != cudaSuccess || count == 0) {
+    std::fprintf(stderr, "No CUDA devices found.\n");
+    return -1;
+  }
+
+  bool found = false;
+  const char* sep = "";
+  for (int device = 0; device < count; ++device) {
+    cudaDeviceProp prop;
+    if (cudaGetDeviceProperties(&prop, device) == cudaSuccess) {
+      std::printf("%s%d%d", sep, prop.major, prop.minor);
+      sep = ";";
+      found = true;
+    }
+  }
+
+  if (!found) {
+    std::fprintf(stderr, "No CUDA architecture detected from any devices.\n");
+  }
+
+  return found;
+}

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeDependentOption.cmake

@@ -0,0 +1,92 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CMakeDependentOption
+--------------------
+
+Macro to provide an option dependent on other options.
+
+This macro presents an option to the user only if a set of other
+conditions are true.
+
+.. command:: cmake_dependent_option
+
+  .. code-block:: cmake
+
+    cmake_dependent_option(<option> "<help_text>" <value> <depends> <force>)
+
+  Makes ``<option>`` available to the user if the
+  :ref:`semicolon-separated list <CMake Language Lists>` of conditions in
+  ``<depends>`` are all true.  Otherwise, a local variable named ``<option>``
+  is set to ``<force>``.
+
+  When ``<option>`` is available, the given ``<help_text>`` and initial
+  ``<value>`` are used. Otherwise, any value set by the user is preserved for
+  when ``<depends>`` is satisfied in the future.
+
+  Note that the ``<option>`` variable only has a value which satisfies the
+  ``<depends>`` condition within the scope of the caller because it is a local
+  variable.
+
+Example invocation:
+
+.. code-block:: cmake
+
+  cmake_dependent_option(USE_FOO "Use Foo" ON "USE_BAR;NOT USE_ZOT" OFF)
+
+If ``USE_BAR`` is true and ``USE_ZOT`` is false, this provides an option called
+``USE_FOO`` that defaults to ON. Otherwise, it sets ``USE_FOO`` to OFF and
+hides the option from the user. If the status of ``USE_BAR`` or ``USE_ZOT``
+ever changes, any value for the ``USE_FOO`` option is saved so that when the
+option is re-enabled it retains its old value.
+
+.. versionadded:: 3.22
+
+  Full :ref:`Condition Syntax` is now supported.  See policy :policy:`CMP0127`.
+
+#]=======================================================================]
+
+macro(CMAKE_DEPENDENT_OPTION option doc default depends force)
+  cmake_policy(GET CMP0127 _CDO_CMP0127
+    PARENT_SCOPE # undocumented, do not use outside of CMake
+    )
+  if(${option}_ISSET MATCHES "^${option}_ISSET$")
+    set(${option}_AVAILABLE 1)
+    if("x${_CDO_CMP0127}x" STREQUAL "xNEWx")
+      foreach(d ${depends})
+        cmake_language(EVAL CODE "
+          if (${d})
+          else()
+            set(${option}_AVAILABLE 0)
+          endif()"
+        )
+      endforeach()
+    else()
+      foreach(d ${depends})
+        string(REGEX REPLACE " +" ";" CMAKE_DEPENDENT_OPTION_DEP "${d}")
+        if(${CMAKE_DEPENDENT_OPTION_DEP})
+        else()
+          set(${option}_AVAILABLE 0)
+        endif()
+      endforeach()
+    endif()
+    if(${option}_AVAILABLE)
+      option(${option} "${doc}" "${default}")
+      set(${option} "${${option}}" CACHE BOOL "${doc}" FORCE)
+    else()
+      if(${option} MATCHES "^${option}$")
+      else()
+        set(${option} "${${option}}" CACHE INTERNAL "${doc}")
+      endif()
+      set(${option} ${force})
+    endif()
+  else()
+    set(${option} "${${option}_ISSET}")
+  endif()
+  if("x${_CDO_CMP0127}x" STREQUAL "xx" AND "x${depends}x" MATCHES "[^A-Za-z0-9_.; ]")
+    cmake_policy(GET_WARNING CMP0127 _CDO_CMP0127_WARNING)
+    message(AUTHOR_WARNING "${_CDO_CMP0127_WARNING}")
+  endif()
+  unset(_CDO_CMP0127)
+endmacro()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeDetermineASMCompiler.cmake

@@ -0,0 +1,281 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# determine the compiler to use for ASM programs
+
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
+
+if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
+  # prefer the environment variable ASM
+  if(NOT $ENV{ASM${ASM_DIALECT}} STREQUAL "")
+    get_filename_component(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT $ENV{ASM${ASM_DIALECT}} PROGRAM PROGRAM_ARGS CMAKE_ASM${ASM_DIALECT}_FLAGS_ENV_INIT)
+    if(CMAKE_ASM${ASM_DIALECT}_FLAGS_ENV_INIT)
+      set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ARG1 "${CMAKE_ASM${ASM_DIALECT}_FLAGS_ENV_INIT}" CACHE STRING "Arguments to ASM${ASM_DIALECT} compiler")
+    endif()
+    if(NOT EXISTS ${CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT})
+      message(FATAL_ERROR "Could not find compiler set in environment variable ASM${ASM_DIALECT}:\n$ENV{ASM${ASM_DIALECT}}.")
+    endif()
+  endif()
+
+  # finally list compilers to try
+  if("ASM${ASM_DIALECT}" STREQUAL "ASM") # the generic assembler support
+    if(NOT CMAKE_ASM_COMPILER_INIT)
+      if(CMAKE_C_COMPILER)
+        set(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST ${CMAKE_C_COMPILER})
+      elseif(CMAKE_CXX_COMPILER)
+        set(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST ${CMAKE_CXX_COMPILER})
+      else()
+        # List all default C and CXX compilers
+        set(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST
+             ${_CMAKE_TOOLCHAIN_PREFIX}cc  ${_CMAKE_TOOLCHAIN_PREFIX}gcc cl bcc xlc
+          CC ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ aCC cl bcc xlC)
+      endif()
+    endif()
+  else() # some specific assembler "dialect"
+    if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT  AND NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST)
+      message(FATAL_ERROR "CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT or CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST must be preset !")
+    endif()
+  endif()
+
+  # Find the compiler.
+  _cmake_find_compiler(ASM${ASM_DIALECT})
+
+else()
+  _cmake_find_compiler_path(ASM${ASM_DIALECT})
+endif()
+mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER)
+
+if (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
+endif ()
+
+
+if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
+
+  # Table of per-vendor compiler id flags with expected output.
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS GNU )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_GNU "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_GNU "(GNU assembler)|(GCC)|(Free Software Foundation)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS AppleClang )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_AppleClang "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_AppleClang "(Apple (clang|LLVM) version)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS Clang )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Clang "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Clang "(clang version)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS ARMClang )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_ARMClang "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_ARMClang "armclang")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS OrangeC )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_OrangeC "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_OrangeC "occ \\(OrangeC\\) Version")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS HP )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_HP "-V")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_HP "HP C")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS Intel )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Intel "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Intel "(ICC)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS IntelLLVM )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_IntelLLVM "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_IntelLLVM "(Intel[^\n]+oneAPI)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS SunPro )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_SunPro "-V")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_SunPro "Sun C")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS XL )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_XL "-qversion")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_XL "XL C")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS MSVC )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_MSVC "-?")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_MSVC "Microsoft")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TI )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TI "-h")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TI "Texas Instruments")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TIClang )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TIClang "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TIClang "(TI (.*) Clang Compiler)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS IAR)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_IAR )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_IAR "IAR Assembler")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS ARMCC)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_ARMCC )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_ARMCC "(ARM Compiler)|(ARM Assembler)|(Arm Compiler)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS NASM)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_NASM "-v")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_NASM "(NASM version)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS YASM)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_YASM "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_YASM "(yasm)")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS ADSP)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_ADSP "-version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_ADSP "Analog Devices")
+
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS QCC)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_QCC "-V")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_QCC "gcc_nto")
+
+  include(CMakeDetermineCompilerId)
+  set(userflags)
+  CMAKE_DETERMINE_COMPILER_ID_VENDOR(ASM${ASM_DIALECT} "${userflags}")
+  set(_variant "")
+  if("x${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}" STREQUAL "xIAR")
+    # primary necessary to detect architecture, so the right archiver and linker can be picked
+    # eg. "IAR Assembler V8.10.1.12857/W32 for ARM" or "IAR Assembler V4.11.1.4666 for Renesas RX"
+    # Earlier versions did not provide `--version`, so grep the full output to extract Assembler ID string
+    string(REGEX MATCH "IAR Assembler[^\r\n]*" _compileid "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_OUTPUT}")
+    if("${_compileid}" MATCHES "V([0-9]+\\.[0-9]+\\.[0-9]+)")
+      set(CMAKE_ASM${ASM_DIALECT}_COMPILER_VERSION ${CMAKE_MATCH_1})
+    endif()
+    if("${_compileid}" MATCHES "for.*(MSP430|8051|ARM|AVR|RH850|RISC-?V|RL78|RX|STM8|V850)")
+      set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID ${CMAKE_MATCH_1})
+    endif()
+  elseif("x${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}" STREQUAL "xClang")
+    # Test whether an MSVC-like command-line option works.
+    execute_process(COMMAND ${CMAKE_ASM${ASM_DIALECT}_COMPILER} -?
+      OUTPUT_VARIABLE _clang_output
+      ERROR_VARIABLE _clang_output
+      RESULT_VARIABLE _clang_result)
+      if(_clang_result EQUAL 0)
+        set(CMAKE_ASM${ASM_DIALECT}_COMPILER_FRONTEND_VARIANT "MSVC")
+        set(CMAKE_ASM${ASM_DIALECT}_SIMULATE_ID MSVC)
+      else()
+        set(CMAKE_ASM${ASM_DIALECT}_COMPILER_FRONTEND_VARIANT "GNU")
+      endif()
+      set(_variant " with ${CMAKE_ASM${ASM_DIALECT}_COMPILER_FRONTEND_VARIANT}-like command-line")
+  endif()
+
+  _cmake_find_compiler_sysroot(ASM${ASM_DIALECT})
+
+  unset(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_OUTPUT)
+  unset(_all_compileid_matches)
+  unset(_compileid)
+  unset(_clang_result)
+  unset(_clang_output)
+endif()
+
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
+  if(CMAKE_ASM${ASM_DIALECT}_COMPILER_VERSION)
+    set(_version " ${CMAKE_ASM${ASM_DIALECT}_COMPILER_VERSION}")
+  else()
+    set(_version "")
+  endif()
+  if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}" STREQUAL "xIAR")
+    set(_archid " ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}")
+  else()
+    set(_archid "")
+  endif()
+  message(STATUS "The ASM${ASM_DIALECT} compiler identification is ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}${_archid}${_version}${_variant}")
+  unset(_archid)
+  unset(_version)
+  unset(_variant)
+else()
+  message(STATUS "The ASM${ASM_DIALECT} compiler identification is unknown")
+endif()
+
+# If we have a gas/as cross compiler, they have usually some prefix, like
+# e.g. powerpc-linux-gas, arm-elf-gas or i586-mingw32msvc-gas , optionally
+# with a 3-component version number at the end
+# The other tools of the toolchain usually have the same prefix
+# NAME_WE cannot be used since then this test will fail for names like
+# "arm-unknown-nto-qnx6.3.0-gas.exe", where BASENAME would be
+# "arm-unknown-nto-qnx6" instead of the correct "arm-unknown-nto-qnx6.3.0-"
+if (NOT _CMAKE_TOOLCHAIN_PREFIX)
+  get_filename_component(COMPILER_BASENAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME)
+  if (COMPILER_BASENAME MATCHES "^(.+-)g?as(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+endif ()
+
+# Now try the C compiler regexp:
+if (NOT _CMAKE_TOOLCHAIN_PREFIX)
+  if (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+endif ()
+
+# Finally try the CXX compiler regexp:
+if (NOT _CMAKE_TOOLCHAIN_PREFIX)
+  if (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+endif ()
+
+
+set(_CMAKE_PROCESSING_LANGUAGE "ASM")
+include(CMakeFindBinUtils)
+include(Compiler/${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-FindBinUtils OPTIONAL)
+unset(_CMAKE_PROCESSING_LANGUAGE)
+
+set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR "ASM${ASM_DIALECT}")
+
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER)
+  message(STATUS "Found assembler: ${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
+else()
+  message(STATUS "Didn't find assembler")
+endif()
+
+foreach(_var
+    COMPILER
+    COMPILER_ID
+    COMPILER_ARG1
+    COMPILER_ENV_VAR
+    COMPILER_AR
+    COMPILER_RANLIB
+    COMPILER_VERSION
+    )
+  set(_CMAKE_ASM_${_var} "${CMAKE_ASM${ASM_DIALECT}_${_var}}")
+endforeach()
+
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_SYSROOT)
+  string(CONCAT _SET_CMAKE_ASM_COMPILER_SYSROOT
+    "set(CMAKE_ASM${ASM_DIALECT}_COMPILER_SYSROOT \"${CMAKE_ASM${ASM_DIALECT}_COMPILER_SYSROOT}\")\n"
+    "set(CMAKE_COMPILER_SYSROOT \"${CMAKE_ASM${ASM_DIALECT}_COMPILER_SYSROOT}\")")
+else()
+  set(_SET_CMAKE_ASM_COMPILER_SYSROOT "")
+endif()
+
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_MATCH)
+  set(_SET_CMAKE_ASM_COMPILER_ID_VENDOR_MATCH
+    "set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_MATCH [==[${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_MATCH}]==])")
+else()
+  set(_SET_CMAKE_ASM_COMPILER_ID_VENDOR_MATCH "")
+endif()
+
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID)
+  set(_SET_CMAKE_ASM_COMPILER_ARCHITECTURE_ID
+    "set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID})")
+else()
+  set(_SET_CMAKE_ASM_COMPILER_ARCHITECTURE_ID "")
+endif()
+
+# configure variables set in this file for fast reload later on
+configure_file(${CMAKE_ROOT}/Modules/CMakeASMCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeASM${ASM_DIALECT}Compiler.cmake @ONLY)
+
+foreach(_var
+    COMPILER
+    COMPILER_ID
+    COMPILER_ARG1
+    COMPILER_ENV_VAR
+    COMPILER_AR
+    COMPILER_RANLIB
+    COMPILER_VERSION
+    )
+  unset(_CMAKE_ASM_${_var})
+endforeach()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeDetermineISPCCompiler.cmake

@@ -0,0 +1,96 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# determine the compiler to use for ISPC programs
+
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
+
+if( NOT (("${CMAKE_GENERATOR}" MATCHES "Make") OR ("${CMAKE_GENERATOR}" MATCHES "Ninja")) )
+  message(FATAL_ERROR "ISPC language not currently supported by \"${CMAKE_GENERATOR}\" generator")
+endif()
+
+# Load system-specific compiler preferences for this language.
+include(Platform/${CMAKE_SYSTEM_NAME}-Determine-ISPC OPTIONAL)
+include(Platform/${CMAKE_SYSTEM_NAME}-ISPC OPTIONAL)
+if(NOT CMAKE_ISPC_COMPILER_NAMES)
+  set(CMAKE_ISPC_COMPILER_NAMES ispc)
+endif()
+
+
+if(NOT CMAKE_ISPC_COMPILER)
+
+  set(CMAKE_ISPC_COMPILER_INIT NOTFOUND)
+
+  # prefer the environment variable CC
+  if(NOT $ENV{ISPC} STREQUAL "")
+    get_filename_component(CMAKE_ISPC_COMPILER_INIT $ENV{ISPC} PROGRAM PROGRAM_ARGS CMAKE_ISPC_FLAGS_ENV_INIT)
+    if(CMAKE_ISPC_FLAGS_ENV_INIT)
+      set(CMAKE_ISPC_COMPILER_ARG1 "${CMAKE_ISPC_FLAGS_ENV_INIT}" CACHE STRING "First argument to ISPC compiler")
+    endif()
+    if(NOT EXISTS ${CMAKE_ISPC_COMPILER_INIT})
+      message(FATAL_ERROR "Could not find compiler set in environment variable ISPC:\n$ENV{ISPC}.")
+    endif()
+  endif()
+
+  # next try prefer the compiler specified by the generator
+  if(CMAKE_GENERATOR_ISPC)
+    if(NOT CMAKE_ISPC_COMPILER_INIT)
+      set(CMAKE_ISPC_COMPILER_INIT ${CMAKE_GENERATOR_ISPC})
+    endif()
+  endif()
+
+  # finally list compilers to try
+  if(NOT CMAKE_ISPC_COMPILER_INIT)
+    set(CMAKE_ISPC_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}ispc ispc)
+  endif()
+
+  # Find the compiler.
+  _cmake_find_compiler(ISPC)
+
+else()
+  _cmake_find_compiler_path(ISPC)
+endif()
+mark_as_advanced(CMAKE_ISPC_COMPILER)
+
+if(NOT CMAKE_ISPC_COMPILER_ID_RUN)
+set(CMAKE_ISPC_COMPILER_ID_RUN 1)
+
+  # Try to identify the compiler.
+  set(CMAKE_ISPC_COMPILER_ID)
+  set(CMAKE_ISPC_PLATFORM_ID)
+
+
+  set(CMAKE_ISPC_COMPILER_ID_TEST_FLAGS_FIRST
+  # setup logic to make sure ISPC outputs a file
+  "-o cmake_ispc_output"
+  )
+
+  include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
+  CMAKE_DETERMINE_COMPILER_ID(ISPC ISPCFLAGS CMakeISPCCompilerId.ispc)
+
+  _cmake_find_compiler_sysroot(ISPC)
+endif()
+
+if (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_ISPC_COMPILER}" PATH)
+endif ()
+
+set(_CMAKE_PROCESSING_LANGUAGE "ISPC")
+include(CMakeFindBinUtils)
+include(Compiler/${CMAKE_ISPC_COMPILER_ID}-FindBinUtils OPTIONAL)
+unset(_CMAKE_PROCESSING_LANGUAGE)
+
+if(CMAKE_ISPC_COMPILER_ID_VENDOR_MATCH)
+  set(_SET_CMAKE_ISPC_COMPILER_ID_VENDOR_MATCH
+    "set(CMAKE_ISPC_COMPILER_ID_VENDOR_MATCH [==[${CMAKE_ISPC_COMPILER_ID_VENDOR_MATCH}]==])")
+else()
+  set(_SET_CMAKE_ISPC_COMPILER_ID_VENDOR_MATCH "")
+endif()
+
+
+# configure variables set in this file for fast reload later on
+configure_file(${CMAKE_ROOT}/Modules/CMakeISPCCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeISPCCompiler.cmake @ONLY)
+
+set(CMAKE_ISPC_COMPILER_ENV_VAR "ISPC")

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeDetermineJavaCompiler.cmake

@@ -0,0 +1,94 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# determine the compiler to use for Java programs
+# NOTE, a generator may set CMAKE_Java_COMPILER before
+# loading this file to force a compiler.
+
+if(NOT CMAKE_Java_COMPILER)
+  # prefer the environment variable CC
+  if(NOT $ENV{JAVA_COMPILER} STREQUAL "")
+    get_filename_component(CMAKE_Java_COMPILER_INIT $ENV{JAVA_COMPILER} PROGRAM PROGRAM_ARGS CMAKE_Java_FLAGS_ENV_INIT)
+    if(CMAKE_Java_FLAGS_ENV_INIT)
+      set(CMAKE_Java_COMPILER_ARG1 "${CMAKE_Java_FLAGS_ENV_INIT}" CACHE STRING "Arguments to Java compiler")
+    endif()
+    if(NOT EXISTS ${CMAKE_Java_COMPILER_INIT})
+      message(SEND_ERROR "Could not find compiler set in environment variable JAVA_COMPILER:\n$ENV{JAVA_COMPILER}.")
+    endif()
+  endif()
+
+  if(NOT $ENV{JAVA_RUNTIME} STREQUAL "")
+    get_filename_component(CMAKE_Java_RUNTIME_INIT $ENV{JAVA_RUNTIME} PROGRAM PROGRAM_ARGS CMAKE_Java_FLAGS_ENV_INIT)
+    if(NOT EXISTS ${CMAKE_Java_RUNTIME_INIT})
+      message(SEND_ERROR "Could not find compiler set in environment variable JAVA_RUNTIME:\n$ENV{JAVA_RUNTIME}.")
+    endif()
+  endif()
+
+  if(NOT $ENV{JAVA_ARCHIVE} STREQUAL "")
+    get_filename_component(CMAKE_Java_ARCHIVE_INIT $ENV{JAVA_ARCHIVE} PROGRAM PROGRAM_ARGS CMAKE_Java_FLAGS_ENV_INIT)
+    if(NOT EXISTS ${CMAKE_Java_ARCHIVE_INIT})
+      message(SEND_ERROR "Could not find compiler set in environment variable JAVA_ARCHIVE:\n$ENV{JAVA_ARCHIVE}.")
+    endif()
+  endif()
+
+  set(Java_BIN_PATH
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\2.0;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.9;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.8;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.7;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.6;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.5;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.4;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.3;JavaHome]/bin"
+    $ENV{JAVA_HOME}/bin
+    /usr/bin
+    /usr/lib/java/bin
+    /usr/share/java/bin
+    /usr/local/bin
+    /usr/local/java/bin
+    /usr/local/java/share/bin
+    /usr/java/j2sdk1.4.2_04
+    /usr/lib/j2sdk1.4-sun/bin
+    /usr/java/j2sdk1.4.2_09/bin
+    /usr/lib/j2sdk1.5-sun/bin
+    /opt/sun-jdk-1.5.0.04/bin
+    /usr/local/jdk-1.7.0/bin
+    /usr/local/jdk-1.6.0/bin
+    )
+  # if no compiler has been specified yet, then look for one
+  if(CMAKE_Java_COMPILER_INIT)
+    set(CMAKE_Java_COMPILER ${CMAKE_Java_COMPILER_INIT} CACHE PATH "Java Compiler")
+  else()
+    find_program(CMAKE_Java_COMPILER
+      NAMES javac
+      PATHS ${Java_BIN_PATH}
+    )
+  endif()
+
+  # if no runtime has been specified yet, then look for one
+  if(CMAKE_Java_RUNTIME_INIT)
+    set(CMAKE_Java_RUNTIME ${CMAKE_Java_RUNTIME_INIT} CACHE PATH "Java Compiler")
+  else()
+    find_program(CMAKE_Java_RUNTIME
+      NAMES java
+      PATHS ${Java_BIN_PATH}
+    )
+  endif()
+
+  # if no archive has been specified yet, then look for one
+  if(CMAKE_Java_ARCHIVE_INIT)
+    set(CMAKE_Java_ARCHIVE ${CMAKE_Java_ARCHIVE_INIT} CACHE PATH "Java Compiler")
+  else()
+    find_program(CMAKE_Java_ARCHIVE
+      NAMES jar
+      PATHS ${Java_BIN_PATH}
+    )
+  endif()
+endif()
+mark_as_advanced(CMAKE_Java_COMPILER)
+
+# configure variables set in this file for fast reload later on
+configure_file(${CMAKE_ROOT}/Modules/CMakeJavaCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeJavaCompiler.cmake @ONLY)
+set(CMAKE_Java_COMPILER_ENV_VAR "JAVA_COMPILER")

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeFindBinUtils.cmake

@@ -0,0 +1,278 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# search for additional tools required for C/C++ (and other languages ?)
+#
+# If the internal cmake variable _CMAKE_TOOLCHAIN_PREFIX is set, this is used
+# as prefix for the tools (e.g. arm-elf-gcc etc.)
+# If the cmake variable _CMAKE_TOOLCHAIN_LOCATION is set, the compiler is
+# searched only there. The other tools are at first searched there, then
+# also in the default locations.
+#
+# Sets the following variables:
+#   CMAKE_AR
+#   CMAKE_RANLIB
+#   CMAKE_LINKER
+#   CMAKE_MT
+#   CMAKE_STRIP
+#   CMAKE_INSTALL_NAME_TOOL
+
+# on UNIX, cygwin and mingw
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0057 NEW) # if IN_LIST
+
+# Resolve full path of CMAKE_TOOL from user-defined name and SEARCH_PATH.
+function(__resolve_tool_path CMAKE_TOOL SEARCH_PATH DOCSTRING)
+
+  if(${CMAKE_TOOL})
+    # We only get here if CMAKE_TOOL was
+    # specified using -D or a pre-made CMakeCache.txt (e.g. via ctest)
+    # or set in CMAKE_TOOLCHAIN_FILE.
+
+    get_filename_component(_CMAKE_USER_TOOL_PATH "${${CMAKE_TOOL}}" DIRECTORY)
+    # Is CMAKE_TOOL a user-defined name instead of a full path?
+    if(NOT _CMAKE_USER_TOOL_PATH)
+
+      # Find CMAKE_TOOL in the SEARCH_PATH directory by user-defined name.
+      find_program(_CMAKE_TOOL_WITH_PATH NAMES ${${CMAKE_TOOL}} HINTS ${SEARCH_PATH} NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH)
+      if(_CMAKE_TOOL_WITH_PATH)
+
+        # Overwrite CMAKE_TOOL with full path found in SEARCH_PATH.
+        set(${CMAKE_TOOL} ${_CMAKE_TOOL_WITH_PATH} PARENT_SCOPE)
+
+        get_property(_CMAKE_TOOL_CACHED CACHE ${CMAKE_TOOL} PROPERTY TYPE)
+        # If CMAKE_TOOL is present in the CMake Cache, then overwrit it as well.
+        if(_CMAKE_TOOL_CACHED)
+          set(${CMAKE_TOOL} "${_CMAKE_TOOL_WITH_PATH}" CACHE STRING ${DOCSTRING} FORCE)
+        endif()
+
+      endif()
+      unset(_CMAKE_TOOL_WITH_PATH CACHE)
+
+    endif()
+
+  endif()
+
+endfunction()
+
+__resolve_tool_path(CMAKE_LINKER "${_CMAKE_TOOLCHAIN_LOCATION}" "Default Linker")
+__resolve_tool_path(CMAKE_MT     "${_CMAKE_TOOLCHAIN_LOCATION}" "Default Manifest Tool")
+
+macro(__resolve_linker_path __linker_type __name __search_path __doc)
+  if(NOT CMAKE_LINKER_${__linker_type})
+    set( CMAKE_LINKER_${__linker_type} "${__name}")
+  endif()
+  __resolve_tool_path(CMAKE_LINKER_${__linker_type} "${__search_path}" "${__doc}")
+endmacro()
+
+set(_CMAKE_TOOL_VARS "")
+
+# if it's the MS C/CXX compiler, search for link
+if(("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_SIMULATE_ID}" STREQUAL "xMSVC" AND
+   ("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC"
+    OR NOT "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xClang"))
+   OR "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xMSVC"
+   OR (CMAKE_HOST_WIN32 AND "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xPGI")
+   OR (CMAKE_HOST_WIN32 AND "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xNVIDIA")
+   OR (CMAKE_HOST_WIN32 AND "x${_CMAKE_PROCESSING_LANGUAGE}" STREQUAL "xISPC")
+   OR (CMAKE_GENERATOR MATCHES "Visual Studio"
+       AND NOT CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android"))
+
+  # Start with the canonical names.
+  set(_CMAKE_LINKER_NAMES "link")
+  set(_CMAKE_AR_NAMES "lib")
+  set(_CMAKE_MT_NAMES "mt")
+
+  # Prepend toolchain-specific names.
+  if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" MATCHES "^x(Clang|LLVMFlang)$")
+    set(_CMAKE_NM_NAMES "llvm-nm" "nm")
+    list(PREPEND _CMAKE_AR_NAMES "llvm-lib")
+    if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}" VERSION_GREATER_EQUAL 14.0.2)
+      list(PREPEND _CMAKE_MT_NAMES "llvm-mt")
+    endif()
+    list(PREPEND _CMAKE_LINKER_NAMES "lld-link")
+    list(APPEND _CMAKE_TOOL_VARS NM)
+  elseif("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xIntel")
+    list(PREPEND _CMAKE_AR_NAMES "xilib")
+    list(PREPEND _CMAKE_LINKER_NAMES "xilink")
+  endif()
+
+  list(APPEND _CMAKE_TOOL_VARS LINKER MT AR)
+
+  # look-up for possible usable linker
+  __resolve_linker_path(LINK "link" "${_CMAKE_TOOLCHAIN_LOCATION}" "link Linker")
+  __resolve_linker_path(LLD "lld-link" "${_CMAKE_TOOLCHAIN_LOCATION}" "lld-link Linker")
+
+elseif("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" MATCHES "^x(Open)?Watcom$")
+  set(_CMAKE_LINKER_NAMES "wlink")
+  set(_CMAKE_AR_NAMES "wlib")
+  list(APPEND _CMAKE_TOOL_VARS LINKER AR)
+
+elseif("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" MATCHES "^xIAR$")
+  # Get the architecture from the IAR compiler parent directory
+  get_filename_component(__iar_bin_dir "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER}" DIRECTORY)
+  get_filename_component(__iar_toolkit_dir "${__iar_bin_dir}" DIRECTORY)
+  get_filename_component(__iar_arch_id "${__iar_toolkit_dir}" NAME)
+  # IAR Archive Tool
+  set(_CMAKE_AR_NAMES
+    "iarchive" "iarchive.exe"
+    "xar" "xar.exe"
+  )
+  # IAR Linker
+  set(_CMAKE_LINKER_NAMES
+    "ilink${__iar_arch_id}" "ilink${__iar_arch_id}.exe"
+    "xlink${__iar_arch_id}" "xlink${__iar_arch_id}.exe"
+    "xlink" "xlink.exe"
+  )
+  # IAR ELF Dumper
+  set(_CMAKE_IAR_ELFDUMP_NAMES
+    "ielfdump${__iar_arch_id}" "ielfdump${__iar_arch_id}.exe"
+  )
+  # IAR ELF Tool
+  set(_CMAKE_IAR_ELFTOOL_NAMES
+    "ielftool" "ielftool.exe"
+  )
+  # IAR ELF Exe to Object Tool
+  set(_CMAKE_IAR_EXE2OBJ_NAMES
+    "iexe2obj" "iexe2obj.exe"
+  )
+  # IAR Object File Manipulator
+  set(_CMAKE_IAR_OBJMANIP_NAMES
+    "iobjmanip" "iobjmanip.exe"
+  )
+  # IAR Absolute Symbol Exporter
+  set(_CMAKE_IAR_SYMEXPORT_NAMES
+    "isymexport" "isymexport.exe"
+  )
+  list(APPEND _CMAKE_TOOL_VARS AR LINKER IAR_ELFDUMP IAR_ELFTOOL IAR_EXE2OBJ IAR_OBJMANIP IAR_SYMEXPORT)
+  unset(__iar_bin_dir)
+  unset(__iar_toolkit_dir)
+  unset(__iar_arch_id)
+
+# in all other cases search for ar, ranlib, etc.
+else()
+  if(CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN)
+    set(_CMAKE_TOOLCHAIN_LOCATION ${_CMAKE_TOOLCHAIN_LOCATION} ${CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN}/bin)
+  endif()
+  if(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN)
+    set(_CMAKE_TOOLCHAIN_LOCATION ${_CMAKE_TOOLCHAIN_LOCATION} ${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}/bin)
+  endif()
+
+  # Start with the canonical names.
+  set(_CMAKE_AR_NAMES "ar")
+  set(_CMAKE_RANLIB_NAMES "ranlib")
+  set(_CMAKE_STRIP_NAMES "strip")
+  set(_CMAKE_LINKER_NAMES "ld")
+  set(_CMAKE_NM_NAMES "nm")
+  set(_CMAKE_OBJDUMP_NAMES "objdump")
+  set(_CMAKE_OBJCOPY_NAMES "objcopy")
+  set(_CMAKE_READELF_NAMES "readelf")
+  set(_CMAKE_DLLTOOL_NAMES "dlltool")
+  set(_CMAKE_ADDR2LINE_NAMES "addr2line")
+  set(_CMAKE_TAPI_NAMES "tapi")
+
+  # Prepend toolchain-specific names.
+  if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL Clang)
+    if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_SIMULATE_ID}" STREQUAL "xMSVC")
+      list(PREPEND _CMAKE_LINKER_NAMES "lld-link")
+    elseif(NOT APPLE)
+      list(PREPEND _CMAKE_LINKER_NAMES "ld.lld")
+    endif()
+    # llvm-ar does not generate a symbol table that the Apple ld64 linker accepts.
+    if(NOT APPLE)
+      list(PREPEND _CMAKE_AR_NAMES "llvm-ar")
+    endif()
+    list(PREPEND _CMAKE_RANLIB_NAMES "llvm-ranlib")
+    # llvm-strip versions prior to 11 require additional flags we do not yet add.
+    if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}" VERSION_GREATER_EQUAL 11)
+      # llvm-strip does not seem to support chained fixup format on macOS correctly.
+      if(NOT APPLE)
+        list(PREPEND _CMAKE_STRIP_NAMES "llvm-strip")
+      endif()
+    endif()
+    list(PREPEND _CMAKE_NM_NAMES "llvm-nm")
+    if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}" VERSION_GREATER_EQUAL 9)
+      # llvm-objcopy and llvm-objdump on versions prior to 9 did not support everything we need.
+      list(PREPEND _CMAKE_OBJCOPY_NAMES "llvm-objcopy")
+      list(PREPEND _CMAKE_OBJDUMP_NAMES "llvm-objdump")
+    endif()
+    list(PREPEND _CMAKE_READELF_NAMES "llvm-readelf")
+    list(PREPEND _CMAKE_DLLTOOL_NAMES "llvm-dlltool")
+    list(PREPEND _CMAKE_ADDR2LINE_NAMES "llvm-addr2line")
+  elseif("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL ARMClang)
+    list(PREPEND _CMAKE_AR_NAMES "armar")
+    list(PREPEND _CMAKE_LINKER_NAMES "armlink")
+  endif()
+
+  list(APPEND _CMAKE_TOOL_VARS AR RANLIB STRIP LINKER NM OBJDUMP OBJCOPY READELF DLLTOOL ADDR2LINE TAPI)
+endif()
+
+foreach(_CMAKE_TOOL IN LISTS _CMAKE_TOOL_VARS)
+  # Build the final list of prefixed/suffixed names.
+  set(_CMAKE_${_CMAKE_TOOL}_FIND_NAMES "")
+  foreach(_CMAKE_TOOL_NAME IN LISTS _CMAKE_${_CMAKE_TOOL}_NAMES)
+    list(APPEND _CMAKE_${_CMAKE_TOOL}_FIND_NAMES
+      ${_CMAKE_TOOLCHAIN_PREFIX}${_CMAKE_TOOL_NAME}${_CMAKE_TOOLCHAIN_SUFFIX}
+      ${_CMAKE_TOOLCHAIN_PREFIX}${_CMAKE_TOOL_NAME}
+      ${_CMAKE_TOOL_NAME}${_CMAKE_TOOLCHAIN_SUFFIX}
+      ${_CMAKE_TOOL_NAME}
+      )
+  endforeach()
+  list(REMOVE_DUPLICATES _CMAKE_${_CMAKE_TOOL}_FIND_NAMES)
+
+  find_program(CMAKE_${_CMAKE_TOOL} NAMES ${_CMAKE_${_CMAKE_TOOL}_FIND_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION} NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH)
+  unset(_CMAKE_${_CMAKE_TOOL}_FIND_NAMES)
+endforeach()
+
+if(NOT CMAKE_RANLIB)
+    set(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
+endif()
+
+if(APPLE AND "TAPI" IN_LIST _CMAKE_TOOL_VARS AND NOT CMAKE_TAPI)
+  # try to pick-up from Apple toolchain
+  execute_process(COMMAND xcrun --find tapi
+    OUTPUT_VARIABLE _xcrun_out
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+    RESULT_VARIABLE _xcrun_failed)
+  if(NOT _xcrun_failed AND EXISTS "${_xcrun_out}")
+    set_property(CACHE CMAKE_TAPI PROPERTY VALUE "${_xcrun_out}")
+  endif()
+  unset(_xcrun_out)
+  unset(_xcrun_failed)
+endif()
+
+
+if(CMAKE_PLATFORM_HAS_INSTALLNAME)
+  find_program(CMAKE_INSTALL_NAME_TOOL NAMES ${_CMAKE_TOOLCHAIN_PREFIX}install_name_tool HINTS ${_CMAKE_TOOLCHAIN_LOCATION} NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH)
+
+  if(NOT CMAKE_INSTALL_NAME_TOOL)
+    message(FATAL_ERROR "Could not find install_name_tool, please check your installation.")
+  endif()
+
+  list(APPEND _CMAKE_TOOL_VARS INSTALL_NAME_TOOL)
+endif()
+
+# Mark any tool cache entries as advanced.
+foreach(_CMAKE_TOOL IN LISTS _CMAKE_TOOL_VARS)
+  get_property(_CMAKE_TOOL_CACHED CACHE CMAKE_${_CMAKE_TOOL} PROPERTY TYPE)
+  if(_CMAKE_TOOL_CACHED)
+    mark_as_advanced(CMAKE_${_CMAKE_TOOL})
+  endif()
+  unset(_CMAKE_${_CMAKE_TOOL}_NAMES)
+endforeach()
+unset(_CMAKE_TOOL_VARS)
+unset(_CMAKE_TOOL_CACHED)
+unset(_CMAKE_TOOL_NAME)
+unset(_CMAKE_TOOL)
+
+if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" MATCHES "^xIAR$")
+  # Set for backwards compatibility
+  set(CMAKE_IAR_ARCHIVE "${CMAKE_AR}" CACHE FILEPATH "The IAR archiver")
+  set(CMAKE_IAR_LINKER "${CMAKE_LINKER}" CACHE FILEPATH "The IAR ILINK linker")
+  mark_as_advanced(CMAKE_IAR_LINKER CMAKE_IAR_AR)
+endif()
+
+cmake_policy(POP)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeFindCodeBlocks.cmake

@@ -0,0 +1,33 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This file is included in CMakeSystemSpecificInformation.cmake if
+# the CodeBlocks extra generator has been selected.
+
+find_program(CMAKE_CODEBLOCKS_EXECUTABLE NAMES codeblocks DOC "The CodeBlocks executable")
+
+if(CMAKE_CODEBLOCKS_EXECUTABLE)
+  set(CMAKE_OPEN_PROJECT_COMMAND "${CMAKE_CODEBLOCKS_EXECUTABLE} <PROJECT_FILE>" )
+endif()
+
+# Determine builtin macros and include dirs:
+include(${CMAKE_CURRENT_LIST_DIR}/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake)
+
+# Try to find out how many CPUs we have and set the -j argument for make accordingly
+set(_CMAKE_CODEBLOCKS_INITIAL_MAKE_ARGS "")
+
+include(ProcessorCount)
+processorcount(_CMAKE_CODEBLOCKS_PROCESSOR_COUNT)
+
+# Only set -j if we are under UNIX and if the make-tool used actually has "make" in the name
+# (we may also get here in the future e.g. for ninja)
+if("${_CMAKE_CODEBLOCKS_PROCESSOR_COUNT}" GREATER 1  AND  CMAKE_HOST_UNIX  AND  "${CMAKE_MAKE_PROGRAM}" MATCHES make)
+  set(_CMAKE_CODEBLOCKS_INITIAL_MAKE_ARGS "-j${_CMAKE_CODEBLOCKS_PROCESSOR_COUNT}")
+endif()
+
+# This variable is used by the CodeBlocks generator and appended to the make invocation commands.
+set(CMAKE_CODEBLOCKS_MAKE_ARGUMENTS "${_CMAKE_CODEBLOCKS_INITIAL_MAKE_ARGS}" CACHE STRING "Additional command line arguments when CodeBlocks invokes make. Enter e.g. -j<some_number> to get parallel builds")
+
+# This variable is used by the CodeBlocks generator and allows the user to overwrite the autodetected CodeBlocks compiler id
+set(CMAKE_CODEBLOCKS_COMPILER_ID "" CACHE STRING "Id string of the compiler for the CodeBlocks IDE. Automatically detected when left empty")

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeFindPackageMode.cmake

@@ -0,0 +1,203 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CMakeFindPackageMode
+--------------------
+
+This file is executed by cmake when invoked with
+:ref:`--find-package <Find-Package Tool Mode>`.
+It expects that the following variables are set using ``-D``:
+
+``NAME``
+  name of the package
+``COMPILER_ID``
+  the CMake compiler ID for which the result is,
+  i.e. GNU/Intel/Clang/MSVC, etc.
+``LANGUAGE``
+  language for which the result will be used,
+  i.e. C/CXX/Fortran/ASM
+``MODE``
+  ``EXIST``
+    only check for existence of the given package
+  ``COMPILE``
+    print the flags needed for compiling an object file which uses
+    the given package
+  ``LINK``
+    print the flags needed for linking when using the given package
+``QUIET``
+  if TRUE, don't print anything
+#]=======================================================================]
+
+if(NOT NAME)
+  message(FATAL_ERROR "Name of the package to be searched not specified. Set the CMake variable NAME, e.g. -DNAME=JPEG .")
+endif()
+
+if(NOT COMPILER_ID)
+  message(FATAL_ERROR "COMPILER_ID argument not specified. In doubt, use GNU.")
+endif()
+
+if(NOT LANGUAGE)
+  message(FATAL_ERROR "LANGUAGE argument not specified. Use C, CXX or Fortran.")
+endif()
+
+if(NOT MODE)
+  message(FATAL_ERROR "MODE argument not specified. Use either EXIST, COMPILE or LINK.")
+endif()
+
+# require the current version. If we don't do this, Platforms/CYGWIN.cmake complains because
+# it doesn't know whether it should set WIN32 or not:
+cmake_minimum_required(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} )
+
+macro(ENABLE_LANGUAGE)
+  # disable the enable_language() command, otherwise --find-package breaks on Windows.
+  # On Windows, enable_language(RC) is called in the platform files unconditionally.
+  # But in --find-package mode, we don't want (and can't) enable any language.
+endmacro()
+
+set(CMAKE_PLATFORM_INFO_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
+
+include(CMakeDetermineSystem)
+
+# short-cut some tests on Darwin, see Darwin-GNU.cmake:
+if("${CMAKE_SYSTEM_NAME}" MATCHES Darwin  AND  "${COMPILER_ID}" MATCHES GNU)
+  set(CMAKE_${LANGUAGE}_SYSROOT_FLAG "")
+  set(CMAKE_${LANGUAGE}_OSX_DEPLOYMENT_TARGET_FLAG "")
+endif()
+
+include(CMakeSystemSpecificInitialize)
+
+# Also load the system specific file, which sets up e.g. the search paths.
+# This makes the FIND_XXX() calls work much better
+include(CMakeSystemSpecificInformation)
+
+if(UNIX)
+
+  # try to guess whether we have a 64bit system, if it has not been set
+  # from the outside
+  if(NOT CMAKE_SIZEOF_VOID_P)
+    set(CMAKE_SIZEOF_VOID_P 4)
+    if(EXISTS ${CMAKE_SYSROOT}/usr/lib64)
+      set(CMAKE_SIZEOF_VOID_P 8)
+    else()
+      # use the file utility to check whether itself is 64 bit:
+      find_program(FILE_EXECUTABLE file)
+      if(FILE_EXECUTABLE)
+        get_filename_component(FILE_ABSPATH "${FILE_EXECUTABLE}" ABSOLUTE)
+        execute_process(COMMAND "${FILE_ABSPATH}" "${FILE_ABSPATH}" OUTPUT_VARIABLE fileOutput ERROR_QUIET)
+        if("${fileOutput}" MATCHES "64-bit")
+          set(CMAKE_SIZEOF_VOID_P 8)
+        endif()
+      endif()
+    endif()
+  endif()
+
+  # guess Debian multiarch if it has not been set:
+  if(EXISTS /etc/debian_version)
+    if(NOT CMAKE_${LANGUAGE}_LIBRARY_ARCHITECTURE )
+      file(GLOB filesInLib RELATIVE /lib /lib/*-linux-gnu* )
+      foreach(file ${filesInLib})
+        if("${file}" MATCHES "${CMAKE_LIBRARY_ARCHITECTURE_REGEX}")
+          set(CMAKE_${LANGUAGE}_LIBRARY_ARCHITECTURE ${file})
+          break()
+        endif()
+      endforeach()
+    endif()
+    if(NOT CMAKE_LIBRARY_ARCHITECTURE)
+      set(CMAKE_LIBRARY_ARCHITECTURE ${CMAKE_${LANGUAGE}_LIBRARY_ARCHITECTURE})
+    endif()
+  endif()
+
+endif()
+
+set(CMAKE_${LANGUAGE}_COMPILER "dummy")
+set(CMAKE_${LANGUAGE}_COMPILER_ID "${COMPILER_ID}")
+include(CMake${LANGUAGE}Information)
+
+
+function(set_compile_flags_var _packageName)
+  string(TOUPPER "${_packageName}" PACKAGE_NAME)
+  # Check the following variables:
+  # FOO_INCLUDE_DIRS
+  # Foo_INCLUDE_DIRS
+  # FOO_INCLUDES
+  # Foo_INCLUDES
+  # FOO_INCLUDE_DIR
+  # Foo_INCLUDE_DIR
+  set(includes)
+  if(DEFINED ${_packageName}_INCLUDE_DIRS)
+    set(includes ${_packageName}_INCLUDE_DIRS)
+  elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIRS)
+    set(includes ${PACKAGE_NAME}_INCLUDE_DIRS)
+  elseif(DEFINED ${_packageName}_INCLUDES)
+    set(includes ${_packageName}_INCLUDES)
+  elseif(DEFINED ${PACKAGE_NAME}_INCLUDES)
+    set(includes ${PACKAGE_NAME}_INCLUDES)
+  elseif(DEFINED ${_packageName}_INCLUDE_DIR)
+    set(includes ${_packageName}_INCLUDE_DIR)
+  elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIR)
+    set(includes ${PACKAGE_NAME}_INCLUDE_DIR)
+  endif()
+
+  set(PACKAGE_INCLUDE_DIRS "${${includes}}" PARENT_SCOPE)
+
+  # Check the following variables:
+  # FOO_DEFINITIONS
+  # Foo_DEFINITIONS
+  set(definitions)
+  if(DEFINED ${_packageName}_DEFINITIONS)
+    set(definitions ${_packageName}_DEFINITIONS)
+  elseif(DEFINED ${PACKAGE_NAME}_DEFINITIONS)
+    set(definitions ${PACKAGE_NAME}_DEFINITIONS)
+  endif()
+
+  set(PACKAGE_DEFINITIONS  "${${definitions}}" )
+
+endfunction()
+
+
+function(set_link_flags_var _packageName)
+  string(TOUPPER "${_packageName}" PACKAGE_NAME)
+  # Check the following variables:
+  # FOO_LIBRARIES
+  # Foo_LIBRARIES
+  # FOO_LIBS
+  # Foo_LIBS
+  set(libs)
+  if(DEFINED ${_packageName}_LIBRARIES)
+    set(libs ${_packageName}_LIBRARIES)
+  elseif(DEFINED ${PACKAGE_NAME}_LIBRARIES)
+    set(libs ${PACKAGE_NAME}_LIBRARIES)
+  elseif(DEFINED ${_packageName}_LIBS)
+    set(libs ${_packageName}_LIBS)
+  elseif(DEFINED ${PACKAGE_NAME}_LIBS)
+    set(libs ${PACKAGE_NAME}_LIBS)
+  endif()
+
+  set(PACKAGE_LIBRARIES "${${libs}}" PARENT_SCOPE )
+
+endfunction()
+
+
+find_package("${NAME}" QUIET)
+
+set(PACKAGE_FOUND FALSE)
+
+string(TOUPPER "${NAME}" UPPERCASE_NAME)
+
+if(${NAME}_FOUND  OR  ${UPPERCASE_NAME}_FOUND)
+  set(PACKAGE_FOUND TRUE)
+
+  if("${MODE}" STREQUAL "EXIST")
+    # do nothing
+  elseif("${MODE}" STREQUAL "COMPILE")
+    set_compile_flags_var(${NAME})
+  elseif("${MODE}" STREQUAL "LINK")
+    set_link_flags_var(${NAME})
+  else()
+    message(FATAL_ERROR "Invalid mode argument ${MODE} given.")
+  endif()
+
+endif()
+
+set(PACKAGE_QUIET ${SILENT} )

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeFindSublimeText2.cmake

@@ -0,0 +1,23 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This file is included in CMakeSystemSpecificInformation.cmake if
+# the Sublime Text 2 extra generator has been selected.
+
+find_program(CMAKE_SUBLIMETEXT_EXECUTABLE
+    NAMES subl3 subl sublime_text
+    PATHS
+        "/Applications/Sublime Text.app/Contents/SharedSupport/bin"
+        "/Applications/Sublime Text 3.app/Contents/SharedSupport/bin"
+        "/Applications/Sublime Text 2.app/Contents/SharedSupport/bin"
+        "$ENV{HOME}/Applications/Sublime Text.app/Contents/SharedSupport/bin"
+        "$ENV{HOME}/Applications/Sublime Text 3.app/Contents/SharedSupport/bin"
+        "$ENV{HOME}/Applications/Sublime Text 2.app/Contents/SharedSupport/bin"
+        "/opt/sublime_text"
+        "/opt/sublime_text_3"
+    DOC "The Sublime Text executable")
+
+if(CMAKE_SUBLIMETEXT_EXECUTABLE)
+  set(CMAKE_OPEN_PROJECT_COMMAND "${CMAKE_SUBLIMETEXT_EXECUTABLE} --project <PROJECT_FILE>" )
+endif()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeFortranCompilerId.F.in

@@ -0,0 +1,279 @@
+      PROGRAM CMakeFortranCompilerId
+#if 0
+! Identify the compiler
+#endif
+#if defined(_MSC_VER)
+       PRINT *, 'INFO:simulate[MSVC]'
+# if _MSC_VER >= 1900
+       PRINT *, 'INFO:simulate_version[019.00]'
+# elif _MSC_VER >= 1800
+       PRINT *, 'INFO:simulate_version[018.00]'
+# elif _MSC_VER >= 1700
+       PRINT *, 'INFO:simulate_version[017.00]'
+# elif _MSC_VER >= 1600
+       PRINT *, 'INFO:simulate_version[016.00]'
+# elif _MSC_VER >= 1500
+       PRINT *, 'INFO:simulate_version[015.00]'
+# elif _MSC_VER >= 1400
+       PRINT *, 'INFO:simulate_version[014.00]'
+# elif _MSC_VER >= 1310
+       PRINT *, 'INFO:simulate_version[013.01]'
+# else
+       PRINT *, 'INFO:simulate_version[013.00]'
+# endif
+#endif
+#if defined(__INTEL_LLVM_COMPILER)
+        PRINT *, 'INFO:compiler[IntelLLVM]'
+! __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
+! later.  Look for 6 digit vs. 8 digit version number to decide encoding.
+! VVVV is no smaller than the current year when a version is released.
+# if __INTEL_LLVM_COMPILER < 1000000
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER    % 10)
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER     % 100)
+# endif
+#elif defined(__INTEL_COMPILER) && __INTEL_COMPILER == 201900
+        PRINT *, 'INFO:compiler[IntelLLVM]'
+! ifx 2021.1 forgot to define __INTEL_LLVM_COMPILER.
+! Instead it defines __INTEL_COMPILER == 201900.
+# define COMPILER_VERSION_MAJOR DEC(2021)
+# define COMPILER_VERSION_MINOR DEC(1)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+#elif defined(__INTEL_COMPILER) || defined(__ICC)
+        PRINT *, 'INFO:compiler[Intel]'
+! __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later.
+# if __INTEL_COMPILER < 2021
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+#  if defined(__INTEL_COMPILER_UPDATE)
+#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+#  else
+#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+#  endif
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
+!  The third version component from --version is an update index,
+!  but no macro is provided for it.
+#  define COMPILER_VERSION_PATCH DEC(0)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+#elif defined(__SUNPRO_F95)
+        PRINT *, 'INFO:compiler[SunPro]'
+# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_F95>>8)
+# define COMPILER_VERSION_MINOR HEX(__SUNPRO_F95>>4 & 0xF)
+# define COMPILER_VERSION_PATCH HEX(__SUNPRO_F95    & 0xF)
+#elif defined(__SUNPRO_F90)
+        PRINT *, 'INFO:compiler[SunPro]'
+# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_F90>>8)
+# define COMPILER_VERSION_MINOR HEX(__SUNPRO_F90>>4 & 0xF)
+# define COMPILER_VERSION_PATCH HEX(__SUNPRO_F90    & 0xF)
+#elif defined(_CRAYFTN)
+        PRINT *, 'INFO:compiler[Cray]'
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+# if defined(_RELEASE_PATCHLEVEL)
+#  define COMPILER_VERSION_PATCH DEC(_RELEASE_PATCHLEVEL)
+# endif
+#elif defined(__G95__)
+        PRINT *, 'INFO:compiler[G95]'
+# define COMPILER_VERSION_MAJOR DEC(__G95__)
+# define COMPILER_VERSION_MINOR DEC(__G95_MINOR__)
+#elif defined(__PATHSCALE__)
+        PRINT *, 'INFO:compiler[PathScale]'
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+#elif defined(__ABSOFT__)
+        PRINT *, 'INFO:compiler[Absoft]'
+#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
+        PRINT *, 'INFO:compiler[LCC]'
+# define COMPILER_VERSION_MAJOR DEC(1)
+# define COMPILER_VERSION_MINOR DEC(__LCC__ - 100)
+# if defined(__LCC_MINOR__)
+#  define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
+# endif
+#elif defined(__GNUC__)
+        PRINT *, 'INFO:compiler[GNU]'
+# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+#elif defined(__IBMC__)
+# if defined(__COMPILER_VER__)
+        PRINT *, 'INFO:compiler[zOS]'
+# elif __IBMC__ >= 800
+        PRINT *, 'INFO:compiler[XL]'
+#  define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+#  define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+# else
+        PRINT *, 'INFO:compiler[VisualAge]'
+#  define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+#  define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+# endif
+#elif defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__)
+        PRINT *, 'INFO:compiler[NVHPC]'
+# if defined(__NVCOMPILER_MAJOR__)
+#  define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# endif
+# if defined(__NVCOMPILER_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
+# else
+#  define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# endif
+# if defined(__NVCOMPILER_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
+# elif defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+#elif defined(__PGI)
+        PRINT *, 'INFO:compiler[PGI]'
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+#elif defined(__FLANG)
+        PRINT *, 'INFO:compiler[Flang]'
+# define COMPILER_VERSION_MAJOR DEC(__FLANG_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__FLANG_MINOR__)
+# if defined(__FLANG_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__FLANG_PATCHLEVEL__)
+# endif
+#elif defined(__flang__)
+        PRINT *, 'INFO:compiler[LLVMFlang]'
+# define COMPILER_VERSION_MAJOR DEC(__flang_major__)
+# define COMPILER_VERSION_MINOR DEC(__flang_minor__)
+# if defined(__flang_patchlevel__)
+#  define COMPILER_VERSION_PATCH DEC(__flang_patchlevel__)
+# endif
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+        PRINT *, 'INFO:compiler[VisualAge]'
+#elif defined(__hpux) || defined(__hpux__)
+        PRINT *, 'INFO:compiler[HP]'
+#elif defined(NAGFOR)
+        PRINT *, 'INFO:compiler[NAG]'
+#define COMPILER_VERSION_MAJOR DEC(__NAG_COMPILER_RELEASE/10)
+#define COMPILER_VERSION_MINOR DEC(__NAG_COMPILER_RELEASE % 10)
+#define COMPILER_VERSION_PATCH DEC(__NAG_COMPILER_BUILD)
+#elif defined(__FUJITSU)
+        PRINT *, 'INFO:compiler[Fujitsu]'
+# if defined(__FRT_major__)
+#   define COMPILER_VERSION_MAJOR DEC(__FRT_major__)
+#   define COMPILER_VERSION_MINOR DEC(__FRT_minor__)
+#   define COMPILER_VERSION_PATCH DEC(__FRT_patchlevel__)
+# elif defined(__FRT_version__)
+        PRINT *, 'INFO:compiler_version['//__FRT_version__//']'
+# endif
+#elif defined(__LFORTRAN__)
+        PRINT *, 'INFO:compiler[LFortran]'
+#define COMPILER_VERSION_MAJOR DEC(__LFORTRAN_MAJOR__)
+#define COMPILER_VERSION_MINOR DEC(__LFORTRAN_MINOR__)
+#define COMPILER_VERSION_PATCH DEC(__LFORTRAN_PATCHLEVEL__)
+#else
+        PRINT *, 'INFO:compiler[]'
+#endif
+#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
+        PRINT *, 'INFO:compiler_wrapper[CrayPrgEnv]'
+#endif
+
+#if 0
+! Identify the platform
+#endif
+#if defined(__linux) || defined(__linux__) || defined(linux)
+        PRINT *, 'INFO:platform[Linux]'
+#elif defined(__CYGWIN__)
+        PRINT *, 'INFO:platform[Cygwin]'
+#elif defined(__MINGW32__)
+        PRINT *, 'INFO:platform[MinGW]'
+#elif defined(__APPLE__)
+        PRINT *, 'INFO:platform[Darwin]'
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+        PRINT *, 'INFO:platform[Windows]'
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+        PRINT *, 'INFO:platform[FreeBSD]'
+#elif defined(__NetBSD__) || defined(__NetBSD)
+        PRINT *, 'INFO:platform[NetBSD]'
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+        PRINT *, 'INFO:platform[OpenBSD]'
+#elif defined(__sun) || defined(sun)
+        PRINT *, 'INFO:platform[SunOS]'
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+        PRINT *, 'INFO:platform[AIX]'
+#elif defined(__hpux) || defined(__hpux__)
+        PRINT *, 'INFO:platform[HP-UX]'
+#elif defined(__HAIKU__)
+        PRINT *, 'INFO:platform[Haiku]'
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+        PRINT *, 'INFO:platform[BeOS]'
+#elif defined(__QNX__) || defined(__QNXNTO__)
+        PRINT *, 'INFO:platform[QNX]'
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+        PRINT *, 'INFO:platform[Tru64]'
+#elif defined(__riscos) || defined(__riscos__)
+        PRINT *, 'INFO:platform[RISCos]'
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+        PRINT *, 'INFO:platform[SINIX]'
+#elif defined(__UNIX_SV__)
+        PRINT *, 'INFO:platform[UNIX_SV]'
+#elif defined(__bsdos__)
+        PRINT *, 'INFO:platform[BSDOS]'
+#elif defined(_MPRAS) || defined(MPRAS)
+        PRINT *, 'INFO:platform[MP-RAS]'
+#elif defined(__osf) || defined(__osf__)
+        PRINT *, 'INFO:platform[OSF1]'
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+        PRINT *, 'INFO:platform[SCO_SV]'
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+        PRINT *, 'INFO:platform[ULTRIX]'
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+        PRINT *, 'INFO:platform[Xenix]'
+#else
+        PRINT *, 'INFO:platform[]'
+#endif
+#if defined(_MSC_VER)
+# if defined(_M_IA64)
+        PRINT *, 'INFO:arch[IA64]'
+# elif defined(_M_X64) || defined(_M_AMD64)
+        PRINT *, 'INFO:arch[x64]'
+# elif defined(_M_IX86)
+        PRINT *, 'INFO:arch[X86]'
+# endif
+#endif
+
+#if 0
+! Encode compiler version digits
+#endif
+#define DEC_8(n) (((n) / 10000000) % 10)
+#define DEC_7(n) (((n) / 1000000)  % 10)
+#define DEC_6(n) (((n) / 100000)   % 10)
+#define DEC_5(n) (((n) / 10000)    % 10)
+#define DEC_4(n) (((n) / 1000)     % 10)
+#define DEC_3(n) (((n) / 100)      % 10)
+#define DEC_2(n) (((n) / 10)       % 10)
+#define DEC_1(n) (((n)    )        % 10)
+#define HEX_8(n) ((n)>>28 & 0xF)
+#define HEX_7(n) ((n)>>24 & 0xF)
+#define HEX_6(n) ((n)>>20 & 0xF)
+#define HEX_5(n) ((n)>>16 & 0xF)
+#define HEX_4(n) ((n)>>12 & 0xF)
+#define HEX_3(n) ((n)>>8  & 0xF)
+#define HEX_2(n) ((n)>>4  & 0xF)
+#define HEX_1(n) ((n)     & 0xF)
+@CMAKE_Fortran_COMPILER_ID_VERSION_INFO@
+
+      END

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeFortranInformation.cmake

@@ -0,0 +1,135 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+include(CMakeLanguageInformation)
+
+# This file sets the basic flags for the Fortran language in CMake.
+# It also loads the available platform file for the system-compiler
+# if it exists.
+
+set(_INCLUDED_FILE 0)
+
+# Load compiler-specific information.
+if(CMAKE_Fortran_COMPILER_ID)
+  include(Compiler/${CMAKE_Fortran_COMPILER_ID}-Fortran OPTIONAL)
+endif()
+
+set(CMAKE_BASE_NAME)
+get_filename_component(CMAKE_BASE_NAME "${CMAKE_Fortran_COMPILER}" NAME_WE)
+# since the gnu compiler has several names force g++
+if(CMAKE_COMPILER_IS_GNUG77)
+  set(CMAKE_BASE_NAME g77)
+endif()
+if(CMAKE_Fortran_COMPILER_ID)
+  include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_Fortran_COMPILER_ID}-Fortran OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
+endif()
+if (NOT _INCLUDED_FILE)
+  include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL
+          RESULT_VARIABLE _INCLUDED_FILE)
+endif ()
+
+# load any compiler-wrapper specific information
+if (CMAKE_Fortran_COMPILER_WRAPPER)
+  __cmake_include_compiler_wrapper(Fortran)
+endif ()
+
+# We specify the compiler information in the system file for some
+# platforms, but this language may not have been enabled when the file
+# was first included.  Include it again to get the language info.
+# Remove this when all compiler info is removed from system files.
+if (NOT _INCLUDED_FILE)
+  include(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
+endif ()
+
+if(CMAKE_Fortran_SIZEOF_DATA_PTR)
+  foreach(f IN LISTS CMAKE_Fortran_ABI_FILES)
+    include(${f})
+  endforeach()
+  unset(CMAKE_Fortran_ABI_FILES)
+endif()
+
+# This should be included before the _INIT variables are
+# used to initialize the cache.  Since the rule variables
+# have if blocks on them, users can still define them here.
+# But, it should still be after the platform file so changes can
+# be made to those values.
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE)
+  # Save the full path of the file so try_compile can use it.
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
+endif()
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE_Fortran)
+  # Save the full path of the file so try_compile can use it.
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE_Fortran} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE_Fortran "${_override}")
+endif()
+
+set(CMAKE_VERBOSE_MAKEFILE FALSE CACHE BOOL "If this value is on, makefiles will be generated without the .SILENT directive, and all commands will be echoed to the console during the make.  This is useful for debugging only. With Visual Studio IDE projects all commands are done without /nologo.")
+
+set(CMAKE_Fortran_FLAGS_INIT "$ENV{FFLAGS} ${CMAKE_Fortran_FLAGS_INIT}")
+
+cmake_initialize_per_config_variable(CMAKE_Fortran_FLAGS "Flags used by the Fortran compiler")
+
+if(NOT CMAKE_Fortran_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_Fortran_COMPILER_LAUNCHER})
+  set(CMAKE_Fortran_COMPILER_LAUNCHER "$ENV{CMAKE_Fortran_COMPILER_LAUNCHER}"
+    CACHE STRING "Compiler launcher for Fortran.")
+endif()
+
+include(CMakeCommonLanguageInclude)
+_cmake_common_language_platform_flags(Fortran)
+
+# now define the following rule variables
+# CMAKE_Fortran_CREATE_SHARED_LIBRARY
+# CMAKE_Fortran_CREATE_SHARED_MODULE
+# CMAKE_Fortran_COMPILE_OBJECT
+# CMAKE_Fortran_LINK_EXECUTABLE
+
+# create a Fortran shared library
+if(NOT CMAKE_Fortran_CREATE_SHARED_LIBRARY)
+  set(CMAKE_Fortran_CREATE_SHARED_LIBRARY
+      "<CMAKE_Fortran_COMPILER> <CMAKE_SHARED_LIBRARY_Fortran_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
+endif()
+
+# create a Fortran shared module just copy the shared library rule
+if(NOT CMAKE_Fortran_CREATE_SHARED_MODULE)
+  set(CMAKE_Fortran_CREATE_SHARED_MODULE ${CMAKE_Fortran_CREATE_SHARED_LIBRARY})
+endif()
+
+# Create a static archive incrementally for large object file counts.
+# If CMAKE_Fortran_CREATE_STATIC_LIBRARY is set it will override these.
+if(NOT DEFINED CMAKE_Fortran_ARCHIVE_CREATE)
+  set(CMAKE_Fortran_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_Fortran_ARCHIVE_APPEND)
+  set(CMAKE_Fortran_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_Fortran_ARCHIVE_FINISH)
+  set(CMAKE_Fortran_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
+endif()
+
+# compile a Fortran file into an object file
+# (put -o after -c to workaround bug in at least one mpif77 wrapper)
+if(NOT CMAKE_Fortran_COMPILE_OBJECT)
+  set(CMAKE_Fortran_COMPILE_OBJECT
+    "<CMAKE_Fortran_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -c <SOURCE> -o <OBJECT>")
+endif()
+
+# link a fortran program
+if(NOT CMAKE_Fortran_LINK_EXECUTABLE)
+  set(CMAKE_Fortran_LINK_EXECUTABLE
+    "<CMAKE_Fortran_COMPILER> <CMAKE_Fortran_LINK_FLAGS> <LINK_FLAGS> <FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
+endif()
+
+if(CMAKE_Fortran_STANDARD_LIBRARIES_INIT)
+  set(CMAKE_Fortran_STANDARD_LIBRARIES "${CMAKE_Fortran_STANDARD_LIBRARIES_INIT}"
+    CACHE STRING "Libraries linked by default with all Fortran applications.")
+  mark_as_advanced(CMAKE_Fortran_STANDARD_LIBRARIES)
+endif()
+
+set(CMAKE_Fortran_USE_LINKER_INFORMATION TRUE)
+
+# set this variable so we can avoid loading this more than once.
+set(CMAKE_Fortran_INFORMATION_LOADED 1)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeHIPCompilerABI.hip

@@ -0,0 +1,30 @@
+#if !defined(__HIP__) && !defined(__NVCC__)
+#  error "A C or C++ compiler has been selected for HIP"
+#endif
+
+#include "CMakeCompilerABI.h"
+
+#if defined(__NVCC__)
+#  include "CMakeCompilerCUDAArch.h"
+#endif
+
+int main(int argc, char* argv[])
+{
+  int require = 0;
+  require += info_sizeof_dptr[argc];
+#if defined(ABI_ID)
+  require += info_abi[argc];
+#endif
+  static_cast<void>(argv);
+
+#if defined(__NVCC__)
+  if (!cmakeCompilerCUDAArch()) {
+    // Convince the compiler that the non-zero return value depends
+    // on the info strings so they are not optimized out.
+    return require ? -1 : 1;
+  }
+  return 0;
+#else
+  return require;
+#endif
+}

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeISPCCompilerId.ispc.in

@@ -0,0 +1,62 @@
+
+export void ispcCompilerId() {
+
+// Identify the compiler
+#if defined(ISPC)
+  print("INFO:compiler[Intel]");
+#endif
+
+// Identify the platform
+#if defined(__linux) || defined(__linux__) || defined(linux)
+  print("INFO:platform[Linux]");
+#elif defined(__CYGWIN__)
+  print("INFO:platform[Cygwin]");
+#elif defined(__MINGW32__)
+  print("INFO:platform[MinGW]");
+#elif defined(__APPLE__)
+  print("INFO:platform[Darwin]");
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+  print("INFO:platform[Windows]");
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+  print("INFO:platform[FreeBSD]");
+#elif defined(__NetBSD__) || defined(__NetBSD)
+  print("INFO:platform[NetBSD]");
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+  print("INFO:platform[OpenBSD]");
+#elif defined(__sun) || defined(sun)
+  print("INFO:platform[SunOS]");
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+  print("INFO:platform[AIX]");
+#elif defined(__hpux) || defined(__hpux__)
+  print("INFO:platform[HP-UX]");
+#elif defined(__HAIKU__)
+  print("INFO:platform[Haiku]");
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+  print("INFO:platform[BeOS]");
+#elif defined(__QNX__) || defined(__QNXNTO__)
+  print("INFO:platform[QNX]");
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+  print("INFO:platform[Tru64]");
+#elif defined(__riscos) || defined(__riscos__)
+  print("INFO:platform[RISCos]");
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+  print("INFO:platform[SINIX]");
+#elif defined(__UNIX_SV__)
+  print("INFO:platform[UNIX_SV]");
+#elif defined(__bsdos__)
+  print("INFO:platform[BSDOS]");
+#elif defined(_MPRAS) || defined(MPRAS)
+  print("INFO:platform[MP-RAS]");
+#elif defined(__osf) || defined(__osf__)
+  print("INFO:platform[OSF1]");
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+  print("INFO:platform[SCO_SV]");
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+  print("INFO:platform[ULTRIX]");
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+  print("INFO:platform[Xenix]");
+#else
+  print("INFO:platform[]");
+#endif
+
+}

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeMSYSFindMake.cmake

@@ -0,0 +1,15 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+find_program(CMAKE_MAKE_PROGRAM make
+  REGISTRY_VIEW 32
+  PATHS
+      # Typical install path for 32-bit MSYS2 (https://repo.msys2.org/distrib/msys2-i686-latest.sfx.exe)
+      "C:/msys32/usr"
+      # Typical install path for MINGW32 (https://sourceforge.net/projects/mingw)
+      "C:/mingw/msys"
+      # Git for Windows 32-bit (https://gitforwindows.org/)
+      "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GitForWindows;InstallPath]/usr")
+
+mark_as_advanced(CMAKE_MAKE_PROGRAM)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeNMakeFindMake.cmake

@@ -0,0 +1,7 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+set (CMAKE_MAKE_PROGRAM "nmake" CACHE STRING
+     "Program used to build from makefiles.")
+mark_as_advanced(CMAKE_MAKE_PROGRAM)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakePackageConfigHelpers.cmake

@@ -0,0 +1,690 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CMakePackageConfigHelpers
+-------------------------
+
+Helper functions for creating config files that can be included by other
+projects to find and use a package.
+
+Generating a Package Configuration File
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. command:: configure_package_config_file
+
+ Create a config file for a project::
+
+   configure_package_config_file(<input> <output>
+     INSTALL_DESTINATION <path>
+     [PATH_VARS <var1> <var2> ... <varN>]
+     [NO_SET_AND_CHECK_MACRO]
+     [NO_CHECK_REQUIRED_COMPONENTS_MACRO]
+     [INSTALL_PREFIX <path>]
+     )
+
+``configure_package_config_file()`` should be used instead of the plain
+:command:`configure_file()` command when creating the ``<PackageName>Config.cmake``
+or ``<PackageName>-config.cmake`` file for installing a project or library.
+It helps make the resulting package relocatable by avoiding hardcoded paths
+in the installed ``<PackageName>Config.cmake`` file.
+
+In a ``FooConfig.cmake`` file there may be code like this to make the install
+destinations known to the using project:
+
+.. code-block:: cmake
+
+   set(FOO_INCLUDE_DIR   "@CMAKE_INSTALL_FULL_INCLUDEDIR@" )
+   set(FOO_DATA_DIR   "@CMAKE_INSTALL_PREFIX@/@RELATIVE_DATA_INSTALL_DIR@" )
+   set(FOO_ICONS_DIR   "@CMAKE_INSTALL_PREFIX@/share/icons" )
+   #...logic to determine installedPrefix from the own location...
+   set(FOO_CONFIG_DIR  "${installedPrefix}/@CONFIG_INSTALL_DIR@" )
+
+All four options shown above are not sufficient  The first three hardcode the
+absolute directory locations.  The fourth case works only if the logic to
+determine the ``installedPrefix`` is correct, and if ``CONFIG_INSTALL_DIR``
+contains a relative path, which in general cannot be guaranteed.  This has the
+effect that the resulting ``FooConfig.cmake`` file would work poorly under
+Windows and macOS, where users are used to choosing the install location of a
+binary package at install time, independent from how
+:variable:`CMAKE_INSTALL_PREFIX` was set at build/cmake time.
+
+Using ``configure_package_config_file()`` helps.  If used correctly, it makes
+the resulting ``FooConfig.cmake`` file relocatable.  Usage:
+
+1. Write a ``FooConfig.cmake.in`` file as you are used to.
+2. Insert a line at the top containing only the string ``@PACKAGE_INIT@``.
+3. Instead of ``set(FOO_DIR "@SOME_INSTALL_DIR@")``, use
+   ``set(FOO_DIR "@PACKAGE_SOME_INSTALL_DIR@")`` (this must be after the
+   ``@PACKAGE_INIT@`` line).
+4. Instead of using the normal :command:`configure_file()` command, use
+   ``configure_package_config_file()``.
+
+The ``<input>`` and ``<output>`` arguments are the input and output file, the
+same way as in :command:`configure_file()`.
+
+The ``<path>`` given to ``INSTALL_DESTINATION`` must be the destination where
+the ``FooConfig.cmake`` file will be installed to.  This path can either be
+absolute, or relative to the ``INSTALL_PREFIX`` path.
+
+The variables ``<var1>`` to ``<varN>`` given as ``PATH_VARS`` are the
+variables which contain install destinations.  For each of them, the macro will
+create a helper variable ``PACKAGE_<var...>``.  These helper variables must be
+used in the ``FooConfig.cmake.in`` file for setting the installed location.
+They are calculated by ``configure_package_config_file()`` so that they are
+always relative to the installed location of the package.  This works both for
+relative and also for absolute locations.  For absolute locations, it works
+only if the absolute location is a subdirectory of ``INSTALL_PREFIX``.
+
+.. versionadded:: 3.30
+  The variable ``PACKAGE_PREFIX_DIR`` will always be defined after the
+  ``@PACKAGE_INIT@`` line.  It will hold the value of the base install
+  location.  In general, variables defined via the ``PATH_VARS`` mechanism
+  should be used instead, but ``PACKAGE_PREFIX_DIR`` can be used for those
+  cases not easily handled by ``PATH_VARS``, such as for files installed
+  directly to the base install location rather than a subdirectory of it.
+
+  .. note::
+    When consumers of the generated file use CMake 3.29 or older, the value
+    of ``PACKAGE_PREFIX_DIR`` can be changed by a call to
+    :command:`find_dependency` or :command:`find_package`.
+    If a project relies on ``PACKAGE_PREFIX_DIR``, it is the project's
+    responsibility to ensure that the value of ``PACKAGE_PREFIX_DIR`` is
+    preserved across any such calls, or any other calls which might include
+    another file generated by ``configure_package_config_file()``.
+
+.. versionadded:: 3.1
+  If the ``INSTALL_PREFIX`` argument is passed, this is used as the base path to
+  calculate all the relative paths.  The ``<path>`` argument must be an absolute
+  path.  If this argument is not passed, the :variable:`CMAKE_INSTALL_PREFIX`
+  variable will be used instead.  The default value is good when generating a
+  ``FooConfig.cmake`` file to use your package from the install tree.  When
+  generating a ``FooConfig.cmake`` file to use your package from the build tree,
+  this option should be used.
+
+By default, ``configure_package_config_file()`` also generates two helper
+macros, ``set_and_check()`` and ``check_required_components()``, into the
+``FooConfig.cmake`` file.
+
+``set_and_check()`` should be used instead of the normal :command:`set` command
+for setting directories and file locations.  In addition to setting the
+variable, it also checks that the referenced file or directory actually exists
+and fails with a fatal error if it doesn't.  This ensures that the generated
+``FooConfig.cmake`` file does not contain wrong references.
+Add the ``NO_SET_AND_CHECK_MACRO`` option to prevent the generation of the
+``set_and_check()`` macro in the ``FooConfig.cmake`` file.
+
+``check_required_components(<PackageName>)`` should be called at the end of
+the ``FooConfig.cmake`` file. This macro checks whether all requested,
+non-optional components have been found, and if this is not the case, it sets
+the ``Foo_FOUND`` variable to ``FALSE`` so that the package is considered to
+be not found.  It does that by testing the ``Foo_<Component>_FOUND``
+variables for all requested required components.  This macro should be
+called even if the package doesn't provide any components to make sure
+users are not specifying components erroneously.  Add the
+``NO_CHECK_REQUIRED_COMPONENTS_MACRO`` option to prevent the generation of the
+``check_required_components()`` macro in the ``FooConfig.cmake`` file.
+
+See also :ref:`CMakePackageConfigHelpers Examples`.
+
+Generating a Package Version File
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. command:: write_basic_package_version_file
+
+ Create a version file for a project::
+
+   write_basic_package_version_file(<filename>
+     [VERSION <major.minor.patch>]
+     COMPATIBILITY <AnyNewerVersion|SameMajorVersion|SameMinorVersion|ExactVersion>
+     [ARCH_INDEPENDENT] )
+
+
+Writes a file for use as a ``<PackageName>ConfigVersion.cmake`` file to
+``<filename>``.  See the documentation of :command:`find_package()` for
+details on such files.
+
+``<filename>`` is the output filename, which should be in the build tree.
+``<major.minor.patch>`` is the version number of the project to be installed.
+
+If no ``VERSION`` is given, the :variable:`PROJECT_VERSION` variable is used.
+If this hasn't been set, it errors out.
+
+The ``COMPATIBILITY`` mode ``AnyNewerVersion`` means that the installed
+package version will be considered compatible if it is newer or exactly the
+same as the requested version.  This mode should be used for packages which
+are fully backward compatible, also across major versions.
+If ``SameMajorVersion`` is used instead, then the behavior differs from
+``AnyNewerVersion`` in that the major version number must be the same as
+requested, e.g.  version 2.0 will not be considered compatible if 1.0 is
+requested.  This mode should be used for packages which guarantee backward
+compatibility within the same major version.
+If ``SameMinorVersion`` is used, the behavior is the same as
+``SameMajorVersion``, but both major and minor version must be the same as
+requested, e.g version 0.2 will not be compatible if 0.1 is requested.
+If ``ExactVersion`` is used, then the package is only considered compatible if
+the requested version matches exactly its own version number (not considering
+the tweak version).  For example, version 1.2.3 of a package is only
+considered compatible to requested version 1.2.3.  This mode is for packages
+without compatibility guarantees.
+If your project has more elaborate version matching rules, you will need to
+write your own custom ``<PackageName>ConfigVersion.cmake`` file instead of
+using this macro.
+
+.. versionadded:: 3.11
+  The ``SameMinorVersion`` compatibility mode.
+
+.. versionadded:: 3.14
+  If ``ARCH_INDEPENDENT`` is given, the installed package version will be
+  considered compatible even if it was built for a different architecture than
+  the requested architecture.  Otherwise, an architecture check will be performed,
+  and the package will be considered compatible only if the architecture matches
+  exactly.  For example, if the package is built for a 32-bit architecture, the
+  package is only considered compatible if it is used on a 32-bit architecture,
+  unless ``ARCH_INDEPENDENT`` is given, in which case the package is considered
+  compatible on any architecture.
+
+  .. note:: ``ARCH_INDEPENDENT`` is intended for header-only libraries or
+    similar packages with no binaries.
+
+.. versionadded:: 3.19
+  The version file generated by ``AnyNewerVersion``, ``SameMajorVersion`` and
+  ``SameMinorVersion`` arguments of ``COMPATIBILITY`` handle the version range,
+  if one is specified (see :command:`find_package` command for the details).
+  ``ExactVersion`` mode is incompatible with version ranges and will display an
+  author warning if one is specified.
+
+Internally, this macro executes :command:`configure_file()` to create the
+resulting version file.  Depending on the ``COMPATIBILITY``, the corresponding
+``BasicConfigVersion-<COMPATIBILITY>.cmake.in`` file is used.
+Please note that these files are internal to CMake and you should not call
+:command:`configure_file()` on them yourself, but they can be used as a starting
+point to create more sophisticated custom ``<PackageName>ConfigVersion.cmake``
+files.
+
+Generating an Apple Platform Selection File
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. command:: generate_apple_platform_selection_file
+
+  .. versionadded:: 3.29
+
+  Create an Apple platform selection file:
+
+  .. code-block:: cmake
+
+    generate_apple_platform_selection_file(<filename>
+      INSTALL_DESTINATION <path>
+      [INSTALL_PREFIX <path>]
+      [MACOS_INCLUDE_FILE <file>]
+      [IOS_INCLUDE_FILE <file>]
+      [IOS_SIMULATOR_INCLUDE_FILE <file>]
+      [IOS_CATALYST_INCLUDE_FILE <file>]
+      [TVOS_INCLUDE_FILE <file>]
+      [TVOS_SIMULATOR_INCLUDE_FILE <file>]
+      [WATCHOS_INCLUDE_FILE <file>]
+      [WATCHOS_SIMULATOR_INCLUDE_FILE <file>]
+      [VISIONOS_INCLUDE_FILE <file>]
+      [VISIONOS_SIMULATOR_INCLUDE_FILE <file>]
+      [ERROR_VARIABLE <variable>]
+      )
+
+  Write a file that includes an Apple-platform-specific ``.cmake`` file,
+  e.g., for use as ``<PackageName>Config.cmake``.  This can be used in
+  conjunction with the ``XCFRAMEWORK_LOCATION`` argument of
+  :command:`export(SETUP)` to export packages in a way that a project
+  built for any Apple platform can use them.
+
+  ``INSTALL_DESTINATION <path>``
+    Path to which the generated file will be installed by the caller, e.g.,
+    via :command:`install(FILES)`.  The path may be either relative to the
+    ``INSTALL_PREFIX`` or absolute.
+
+  ``INSTALL_PREFIX <path>``
+    Path prefix to which the package will be installed by the caller.
+    The ``<path>`` argument must be an absolute path.  If this argument
+    is not passed, the :variable:`CMAKE_INSTALL_PREFIX` variable will be
+    used instead.
+
+  ``MACOS_INCLUDE_FILE <file>``
+    File to include if the platform is macOS.
+
+  ``IOS_INCLUDE_FILE <file>``
+    File to include if the platform is iOS.
+
+  ``IOS_SIMULATOR_INCLUDE_FILE <file>``
+    File to include if the platform is iOS Simulator.
+
+  ``IOS_CATALYST_INCLUDE_FILE <file>``
+    .. versionadded:: 3.31
+
+    File to include if the platform is iOS Catalyst.
+
+  ``TVOS_INCLUDE_FILE <file>``
+    File to include if the platform is tvOS.
+
+  ``TVOS_SIMULATOR_INCLUDE_FILE <file>``
+    File to include if the platform is tvOS Simulator.
+
+  ``WATCHOS_INCLUDE_FILE <file>``
+    File to include if the platform is watchOS.
+
+  ``WATCHOS_SIMULATOR_INCLUDE_FILE <file>``
+    File to include if the platform is watchOS Simulator.
+
+  ``VISIONOS_INCLUDE_FILE <file>``
+    File to include if the platform is visionOS.
+
+  ``VISIONOS_SIMULATOR_INCLUDE_FILE <file>``
+    File to include if the platform is visionOS Simulator.
+
+  ``ERROR_VARIABLE <variable>``
+    If the consuming project is built for an unsupported platform,
+    set ``<variable>`` to an error message.  The includer may use this
+    information to pretend the package was not found.  If this option
+    is not given, the default behavior is to issue a fatal error.
+
+  If any of the optional include files is not specified, and the consuming
+  project is built for its corresponding platform, the generated file will
+  consider the platform to be unsupported.  The behavior is determined
+  by the ``ERROR_VARIABLE`` option.
+
+Generating an Apple Architecture Selection File
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. command:: generate_apple_architecture_selection_file
+
+  .. versionadded:: 3.29
+
+  Create an Apple architecture selection file:
+
+  .. code-block:: cmake
+
+    generate_apple_architecture_selection_file(<filename>
+      INSTALL_DESTINATION <path>
+      [INSTALL_PREFIX <path>]
+      [SINGLE_ARCHITECTURES <arch>...
+       SINGLE_ARCHITECTURE_INCLUDE_FILES <file>...]
+      [UNIVERSAL_ARCHITECTURES <arch>...
+       UNIVERSAL_INCLUDE_FILE <file>]
+      [ERROR_VARIABLE <variable>]
+      )
+
+  Write a file that includes an Apple-architecture-specific ``.cmake`` file
+  based on :variable:`CMAKE_OSX_ARCHITECTURES`, e.g., for inclusion from an
+  Apple-specific ``<PackageName>Config.cmake`` file.
+
+  ``INSTALL_DESTINATION <path>``
+    Path to which the generated file will be installed by the caller, e.g.,
+    via :command:`install(FILES)`.  The path may be either relative to the
+    ``INSTALL_PREFIX`` or absolute.
+
+  ``INSTALL_PREFIX <path>``
+    Path prefix to which the package will be installed by the caller.
+    The ``<path>`` argument must be an absolute path.  If this argument
+    is not passed, the :variable:`CMAKE_INSTALL_PREFIX` variable will be
+    used instead.
+
+  ``SINGLE_ARCHITECTURES <arch>...``
+    Architectures provided by entries of ``SINGLE_ARCHITECTURE_INCLUDE_FILES``.
+
+  ``SINGLE_ARCHITECTURE_INCLUDE_FILES <file>...``
+    Architecture-specific files.  One of them will be loaded
+    when :variable:`CMAKE_OSX_ARCHITECTURES` contains a single
+    architecture matching the corresponding entry of
+    ``SINGLE_ARCHITECTURES``.
+
+  ``UNIVERSAL_ARCHITECTURES <arch>...``
+    Architectures provided by the ``UNIVERSAL_INCLUDE_FILE``.
+
+    The list may include ``$(ARCHS_STANDARD)`` to support consumption using
+    the :generator:`Xcode` generator, but the architectures should always
+    be listed individually too.
+
+  ``UNIVERSAL_INCLUDE_FILE <file>``
+    A file to load when :variable:`CMAKE_OSX_ARCHITECTURES` contains
+    a (non-strict) subset of the ``UNIVERSAL_ARCHITECTURES`` and
+    does not match any one of the ``SINGLE_ARCHITECTURES``.
+
+  ``ERROR_VARIABLE <variable>``
+    If the consuming project is built for an unsupported architecture,
+    set ``<variable>`` to an error message.  The includer may use this
+    information to pretend the package was not found.  If this option
+    is not given, the default behavior is to issue a fatal error.
+
+.. _`CMakePackageConfigHelpers Examples`:
+
+Example Generating Package Files
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Example using both the :command:`configure_package_config_file` and
+:command:`write_basic_package_version_file()` commands:
+
+.. code-block:: cmake
+   :caption: ``CMakeLists.txt``
+
+   include(GNUInstallDirs)
+   set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR}/Foo
+       CACHE PATH "Location of header files" )
+   set(SYSCONFIG_INSTALL_DIR ${CMAKE_INSTALL_SYSCONFDIR}/foo
+       CACHE PATH "Location of configuration files" )
+   #...
+   include(CMakePackageConfigHelpers)
+   configure_package_config_file(FooConfig.cmake.in
+     ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake
+     INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Foo
+     PATH_VARS INCLUDE_INSTALL_DIR SYSCONFIG_INSTALL_DIR)
+   write_basic_package_version_file(
+     ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake
+     VERSION 1.2.3
+     COMPATIBILITY SameMajorVersion )
+   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake
+                 ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake
+           DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Foo )
+
+.. code-block:: cmake
+   :caption: ``FooConfig.cmake.in``
+   :force:
+
+   set(FOO_VERSION x.y.z)
+   ...
+   @PACKAGE_INIT@
+   ...
+   set_and_check(FOO_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
+   set_and_check(FOO_SYSCONFIG_DIR "@PACKAGE_SYSCONFIG_INSTALL_DIR@")
+
+   check_required_components(Foo)
+#]=======================================================================]
+
+include(WriteBasicConfigVersionFile)
+
+macro(WRITE_BASIC_PACKAGE_VERSION_FILE)
+  write_basic_config_version_file(${ARGN})
+endmacro()
+
+function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile)
+  set(options NO_SET_AND_CHECK_MACRO NO_CHECK_REQUIRED_COMPONENTS_MACRO)
+  set(oneValueArgs INSTALL_DESTINATION INSTALL_PREFIX)
+  set(multiValueArgs PATH_VARS )
+
+  cmake_parse_arguments(CCF "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${ARGN})
+
+  if(CCF_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unknown keywords given to CONFIGURE_PACKAGE_CONFIG_FILE(): \"${CCF_UNPARSED_ARGUMENTS}\"")
+  endif()
+
+  if(NOT CCF_INSTALL_DESTINATION)
+    message(FATAL_ERROR "No INSTALL_DESTINATION given to CONFIGURE_PACKAGE_CONFIG_FILE()")
+  endif()
+
+  if(DEFINED CCF_INSTALL_PREFIX)
+    if(IS_ABSOLUTE "${CCF_INSTALL_PREFIX}")
+      set(installPrefix "${CCF_INSTALL_PREFIX}")
+    else()
+      message(FATAL_ERROR "INSTALL_PREFIX must be an absolute path")
+    endif()
+  elseif(IS_ABSOLUTE "${CMAKE_INSTALL_PREFIX}")
+    set(installPrefix "${CMAKE_INSTALL_PREFIX}")
+  else()
+    get_filename_component(installPrefix "${CMAKE_INSTALL_PREFIX}" ABSOLUTE)
+  endif()
+
+  if(IS_ABSOLUTE "${CCF_INSTALL_DESTINATION}")
+    set(absInstallDir "${CCF_INSTALL_DESTINATION}")
+  else()
+    set(absInstallDir "${installPrefix}/${CCF_INSTALL_DESTINATION}")
+  endif()
+
+  file(RELATIVE_PATH PACKAGE_RELATIVE_PATH "${absInstallDir}" "${installPrefix}" )
+
+  foreach(var ${CCF_PATH_VARS})
+    if(NOT DEFINED ${var})
+      message(FATAL_ERROR "Variable ${var} does not exist")
+    else()
+      if(IS_ABSOLUTE "${${var}}")
+        string(REPLACE "${installPrefix}" "\${PACKAGE_PREFIX_DIR}"
+                        PACKAGE_${var} "${${var}}")
+      else()
+        set(PACKAGE_${var} "\${PACKAGE_PREFIX_DIR}/${${var}}")
+      endif()
+    endif()
+  endforeach()
+
+  get_filename_component(inputFileName "${_inputFile}" NAME)
+
+  set(PACKAGE_INIT "
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was ${inputFileName}                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR \"\${CMAKE_CURRENT_LIST_DIR}/${PACKAGE_RELATIVE_PATH}\" ABSOLUTE)
+")
+
+  if("${absInstallDir}" MATCHES "^(/usr)?/lib(64)?/.+")
+    # Handle "/usr move" symlinks created by some Linux distros.
+    string(APPEND PACKAGE_INIT "
+# Use original install prefix when loaded through a \"/usr move\"
+# cross-prefix symbolic link such as /lib -> /usr/lib.
+get_filename_component(_realCurr \"\${CMAKE_CURRENT_LIST_DIR}\" REALPATH)
+get_filename_component(_realOrig \"${absInstallDir}\" REALPATH)
+if(_realCurr STREQUAL _realOrig)
+  set(PACKAGE_PREFIX_DIR \"${installPrefix}\")
+endif()
+unset(_realOrig)
+unset(_realCurr)
+")
+  endif()
+
+  if(NOT CCF_NO_SET_AND_CHECK_MACRO)
+    string(APPEND PACKAGE_INIT "
+macro(set_and_check _var _file)
+  set(\${_var} \"\${_file}\")
+  if(NOT EXISTS \"\${_file}\")
+    message(FATAL_ERROR \"File or directory \${_file} referenced by variable \${_var} does not exist !\")
+  endif()
+endmacro()
+")
+  endif()
+
+
+  if(NOT CCF_NO_CHECK_REQUIRED_COMPONENTS_MACRO)
+    string(APPEND PACKAGE_INIT "
+macro(check_required_components _NAME)
+  foreach(comp \${\${_NAME}_FIND_COMPONENTS})
+    if(NOT \${_NAME}_\${comp}_FOUND)
+      if(\${_NAME}_FIND_REQUIRED_\${comp})
+        set(\${_NAME}_FOUND FALSE)
+      endif()
+    endif()
+  endforeach()
+endmacro()
+")
+  endif()
+
+  string(APPEND PACKAGE_INIT "
+####################################################################################")
+
+  configure_file("${_inputFile}" "${_outputFile}" @ONLY)
+
+endfunction()
+
+function(generate_apple_platform_selection_file _output_file)
+  set(_config_file_options
+    MACOS_INCLUDE_FILE
+    IOS_INCLUDE_FILE
+    IOS_SIMULATOR_INCLUDE_FILE
+    IOS_CATALYST_INCLUDE_FILE
+    TVOS_INCLUDE_FILE
+    TVOS_SIMULATOR_INCLUDE_FILE
+    WATCHOS_INCLUDE_FILE
+    WATCHOS_SIMULATOR_INCLUDE_FILE
+    VISIONOS_INCLUDE_FILE
+    VISIONOS_SIMULATOR_INCLUDE_FILE
+    )
+
+  set(_options)
+  set(_single
+    INSTALL_DESTINATION
+    INSTALL_PREFIX
+    ${_config_file_options}
+    ERROR_VARIABLE
+    )
+  set(_multi)
+  cmake_parse_arguments(PARSE_ARGV 0 _gpsf "${_options}" "${_single}" "${_multi}")
+
+  if(NOT _gpsf_INSTALL_DESTINATION)
+    message(FATAL_ERROR "No INSTALL_DESTINATION given to generate_apple_platform_selection_file()")
+  endif()
+  if(_gpsf_INSTALL_PREFIX)
+    set(maybe_INSTALL_PREFIX INSTALL_PREFIX ${_gpsf_INSTALL_PREFIX})
+  else()
+    set(maybe_INSTALL_PREFIX "")
+  endif()
+
+  if(_gpsf_ERROR_VARIABLE)
+    set(_branch_INIT "set(\"${_gpsf_ERROR_VARIABLE}\" \"\")")
+  else()
+    set(_branch_INIT "")
+  endif()
+
+  set(_else ELSE)
+  foreach(_opt IN LISTS _config_file_options _else)
+    if(_gpsf_${_opt})
+      set(_config_file "${_gpsf_${_opt}}")
+      if(NOT IS_ABSOLUTE "${_config_file}")
+        string(PREPEND _config_file [[${PACKAGE_PREFIX_DIR}/]])
+      endif()
+      set(_branch_${_opt} "include(\"${_config_file}\")")
+    elseif(_gpsf_ERROR_VARIABLE)
+      set(_branch_${_opt} "set(\"${_gpsf_ERROR_VARIABLE}\" \"Platform not supported\")")
+    else()
+      set(_branch_${_opt} "message(FATAL_ERROR \"Platform not supported\")")
+    endif()
+  endforeach()
+
+  configure_package_config_file("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/Internal/ApplePlatformSelection.cmake.in" "${_output_file}"
+    INSTALL_DESTINATION "${_gpsf_INSTALL_DESTINATION}"
+    ${maybe_INSTALL_PREFIX}
+    NO_SET_AND_CHECK_MACRO
+    NO_CHECK_REQUIRED_COMPONENTS_MACRO
+    )
+endfunction()
+
+function(generate_apple_architecture_selection_file _output_file)
+  set(_options)
+  set(_single
+    INSTALL_DESTINATION
+    INSTALL_PREFIX
+    UNIVERSAL_INCLUDE_FILE
+    ERROR_VARIABLE
+    )
+  set(_multi
+    SINGLE_ARCHITECTURES
+    SINGLE_ARCHITECTURE_INCLUDE_FILES
+    UNIVERSAL_ARCHITECTURES
+    )
+  cmake_parse_arguments(PARSE_ARGV 0 _gasf "${_options}" "${_single}" "${_multi}")
+
+  if(NOT _gasf_INSTALL_DESTINATION)
+    message(FATAL_ERROR "No INSTALL_DESTINATION given to generate_apple_platform_selection_file()")
+  endif()
+  if(_gasf_INSTALL_PREFIX)
+    set(maybe_INSTALL_PREFIX INSTALL_PREFIX ${_gasf_INSTALL_PREFIX})
+  else()
+    set(maybe_INSTALL_PREFIX "")
+  endif()
+
+  list(LENGTH _gasf_SINGLE_ARCHITECTURES _gasf_SINGLE_ARCHITECTURES_len)
+  list(LENGTH _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES_len)
+  if(NOT _gasf_SINGLE_ARCHITECTURES_len EQUAL _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES_len)
+    message(FATAL_ERROR "SINGLE_ARCHITECTURES and SINGLE_ARCHITECTURE_INCLUDE_FILES do not have the same number of entries.")
+  endif()
+
+  set(_branch_code "")
+
+  if(_gasf_ERROR_VARIABLE)
+    string(APPEND _branch_code
+      "set(\"${_gasf_ERROR_VARIABLE}\" \"\")\n"
+      )
+  endif()
+
+  string(APPEND _branch_code
+    "\n"
+    "if(NOT CMAKE_OSX_ARCHITECTURES)\n"
+    )
+  if(_gasf_ERROR_VARIABLE)
+    string(APPEND _branch_code
+      "  set(\"${_gasf_ERROR_VARIABLE}\" \"CMAKE_OSX_ARCHITECTURES must be explicitly set for this package\")\n"
+      "  return()\n"
+      )
+  else()
+    string(APPEND _branch_code
+      "  message(FATAL_ERROR \"CMAKE_OSX_ARCHITECTURES must be explicitly set for this package\")\n"
+      )
+  endif()
+  string(APPEND _branch_code
+    "endif()\n\n"
+    "set(_cmake_apple_archs \"\${CMAKE_OSX_ARCHITECTURES}\")\n"
+    )
+  if(NOT "${_gasf_UNIVERSAL_ARCHITECTURES}" STREQUAL "")
+    string(APPEND _branch_code "list(REMOVE_ITEM _cmake_apple_archs ${_gasf_UNIVERSAL_ARCHITECTURES})\n")
+  endif()
+  string(APPEND _branch_code "\n")
+
+  set(maybe_else "")
+
+  foreach(pair IN ZIP_LISTS _gasf_SINGLE_ARCHITECTURES _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES)
+    set(arch "${pair_0}")
+    set(config_file "${pair_1}")
+    if(NOT IS_ABSOLUTE "${config_file}")
+      string(PREPEND config_file [[${PACKAGE_PREFIX_DIR}/]])
+    endif()
+    string(APPEND _branch_code
+      "${maybe_else}if(CMAKE_OSX_ARCHITECTURES STREQUAL \"${arch}\")\n"
+      "  include(\"${config_file}\")\n"
+      )
+    set(maybe_else else)
+  endforeach()
+
+  if(_gasf_UNIVERSAL_ARCHITECTURES AND _gasf_UNIVERSAL_INCLUDE_FILE)
+    set(config_file "${_gasf_UNIVERSAL_INCLUDE_FILE}")
+    if(NOT IS_ABSOLUTE "${config_file}")
+      string(PREPEND config_file [[${PACKAGE_PREFIX_DIR}/]])
+    endif()
+    string(APPEND _branch_code
+      "${maybe_else}if(NOT _cmake_apple_archs)\n"
+      "  include(\"${config_file}\")\n"
+      )
+    set(maybe_else else)
+  elseif(_gasf_UNIVERSAL_ARCHITECTURES)
+    message(FATAL_ERROR "UNIVERSAL_INCLUDE_FILE requires UNIVERSAL_ARCHITECTURES")
+  elseif(_gasf_UNIVERSAL_INCLUDE_FILE)
+    message(FATAL_ERROR "UNIVERSAL_ARCHITECTURES requires UNIVERSAL_INCLUDE_FILE")
+  endif()
+
+  if(maybe_else)
+    string(APPEND _branch_code "else()\n")
+    set(_indent "  ")
+  else()
+    set(_indent "")
+  endif()
+  if(_gasf_ERROR_VARIABLE)
+    string(APPEND _branch_code
+      "${_indent}set(\"${_gasf_ERROR_VARIABLE}\" \"Architecture not supported\")\n"
+      )
+  else()
+    string(APPEND _branch_code
+      "${_indent}message(FATAL_ERROR \"Architecture not supported\")\n"
+      )
+  endif()
+  if(maybe_else)
+    string(APPEND _branch_code "endif()\n")
+  endif()
+
+  configure_package_config_file("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/Internal/AppleArchitectureSelection.cmake.in" "${_output_file}"
+    INSTALL_DESTINATION "${_gasf_INSTALL_DESTINATION}"
+    ${maybe_INSTALL_PREFIX}
+    NO_SET_AND_CHECK_MACRO
+    NO_CHECK_REQUIRED_COMPONENTS_MACRO
+    )
+endfunction()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeParseLibraryArchitecture.cmake

@@ -0,0 +1,54 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0053 NEW)
+cmake_policy(SET CMP0054 NEW)
+
+# Function parse implicit linker options.
+# This is used internally by CMake and should not be included by user
+# code.
+
+function(cmake_parse_library_architecture lang implicit_dirs implicit_objs output_var)
+  unset(library_arch)
+  # Detect library architecture directory name.
+  if(CMAKE_LIBRARY_ARCHITECTURE_REGEX)
+    foreach(dir IN LISTS implicit_dirs)
+      if("${dir}" MATCHES "/lib/${CMAKE_LIBRARY_ARCHITECTURE_REGEX}$")
+        get_filename_component(arch "${dir}" NAME)
+        set(library_arch "${arch}")
+        break()
+      endif()
+    endforeach()
+
+    foreach(obj IN LISTS implicit_objs)
+      get_filename_component(dir "${obj}" DIRECTORY)
+      if("${dir}" MATCHES "(/usr)?/lib/${CMAKE_LIBRARY_ARCHITECTURE_REGEX}$")
+        get_filename_component(arch "${dir}" NAME)
+        set(library_arch "${arch}")
+        break()
+      endif()
+    endforeach()
+  endif()
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL QCC)
+    foreach(dir ${implicit_dirs})
+      if (dir MATCHES "/lib$")
+        get_filename_component(assumedArchDir "${dir}" DIRECTORY)
+        get_filename_component(archParentDir "${assumedArchDir}" DIRECTORY)
+        if (archParentDir STREQUAL CMAKE_SYSROOT)
+          get_filename_component(archDirName "${assumedArchDir}" NAME)
+          set(library_arch "${archDirName}")
+          break()
+        endif()
+      endif()
+    endforeach()
+  endif()
+
+  # Return results.
+  if(library_arch)
+    set(${output_var} "${library_arch}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+cmake_policy(POP)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakePrintHelpers.cmake

@@ -0,0 +1,171 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CMakePrintHelpers
+-----------------
+
+Convenience functions for printing properties and variables, useful
+e.g. for debugging.
+
+::
+
+  cmake_print_properties(<TARGETS       [<target1> ...] |
+                          SOURCES       [<source1> ...] |
+                          DIRECTORIES   [<dir1> ...]    |
+                          TESTS         [<test1> ...]   |
+                          CACHE_ENTRIES [<entry1> ...]  >
+                         PROPERTIES [<prop1> ...]         )
+
+This function prints the values of the properties of the given targets,
+source files, directories, tests or cache entries.  Exactly one of the
+scope keywords must be used.  The scope keyword and its arguments must
+come before the ``PROPERTIES`` keyword, in the arguments list.
+
+Example::
+
+  cmake_print_properties(TARGETS foo bar PROPERTIES
+                         LOCATION INTERFACE_INCLUDE_DIRECTORIES)
+
+This will print the LOCATION and INTERFACE_INCLUDE_DIRECTORIES properties for
+both targets foo and bar.
+
+::
+
+  cmake_print_variables(var1 var2 ..  varN)
+
+This function will print the name of each variable followed by its value.
+Example::
+
+  cmake_print_variables(CMAKE_C_COMPILER CMAKE_MAJOR_VERSION DOES_NOT_EXIST)
+
+Gives::
+
+  -- CMAKE_C_COMPILER="/usr/bin/gcc" ; CMAKE_MAJOR_VERSION="2" ; DOES_NOT_EXIST=""
+#]=======================================================================]
+
+function(cmake_print_variables)
+  set(msg "")
+  foreach(var ${ARGN})
+    if(msg)
+      string(APPEND msg " ; ")
+    endif()
+    string(APPEND msg "${var}=\"${${var}}\"")
+  endforeach()
+  message(STATUS "${msg}")
+endfunction()
+
+
+function(cmake_print_properties)
+  set(options )
+  set(oneValueArgs )
+  set(cpp_multiValueArgs PROPERTIES )
+  set(cppmode_multiValueArgs TARGETS SOURCES TESTS DIRECTORIES CACHE_ENTRIES )
+
+  string(JOIN " " _mode_names ${cppmode_multiValueArgs})
+  set(_missing_mode_message
+    "Mode keyword missing in cmake_print_properties() call, there must be exactly one of ${_mode_names}")
+
+  cmake_parse_arguments(
+    CPP "${options}" "${oneValueArgs}" "${cpp_multiValueArgs}" ${ARGN})
+
+  if(NOT CPP_PROPERTIES)
+    message(FATAL_ERROR
+      "Required argument PROPERTIES missing in cmake_print_properties() call")
+    return()
+  endif()
+
+  if(NOT CPP_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "${_missing_mode_message}")
+    return()
+  endif()
+
+  cmake_parse_arguments(
+    CPPMODE "${options}" "${oneValueArgs}" "${cppmode_multiValueArgs}"
+    ${CPP_UNPARSED_ARGUMENTS})
+
+  if(CPPMODE_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "Unknown keywords given to cmake_print_properties(): \"${CPPMODE_UNPARSED_ARGUMENTS}\"")
+    return()
+  endif()
+
+  set(mode)
+  set(items)
+  set(keyword)
+
+  if(CPPMODE_TARGETS)
+    set(items ${CPPMODE_TARGETS})
+    set(mode ${mode} TARGETS)
+    set(keyword TARGET)
+  endif()
+
+  if(CPPMODE_SOURCES)
+    set(items ${CPPMODE_SOURCES})
+    set(mode ${mode} SOURCES)
+    set(keyword SOURCE)
+  endif()
+
+  if(CPPMODE_TESTS)
+    set(items ${CPPMODE_TESTS})
+    set(mode ${mode} TESTS)
+    set(keyword TEST)
+  endif()
+
+  if(CPPMODE_DIRECTORIES)
+    set(items ${CPPMODE_DIRECTORIES})
+    set(mode ${mode} DIRECTORIES)
+    set(keyword DIRECTORY)
+  endif()
+
+  if(CPPMODE_CACHE_ENTRIES)
+    set(items ${CPPMODE_CACHE_ENTRIES})
+    set(mode ${mode} CACHE_ENTRIES)
+    # This is a workaround for the fact that passing `CACHE` as an argument to
+    # set() causes a cache variable to be set.
+    set(keyword "")
+    string(APPEND keyword CACHE)
+  endif()
+
+  if(NOT mode)
+    message(FATAL_ERROR "${_missing_mode_message}")
+    return()
+  endif()
+
+  list(LENGTH mode modeLength)
+  if("${modeLength}" GREATER 1)
+    message(FATAL_ERROR
+      "Multiple mode keywords used in cmake_print_properties() call, there must be exactly one of ${_mode_names}.")
+    return()
+  endif()
+
+  set(msg "\n")
+  foreach(item ${items})
+
+    set(itemExists TRUE)
+    if(keyword STREQUAL "TARGET")
+      if(NOT TARGET ${item})
+        set(itemExists FALSE)
+        string(APPEND msg "\n No such TARGET \"${item}\" !\n\n")
+      endif()
+    endif()
+
+    if (itemExists)
+      string(APPEND msg " Properties for ${keyword} ${item}:\n")
+      foreach(prop ${CPP_PROPERTIES})
+
+        get_property(propertySet ${keyword} ${item} PROPERTY "${prop}" SET)
+
+        if(propertySet)
+          get_property(property ${keyword} ${item} PROPERTY "${prop}")
+          string(APPEND msg "   ${item}.${prop} = \"${property}\"\n")
+        else()
+          string(APPEND msg "   ${item}.${prop} = <NOTFOUND>\n")
+        endif()
+      endforeach()
+    endif()
+
+  endforeach()
+  message(STATUS "${msg}")
+
+endfunction()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake

@@ -0,0 +1,36 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This file is included by cmGlobalGenerator::EnableLanguage.
+# It is included before the compiler has been determined.
+
+# before cmake 2.6 these variables were set in cmMakefile.cxx. This is still
+# done to keep scripts and custom language and compiler modules working.
+# But they are reset here and set again in the platform files for the target
+# platform, so they can be used for testing the target platform instead
+# of testing the host platform.
+unset(APPLE)
+unset(UNIX)
+unset(CYGWIN)
+unset(MSYS)
+unset(WIN32)
+unset(BSD)
+unset(LINUX)
+
+# The CMAKE_EFFECTIVE_SYSTEM_NAME is used to load compiler and compiler
+# wrapper configuration files. By default it equals to CMAKE_SYSTEM_NAME
+# but could be overridden in the ${CMAKE_SYSTEM_NAME}-Initialize files.
+#
+# It is useful to share the same aforementioned configuration files and
+# avoids duplicating them in case of tightly related platforms.
+#
+# An example are the platforms supported by Xcode (macOS, iOS, tvOS, visionOS
+# and watchOS). For all of those the CMAKE_EFFECTIVE_SYSTEM_NAME is
+# set to Apple which results in using
+# Platform/Apple-AppleClang-CXX.cmake for the Apple C++ compiler.
+set(CMAKE_EFFECTIVE_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}")
+
+include(Platform/${CMAKE_SYSTEM_NAME}-Initialize OPTIONAL)
+
+set(CMAKE_SYSTEM_SPECIFIC_INITIALIZE_LOADED 1)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeTestASM-ATTCompiler.cmake

@@ -0,0 +1,13 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This file is used by EnableLanguage in cmGlobalGenerator to
+# determine that the selected ASM-ATT "compiler" works.
+# For assembler this can only check whether the compiler has been found,
+# because otherwise there would have to be a separate assembler source file
+# for each assembler on every architecture.
+
+set(ASM_DIALECT "-ATT")
+include(CMakeTestASMCompiler)
+set(ASM_DIALECT)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeTestASM_NASMCompiler.cmake

@@ -0,0 +1,13 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This file is used by EnableLanguage in cmGlobalGenerator to
+# determine that the selected ASM_NASM "compiler" works.
+# For assembler this can only check whether the compiler has been found,
+# because otherwise there would have to be a separate assembler source file
+# for each assembler on every architecture.
+
+set(ASM_DIALECT "_NASM")
+include(CMakeTestASMCompiler)
+set(ASM_DIALECT)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeTestCXXCompiler.cmake

@@ -0,0 +1,102 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+if(CMAKE_CXX_COMPILER_FORCED)
+  # The compiler configuration was forced by the user.
+  # Assume the user has configured all compiler information.
+  set(CMAKE_CXX_COMPILER_WORKS TRUE)
+  return()
+endif()
+
+include(CMakeTestCompilerCommon)
+
+# work around enforced code signing and / or missing executable target type
+set(__CMAKE_SAVED_TRY_COMPILE_TARGET_TYPE ${CMAKE_TRY_COMPILE_TARGET_TYPE})
+if(_CMAKE_FEATURE_DETECTION_TARGET_TYPE)
+  set(CMAKE_TRY_COMPILE_TARGET_TYPE ${_CMAKE_FEATURE_DETECTION_TARGET_TYPE})
+endif()
+
+# Remove any cached result from an older CMake version.
+# We now store this in CMakeCXXCompiler.cmake.
+unset(CMAKE_CXX_COMPILER_WORKS CACHE)
+
+# Try to identify the ABI and configure it into CMakeCXXCompiler.cmake
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
+CMAKE_DETERMINE_COMPILER_ABI(CXX ${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp)
+if(CMAKE_CXX_ABI_COMPILED)
+  # The compiler worked so skip dedicated test below.
+  set(CMAKE_CXX_COMPILER_WORKS TRUE)
+  message(STATUS "Check for working CXX compiler: ${CMAKE_CXX_COMPILER} - skipped")
+endif()
+
+# This file is used by EnableLanguage in cmGlobalGenerator to
+# determine that the selected C++ compiler can actually compile
+# and link the most basic of programs.   If not, a fatal error
+# is set and cmake stops processing commands and will not generate
+# any makefiles or projects.
+if(NOT CMAKE_CXX_COMPILER_WORKS)
+  PrintTestCompilerStatus("CXX")
+  # FIXME: Use a block() to isolate the variables we set/unset here.
+  if(DEFINED CMAKE_CXX_SCAN_FOR_MODULES)
+    set(__CMAKE_SAVED_CXX_SCAN_FOR_MODULES "${CMAKE_CXX_SCAN_FOR_MODULES}")
+  else()
+    unset(__CMAKE_SAVED_CXX_SCAN_FOR_MODULES)
+  endif()
+  set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
+  __TestCompiler_setTryCompileTargetType()
+  string(CONCAT __TestCompiler_testCXXCompilerSource
+    "#ifndef __cplusplus\n"
+    "# error \"The CMAKE_CXX_COMPILER is set to a C compiler\"\n"
+    "#endif\n"
+    "int main(){return 0;}\n")
+  # Clear result from normal variable.
+  unset(CMAKE_CXX_COMPILER_WORKS)
+  # Puts test result in cache variable.
+  try_compile(CMAKE_CXX_COMPILER_WORKS
+    SOURCE_FROM_VAR testCXXCompiler.cxx __TestCompiler_testCXXCompilerSource
+    OUTPUT_VARIABLE __CMAKE_CXX_COMPILER_OUTPUT)
+  if(DEFINED __CMAKE_SAVED_CXX_SCAN_FOR_MODULES)
+    set(CMAKE_CXX_SCAN_FOR_MODULES "${__CMAKE_SAVED_CXX_SCAN_FOR_MODULES}")
+    unset(__CMAKE_SAVED_CXX_SCAN_FOR_MODULES)
+  else()
+    unset(CMAKE_CXX_SCAN_FOR_MODULES)
+  endif()
+  unset(__TestCompiler_testCXXCompilerSource)
+  # Move result from cache to normal variable.
+  set(CMAKE_CXX_COMPILER_WORKS ${CMAKE_CXX_COMPILER_WORKS})
+  unset(CMAKE_CXX_COMPILER_WORKS CACHE)
+  __TestCompiler_restoreTryCompileTargetType()
+  if(NOT CMAKE_CXX_COMPILER_WORKS)
+    PrintTestCompilerResult(CHECK_FAIL "broken")
+    string(REPLACE "\n" "\n  " _output "${__CMAKE_CXX_COMPILER_OUTPUT}")
+    message(FATAL_ERROR "The C++ compiler\n  \"${CMAKE_CXX_COMPILER}\"\n"
+      "is not able to compile a simple test program.\nIt fails "
+      "with the following output:\n  ${_output}\n\n"
+      "CMake will not be able to correctly generate this project.")
+  endif()
+  PrintTestCompilerResult(CHECK_PASS "works")
+endif()
+
+# Try to identify the compiler features
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerSupport.cmake)
+CMAKE_DETERMINE_COMPILER_SUPPORT(CXX)
+
+# Re-configure to save learned information.
+configure_file(
+  ${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXCompiler.cmake
+  @ONLY
+  )
+include(${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXCompiler.cmake)
+
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  foreach(f ${CMAKE_CXX_ABI_FILES})
+    include(${f})
+  endforeach()
+  unset(CMAKE_CXX_ABI_FILES)
+endif()
+
+set(CMAKE_TRY_COMPILE_TARGET_TYPE ${__CMAKE_SAVED_TRY_COMPILE_TARGET_TYPE})
+unset(__CMAKE_SAVED_TRY_COMPILE_TARGET_TYPE)
+unset(__CMAKE_CXX_COMPILER_OUTPUT)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CMakeTestFortranCompiler.cmake

@@ -0,0 +1,102 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+if(CMAKE_Fortran_COMPILER_FORCED)
+  # The compiler configuration was forced by the user.
+  # Assume the user has configured all compiler information.
+  set(CMAKE_Fortran_COMPILER_WORKS TRUE)
+  return()
+endif()
+
+include(CMakeTestCompilerCommon)
+
+# Remove any cached result from an older CMake version.
+# We now store this in CMakeFortranCompiler.cmake.
+unset(CMAKE_Fortran_COMPILER_WORKS CACHE)
+
+# Try to identify the ABI and configure it into CMakeFortranCompiler.cmake
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
+CMAKE_DETERMINE_COMPILER_ABI(Fortran ${CMAKE_ROOT}/Modules/CMakeFortranCompilerABI.F90)
+if(CMAKE_Fortran_ABI_COMPILED)
+  # The compiler worked so skip dedicated test below.
+  set(CMAKE_Fortran_COMPILER_WORKS TRUE)
+  set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 1)
+  message(STATUS "Check for working Fortran compiler: ${CMAKE_Fortran_COMPILER} - skipped")
+else()
+  cmake_determine_compiler_abi(Fortran ${CMAKE_ROOT}/Modules/CMakeFortranCompilerABI.F)
+  if(CMAKE_Fortran_ABI_COMPILED)
+    set(CMAKE_Fortran_COMPILER_WORKS TRUE)
+    message(STATUS "Check for working Fortran 77 compiler: ${CMAKE_Fortran_COMPILER} - skipped")
+  endif()
+endif()
+
+# This file is used by EnableLanguage in cmGlobalGenerator to
+# determine that the selected Fortran compiler can actually compile
+# and link the most basic of programs.   If not, a fatal error
+# is set and cmake stops processing commands and will not generate
+# any makefiles or projects.
+if(NOT CMAKE_Fortran_COMPILER_WORKS)
+  PrintTestCompilerStatus("Fortran")
+  set(__TestCompiler_testFortranCompilerSource "
+        PROGRAM TESTFortran
+        PRINT *, 'Hello'
+        END
+  ")
+  # Clear result from normal variable.
+  unset(CMAKE_Fortran_COMPILER_WORKS)
+  # Puts test result in cache variable.
+  try_compile(CMAKE_Fortran_COMPILER_WORKS
+    SOURCE_FROM_VAR testFortranCompiler.f __TestCompiler_testFortranCompilerSource
+    OUTPUT_VARIABLE OUTPUT)
+  unset(__TestCompiler_testFortranCompilerSource)
+  # Move result from cache to normal variable.
+  set(CMAKE_Fortran_COMPILER_WORKS ${CMAKE_Fortran_COMPILER_WORKS})
+  unset(CMAKE_Fortran_COMPILER_WORKS CACHE)
+  if(NOT CMAKE_Fortran_COMPILER_WORKS)
+    PrintTestCompilerResult(CHECK_FAIL "broken")
+    string(REPLACE "\n" "\n  " _output "${OUTPUT}")
+    message(FATAL_ERROR "The Fortran compiler\n  \"${CMAKE_Fortran_COMPILER}\"\n"
+      "is not able to compile a simple test program.\nIt fails "
+      "with the following output:\n  ${_output}\n\n"
+      "CMake will not be able to correctly generate this project.")
+  endif()
+  PrintTestCompilerResult(CHECK_PASS "works")
+endif()
+
+# Test for Fortran 90 support by using an f90-specific construct.
+if(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F90)
+  message(CHECK_START "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90")
+  set(__TestCompiler_testFortranCompilerSource "
+    PROGRAM TESTFortran90
+    integer stop ; stop = 1 ; do while ( stop .eq. 0 ) ; end do
+    END PROGRAM TESTFortran90
+")
+  try_compile(CMAKE_Fortran_COMPILER_SUPPORTS_F90
+    SOURCE_FROM_VAR testFortranCompilerF90.f90 __TestCompiler_testFortranCompilerF90Source
+    OUTPUT_VARIABLE OUTPUT)
+  unset(__TestCompiler_testFortranCompilerF90Source)
+  if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
+    message(CHECK_PASS "yes")
+    set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 1)
+  else()
+    message(CHECK_FAIL "no")
+    set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 0)
+  endif()
+  unset(CMAKE_Fortran_COMPILER_SUPPORTS_F90 CACHE)
+endif()
+
+# Re-configure to save learned information.
+configure_file(
+  ${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeFortranCompiler.cmake
+  @ONLY
+  )
+include(${CMAKE_PLATFORM_INFO_DIR}/CMakeFortranCompiler.cmake)
+
+if(CMAKE_Fortran_SIZEOF_DATA_PTR)
+  foreach(f ${CMAKE_Fortran_ABI_FILES})
+    include(${f})
+  endforeach()
+  unset(CMAKE_Fortran_ABI_FILES)
+endif()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CTestScriptMode.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.
+
+#[=======================================================================[.rst:
+CTestScriptMode
+---------------
+
+
+
+This file is read by ctest in script mode (-S)
+#]=======================================================================]
+
+# Determine the current system, so this information can be used
+# in ctest scripts
+include(CMakeDetermineSystem)
+
+# Also load the system specific file, which sets up e.g. the search paths.
+# This makes the FIND_XXX() calls work much better
+include(CMakeSystemSpecificInformation)
+

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CXX-DetectStdlib.h

@@ -0,0 +1,10 @@
+#include <version>
+// clang-format off
+#if defined(_LIBCPP_VERSION)
+CMAKE-STDLIB-DETECT: libc++
+#elif defined(__GLIBCXX__)
+CMAKE-STDLIB-DETECT: libstdc++
+#else
+CMAKE-STDLIB-DETECT: UNKNOWN
+#endif
+    // clang-format on

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckFortranCompilerFlag.cmake

@@ -0,0 +1,63 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CheckFortranCompilerFlag
+------------------------
+
+.. versionadded:: 3.3
+
+Check once whether the Fortran compiler supports a given flag.
+
+.. command:: check_fortran_compiler_flag
+
+  .. code-block:: cmake
+
+    check_fortran_compiler_flag(<flag> <resultVar>)
+
+Check once that the ``<flag>`` is accepted by the compiler without a diagnostic.
+The result is stored in the internal cache variable specified by
+``<resultVar>``, with boolean ``true`` for success and boolean ``false`` for
+failure.
+
+``true`` indicates only that the compiler did not issue a diagnostic message
+when given the flag. Whether the flag has any effect is beyond the scope of
+this module.
+
+Internally, :command:`try_compile` is used to perform the check. If
+:variable:`CMAKE_TRY_COMPILE_TARGET_TYPE` is set to ``EXECUTABLE`` (default),
+the check compiles and links an executable program. If set to
+``STATIC_LIBRARY``, the check is compiled but not linked.
+
+See also :command:`check_compiler_flag` for a more general command syntax.
+
+The compile and link commands can be influenced by setting any of the
+following variables prior to calling ``check_fortran_compiler_flag()``. Unknown
+flags in these variables can case a false negative result.
+
+.. include:: /module/CMAKE_REQUIRED_FLAGS.txt
+
+.. include:: /module/CMAKE_REQUIRED_DEFINITIONS.txt
+
+.. include:: /module/CMAKE_REQUIRED_INCLUDES.txt
+
+.. include:: /module/CMAKE_REQUIRED_LINK_OPTIONS.txt
+
+.. include:: /module/CMAKE_REQUIRED_LIBRARIES.txt
+
+.. include:: /module/CMAKE_REQUIRED_LINK_DIRECTORIES.txt
+
+.. include:: /module/CMAKE_REQUIRED_QUIET.txt
+
+#]=======================================================================]
+
+include_guard(GLOBAL)
+include(Internal/CheckCompilerFlag)
+
+macro (CHECK_FORTRAN_COMPILER_FLAG _FLAG _RESULT)
+  cmake_check_compiler_flag(Fortran "${_FLAG}" ${_RESULT})
+endmacro ()
+
+# FIXME(#24994): The following module is included only for compatibility
+# with projects that accidentally relied on it with CMake 3.26 and below.
+include(CheckFortranSourceCompiles)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIPOSupported.cmake

@@ -0,0 +1,265 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CheckIPOSupported
+-----------------
+
+.. versionadded:: 3.9
+
+Check whether the compiler supports an interprocedural optimization (IPO/LTO).
+Use this before enabling the :prop_tgt:`INTERPROCEDURAL_OPTIMIZATION` target
+property.
+
+.. command:: check_ipo_supported
+
+  ::
+
+    check_ipo_supported([RESULT <result>] [OUTPUT <output>]
+                        [LANGUAGES <lang>...])
+
+  Options are:
+
+  ``RESULT <result>``
+    Set ``<result>`` variable to ``YES`` if IPO is supported by the
+    compiler and ``NO`` otherwise.  If this option is not given then
+    the command will issue a fatal error if IPO is not supported.
+  ``OUTPUT <output>``
+    Set ``<output>`` variable with details about any error.
+  ``LANGUAGES <lang>...``
+    Specify languages whose compilers to check.
+    Languages ``C``, ``CXX``, and ``Fortran`` are supported.
+
+It makes no sense to use this module when :policy:`CMP0069` is set to ``OLD`` so
+module will return error in this case. See policy :policy:`CMP0069` for details.
+
+.. versionadded:: 3.13
+  Add support for Visual Studio generators.
+
+.. versionadded:: 3.24
+  The check uses the caller's :variable:`CMAKE_<LANG>_FLAGS`
+  and :variable:`CMAKE_<LANG>_FLAGS_<CONFIG>` values.
+  See policy :policy:`CMP0138`.
+
+Examples
+^^^^^^^^
+
+.. code-block:: cmake
+
+  check_ipo_supported() # fatal error if IPO is not supported
+  set_property(TARGET foo PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+
+.. code-block:: cmake
+
+  # Optional IPO. Do not use IPO if it's not supported by compiler.
+  check_ipo_supported(RESULT result OUTPUT output)
+  if(result)
+    set_property(TARGET foo PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+    message(WARNING "IPO is not supported: ${output}")
+  endif()
+
+#]=======================================================================]
+
+# X_RESULT - name of the final result variable
+# X_OUTPUT - name of the variable with information about error
+macro(_ipo_not_supported output)
+  if(NOT X_RESULT)
+    message(FATAL_ERROR "IPO is not supported (${output}).")
+  endif()
+
+  set("${X_RESULT}" NO PARENT_SCOPE)
+  if(X_OUTPUT)
+    set("${X_OUTPUT}" "${output}" PARENT_SCOPE)
+  endif()
+endmacro()
+
+# Run IPO/LTO test
+macro(_ipo_run_language_check language)
+  set(_C_ext "c")
+  set(_CXX_ext "cpp")
+  set(_Fortran_ext "f")
+  string(COMPARE EQUAL "${language}" "CUDA" is_cuda)
+
+  set(ext ${_${language}_ext})
+  if(NOT "${ext}" STREQUAL "")
+    set(copy_sources foo.${ext} main.${ext})
+  elseif(is_cuda)
+    if(_CMAKE_CUDA_IPO_SUPPORTED_BY_CMAKE)
+      set("${X_RESULT}" YES PARENT_SCOPE)
+    endif()
+    return()
+  else()
+    message(FATAL_ERROR "Language not supported")
+  endif()
+
+  set(testdir "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/_CMakeLTOTest-${language}")
+
+  file(REMOVE_RECURSE "${testdir}")
+  file(MAKE_DIRECTORY "${testdir}")
+
+  set(bindir "${testdir}/bin")
+  set(srcdir "${testdir}/src")
+
+  file(MAKE_DIRECTORY "${bindir}")
+  file(MAKE_DIRECTORY "${srcdir}")
+
+  set(TRY_COMPILE_PROJECT_NAME "lto-test")
+
+  set(try_compile_src "${CMAKE_ROOT}/Modules/CheckIPOSupported")
+
+  # Use:
+  # * TRY_COMPILE_PROJECT_NAME
+  # * CMAKE_VERSION
+  configure_file(
+      "${try_compile_src}/CMakeLists-${language}.txt.in"
+      "${srcdir}/CMakeLists.txt"
+      @ONLY
+  )
+
+  foreach(x ${copy_sources})
+    configure_file(
+        "${try_compile_src}/${x}"
+        "${srcdir}/${x}"
+        COPYONLY
+    )
+  endforeach()
+
+  if(ipo_CMP0138 STREQUAL "NEW")
+    set(CMAKE_TRY_COMPILE_CONFIGURATION Debug)
+    set(_CMAKE_LANG_FLAGS
+      "-DCMAKE_${language}_FLAGS:STRING=${CMAKE_${language}_FLAGS}"
+      "-DCMAKE_${language}_FLAGS_DEBUG:STRING=${CMAKE_${language}_FLAGS_DEBUG}"
+      )
+  else()
+    set(_CMAKE_LANG_FLAGS "")
+  endif()
+
+  try_compile(
+      _IPO_LANGUAGE_CHECK_RESULT
+      PROJECT "${TRY_COMPILE_PROJECT_NAME}"
+      SOURCE_DIR "${srcdir}"
+      BINARY_DIR "${bindir}"
+      CMAKE_FLAGS
+      "-DCMAKE_VERBOSE_MAKEFILE=ON"
+      "-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON"
+      ${_CMAKE_LANG_FLAGS}
+      OUTPUT_VARIABLE output
+  )
+  set(_IPO_LANGUAGE_CHECK_RESULT "${_IPO_LANGUAGE_CHECK_RESULT}")
+  unset(_IPO_LANGUAGE_CHECK_RESULT CACHE)
+
+  if(NOT _IPO_LANGUAGE_CHECK_RESULT)
+    _ipo_not_supported("check failed to compile")
+    if(X_OUTPUT)
+      set("${X_OUTPUT}" "${output}" PARENT_SCOPE)
+    endif()
+    return()
+  endif()
+endmacro()
+
+function(check_ipo_supported)
+  cmake_policy(GET CMP0069 x)
+
+  string(COMPARE EQUAL "${x}" "" not_set)
+  if(not_set)
+    message(FATAL_ERROR "Policy CMP0069 is not set")
+  endif()
+
+  string(COMPARE EQUAL "${x}" "OLD" is_old)
+  if(is_old)
+    message(FATAL_ERROR "Policy CMP0069 set to OLD")
+  endif()
+
+  # Save policy setting for condition in _ipo_run_language_check.
+  cmake_policy(GET CMP0138 ipo_CMP0138
+    PARENT_SCOPE # undocumented, do not use outside of CMake
+    )
+
+  set(optional)
+  set(one RESULT OUTPUT)
+  set(multiple LANGUAGES)
+
+  # Introduce:
+  # * X_RESULT
+  # * X_OUTPUT
+  # * X_LANGUAGES
+  cmake_parse_arguments(X "${optional}" "${one}" "${multiple}" "${ARGV}")
+
+  string(COMPARE NOTEQUAL "${X_UNPARSED_ARGUMENTS}" "" has_unparsed)
+  if(has_unparsed)
+    message(FATAL_ERROR "Unparsed arguments: ${X_UNPARSED_ARGUMENTS}")
+  endif()
+
+  string(COMPARE EQUAL "${X_LANGUAGES}" "" no_languages)
+  if(no_languages)
+    # User did not set any languages, use defaults
+    get_property(enabled_languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+    string(COMPARE EQUAL "${enabled_languages}" "" no_languages)
+    if(no_languages)
+      _ipo_not_supported(
+          "no languages found in ENABLED_LANGUAGES global property"
+      )
+      return()
+    endif()
+
+    set(languages "")
+    list(FIND enabled_languages "CXX" result)
+    if(NOT result EQUAL -1)
+      list(APPEND languages "CXX")
+    endif()
+
+    list(FIND enabled_languages "C" result)
+    if(NOT result EQUAL -1)
+      list(APPEND languages "C")
+    endif()
+
+    list(FIND enabled_languages "CUDA" result)
+    if(NOT result EQUAL -1)
+      list(APPEND languages "CUDA")
+    endif()
+
+    list(FIND enabled_languages "Fortran" result)
+    if(NOT result EQUAL -1)
+      list(APPEND languages "Fortran")
+    endif()
+
+    string(COMPARE EQUAL "${languages}" "" no_languages)
+    if(no_languages)
+      _ipo_not_supported(
+          "no C/CXX/CUDA/Fortran languages found in ENABLED_LANGUAGES global property"
+      )
+      return()
+    endif()
+  else()
+    set(languages "${X_LANGUAGES}")
+
+    set(unsupported_languages "${languages}")
+    list(REMOVE_ITEM unsupported_languages "C" "CXX" "CUDA" "Fortran")
+    string(COMPARE NOTEQUAL "${unsupported_languages}" "" has_unsupported)
+    if(has_unsupported)
+      _ipo_not_supported(
+          "language(s) '${unsupported_languages}' not supported"
+      )
+      return()
+    endif()
+  endif()
+
+  foreach(lang ${languages})
+    if(NOT _CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE)
+      _ipo_not_supported("CMake doesn't support IPO for current ${lang} compiler")
+      return()
+    endif()
+
+    if(NOT _CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER)
+      _ipo_not_supported("${lang} compiler doesn't support IPO")
+      return()
+    endif()
+  endforeach()
+
+  foreach(x ${languages})
+    _ipo_run_language_check(${x})
+  endforeach()
+
+  set("${X_RESULT}" YES PARENT_SCOPE)
+endfunction()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIncludeFile.cmake

@@ -0,0 +1,129 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CheckIncludeFile
+----------------
+
+Provides a macro to check if a header file can be included in ``C``.
+
+.. command:: CHECK_INCLUDE_FILE
+
+  .. code-block:: cmake
+
+    CHECK_INCLUDE_FILE(<include> <variable> [<flags>])
+
+  Check if the given ``<include>`` file may be included in a ``C``
+  source file and store the result in an internal cache entry named
+  ``<variable>``.  The optional third argument may be used to add
+  compilation flags to the check (or use ``CMAKE_REQUIRED_FLAGS`` below).
+
+The following variables may be set before calling this macro to modify
+the way the check is run:
+
+.. include:: /module/CMAKE_REQUIRED_FLAGS.txt
+
+.. include:: /module/CMAKE_REQUIRED_DEFINITIONS.txt
+
+.. include:: /module/CMAKE_REQUIRED_INCLUDES.txt
+
+.. include:: /module/CMAKE_REQUIRED_LINK_OPTIONS.txt
+
+.. include:: /module/CMAKE_REQUIRED_LIBRARIES.txt
+
+.. include:: /module/CMAKE_REQUIRED_LINK_DIRECTORIES.txt
+
+.. include:: /module/CMAKE_REQUIRED_QUIET.txt
+
+See the :module:`CheckIncludeFiles` module to check for multiple headers
+at once.  See the :module:`CheckIncludeFileCXX` module to check for headers
+using the ``CXX`` language.
+#]=======================================================================]
+
+include_guard(GLOBAL)
+
+macro(CHECK_INCLUDE_FILE INCLUDE VARIABLE)
+  if(NOT DEFINED "${VARIABLE}")
+    if(CMAKE_REQUIRED_INCLUDES)
+      set(CHECK_INCLUDE_FILE_C_INCLUDE_DIRS "-DINCLUDE_DIRECTORIES=${CMAKE_REQUIRED_INCLUDES}")
+    else()
+      set(CHECK_INCLUDE_FILE_C_INCLUDE_DIRS)
+    endif()
+    set(MACRO_CHECK_INCLUDE_FILE_FLAGS ${CMAKE_REQUIRED_FLAGS})
+    set(CHECK_INCLUDE_FILE_VAR ${INCLUDE})
+    file(READ ${CMAKE_ROOT}/Modules/CheckIncludeFile.c.in _CIF_SOURCE_CONTENT)
+    string(CONFIGURE "${_CIF_SOURCE_CONTENT}" _CIF_SOURCE_CONTENT)
+    if(NOT CMAKE_REQUIRED_QUIET)
+      message(CHECK_START "Looking for ${INCLUDE}")
+    endif()
+    if(${ARGC} EQUAL 3)
+      set(CMAKE_C_FLAGS_SAVE ${CMAKE_C_FLAGS})
+      string(APPEND CMAKE_C_FLAGS " ${ARGV2}")
+    endif()
+
+    set(_CIF_LINK_OPTIONS)
+    if(CMAKE_REQUIRED_LINK_OPTIONS)
+      set(_CIF_LINK_OPTIONS LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS})
+    endif()
+
+    set(_CIF_LINK_LIBRARIES "")
+    if(CMAKE_REQUIRED_LIBRARIES)
+      cmake_policy(GET CMP0075 _CIF_CMP0075
+        PARENT_SCOPE # undocumented, do not use outside of CMake
+        )
+      if("x${_CIF_CMP0075}x" STREQUAL "xNEWx")
+        set(_CIF_LINK_LIBRARIES LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
+      elseif("x${_CIF_CMP0075}x" STREQUAL "xOLDx")
+      elseif(NOT _CIF_CMP0075_WARNED)
+        set(_CIF_CMP0075_WARNED 1)
+        message(AUTHOR_WARNING
+          "Policy CMP0075 is not set: Include file check macros honor CMAKE_REQUIRED_LIBRARIES.  "
+          "Run \"cmake --help-policy CMP0075\" for policy details.  "
+          "Use the cmake_policy command to set the policy and suppress this warning."
+          "\n"
+          "CMAKE_REQUIRED_LIBRARIES is set to:\n"
+          "  ${CMAKE_REQUIRED_LIBRARIES}\n"
+          "For compatibility with CMake 3.11 and below this check is ignoring it."
+          )
+      endif()
+      unset(_CIF_CMP0075)
+    endif()
+
+    if(CMAKE_REQUIRED_LINK_DIRECTORIES)
+      set(_CIF_LINK_DIRECTORIES
+        "-DLINK_DIRECTORIES:STRING=${CMAKE_REQUIRED_LINK_DIRECTORIES}")
+    else()
+      set(_CIF_LINK_DIRECTORIES)
+    endif()
+
+    try_compile(${VARIABLE}
+      SOURCE_FROM_VAR CheckIncludeFile.c _CIF_SOURCE_CONTENT
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+      ${_CIF_LINK_OPTIONS}
+      ${_CIF_LINK_LIBRARIES}
+      CMAKE_FLAGS
+      -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_INCLUDE_FILE_FLAGS}
+      "${CHECK_INCLUDE_FILE_C_INCLUDE_DIRS}"
+      "${_CIF_LINK_DIRECTORIES}"
+      )
+    unset(_CIF_LINK_OPTIONS)
+    unset(_CIF_LINK_LIBRARIES)
+    unset(_CIF_LINK_DIRECTORIES)
+
+    if(${ARGC} EQUAL 3)
+      set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS_SAVE})
+    endif()
+
+    if(${VARIABLE})
+      if(NOT CMAKE_REQUIRED_QUIET)
+        message(CHECK_PASS "found")
+      endif()
+      set(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}")
+    else()
+      if(NOT CMAKE_REQUIRED_QUIET)
+        message(CHECK_FAIL "not found")
+      endif()
+      set(${VARIABLE} "" CACHE INTERNAL "Have include ${INCLUDE}")
+    endif()
+  endif()
+endmacro()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIncludeFile.cxx.in

@@ -0,0 +1,6 @@
+#include <${CHECK_INCLUDE_FILE_VAR}>
+
+int main()
+{
+  return 0;
+}

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckLanguage.cmake

@@ -0,0 +1,161 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+CheckLanguage
+-------------
+
+Check whether a language can be enabled by the :command:`enable_language`
+or :command:`project` commands:
+
+.. command:: check_language
+
+  .. code-block:: cmake
+
+    check_language(<lang>)
+
+  Try enabling language ``<lang>`` in a test project and record results
+  in the cache:
+
+  :variable:`CMAKE_<LANG>_COMPILER`
+    If the language can be enabled, this variable is set to the compiler
+    that was found.  If the language cannot be enabled, this variable is
+    set to ``NOTFOUND``.
+
+    If this variable is already set, either explicitly or cached by
+    a previous call, the check is skipped.
+
+  :variable:`CMAKE_<LANG>_HOST_COMPILER`
+    This variable is set when ``<lang>`` is ``CUDA`` or ``HIP``.
+
+    If the check detects an explicit host compiler that is required for
+    compilation, this variable will be set to that compiler.
+    If the check detects that no explicit host compiler is needed,
+    this variable will be cleared.
+
+    If this variable is already set, its value is preserved only if
+    :variable:`CMAKE_<LANG>_COMPILER` is also set.
+    Otherwise, the check runs and overwrites
+    :variable:`CMAKE_<LANG>_HOST_COMPILER` with a new result.
+    Note that :variable:`CMAKE_<LANG>_HOST_COMPILER` documents it should
+    not be set without also setting
+    :variable:`CMAKE_<LANG>_COMPILER` to a NVCC compiler.
+
+  :variable:`CMAKE_<LANG>_PLATFORM <CMAKE_HIP_PLATFORM>`
+    This variable is set to the detected GPU platform when ``<lang>`` is ``HIP``.
+
+    If the variable is already set its value is always preserved. Only compatible values
+    will be considered for :variable:`CMAKE_<LANG>_COMPILER`.
+
+For example:
+
+.. code-block:: cmake
+
+  check_language(Fortran)
+  if(CMAKE_Fortran_COMPILER)
+    enable_language(Fortran)
+  else()
+    message(STATUS "No Fortran support")
+  endif()
+#]=======================================================================]
+
+include_guard(GLOBAL)
+
+block(SCOPE_FOR POLICIES)
+cmake_policy(SET CMP0126 NEW)
+
+macro(check_language lang)
+  if(NOT DEFINED CMAKE_${lang}_COMPILER)
+    set(_desc "Looking for a ${lang} compiler")
+    message(CHECK_START "${_desc}")
+    file(REMOVE_RECURSE ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/Check${lang})
+
+    set(extra_compiler_variables)
+    if("${lang}" MATCHES "^(CUDA|HIP)$" AND NOT CMAKE_GENERATOR MATCHES "Visual Studio")
+      set(extra_compiler_variables "set(CMAKE_${lang}_HOST_COMPILER \\\"\${CMAKE_${lang}_HOST_COMPILER}\\\")")
+    endif()
+
+    if("${lang}" STREQUAL "HIP")
+      list(APPEND extra_compiler_variables "set(CMAKE_${lang}_PLATFORM \\\"\${CMAKE_${lang}_PLATFORM}\\\")")
+    endif()
+
+    list(TRANSFORM extra_compiler_variables PREPEND "\"")
+    list(TRANSFORM extra_compiler_variables APPEND "\\n\"")
+    list(JOIN extra_compiler_variables "\n  " extra_compiler_variables)
+
+    set(_cl_content
+      "cmake_minimum_required(VERSION ${CMAKE_VERSION})
+set(CMAKE_MODULE_PATH \"${CMAKE_MODULE_PATH}\")
+project(Check${lang} ${lang})
+file(WRITE \"\${CMAKE_CURRENT_BINARY_DIR}/result.cmake\"
+  \"set(CMAKE_${lang}_COMPILER \\\"\${CMAKE_${lang}_COMPILER}\\\")\\n\"
+  ${extra_compiler_variables}
+  )"
+    )
+
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/Check${lang}/CMakeLists.txt"
+      "${_cl_content}")
+    if(CMAKE_GENERATOR_INSTANCE)
+      set(_D_CMAKE_GENERATOR_INSTANCE "-DCMAKE_GENERATOR_INSTANCE:INTERNAL=${CMAKE_GENERATOR_INSTANCE}")
+    else()
+      set(_D_CMAKE_GENERATOR_INSTANCE "")
+    endif()
+    if(CMAKE_GENERATOR MATCHES "^(Xcode$|Green Hills MULTI$|Visual Studio)")
+      set(_D_CMAKE_MAKE_PROGRAM "")
+    else()
+      set(_D_CMAKE_MAKE_PROGRAM "-DCMAKE_MAKE_PROGRAM:FILEPATH=${CMAKE_MAKE_PROGRAM}")
+    endif()
+    if(CMAKE_TOOLCHAIN_FILE)
+      set(_D_CMAKE_TOOLCHAIN_FILE "-DCMAKE_TOOLCHAIN_FILE:FILEPATH=${CMAKE_TOOLCHAIN_FILE}")
+    else()
+      set(_D_CMAKE_TOOLCHAIN_FILE "")
+    endif()
+    if(CMAKE_${lang}_PLATFORM)
+      set(_D_CMAKE_LANG_PLATFORM "-DCMAKE_${lang}_PLATFORM:STRING=${CMAKE_${lang}_PLATFORM}")
+    else()
+      set(_D_CMAKE_LANG_PLATFORM "")
+    endif()
+    execute_process(
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/Check${lang}
+      COMMAND ${CMAKE_COMMAND} . -G ${CMAKE_GENERATOR}
+                                 -A "${CMAKE_GENERATOR_PLATFORM}"
+                                 -T "${CMAKE_GENERATOR_TOOLSET}"
+                                 ${_D_CMAKE_GENERATOR_INSTANCE}
+                                 ${_D_CMAKE_MAKE_PROGRAM}
+                                 ${_D_CMAKE_TOOLCHAIN_FILE}
+                                 ${_D_CMAKE_LANG_PLATFORM}
+      OUTPUT_VARIABLE _cl_output
+      ERROR_VARIABLE _cl_output
+      RESULT_VARIABLE _cl_result
+      )
+    include(${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/Check${lang}/result.cmake OPTIONAL)
+    if(CMAKE_${lang}_COMPILER AND "${_cl_result}" STREQUAL "0")
+      message(CONFIGURE_LOG
+        "${_desc} passed with the following output:\n"
+        "${_cl_output}\n")
+      set(_CHECK_COMPILER_STATUS CHECK_PASS)
+    else()
+      set(CMAKE_${lang}_COMPILER NOTFOUND)
+      set(_CHECK_COMPILER_STATUS CHECK_FAIL)
+      message(CONFIGURE_LOG
+        "${_desc} failed with the following output:\n"
+        "${_cl_output}\n")
+    endif()
+    message(${_CHECK_COMPILER_STATUS} "${CMAKE_${lang}_COMPILER}")
+    set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER}" CACHE FILEPATH "${lang} compiler")
+    mark_as_advanced(CMAKE_${lang}_COMPILER)
+
+    if(CMAKE_${lang}_HOST_COMPILER)
+      message(STATUS "Looking for a ${lang} host compiler - ${CMAKE_${lang}_HOST_COMPILER}")
+      set(CMAKE_${lang}_HOST_COMPILER "${CMAKE_${lang}_HOST_COMPILER}" CACHE FILEPATH "${lang} host compiler")
+      mark_as_advanced(CMAKE_${lang}_HOST_COMPILER)
+    endif()
+
+    if(CMAKE_${lang}_PLATFORM)
+      set(CMAKE_${lang}_PLATFORM "${CMAKE_${lang}_PLATFORM}" CACHE STRING "${lang} platform")
+      mark_as_advanced(CMAKE_${lang}_PLATFORM)
+    endif()
+  endif()
+endmacro()
+
+endblock()

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckPrototypeDefinition.c.in

@@ -0,0 +1,29 @@
+@CHECK_PROTOTYPE_DEFINITION_HEADER@
+
+static void cmakeRequireSymbol(int dummy, ...) {
+  (void) dummy;
+}
+
+static void checkSymbol(void) {
+#ifndef @CHECK_PROTOTYPE_DEFINITION_SYMBOL@
+  cmakeRequireSymbol(0, &@CHECK_PROTOTYPE_DEFINITION_SYMBOL@);
+#endif
+}
+
+@CHECK_PROTOTYPE_DEFINITION_PROTO@ {
+  return @CHECK_PROTOTYPE_DEFINITION_RETURN@;
+}
+
+#ifdef __CLASSIC_C__
+int main() {
+  int ac;
+  char*av[];
+#else
+int main(int ac, char *av[]) {
+#endif
+  checkSymbol();
+  if (ac > 1000) {
+    return *av[0];
+  }
+  return 0;
+}

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckTypeSize.c.in

@@ -0,0 +1,47 @@
+@headers@
+
+#undef KEY
+#if defined(__i386)
+# define KEY '_','_','i','3','8','6'
+#elif defined(__x86_64)
+# define KEY '_','_','x','8','6','_','6','4'
+#elif defined(__PPC64__)
+# define KEY '_','_','P','P','C','6','4','_','_'
+#elif defined(__ppc64__)
+# define KEY '_','_','p','p','c','6','4','_','_'
+#elif defined(__PPC__)
+# define KEY '_','_','P','P','C','_','_'
+#elif defined(__ppc__)
+# define KEY '_','_','p','p','c','_','_'
+#elif defined(__aarch64__)
+# define KEY '_','_','a','a','r','c','h','6','4','_','_'
+#elif defined(__ARM_ARCH_7A__)
+# define KEY '_','_','A','R','M','_','A','R','C','H','_','7','A','_','_'
+#elif defined(__ARM_ARCH_7S__)
+# define KEY '_','_','A','R','M','_','A','R','C','H','_','7','S','_','_'
+#endif
+
+#define SIZE (sizeof(@type@))
+static char info_size[] =  {'I', 'N', 'F', 'O', ':', 's','i','z','e','[',
+  ('0' + ((SIZE / 10000)%10)),
+  ('0' + ((SIZE / 1000)%10)),
+  ('0' + ((SIZE / 100)%10)),
+  ('0' + ((SIZE / 10)%10)),
+  ('0' +  (SIZE    % 10)),
+  ']',
+#ifdef KEY
+  ' ','k','e','y','[', KEY, ']',
+#endif
+  '\0'};
+
+#ifdef __CLASSIC_C__
+int main(argc, argv) int argc; char *argv[];
+#else
+int main(int argc, char *argv[])
+#endif
+{
+  int require = 0;
+  require += info_size[argc];
+  (void)argv;
+  return require;
+}

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FindCURL.cmake

@@ -0,0 +1,250 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindCURL
+--------
+
+Find the native CURL headers and libraries.
+
+.. versionadded:: 3.14
+  This module accept optional COMPONENTS to check supported features and
+  protocols:
+
+::
+
+  PROTOCOLS: ICT FILE FTP FTPS GOPHER HTTP HTTPS IMAP IMAPS LDAP LDAPS POP3
+             POP3S RTMP RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP
+  FEATURES:  SSL IPv6 UnixSockets libz AsynchDNS IDN GSS-API PSL SPNEGO
+             Kerberos NTLM NTLM_WB TLS-SRP HTTP2 HTTPS-proxy
+
+IMPORTED Targets
+^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.12
+
+This module defines :prop_tgt:`IMPORTED` target ``CURL::libcurl``, if
+curl has been found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``CURL_FOUND``
+  "True" if ``curl`` found.
+
+``CURL_INCLUDE_DIRS``
+  where to find ``curl``/``curl.h``, etc.
+
+``CURL_LIBRARIES``
+  List of libraries when using ``curl``.
+
+``CURL_VERSION_STRING``
+  The version of ``curl`` found.
+
+.. versionadded:: 3.13
+  Debug and Release variants are found separately.
+
+CURL CMake
+^^^^^^^^^^
+
+.. versionadded:: 3.17
+
+If CURL was built using the CMake buildsystem then it provides its own
+``CURLConfig.cmake`` file for use with the :command:`find_package` command's
+config mode. This module looks for this file and, if found,
+returns its results with no further action.
+
+Set ``CURL_NO_CURL_CMAKE`` to ``ON`` to disable this search.
+
+Hints
+^^^^^
+
+``CURL_USE_STATIC_LIBS``
+
+  .. versionadded:: 3.28
+
+  Set to ``TRUE`` to use static libraries.
+
+  This is meaningful only when CURL is not found via its
+  CMake Package Configuration file.
+
+#]=======================================================================]
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+
+if(NOT CURL_NO_CURL_CMAKE)
+  # do a find package call to specifically look for the CMake version
+  # of curl
+  find_package(CURL QUIET NO_MODULE)
+  mark_as_advanced(CURL_DIR)
+
+  # if we found the CURL cmake package then we are done, and
+  # can print what we found and return.
+  if(CURL_FOUND)
+    find_package_handle_standard_args(CURL HANDLE_COMPONENTS CONFIG_MODE)
+    # The upstream curl package sets CURL_VERSION, not CURL_VERSION_STRING.
+    set(CURL_VERSION_STRING "${CURL_VERSION}")
+
+    cmake_policy(POP)
+    return()
+  endif()
+endif()
+
+find_package(PkgConfig QUIET)
+if(PKG_CONFIG_FOUND)
+  pkg_check_modules(PC_CURL QUIET libcurl)
+  if(PC_CURL_FOUND)
+    pkg_get_variable(CURL_SUPPORTED_PROTOCOLS_STRING libcurl supported_protocols)
+    string(REPLACE " " ";" CURL_SUPPORTED_PROTOCOLS "${CURL_SUPPORTED_PROTOCOLS_STRING}")
+    pkg_get_variable(CURL_SUPPORTED_FEATURES_STRING libcurl supported_features)
+    string(REPLACE " " ";" CURL_SUPPORTED_FEATURES "${CURL_SUPPORTED_FEATURES_STRING}")
+  endif()
+endif()
+
+# Look for the header file.
+find_path(CURL_INCLUDE_DIR
+          NAMES curl/curl.h
+          HINTS ${PC_CURL_INCLUDE_DIRS})
+mark_as_advanced(CURL_INCLUDE_DIR)
+
+if(NOT CURL_LIBRARY)
+  # Look for the library (sorted from most current/relevant entry to least).
+  find_library(CURL_LIBRARY_RELEASE NAMES
+      curl
+    # Windows MSVC prebuilts:
+      curllib
+      libcurl_imp
+      curllib_static
+    # Windows older "Win32 - MSVC" prebuilts (libcurl.lib, e.g. libcurl-7.15.5-win32-msvc.zip):
+      libcurl
+    # Some Windows prebuilt versions distribute `libcurl_a.lib` instead of `libcurl.lib`
+      libcurl_a
+      NAMES_PER_DIR
+      HINTS ${PC_CURL_LIBRARY_DIRS}
+  )
+  mark_as_advanced(CURL_LIBRARY_RELEASE)
+
+  find_library(CURL_LIBRARY_DEBUG NAMES
+    # Windows MSVC CMake builds in debug configuration on vcpkg:
+      libcurl-d_imp
+      libcurl-d
+      NAMES_PER_DIR
+      HINTS ${PC_CURL_LIBRARY_DIRS}
+  )
+  mark_as_advanced(CURL_LIBRARY_DEBUG)
+
+  include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
+  select_library_configurations(CURL)
+endif()
+
+if(CURL_INCLUDE_DIR)
+  foreach(_curl_version_header curlver.h curl.h)
+    if(EXISTS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}")
+      file(STRINGS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}" curl_version_str REGEX "^#define[\t ]+LIBCURL_VERSION[\t ]+\".*\"")
+
+      string(REGEX REPLACE "^#define[\t ]+LIBCURL_VERSION[\t ]+\"([^\"]*)\".*" "\\1" CURL_VERSION_STRING "${curl_version_str}")
+      unset(curl_version_str)
+      break()
+    endif()
+  endforeach()
+endif()
+
+if(CURL_FIND_COMPONENTS)
+  set(CURL_KNOWN_PROTOCOLS ICT FILE FTP FTPS GOPHER HTTP HTTPS IMAP IMAPS LDAP LDAPS POP3 POP3S RTMP RTSP SCP SFTP SMB SMBS SMTP SMTPS TELNET TFTP)
+  set(CURL_KNOWN_FEATURES  SSL IPv6 UnixSockets libz AsynchDNS IDN GSS-API PSL SPNEGO Kerberos NTLM NTLM_WB TLS-SRP HTTP2 HTTPS-proxy)
+  foreach(component IN LISTS CURL_KNOWN_PROTOCOLS CURL_KNOWN_FEATURES)
+    set(CURL_${component}_FOUND FALSE)
+  endforeach()
+  if(NOT PC_CURL_FOUND)
+    find_program(CURL_CONFIG_EXECUTABLE NAMES curl-config)
+    if(CURL_CONFIG_EXECUTABLE)
+      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --version
+                      OUTPUT_VARIABLE CURL_CONFIG_VERSION_STRING
+                      ERROR_QUIET
+                      OUTPUT_STRIP_TRAILING_WHITESPACE)
+      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --feature
+                      OUTPUT_VARIABLE CURL_CONFIG_FEATURES_STRING
+                      ERROR_QUIET
+                      OUTPUT_STRIP_TRAILING_WHITESPACE)
+      string(REPLACE "\n" ";" CURL_SUPPORTED_FEATURES "${CURL_CONFIG_FEATURES_STRING}")
+      execute_process(COMMAND ${CURL_CONFIG_EXECUTABLE} --protocols
+                      OUTPUT_VARIABLE CURL_CONFIG_PROTOCOLS_STRING
+                      ERROR_QUIET
+                      OUTPUT_STRIP_TRAILING_WHITESPACE)
+      string(REPLACE "\n" ";" CURL_SUPPORTED_PROTOCOLS "${CURL_CONFIG_PROTOCOLS_STRING}")
+    endif()
+
+  endif()
+  foreach(component IN LISTS CURL_FIND_COMPONENTS)
+    list(FIND CURL_KNOWN_PROTOCOLS ${component} _found)
+    if(NOT _found EQUAL -1)
+      list(FIND CURL_SUPPORTED_PROTOCOLS ${component} _found)
+      if(NOT _found EQUAL -1)
+        set(CURL_${component}_FOUND TRUE)
+      elseif(CURL_FIND_REQUIRED)
+        message(FATAL_ERROR "CURL: Required protocol ${component} is not found")
+      endif()
+    else()
+      list(FIND CURL_SUPPORTED_FEATURES ${component} _found)
+      if(NOT _found EQUAL -1)
+        set(CURL_${component}_FOUND TRUE)
+      elseif(CURL_FIND_REQUIRED)
+        message(FATAL_ERROR "CURL: Required feature ${component} is not found")
+      endif()
+    endif()
+  endforeach()
+endif()
+
+find_package_handle_standard_args(CURL
+                                  REQUIRED_VARS CURL_LIBRARY CURL_INCLUDE_DIR
+                                  VERSION_VAR CURL_VERSION_STRING
+                                  HANDLE_COMPONENTS)
+
+if(CURL_FOUND)
+  set(CURL_LIBRARIES ${CURL_LIBRARY})
+  set(CURL_INCLUDE_DIRS ${CURL_INCLUDE_DIR})
+
+  if(NOT TARGET CURL::libcurl)
+    add_library(CURL::libcurl UNKNOWN IMPORTED)
+    set_target_properties(CURL::libcurl PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${CURL_INCLUDE_DIRS}")
+
+    if(CURL_USE_STATIC_LIBS)
+      set_property(TARGET CURL::libcurl APPEND PROPERTY
+                   INTERFACE_COMPILE_DEFINITIONS "CURL_STATICLIB")
+    endif()
+
+    if(EXISTS "${CURL_LIBRARY}")
+      set_target_properties(CURL::libcurl PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+        IMPORTED_LOCATION "${CURL_LIBRARY}")
+    endif()
+    if(CURL_LIBRARY_RELEASE)
+      set_property(TARGET CURL::libcurl APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS RELEASE)
+      set_target_properties(CURL::libcurl PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+        IMPORTED_LOCATION_RELEASE "${CURL_LIBRARY_RELEASE}")
+    endif()
+    if(CURL_LIBRARY_DEBUG)
+      set_property(TARGET CURL::libcurl APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS DEBUG)
+      set_target_properties(CURL::libcurl PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+        IMPORTED_LOCATION_DEBUG "${CURL_LIBRARY_DEBUG}")
+    endif()
+
+    if(CURL_USE_STATIC_LIBS AND MSVC)
+       set_target_properties(CURL::libcurl PROPERTIES
+           INTERFACE_LINK_LIBRARIES "normaliz.lib;ws2_32.lib;wldap32.lib")
+    endif()
+
+  endif()
+endif()
+
+cmake_policy(POP)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FindGDAL.cmake

@@ -0,0 +1,204 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindGDAL
+--------
+
+Find Geospatial Data Abstraction Library (GDAL).
+
+IMPORTED Targets
+^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.14
+
+This module defines :prop_tgt:`IMPORTED` target ``GDAL::GDAL``
+if GDAL has been found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project:
+
+``GDAL_FOUND``
+  True if GDAL is found.
+``GDAL_INCLUDE_DIRS``
+  Include directories for GDAL headers.
+``GDAL_LIBRARIES``
+  Libraries to link to GDAL.
+``GDAL_VERSION``
+  .. versionadded:: 3.14
+    The version of GDAL found.
+
+Cache variables
+^^^^^^^^^^^^^^^
+
+The following cache variables may also be set:
+
+``GDAL_LIBRARY``
+  The libgdal library file.
+``GDAL_INCLUDE_DIR``
+  The directory containing ``gdal.h``.
+
+Hints
+^^^^^
+
+Set ``GDAL_DIR`` or ``GDAL_ROOT`` in the environment to specify the
+GDAL installation prefix.
+
+The following variables may be set to modify the search strategy:
+
+``FindGDAL_SKIP_GDAL_CONFIG``
+  If set, ``gdal-config`` will not be used. This can be useful if there are
+  GDAL libraries built with autotools (which provide the tool) and CMake (which
+  do not) in the same environment.
+``GDAL_ADDITIONAL_LIBRARY_VERSIONS``
+  Extra versions of library names to search for.
+#]=======================================================================]
+
+# $GDALDIR is an environment variable that would
+# correspond to the ./configure --prefix=$GDAL_DIR
+# used in building gdal.
+#
+# Created by Eric Wing. I'm not a gdal user, but OpenSceneGraph uses it
+# for osgTerrain so I whipped this module together for completeness.
+# I actually don't know the conventions or where files are typically
+# placed in distros.
+# Any real gdal users are encouraged to correct this (but please don't
+# break the OS X framework stuff when doing so which is what usually seems
+# to happen).
+
+# This makes the presumption that you are include gdal.h like
+#
+#include "gdal.h"
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
+
+find_path(GDAL_INCLUDE_DIR gdal.h
+  HINTS
+    ENV GDAL_DIR
+    ENV GDAL_ROOT
+  PATH_SUFFIXES
+    include/gdal
+    include/GDAL
+    include
+  DOC "Path to the GDAL include directory"
+)
+mark_as_advanced(GDAL_INCLUDE_DIR)
+
+if(UNIX AND NOT FindGDAL_SKIP_GDAL_CONFIG)
+    # Use gdal-config to obtain the library version (this should hopefully
+    # allow us to -lgdal1.x.y where x.y are correct version)
+    # For some reason, libgdal development packages do not contain
+    # libgdal.so...
+    find_program(GDAL_CONFIG gdal-config
+        HINTS
+          ENV GDAL_DIR
+          ENV GDAL_ROOT
+        PATH_SUFFIXES bin
+        DOC "Path to the gdal-config tool"
+    )
+    mark_as_advanced(GDAL_CONFIG)
+
+    if(GDAL_CONFIG)
+        execute_process(COMMAND ${GDAL_CONFIG} --libs OUTPUT_VARIABLE GDAL_CONFIG_LIBS)
+
+        if(GDAL_CONFIG_LIBS)
+            # treat the output as a command line and split it up
+            separate_arguments(args NATIVE_COMMAND "${GDAL_CONFIG_LIBS}")
+
+            # only consider libraries whose name matches this pattern
+            set(name_pattern "[gG][dD][aA][lL]")
+
+            # consider each entry as a possible library path, name, or parent directory
+            foreach(arg IN LISTS args)
+                # library name
+                if("${arg}" MATCHES "^-l(.*)$")
+                    set(lib "${CMAKE_MATCH_1}")
+
+                    # only consider libraries whose name matches the expected pattern
+                    if("${lib}" MATCHES "${name_pattern}")
+                        list(APPEND _gdal_lib "${lib}")
+                    endif()
+                # library search path
+                elseif("${arg}" MATCHES "^-L(.*)$")
+                    list(APPEND _gdal_libpath "${CMAKE_MATCH_1}")
+                # assume this is a full path to a library
+                elseif(IS_ABSOLUTE "${arg}" AND EXISTS "${arg}")
+                    # extract the file name
+                    get_filename_component(lib "${arg}" NAME)
+
+                    # only consider libraries whose name matches the expected pattern
+                    if(NOT "${lib}" MATCHES "${name_pattern}")
+                        continue()
+                    endif()
+
+                    # extract the file directory
+                    get_filename_component(dir "${arg}" DIRECTORY)
+
+                    # remove library prefixes/suffixes
+                    string(REGEX REPLACE "^(${CMAKE_SHARED_LIBRARY_PREFIX}|${CMAKE_STATIC_LIBRARY_PREFIX})" "" lib "${lib}")
+                    string(REGEX REPLACE "(${CMAKE_SHARED_LIBRARY_SUFFIX}|${CMAKE_STATIC_LIBRARY_SUFFIX})$" "" lib "${lib}")
+
+                    # use the file name and directory as hints
+                    list(APPEND _gdal_libpath "${dir}")
+                    list(APPEND _gdal_lib "${lib}")
+                endif()
+            endforeach()
+        endif()
+    endif()
+endif()
+
+# GDAL name its library when built with CMake as `gdal${major}${minor}`.
+set(_gdal_versions
+    ${GDAL_ADDITIONAL_LIBRARY_VERSIONS} 3.0 2.4 2.3 2.2 2.1 2.0 1.11 1.10 1.9 1.8 1.7 1.6 1.5 1.4 1.3 1.2)
+
+set(_gdal_libnames)
+foreach (_gdal_version IN LISTS _gdal_versions)
+    string(REPLACE "." "" _gdal_version "${_gdal_version}")
+    list(APPEND _gdal_libnames "gdal${_gdal_version}" "GDAL${_gdal_version}")
+endforeach ()
+unset(_gdal_version)
+unset(_gdal_versions)
+
+find_library(GDAL_LIBRARY
+  NAMES ${_gdal_lib} ${_gdal_libnames} gdal gdald gdal_i gdal1.5.0 gdal1.4.0 gdal1.3.2 GDAL
+  HINTS
+     ENV GDAL_DIR
+     ENV GDAL_ROOT
+     ${_gdal_libpath}
+  PATH_SUFFIXES lib
+  DOC "Path to the GDAL library"
+)
+mark_as_advanced(GDAL_LIBRARY)
+unset(_gdal_libnames)
+unset(_gdal_lib)
+
+if (EXISTS "${GDAL_INCLUDE_DIR}/gdal_version.h")
+    file(STRINGS "${GDAL_INCLUDE_DIR}/gdal_version.h" _gdal_version
+        REGEX "GDAL_RELEASE_NAME")
+    string(REGEX REPLACE ".*\"\(.*\)\"" "\\1" GDAL_VERSION "${_gdal_version}")
+    unset(_gdal_version)
+else ()
+    set(GDAL_VERSION GDAL_VERSION-NOTFOUND)
+endif ()
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(GDAL
+    VERSION_VAR GDAL_VERSION
+    REQUIRED_VARS GDAL_LIBRARY GDAL_INCLUDE_DIR)
+
+if (GDAL_FOUND)
+    set(GDAL_LIBRARIES ${GDAL_LIBRARY})
+    set(GDAL_INCLUDE_DIRS ${GDAL_INCLUDE_DIR})
+
+    if (NOT TARGET GDAL::GDAL)
+        add_library(GDAL::GDAL UNKNOWN IMPORTED)
+        set_target_properties(GDAL::GDAL PROPERTIES
+            IMPORTED_LOCATION "${GDAL_LIBRARY}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GDAL_INCLUDE_DIR}")
+    endif ()
+endif ()
+
+cmake_policy(POP)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FindKDE3.cmake

@@ -0,0 +1,360 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindKDE3
+--------
+
+Find the KDE3 include and library dirs, KDE preprocessors and define a some macros
+
+
+
+This module defines the following variables:
+
+``KDE3_DEFINITIONS``
+  compiler definitions required for compiling KDE software
+``KDE3_INCLUDE_DIR``
+  the KDE include directory
+``KDE3_INCLUDE_DIRS``
+  the KDE and the Qt include directory, for use with include_directories()
+``KDE3_LIB_DIR``
+  the directory where the KDE libraries are installed, for use with link_directories()
+``QT_AND_KDECORE_LIBS``
+  this contains both the Qt and the kdecore library
+``KDE3_DCOPIDL_EXECUTABLE``
+  the dcopidl executable
+``KDE3_DCOPIDL2CPP_EXECUTABLE``
+  the dcopidl2cpp executable
+``KDE3_KCFGC_EXECUTABLE``
+  the kconfig_compiler executable
+``KDE3_FOUND``
+  set to TRUE if all of the above has been found
+
+The following user adjustable options are provided:
+
+``KDE3_BUILD_TESTS``
+  enable this to build KDE testcases
+
+It also adds the following macros (from ``KDE3Macros.cmake``) ``SRCS_VAR`` is
+always the variable which contains the list of source files for your
+application or library.
+
+KDE3_AUTOMOC(file1 ...  fileN)
+
+::
+
+    Call this if you want to have automatic moc file handling.
+    This means if you include "foo.moc" in the source file foo.cpp
+    a moc file for the header foo.h will be created automatically.
+    You can set the property SKIP_AUTOMAKE using set_source_files_properties()
+    to exclude some files in the list from being processed.
+
+
+
+KDE3_ADD_MOC_FILES(SRCS_VAR file1 ...  fileN )
+
+::
+
+    If you don't use the KDE3_AUTOMOC() macro, for the files
+    listed here moc files will be created (named "foo.moc.cpp")
+
+
+
+KDE3_ADD_DCOP_SKELS(SRCS_VAR header1.h ...  headerN.h )
+
+::
+
+    Use this to generate DCOP skeletions from the listed headers.
+
+
+
+KDE3_ADD_DCOP_STUBS(SRCS_VAR header1.h ...  headerN.h )
+
+::
+
+     Use this to generate DCOP stubs from the listed headers.
+
+
+
+KDE3_ADD_UI_FILES(SRCS_VAR file1.ui ...  fileN.ui )
+
+::
+
+    Use this to add the Qt designer ui files to your application/library.
+
+
+
+KDE3_ADD_KCFG_FILES(SRCS_VAR file1.kcfgc ...  fileN.kcfgc )
+
+::
+
+    Use this to add KDE kconfig compiler files to your application/library.
+
+
+
+KDE3_INSTALL_LIBTOOL_FILE(target)
+
+::
+
+    This will create and install a simple libtool file for the given target.
+
+
+
+KDE3_ADD_EXECUTABLE(name file1 ...  fileN )
+
+::
+
+    Currently identical to add_executable(), may provide some advanced
+    features in the future.
+
+
+
+KDE3_ADD_KPART(name [WITH_PREFIX] file1 ...  fileN )
+
+::
+
+    Create a KDE plugin (KPart, kioslave, etc.) from the given source files.
+    If WITH_PREFIX is given, the resulting plugin will have the prefix "lib",
+    otherwise it won't.
+    It creates and installs an appropriate libtool la-file.
+
+
+
+KDE3_ADD_KDEINIT_EXECUTABLE(name file1 ...  fileN )
+
+::
+
+    Create a KDE application in the form of a module loadable via kdeinit.
+    A library named kdeinit_<name> will be created and a small executable
+    which links to it.
+
+
+
+The option KDE3_ENABLE_FINAL to enable all-in-one compilation is no
+longer supported.
+
+
+
+Author: Alexander Neundorf <neundorf@kde.org>
+#]=======================================================================]
+
+if(NOT UNIX AND KDE3_FIND_REQUIRED)
+  message(FATAL_ERROR "Compiling KDE3 applications and libraries under Windows is not supported")
+endif()
+
+# If Qt4 has already been found, fail.
+if(QT4_FOUND)
+  if(KDE3_FIND_REQUIRED)
+    message( FATAL_ERROR "KDE3/Qt3 and Qt4 cannot be used together in one project.")
+  else()
+    if(NOT KDE3_FIND_QUIETLY)
+      message( STATUS    "KDE3/Qt3 and Qt4 cannot be used together in one project.")
+    endif()
+    return()
+  endif()
+endif()
+
+
+set(QT_MT_REQUIRED TRUE)
+#set(QT_MIN_VERSION "3.0.0")
+
+#this line includes FindQt.cmake, which searches the Qt library and headers
+if(KDE3_FIND_REQUIRED)
+  set(_REQ_STRING_KDE3 "REQUIRED")
+endif()
+
+find_package(Qt3 ${_REQ_STRING_KDE3})
+find_package(X11 ${_REQ_STRING_KDE3})
+
+
+#now try to find some kde stuff
+find_program(KDECONFIG_EXECUTABLE NAMES kde-config
+  HINTS
+    $ENV{KDEDIR}/bin
+  PATHS
+    /opt/kde3/bin
+    /opt/kde/bin
+  )
+
+set(KDE3PREFIX)
+if(KDECONFIG_EXECUTABLE)
+  execute_process(COMMAND ${KDECONFIG_EXECUTABLE} --version
+                  OUTPUT_VARIABLE kde_config_version )
+
+  string(REGEX MATCH "KDE: .\\." kde_version "${kde_config_version}")
+  if ("${kde_version}" MATCHES "KDE: 3\\.")
+    execute_process(COMMAND ${KDECONFIG_EXECUTABLE} --prefix
+                    OUTPUT_VARIABLE kdedir )
+    string(REPLACE "\n" "" KDE3PREFIX "${kdedir}")
+
+  endif ()
+endif()
+
+
+
+# at first the KDE include directory
+# kpassdlg.h comes from kdeui and doesn't exist in KDE4 anymore
+find_path(KDE3_INCLUDE_DIR kpassdlg.h
+  HINTS
+    $ENV{KDEDIR}/include
+    ${KDE3PREFIX}/include
+  PATHS
+    /opt/kde3/include
+    /opt/kde/include
+  PATH_SUFFIXES include/kde
+  )
+
+#now the KDE library directory
+find_library(KDE3_KDECORE_LIBRARY NAMES kdecore
+  HINTS
+    $ENV{KDEDIR}/lib
+    ${KDE3PREFIX}/lib
+  PATHS
+    /opt/kde3/lib
+    /opt/kde/lib
+)
+
+set(QT_AND_KDECORE_LIBS ${QT_LIBRARIES} ${KDE3_KDECORE_LIBRARY})
+
+get_filename_component(KDE3_LIB_DIR ${KDE3_KDECORE_LIBRARY} PATH )
+
+if(NOT KDE3_LIBTOOL_DIR)
+  if(KDE3_KDECORE_LIBRARY MATCHES lib64)
+    set(KDE3_LIBTOOL_DIR /lib64/kde3)
+  elseif(KDE3_KDECORE_LIBRARY MATCHES libx32)
+    set(KDE3_LIBTOOL_DIR /libx32/kde3)
+  else()
+    set(KDE3_LIBTOOL_DIR /lib/kde3)
+  endif()
+endif()
+
+#now search for the dcop utilities
+find_program(KDE3_DCOPIDL_EXECUTABLE NAMES dcopidl
+  HINTS
+    $ENV{KDEDIR}/bin
+    ${KDE3PREFIX}/bin
+  PATHS
+    /opt/kde3/bin
+    /opt/kde/bin
+  )
+
+find_program(KDE3_DCOPIDL2CPP_EXECUTABLE NAMES dcopidl2cpp
+  HINTS
+    $ENV{KDEDIR}/bin
+    ${KDE3PREFIX}/bin
+  PATHS
+    /opt/kde3/bin
+    /opt/kde/bin
+  )
+
+find_program(KDE3_KCFGC_EXECUTABLE NAMES kconfig_compiler
+  HINTS
+    $ENV{KDEDIR}/bin
+    ${KDE3PREFIX}/bin
+  PATHS
+    /opt/kde3/bin
+    /opt/kde/bin
+  )
+
+
+#SET KDE3_FOUND
+if (KDE3_INCLUDE_DIR AND KDE3_LIB_DIR AND KDE3_DCOPIDL_EXECUTABLE AND KDE3_DCOPIDL2CPP_EXECUTABLE AND KDE3_KCFGC_EXECUTABLE)
+  set(KDE3_FOUND TRUE)
+else ()
+  set(KDE3_FOUND FALSE)
+endif ()
+
+# add some KDE specific stuff
+set(KDE3_DEFINITIONS -DQT_CLEAN_NAMESPACE -D_GNU_SOURCE)
+
+# set compiler flags only if KDE3 has actually been found
+if(KDE3_FOUND)
+  set(_KDE3_USE_FLAGS FALSE)
+  if(CMAKE_COMPILER_IS_GNUCXX)
+    set(_KDE3_USE_FLAGS TRUE) # use flags for gnu compiler
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version
+                    OUTPUT_VARIABLE out)
+    # gnu gcc 2.96 does not work with flags
+    # I guess 2.95 also doesn't then
+    if("${out}" MATCHES "2.9[56]")
+      set(_KDE3_USE_FLAGS FALSE)
+    endif()
+  endif()
+
+  #only on linux, but NOT e.g. on FreeBSD:
+  if(CMAKE_SYSTEM_NAME MATCHES "Linux" AND _KDE3_USE_FLAGS)
+    set (KDE3_DEFINITIONS ${KDE3_DEFINITIONS} -D_XOPEN_SOURCE=500 -D_BSD_SOURCE)
+    set ( CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} -Wno-long-long -ansi -Wundef -Wcast-align -Wconversion -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-common")
+    set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wno-long-long -ansi -Wundef -Wcast-align -Wconversion -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -fno-exceptions -fno-check-new -fno-common")
+  endif()
+
+  # works on FreeBSD, NOT tested on NetBSD and OpenBSD
+  if (CMAKE_SYSTEM_NAME MATCHES BSD AND _KDE3_USE_FLAGS)
+    set ( CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} -Wno-long-long -ansi -Wundef -Wcast-align -Wconversion -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-common")
+    set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wno-long-long -Wundef -Wcast-align -Wconversion -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-exceptions -fno-check-new -fno-common")
+  endif ()
+
+  # if no special buildtype is selected, add -O2 as default optimization
+  if (NOT CMAKE_BUILD_TYPE AND _KDE3_USE_FLAGS)
+    set ( CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} -O2")
+    set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
+  endif ()
+
+#set(CMAKE_SHARED_LINKER_FLAGS "-avoid-version -module -Wl,--no-undefined -Wl,--allow-shlib-undefined")
+#set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -avoid-version -Wl,--no-undefined -lc")
+#set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -avoid-version -Wl,--no-undefined -lc")
+endif()
+
+
+# KDE3Macros.cmake contains all the KDE specific macros
+include(${CMAKE_CURRENT_LIST_DIR}/KDE3Macros.cmake)
+
+
+macro (KDE3_PRINT_RESULTS)
+  if(KDE3_INCLUDE_DIR)
+    message(STATUS "Found KDE3 include dir: ${KDE3_INCLUDE_DIR}")
+  else()
+    message(STATUS "Didn't find KDE3 headers")
+  endif()
+
+  if(KDE3_LIB_DIR)
+    message(STATUS "Found KDE3 library dir: ${KDE3_LIB_DIR}")
+  else()
+    message(STATUS "Didn't find KDE3 core library")
+  endif()
+
+  if(KDE3_DCOPIDL_EXECUTABLE)
+    message(STATUS "Found KDE3 dcopidl preprocessor: ${KDE3_DCOPIDL_EXECUTABLE}")
+  else()
+    message(STATUS "Didn't find the KDE3 dcopidl preprocessor")
+  endif()
+
+  if(KDE3_DCOPIDL2CPP_EXECUTABLE)
+    message(STATUS "Found KDE3 dcopidl2cpp preprocessor: ${KDE3_DCOPIDL2CPP_EXECUTABLE}")
+  else()
+    message(STATUS "Didn't find the KDE3 dcopidl2cpp preprocessor")
+  endif()
+
+  if(KDE3_KCFGC_EXECUTABLE)
+    message(STATUS "Found KDE3 kconfig_compiler preprocessor: ${KDE3_KCFGC_EXECUTABLE}")
+  else()
+    message(STATUS "Didn't find the KDE3 kconfig_compiler preprocessor")
+  endif()
+
+endmacro ()
+
+
+if (KDE3_FIND_REQUIRED AND NOT KDE3_FOUND)
+  #bail out if something wasn't found
+  KDE3_PRINT_RESULTS()
+  message(FATAL_ERROR "Could NOT find everything required for compiling KDE 3 programs")
+
+endif ()
+
+
+if (NOT KDE3_FIND_QUIETLY)
+  KDE3_PRINT_RESULTS()
+endif ()
+
+#add the found Qt and KDE include directories to the current include path
+set(KDE3_INCLUDE_DIRS ${QT_INCLUDE_DIR} ${KDE3_INCLUDE_DIR})

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FindLAPACK.cmake

@@ -0,0 +1,815 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindLAPACK
+----------
+
+Find Linear Algebra PACKage (LAPACK) library
+
+This module finds an installed Fortran library that implements the
+`LAPACK linear-algebra interface`_.
+
+At least one of the ``C``, ``CXX``, or ``Fortran`` languages must be enabled.
+
+.. _`LAPACK linear-algebra interface`: https://netlib.org/lapack/
+
+Input Variables
+^^^^^^^^^^^^^^^
+
+The following variables may be set to influence this module's behavior:
+
+``BLA_STATIC``
+  if ``ON`` use static linkage
+
+``BLA_VENDOR``
+  Set to one of the :ref:`BLAS/LAPACK Vendors` to search for BLAS only
+  from the specified vendor.  If not set, all vendors are considered.
+
+``BLA_F95``
+  if ``ON`` tries to find the BLAS95/LAPACK95 interfaces
+
+``BLA_PREFER_PKGCONFIG``
+  .. versionadded:: 3.20
+
+  if set ``pkg-config`` will be used to search for a LAPACK library first
+  and if one is found that is preferred
+
+``BLA_PKGCONFIG_LAPACK``
+  .. versionadded:: 3.25
+
+  If set, the ``pkg-config`` method will look for this module name instead of
+  just ``lapack``.
+
+
+``BLA_SIZEOF_INTEGER``
+  .. versionadded:: 3.22
+
+  Specify the BLAS/LAPACK library integer size:
+
+  ``4``
+    Search for a BLAS/LAPACK with 32-bit integer interfaces.
+  ``8``
+    Search for a BLAS/LAPACK with 64-bit integer interfaces.
+  ``ANY``
+    Search for any BLAS/LAPACK.
+    Most likely, a BLAS/LAPACK with 32-bit integer interfaces will be found.
+
+Imported targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :prop_tgt:`IMPORTED` targets:
+
+``LAPACK::LAPACK``
+  .. versionadded:: 3.18
+
+  The libraries to use for LAPACK, if found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``LAPACK_FOUND``
+  library implementing the LAPACK interface is found
+``LAPACK_LINKER_FLAGS``
+  uncached list of required linker flags (excluding ``-l`` and ``-L``).
+``LAPACK_LIBRARIES``
+  uncached list of libraries (using full path name) to link against
+  to use LAPACK
+``LAPACK95_LIBRARIES``
+  uncached list of libraries (using full path name) to link against
+  to use LAPACK95
+``LAPACK95_FOUND``
+  library implementing the LAPACK95 interface is found
+
+Intel MKL
+^^^^^^^^^
+
+To use the Intel MKL implementation of LAPACK, a project must enable at least
+one of the ``C`` or ``CXX`` languages.  Set ``BLA_VENDOR`` to an Intel MKL
+variant either on the command-line as ``-DBLA_VENDOR=Intel10_64lp`` or in
+project code:
+
+.. code-block:: cmake
+
+  set(BLA_VENDOR Intel10_64lp)
+  find_package(LAPACK)
+
+In order to build a project using Intel MKL, and end user must first
+establish an Intel MKL environment.  See the :module:`FindBLAS` module
+section on :ref:`Intel MKL` for details.
+
+#]=======================================================================]
+
+# The approach follows that of the ``autoconf`` macro file, ``acx_lapack.m4``
+# (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html).
+
+if(CMAKE_Fortran_COMPILER_LOADED)
+  include(${CMAKE_CURRENT_LIST_DIR}/CheckFortranFunctionExists.cmake)
+else()
+  include(${CMAKE_CURRENT_LIST_DIR}/CheckFunctionExists.cmake)
+endif()
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+
+function(_add_lapack_target)
+  if(LAPACK_FOUND AND NOT TARGET LAPACK::LAPACK)
+    add_library(LAPACK::LAPACK INTERFACE IMPORTED)
+
+    # Filter out redundant BLAS info and replace with the BLAS target
+    set(_lapack_libs "${LAPACK_LIBRARIES}")
+    set(_lapack_flags "${LAPACK_LINKER_FLAGS}")
+    if(TARGET BLAS::BLAS)
+      if(_lapack_libs AND BLAS_LIBRARIES)
+        foreach(_blas_lib IN LISTS BLAS_LIBRARIES)
+          list(REMOVE_ITEM _lapack_libs "${_blas_lib}")
+        endforeach()
+      endif()
+      if(_lapack_flags AND BLAS_LINKER_FLAGS)
+        foreach(_blas_flag IN LISTS BLAS_LINKER_FLAGS)
+          list(REMOVE_ITEM _lapack_flags "${_blas_flag}")
+        endforeach()
+      endif()
+      list(APPEND _lapack_libs BLAS::BLAS)
+    endif()
+    if(_lapack_libs)
+      set_target_properties(LAPACK::LAPACK PROPERTIES
+        INTERFACE_LINK_LIBRARIES "${_lapack_libs}"
+      )
+    endif()
+    if(_lapack_flags)
+      set_target_properties(LAPACK::LAPACK PROPERTIES
+        INTERFACE_LINK_OPTIONS "${_lapack_flags}"
+      )
+    endif()
+  endif()
+endfunction()
+
+# TODO: move this stuff to a separate module
+
+function(CHECK_LAPACK_LIBRARIES LIBRARIES _prefix _name _flags _list _deps _addlibdir _subdirs _blas)
+  # This function checks for the existence of the combination of libraries
+  # given by _list.  If the combination is found, this checks whether can link
+  # against that library combination using the name of a routine given by _name
+  # using the linker flags given by _flags.  If the combination of libraries is
+  # found and passes the link test, ${LIBRARIES} is set to the list of complete
+  # library paths that have been found.  Otherwise, ${LIBRARIES} is set to FALSE.
+
+  set(_libraries_work TRUE)
+  set(_libraries)
+  set(_combined_name)
+
+  if(BLA_STATIC)
+    if(WIN32)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    else()
+      set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
+    endif()
+  else()
+    if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+      # for ubuntu's libblas3gf and liblapack3gf packages
+      set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf)
+    endif()
+  endif()
+
+  set(_extaddlibdir "${_addlibdir}")
+  if(WIN32)
+    list(APPEND _extaddlibdir ENV LIB)
+  elseif(APPLE)
+    list(APPEND _extaddlibdir ENV DYLD_LIBRARY_PATH)
+  else()
+    list(APPEND _extaddlibdir ENV LD_LIBRARY_PATH)
+  endif()
+  list(APPEND _extaddlibdir "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}")
+
+  foreach(_library ${_list})
+    if(_library MATCHES "^-")
+      # Respect linker flags as-is (required by MKL)
+      list(APPEND _libraries "${_library}")
+    else()
+      string(REGEX REPLACE "[^A-Za-z0-9]" "_" _lib_var "${_library}")
+      string(APPEND _combined_name "_${_lib_var}")
+      if(NOT "${_deps}" STREQUAL "")
+        string(APPEND _combined_name "_deps")
+      endif()
+      if(_libraries_work)
+        find_library(${_prefix}_${_lib_var}_LIBRARY
+          NAMES ${_library}
+          NAMES_PER_DIR
+          PATHS ${_extaddlibdir}
+          PATH_SUFFIXES ${_subdirs}
+        )
+        mark_as_advanced(${_prefix}_${_lib_var}_LIBRARY)
+        list(APPEND _libraries ${${_prefix}_${_lib_var}_LIBRARY})
+        set(_libraries_work ${${_prefix}_${_lib_var}_LIBRARY})
+      endif()
+    endif()
+  endforeach()
+
+  foreach(_flag ${_flags})
+    string(REGEX REPLACE "[^A-Za-z0-9]" "_" _flag_var "${_flag}")
+    string(APPEND _combined_name "_${_flag_var}")
+  endforeach()
+  if(_libraries_work)
+    # Test this combination of libraries.
+    set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${_libraries} ${_blas} ${_deps})
+    set(CMAKE_REQUIRED_QUIET ${LAPACK_FIND_QUIETLY})
+    if(CMAKE_Fortran_COMPILER_LOADED)
+      check_fortran_function_exists("${_name}" ${_prefix}${_combined_name}_WORKS)
+    else()
+      check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS)
+    endif()
+    set(CMAKE_REQUIRED_LIBRARIES)
+    set(_libraries_work ${${_prefix}${_combined_name}_WORKS})
+  endif()
+
+  if(_libraries_work)
+    if("${_list}${_blas}" STREQUAL "")
+      set(_libraries "${LIBRARIES}-PLACEHOLDER-FOR-EMPTY-LIBRARIES")
+    else()
+      list(APPEND _libraries ${_blas} ${_deps})
+    endif()
+  else()
+    set(_libraries FALSE)
+  endif()
+  set(${LIBRARIES} "${_libraries}" PARENT_SCOPE)
+endfunction()
+
+macro(_lapack_find_dependency dep)
+  set(_lapack_quiet_arg)
+  if(LAPACK_FIND_QUIETLY)
+    set(_lapack_quiet_arg QUIET)
+  endif()
+  set(_lapack_required_arg)
+  if(LAPACK_FIND_REQUIRED)
+    set(_lapack_required_arg REQUIRED)
+  endif()
+  find_package(${dep} ${ARGN}
+    ${_lapack_quiet_arg}
+    ${_lapack_required_arg}
+  )
+  if (NOT ${dep}_FOUND)
+    set(LAPACK_NOT_FOUND_MESSAGE "LAPACK could not be found because dependency ${dep} could not be found.")
+  endif()
+
+  set(_lapack_required_arg)
+  set(_lapack_quiet_arg)
+endmacro()
+
+set(LAPACK_LINKER_FLAGS)
+set(LAPACK_LIBRARIES)
+set(LAPACK95_LIBRARIES)
+set(_lapack_fphsa_req_var LAPACK_LIBRARIES)
+
+# Check the language being used
+if(NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED OR CMAKE_Fortran_COMPILER_LOADED))
+  set(LAPACK_NOT_FOUND_MESSAGE
+    "FindLAPACK requires Fortran, C, or C++ to be enabled.")
+endif()
+
+if(NOT BLA_SIZEOF_INTEGER)
+  # in the reality we do not know which API of BLAS/LAPACK is masked in library
+  set(_lapack_sizeof_integer "ANY")
+elseif((BLA_SIZEOF_INTEGER STREQUAL "ANY") OR
+       (BLA_SIZEOF_INTEGER STREQUAL "4") OR
+       (BLA_SIZEOF_INTEGER STREQUAL "8"))
+  set(_lapack_sizeof_integer ${BLA_SIZEOF_INTEGER})
+else()
+  message(FATAL_ERROR "BLA_SIZEOF_INTEGER can have only <no value>, ANY, 4, or 8 values")
+endif()
+
+# Load BLAS
+if(NOT LAPACK_NOT_FOUND_MESSAGE)
+  _lapack_find_dependency(BLAS)
+endif()
+
+# Search with pkg-config if specified
+if(BLA_PREFER_PKGCONFIG)
+  if(NOT BLA_PKGCONFIG_LAPACK)
+    set(BLA_PKGCONFIG_LAPACK "lapack")
+  endif()
+  find_package(PkgConfig QUIET)
+  if(PKG_CONFIG_FOUND)
+    pkg_check_modules(PKGC_LAPACK QUIET ${BLA_PKGCONFIG_LAPACK})
+    if(PKGC_LAPACK_FOUND)
+      set(LAPACK_FOUND TRUE)
+      set(LAPACK_LIBRARIES "${PKGC_LAPACK_LINK_LIBRARIES}")
+      if (BLAS_LIBRARIES)
+        list(APPEND LAPACK_LIBRARIES "${BLAS_LIBRARIES}")
+      endif()
+      _add_lapack_target()
+      return()
+    endif()
+  endif()
+endif()
+
+# Search for different LAPACK distributions if BLAS is found
+if(NOT LAPACK_NOT_FOUND_MESSAGE)
+  set(LAPACK_LINKER_FLAGS ${BLAS_LINKER_FLAGS})
+  if(NOT BLA_VENDOR)
+    if(NOT "$ENV{BLA_VENDOR}" STREQUAL "")
+      set(BLA_VENDOR "$ENV{BLA_VENDOR}")
+    else()
+      set(BLA_VENDOR "All")
+    endif()
+  endif()
+
+  # LAPACK in the Intel MKL 10+ library?
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "Intel" OR BLA_VENDOR STREQUAL "All")
+      AND (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED))
+    # System-specific settings
+    if(NOT WIN32)
+      set(LAPACK_mkl_LM "-lm")
+      set(LAPACK_mkl_LDL "-ldl")
+    endif()
+
+    _lapack_find_dependency(Threads)
+
+    if(_lapack_sizeof_integer EQUAL 8)
+      set(LAPACK_mkl_ILP_MODE "ilp64")
+    elseif(_lapack_sizeof_integer EQUAL 4)
+      set(LAPACK_mkl_ILP_MODE "lp64")
+    else()
+      if(BLA_VENDOR MATCHES "_64ilp")
+        set(LAPACK_mkl_ILP_MODE "ilp64")
+      else()
+        set(LAPACK_mkl_ILP_MODE "lp64")
+      endif()
+    endif()
+
+    set(LAPACK_SEARCH_LIBS "")
+
+    if(BLA_F95)
+      set(LAPACK_mkl_SEARCH_SYMBOL "cheev_f95")
+      set(_LAPACK_LIBRARIES LAPACK95_LIBRARIES)
+      set(_BLAS_LIBRARIES ${BLAS95_LIBRARIES})
+
+      # old
+      list(APPEND LAPACK_SEARCH_LIBS
+        "mkl_lapack95")
+      # new >= 10.3
+      list(APPEND LAPACK_SEARCH_LIBS
+        "mkl_intel_c")
+      list(APPEND LAPACK_SEARCH_LIBS
+        "mkl_lapack95_${LAPACK_mkl_ILP_MODE}")
+    else()
+      set(LAPACK_mkl_SEARCH_SYMBOL "cheev")
+      set(_LAPACK_LIBRARIES LAPACK_LIBRARIES)
+      set(_BLAS_LIBRARIES ${BLAS_LIBRARIES})
+
+      # old and new >= 10.3
+      list(APPEND LAPACK_SEARCH_LIBS
+        "mkl_lapack")
+    endif()
+
+    # MKL uses a multitude of partially platform-specific subdirectories:
+    if(BLA_VENDOR STREQUAL "Intel10_32")
+      set(LAPACK_mkl_ARCH_NAME "ia32")
+    else()
+      set(LAPACK_mkl_ARCH_NAME "intel64")
+    endif()
+    if(WIN32)
+      set(LAPACK_mkl_OS_NAME "win")
+    elseif(APPLE)
+      set(LAPACK_mkl_OS_NAME "mac")
+    else()
+      set(LAPACK_mkl_OS_NAME "lin")
+    endif()
+    if(DEFINED ENV{MKLROOT})
+      file(TO_CMAKE_PATH "$ENV{MKLROOT}" LAPACK_mkl_MKLROOT)
+      # If MKLROOT points to the subdirectory 'mkl', use the parent directory instead
+      # so we can better detect other relevant libraries in 'compiler' or 'tbb':
+      get_filename_component(LAPACK_mkl_MKLROOT_LAST_DIR "${LAPACK_mkl_MKLROOT}" NAME)
+      if(LAPACK_mkl_MKLROOT_LAST_DIR STREQUAL "mkl")
+          get_filename_component(LAPACK_mkl_MKLROOT "${LAPACK_mkl_MKLROOT}" DIRECTORY)
+      endif()
+    endif()
+    set(LAPACK_mkl_LIB_PATH_SUFFIXES
+        "compiler/lib" "compiler/lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}"
+        "compiler/lib/${LAPACK_mkl_ARCH_NAME}"
+        "mkl/lib" "mkl/lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}"
+        "mkl/lib/${LAPACK_mkl_ARCH_NAME}"
+        "lib" "lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}"
+        "lib/${LAPACK_mkl_ARCH_NAME}"
+        )
+
+    # First try empty lapack libs (implicitly linked or automatic from BLAS)
+    if(NOT ${_LAPACK_LIBRARIES})
+      check_lapack_libraries(
+        ${_LAPACK_LIBRARIES}
+        LAPACK
+        ${LAPACK_mkl_SEARCH_SYMBOL}
+        ""
+        ""
+        "${CMAKE_THREAD_LIBS_INIT};${LAPACK_mkl_LM};${LAPACK_mkl_LDL}"
+        "${LAPACK_mkl_MKLROOT}"
+        "${LAPACK_mkl_LIB_PATH_SUFFIXES}"
+        "${_BLAS_LIBRARIES}"
+      )
+      if(LAPACK_WORKS AND NOT _BLAS_LIBRARIES)
+        # Give a more helpful "found" message
+        set(LAPACK_WORKS "implicitly linked")
+        set(_lapack_fphsa_req_var LAPACK_WORKS)
+      endif()
+    endif()
+
+    # Then try the search libs
+    foreach(_search ${LAPACK_SEARCH_LIBS})
+      string(REPLACE " " ";" _search ${_search})
+      if(NOT ${_LAPACK_LIBRARIES})
+        check_lapack_libraries(
+          ${_LAPACK_LIBRARIES}
+          LAPACK
+          ${LAPACK_mkl_SEARCH_SYMBOL}
+          ""
+          "${_search}"
+          "${CMAKE_THREAD_LIBS_INIT};${LAPACK_mkl_LM};${LAPACK_mkl_LDL}"
+          "${LAPACK_mkl_MKLROOT}"
+          "${LAPACK_mkl_LIB_PATH_SUFFIXES}"
+          "${_BLAS_LIBRARIES}"
+        )
+      endif()
+    endforeach()
+
+    unset(_search)
+    unset(LAPACK_mkl_ILP_MODE)
+    unset(LAPACK_mkl_SEARCH_SYMBOL)
+    unset(LAPACK_mkl_LM)
+    unset(LAPACK_mkl_LDL)
+    unset(LAPACK_mkl_MKLROOT)
+    unset(LAPACK_mkl_ARCH_NAME)
+    unset(LAPACK_mkl_OS_NAME)
+    unset(LAPACK_mkl_LIB_PATH_SUFFIXES)
+  endif()
+
+  # gotoblas? (http://www.tacc.utexas.edu/tacc-projects/gotoblas2)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All"))
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "goto2"
+      ""
+      ""
+      ""
+      "${BLAS_LIBRARIES}"
+    )
+  endif()
+
+  # FlexiBLAS? (http://www.mpi-magdeburg.mpg.de/mpcsc/software/FlexiBLAS/)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "FlexiBLAS" OR BLA_VENDOR STREQUAL "All"))
+    set(_lapack_flexiblas_lib "flexiblas")
+
+    if(_lapack_sizeof_integer EQUAL 8)
+      string(APPEND _lapack_flexiblas_lib "64")
+    endif()
+
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "${_lapack_flexiblas_lib}"
+      ""
+      ""
+      ""
+      "${BLAS_LIBRARIES}"
+    )
+
+    unset(_lapack_flexiblas_lib)
+  endif()
+
+  # OpenBLAS? (http://www.openblas.net)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All"))
+    set(_lapack_openblas_lib "openblas")
+
+    if(_lapack_sizeof_integer EQUAL 8)
+      if(MINGW)
+        string(APPEND _lapack_openblas_lib "_64")
+      else()
+        string(APPEND _lapack_openblas_lib "64")
+      endif()
+    endif()
+
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "${_lapack_openblas_lib}"
+      ""
+      ""
+      ""
+      "${BLAS_LIBRARIES}"
+    )
+
+    unset(_lapack_openblas_lib)
+  endif()
+
+  # ArmPL? (https://developer.arm.com/tools-and-software/server-and-hpc/compile/arm-compiler-for-linux/arm-performance-libraries)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "Arm" OR BLA_VENDOR STREQUAL "All"))
+    # Check for 64bit Integer support
+    if(_lapack_sizeof_integer EQUAL 8)
+      set(LAPACK_armpl_LIB "armpl_ilp64")
+    elseif(_lapack_sizeof_integer EQUAL 4)
+      set(LAPACK_armpl_LIB "armpl_lp64")
+    else()
+      if(BLA_VENDOR MATCHES "_ilp64")
+        set(LAPACK_armpl_LIB "armpl_ilp64")
+      else()
+        set(LAPACK_armpl_LIB "armpl_lp64")
+      endif()
+    endif()
+
+    # Check for OpenMP support, VIA BLA_VENDOR of Arm_mp or Arm_ipl64_mp
+    if(BLA_VENDOR MATCHES "_mp")
+      string(APPEND LAPACK_armpl_LIB "_mp")
+    endif()
+
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "${LAPACK_armpl_LIB}"
+      ""
+      ""
+      ""
+      "${BLAS_LIBRARIES}"
+    )
+  endif()
+
+  # FLAME's blis library? (https://github.com/flame/blis)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "FLAME" OR BLA_VENDOR STREQUAL "All"))
+    if(_lapack_sizeof_integer EQUAL 8)
+      if(BLA_VENDOR STREQUAL "FLAME")
+        message(FATAL_ERROR "libFLAME does not support Int64 type")
+      endif()
+    else()
+      check_lapack_libraries(
+        LAPACK_LIBRARIES
+        LAPACK
+        cheev
+        ""
+        "flame"
+        ""
+        ""
+        ""
+        "${BLAS_LIBRARIES}"
+      )
+    endif()
+  endif()
+
+  # AOCL? (https://developer.amd.com/amd-aocl/)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "AOCL" OR BLA_VENDOR STREQUAL "All"))
+    if(_lapack_sizeof_integer EQUAL 8)
+      set(_lapack_aocl_subdir "ILP64")
+    else()
+      set(_lapack_aocl_subdir "LP64")
+    endif()
+
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "flame"
+      "-fopenmp"
+      ""
+      "${_lapack_aocl_subdir}"
+      "${BLAS_LIBRARIES}"
+    )
+    unset(_lapack_aocl_subdir)
+  endif()
+
+  # LAPACK in SCSL library? (SGI/Cray Scientific Library)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "SCSL" OR BLA_VENDOR STREQUAL "All"))
+    set(_lapack_scsl_lib "scs")
+
+    if(_lapack_sizeof_integer EQUAL 8)
+      string(APPEND _lapack_scsl_lib "_i8")
+    endif()
+    # Check for OpenMP support, VIA BLA_VENDOR of scs_mp
+    if(BLA_VENDOR MATCHES "_mp")
+      string(APPEND _lapack_scsl_lib "_mp")
+    endif()
+
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "${_lapack_scsl_lib}"
+      ""
+      ""
+      ""
+      "${BLAS_LIBRARIES}"
+    )
+    unset(_lapack_scsl_lib)
+  endif()
+
+  # BLAS in acml library?
+  if(BLA_VENDOR MATCHES "ACML" OR BLA_VENDOR STREQUAL "All")
+    if(BLAS_LIBRARIES MATCHES ".+acml.+")
+      set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
+    endif()
+  endif()
+
+  # Apple LAPACK library?
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All"))
+    if(_lapack_sizeof_integer EQUAL 8)
+      if(BLA_VENDOR STREQUAL "Apple")
+        message(FATAL_ERROR "Accelerate Framework does not support Int64 type")
+      endif()
+    else()
+      check_lapack_libraries(
+        LAPACK_LIBRARIES
+        LAPACK
+        cheev
+        ""
+        "Accelerate"
+        ""
+        ""
+        ""
+        "${BLAS_LIBRARIES}"
+      )
+    endif()
+  endif()
+
+  # Apple NAS (vecLib) library?
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All"))
+    if(_lapack_sizeof_integer EQUAL 8)
+      if(BLA_VENDOR STREQUAL "NAS")
+        message(FATAL_ERROR "Accelerate Framework does not support Int64 type")
+      endif()
+    else()
+      check_lapack_libraries(
+        LAPACK_LIBRARIES
+        LAPACK
+        cheev
+        ""
+        "vecLib"
+        ""
+        ""
+        ""
+        "${BLAS_LIBRARIES}"
+      )
+    endif()
+  endif()
+
+  # Elbrus Math Library?
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "EML" OR BLA_VENDOR STREQUAL "All"))
+    if(BLAS_LIBRARIES MATCHES "eml.+")
+      set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
+    endif()
+  endif()
+
+  # Fujitsu SSL2 Library?
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "Fujitsu_SSL2" OR BLA_VENDOR STREQUAL "All"))
+    if(BLAS_LIBRARIES MATCHES "fjlapack.+")
+      set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
+      set(LAPACK_LINKER_FLAGS ${BLAS_LINKER_FLAGS})
+    endif()
+  endif()
+
+  # LAPACK in IBM ESSL library?
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "IBMESSL" OR BLA_VENDOR STREQUAL "All"))
+    if(BLAS_LIBRARIES MATCHES "essl.+")
+      set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
+    endif()
+  endif()
+
+  # NVHPC Library?
+
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR MATCHES "NVHPC" OR BLA_VENDOR STREQUAL "All"))
+    set(_lapack_nvhpc_lib "lapack")
+
+    if(_lapack_sizeof_integer EQUAL 8)
+      string(APPEND _lapack_nvhpc_lib "_ilp64")
+    elseif(_lapack_sizeof_integer EQUAL 4)
+      string(APPEND _lapack_nvhpc_lib "_lp64")
+    endif()
+    set(_lapack_nvhpc_flags)
+    if(";${CMAKE_C_COMPILER_ID};${CMAKE_CXX_COMPILER_ID};${CMAKE_Fortran_COMPILER_ID};" MATCHES ";(NVHPC|PGI);")
+      set(_lapack_nvhpc_flags "-fortranlibs")
+    endif()
+
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "${_lapack_nvhpc_lib}"
+      "${_lapack_nvhpc_flags}"
+      ""
+      ""
+      "${BLAS_LIBRARIES}"
+    )
+
+    # an additional check for NVHPC 2020
+    # which does not have differentiation
+    # between lp64 and ilp64 modes
+    if(NOT LAPACK_LIBRARIES AND NOT _lapack_sizeof_integer EQUAL 8)
+      set(_lapack_nvhpc_lib "lapack")
+
+      check_lapack_libraries(
+        LAPACK_LIBRARIES
+        LAPACK
+        cheev
+        ""
+        "${_lapack_nvhpc_lib}"
+        "${_lapack_nvhpc_flags}"
+        ""
+        ""
+        "${BLAS_LIBRARIES}"
+      )
+    endif()
+
+    unset(_lapack_nvhpc_lib)
+    unset(_lapack_nvhpc_flags)
+  endif()
+
+  # libblastrampoline? (https://github.com/JuliaLinearAlgebra/libblastrampoline/tree/main)
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "libblastrampoline" OR BLA_VENDOR STREQUAL "All"))
+    if(BLAS_LIBRARIES MATCHES "blastrampoline.+")
+      set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
+    endif()
+  endif()
+
+  # Generic LAPACK library?
+  if(NOT LAPACK_LIBRARIES
+      AND (BLA_VENDOR STREQUAL "Generic"
+           OR BLA_VENDOR STREQUAL "ATLAS"
+           OR BLA_VENDOR STREQUAL "All"))
+    set(_lapack_generic_lib "lapack")
+    if(BLA_STATIC)
+      # We do not know for sure how the LAPACK reference implementation
+      # is built on this host.  Guess typical dependencies.
+      set(_lapack_generic_deps "-lgfortran;-lm")
+    else()
+      set(_lapack_generic_deps "")
+    endif()
+
+    if(_lapack_sizeof_integer EQUAL 8)
+      string(APPEND _lapack_generic_lib "64")
+    endif()
+
+    check_lapack_libraries(
+      LAPACK_LIBRARIES
+      LAPACK
+      cheev
+      ""
+      "${_lapack_generic_lib}"
+      "${_lapack_generic_deps}"
+      ""
+      ""
+      "${BLAS_LIBRARIES}"
+    )
+
+    unset(_lapack_generic_deps)
+    unset(_lapack_generic_lib)
+  endif()
+endif()
+
+if(BLA_F95)
+  set(LAPACK_LIBRARIES "${LAPACK95_LIBRARIES}")
+endif()
+
+if(LAPACK_NOT_FOUND_MESSAGE)
+  set(LAPACK_NOT_FOUND_MESSAGE
+    REASON_FAILURE_MESSAGE ${LAPACK_NOT_FOUND_MESSAGE})
+endif()
+find_package_handle_standard_args(LAPACK REQUIRED_VARS ${_lapack_fphsa_req_var}
+  ${LAPACK_NOT_FOUND_MESSAGE})
+unset(LAPACK_NOT_FOUND_MESSAGE)
+
+if(BLA_F95)
+  set(LAPACK95_FOUND ${LAPACK_FOUND})
+endif()
+
+# On compilers that implicitly link LAPACK (such as ftn, cc, and CC on Cray HPC machines)
+# we used a placeholder for empty LAPACK_LIBRARIES to get through our logic above.
+if(LAPACK_LIBRARIES STREQUAL "LAPACK_LIBRARIES-PLACEHOLDER-FOR-EMPTY-LIBRARIES")
+  set(LAPACK_LIBRARIES "")
+endif()
+
+_add_lapack_target()
+unset(_lapack_fphsa_req_var)
+unset(_lapack_sizeof_integer)
+unset(_LAPACK_LIBRARIES)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FindLua.cmake

@@ -0,0 +1,243 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindLua
+-------
+
+Locate Lua library.
+
+.. versionadded:: 3.18
+  Support for Lua 5.4.
+
+This module defines:
+
+``LUA_FOUND``
+  if false, do not try to link to Lua
+``LUA_LIBRARIES``
+  both lua and lualib
+``LUA_INCLUDE_DIR``
+  where to find lua.h
+``LUA_VERSION_STRING``
+  the version of Lua found
+``LUA_VERSION_MAJOR``
+  the major version of Lua
+``LUA_VERSION_MINOR``
+  the minor version of Lua
+``LUA_VERSION_PATCH``
+  the patch version of Lua
+
+Note that the expected include convention is
+
+::
+
+  #include "lua.h"
+
+and not
+
+::
+
+  #include <lua/lua.h>
+
+This is because, the lua location is not standardized and may exist in
+locations other than lua/
+#]=======================================================================]
+
+cmake_policy(PUSH)  # Policies apply to functions at definition-time
+cmake_policy(SET CMP0012 NEW)  # For while(TRUE)
+cmake_policy(SET CMP0159 NEW)  # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
+
+unset(_lua_include_subdirs)
+unset(_lua_library_names)
+unset(_lua_append_versions)
+
+# this is a function only to have all the variables inside go away automatically
+function(_lua_get_versions)
+    set(LUA_VERSIONS5 5.4 5.3 5.2 5.1 5.0)
+
+    if (Lua_FIND_VERSION_EXACT)
+        if (Lua_FIND_VERSION_COUNT GREATER 1)
+            set(_lua_append_versions ${Lua_FIND_VERSION_MAJOR}.${Lua_FIND_VERSION_MINOR})
+        endif ()
+    elseif (Lua_FIND_VERSION)
+        # once there is a different major version supported this should become a loop
+        if (NOT Lua_FIND_VERSION_MAJOR GREATER 5)
+            if (Lua_FIND_VERSION_COUNT EQUAL 1)
+                set(_lua_append_versions ${LUA_VERSIONS5})
+            else ()
+                foreach (subver IN LISTS LUA_VERSIONS5)
+                    if (NOT subver VERSION_LESS ${Lua_FIND_VERSION})
+                        list(APPEND _lua_append_versions ${subver})
+                    endif ()
+                endforeach ()
+                # New version -> Search for it (heuristic only! Defines in include might have changed)
+                if (NOT _lua_append_versions)
+                    set(_lua_append_versions ${Lua_FIND_VERSION_MAJOR}.${Lua_FIND_VERSION_MINOR})
+                endif()
+            endif ()
+        endif ()
+    else ()
+        # once there is a different major version supported this should become a loop
+        set(_lua_append_versions ${LUA_VERSIONS5})
+    endif ()
+
+    if (LUA_Debug)
+        message(STATUS "Considering following Lua versions: ${_lua_append_versions}")
+    endif()
+
+    set(_lua_append_versions "${_lua_append_versions}" PARENT_SCOPE)
+endfunction()
+
+function(_lua_set_version_vars)
+  set(_lua_include_subdirs_raw "lua")
+
+  foreach (ver IN LISTS _lua_append_versions)
+    string(REGEX MATCH "^([0-9]+)\\.([0-9]+)$" _ver "${ver}")
+    list(APPEND _lua_include_subdirs_raw
+        lua${CMAKE_MATCH_1}${CMAKE_MATCH_2}
+        lua${CMAKE_MATCH_1}.${CMAKE_MATCH_2}
+        lua-${CMAKE_MATCH_1}.${CMAKE_MATCH_2}
+        )
+  endforeach ()
+
+  # Prepend "include/" to each path directly after the path
+  set(_lua_include_subdirs "include")
+  foreach (dir IN LISTS _lua_include_subdirs_raw)
+    list(APPEND _lua_include_subdirs "${dir}" "include/${dir}")
+  endforeach ()
+
+  set(_lua_include_subdirs "${_lua_include_subdirs}" PARENT_SCOPE)
+endfunction(_lua_set_version_vars)
+
+function(_lua_get_header_version)
+  unset(LUA_VERSION_STRING PARENT_SCOPE)
+  set(_hdr_file "${LUA_INCLUDE_DIR}/lua.h")
+
+  if (NOT EXISTS "${_hdr_file}")
+    return()
+  endif ()
+
+  # At least 5.[012] have different ways to express the version
+  # so all of them need to be tested. Lua 5.2 defines LUA_VERSION
+  # and LUA_RELEASE as joined by the C preprocessor, so avoid those.
+  file(STRINGS "${_hdr_file}" lua_version_strings
+       REGEX "^#define[ \t]+LUA_(RELEASE[ \t]+\"Lua [0-9]|VERSION([ \t]+\"Lua [0-9]|_[MR])).*")
+
+  string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION_MAJOR[ \t]+\"([0-9])\"[ \t]*;.*" "\\1" LUA_VERSION_MAJOR ";${lua_version_strings};")
+  if (LUA_VERSION_MAJOR MATCHES "^[0-9]+$")
+    string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION_MINOR[ \t]+\"([0-9])\"[ \t]*;.*" "\\1" LUA_VERSION_MINOR ";${lua_version_strings};")
+    string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION_RELEASE[ \t]+\"([0-9])\"[ \t]*;.*" "\\1" LUA_VERSION_PATCH ";${lua_version_strings};")
+    set(LUA_VERSION_STRING "${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}.${LUA_VERSION_PATCH}")
+  else ()
+    string(REGEX REPLACE ".*;#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([0-9.]+)\"[ \t]*;.*" "\\1" LUA_VERSION_STRING ";${lua_version_strings};")
+    if (NOT LUA_VERSION_STRING MATCHES "^[0-9.]+$")
+      string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION[ \t]+\"Lua ([0-9.]+)\"[ \t]*;.*" "\\1" LUA_VERSION_STRING ";${lua_version_strings};")
+    endif ()
+    string(REGEX REPLACE "^([0-9]+)\\.[0-9.]*$" "\\1" LUA_VERSION_MAJOR "${LUA_VERSION_STRING}")
+    string(REGEX REPLACE "^[0-9]+\\.([0-9]+)[0-9.]*$" "\\1" LUA_VERSION_MINOR "${LUA_VERSION_STRING}")
+    string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]).*" "\\1" LUA_VERSION_PATCH "${LUA_VERSION_STRING}")
+  endif ()
+  foreach (ver IN LISTS _lua_append_versions)
+    if (ver STREQUAL "${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}")
+      set(LUA_VERSION_MAJOR ${LUA_VERSION_MAJOR} PARENT_SCOPE)
+      set(LUA_VERSION_MINOR ${LUA_VERSION_MINOR} PARENT_SCOPE)
+      set(LUA_VERSION_PATCH ${LUA_VERSION_PATCH} PARENT_SCOPE)
+      set(LUA_VERSION_STRING ${LUA_VERSION_STRING} PARENT_SCOPE)
+      return()
+    endif ()
+  endforeach ()
+endfunction(_lua_get_header_version)
+
+function(_lua_find_header)
+  _lua_set_version_vars()
+
+  # Initialize as local variable
+  set(CMAKE_IGNORE_PATH ${CMAKE_IGNORE_PATH})
+  while (TRUE)
+    # Find the next header to test. Check each possible subdir in order
+    # This prefers e.g. higher versions as they are earlier in the list
+    # It is also consistent with previous versions of FindLua
+    foreach (subdir IN LISTS _lua_include_subdirs)
+      find_path(LUA_INCLUDE_DIR lua.h
+        HINTS ENV LUA_DIR
+        PATH_SUFFIXES ${subdir}
+        )
+      if (LUA_INCLUDE_DIR)
+        break()
+      endif()
+    endforeach()
+    # Did not found header -> Fail
+    if (NOT LUA_INCLUDE_DIR)
+      return()
+    endif()
+    _lua_get_header_version()
+    # Found accepted version -> Ok
+    if (LUA_VERSION_STRING)
+      if (LUA_Debug)
+        message(STATUS "Found suitable version ${LUA_VERSION_STRING} in ${LUA_INCLUDE_DIR}/lua.h")
+      endif()
+      return()
+    endif()
+    # Found wrong version -> Ignore this path and retry
+    if (LUA_Debug)
+      message(STATUS "Ignoring unsuitable version in ${LUA_INCLUDE_DIR}")
+    endif()
+    list(APPEND CMAKE_IGNORE_PATH "${LUA_INCLUDE_DIR}")
+    unset(LUA_INCLUDE_DIR CACHE)
+    unset(LUA_INCLUDE_DIR)
+    unset(LUA_INCLUDE_DIR PARENT_SCOPE)
+  endwhile ()
+endfunction()
+
+_lua_get_versions()
+_lua_find_header()
+_lua_get_header_version()
+unset(_lua_append_versions)
+
+if (LUA_VERSION_STRING)
+  set(_lua_library_names
+    lua${LUA_VERSION_MAJOR}${LUA_VERSION_MINOR}
+    lua${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}
+    lua-${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}
+    lua.${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}
+    )
+endif ()
+
+find_library(LUA_LIBRARY
+  NAMES ${_lua_library_names} lua
+  NAMES_PER_DIR
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES lib
+)
+unset(_lua_library_names)
+
+if (LUA_LIBRARY)
+  # include the math library for Unix
+  if (UNIX AND NOT APPLE AND NOT BEOS)
+    find_library(LUA_MATH_LIBRARY m)
+    mark_as_advanced(LUA_MATH_LIBRARY)
+    set(LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}")
+
+    # include dl library for statically-linked Lua library
+    get_filename_component(LUA_LIB_EXT ${LUA_LIBRARY} EXT)
+    if(LUA_LIB_EXT STREQUAL CMAKE_STATIC_LIBRARY_SUFFIX)
+      list(APPEND LUA_LIBRARIES ${CMAKE_DL_LIBS})
+    endif()
+
+  # For Windows and Mac, don't need to explicitly include the math library
+  else ()
+    set(LUA_LIBRARIES "${LUA_LIBRARY}")
+  endif ()
+endif ()
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+# handle the QUIETLY and REQUIRED arguments and set LUA_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua
+                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
+                                  VERSION_VAR LUA_VERSION_STRING)
+
+mark_as_advanced(LUA_INCLUDE_DIR LUA_LIBRARY)
+
+cmake_policy(POP)

falcon/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FindLua50.cmake

@@ -0,0 +1,81 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindLua50
+---------
+
+Locate Lua library.
+
+This module defines::
+
+  LUA50_FOUND, if false, do not try to link to Lua
+  LUA_LIBRARIES, both lua and lualib
+  LUA_INCLUDE_DIR, where to find lua.h and lualib.h (and probably lauxlib.h)
+
+Note that the expected include convention is::
+
+  #include "lua.h"
+
+and not::
+
+  #include <lua/lua.h>
+
+This is because, the lua location is not standardized and may exist in
+locations other than lua/
+#]=======================================================================]
+
+find_path(LUA_INCLUDE_DIR lua.h
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES include/lua50 include/lua5.0 include/lua5 include/lua include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /opt
+)
+
+find_library(LUA_LIBRARY_lua
+  NAMES lua50 lua5.0 lua-5.0 lua5 lua
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /opt
+)
+
+# In an OS X framework, lualib is usually included as part of the framework
+# (like GLU in OpenGL.framework)
+if(${LUA_LIBRARY_lua} MATCHES "framework")
+  set( LUA_LIBRARIES "${LUA_LIBRARY_lua}" CACHE STRING "Lua framework")
+else()
+  find_library(LUA_LIBRARY_lualib
+    NAMES lualib50 lualib5.0 lualib5 lualib
+    HINTS
+      ENV LUALIB_DIR
+      ENV LUA_DIR
+    PATH_SUFFIXES lib
+    PATHS
+    /opt
+  )
+  if(LUA_LIBRARY_lualib AND LUA_LIBRARY_lua)
+    # include the math library for Unix
+    if(UNIX AND NOT APPLE)
+      find_library(MATH_LIBRARY_FOR_LUA m)
+      set( LUA_LIBRARIES "${LUA_LIBRARY_lualib};${LUA_LIBRARY_lua};${MATH_LIBRARY_FOR_LUA}" CACHE STRING "This is the concatenation of lua and lualib libraries")
+    # For Windows and Mac, don't need to explicitly include the math library
+    else()
+      set( LUA_LIBRARIES "${LUA_LIBRARY_lualib};${LUA_LIBRARY_lua}" CACHE STRING "This is the concatenation of lua and lualib libraries")
+    endif()
+  endif()
+endif()
+
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+# handle the QUIETLY and REQUIRED arguments and set LUA_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua50  DEFAULT_MSG  LUA_LIBRARIES LUA_INCLUDE_DIR)
+
+mark_as_advanced(LUA_INCLUDE_DIR LUA_LIBRARIES)