diff --git a/cc-multilingual-main/cc_net/config/.myconfig.json.swo b/cc-multilingual-main/cc_net/config/.myconfig.json.swo
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/cc-multilingual-main/cc_net/config/.myconfig.json.swp b/cc-multilingual-main/cc_net/config/.myconfig.json.swp
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/cc-multilingual-main/cc_net/config/lid_exp.json b/cc-multilingual-main/cc_net/config/lid_exp.json
new file mode 100644
index 0000000000000000000000000000000000000000..061e847ee394683c1a16bf4f7f086e326f549024
--- /dev/null
+++ b/cc-multilingual-main/cc_net/config/lid_exp.json
@@ -0,0 +1,12 @@
+{
+  "output_dir": "/checkpoint/guw/cc_clean2/",
+  "dump": "2019-09",
+  "num_shards": 1600,
+  "pipeline": [
+    "lid_before_dedup",
+    "dedup",
+    "lid_after_dedup"
+  ],
+  "hash_in_mem": 50,
+  "execution": "slurm"
+}
diff --git a/cc-multilingual-main/cc_net/config/mine_segment.json b/cc-multilingual-main/cc_net/config/mine_segment.json
new file mode 100644
index 0000000000000000000000000000000000000000..d0489101f18bdeb9450549fe6053555e976867d4
--- /dev/null
+++ b/cc-multilingual-main/cc_net/config/mine_segment.json
@@ -0,0 +1,15 @@
+{
+    "dump": "2019-09",
+    "mined_dir": "mini_by_segment",
+    "pipeline": [
+        "dedup",
+        "lid",
+        "keep_lang",
+        "sp",
+        "lm",
+        "pp_bucket",
+        "minify",
+        "split_by_segment"
+    ],
+    "execution": "slurm"
+}
diff --git a/cc-multilingual-main/cc_net/config/myconfig.json b/cc-multilingual-main/cc_net/config/myconfig.json
new file mode 100644
index 0000000000000000000000000000000000000000..a09bfa9bc6e0a91cf33e41a66368dce707ee2505
--- /dev/null
+++ b/cc-multilingual-main/cc_net/config/myconfig.json
@@ -0,0 +1,21 @@
+{
+    "hash_in_mem": 20,
+    "dump": "2020-05",
+    "num_shards": 1600,
+    "lang_whitelist": ["as","bn","gu","kn","hi","ml","mr","ne","or","pb","sa","sd","ta","ur","te","ks","sat","mai","mni","kok","doi","brx"],
+    "num_segments_per_shard": -1,
+    "mine_num_processes": 16,
+    "pipeline": [
+        "lid",
+        "keep_lang",
+        "pp_bucket",
+        "split_by_lang"
+    ],
+    "task_parallelism":32,
+    "cleanup_after_regroup": true,
+    "execution": "auto",
+    "target_size": "5M",
+    "output_dir": "/mnt/weka/peacock/wet-data/output",
+    "mined_dir": "mined",
+    "cache_dir": "/mnt/weka/peacock/wet-data/cache"
+}
diff --git a/cc-multilingual-main/cc_net/config/test_reproduce.json b/cc-multilingual-main/cc_net/config/test_reproduce.json
new file mode 100644
index 0000000000000000000000000000000000000000..f15a3c33eb52832997904c753c3d9fabfbaf2a95
--- /dev/null
+++ b/cc-multilingual-main/cc_net/config/test_reproduce.json
@@ -0,0 +1,16 @@
+{
+    "hash_in_mem": 2,
+    "dump": "2019-09",
+    "num_shards": 1,
+    "num_segments_per_shard": 1,
+    "pipeline": [
+        "fetch_metadata",
+        "split_by_lang"
+    ],
+    "metadata": "test_data2/mined_by_segment",
+    "execution": "debug",
+    "output_dir": "test_data2",
+    "mined_dir": "reproduce",
+    "target_size": "32M",
+    "cache_dir": "test_data/wet_cache"
+}
diff --git a/cc-multilingual-main/cc_net/config/test_segment.json b/cc-multilingual-main/cc_net/config/test_segment.json
new file mode 100644
index 0000000000000000000000000000000000000000..79b2613c19beb5f7a092c043d2825420c5508dc0
--- /dev/null
+++ b/cc-multilingual-main/cc_net/config/test_segment.json
@@ -0,0 +1,23 @@
+{
+    "hash_in_mem": 2,
+    "dump": "2019-09",
+    "num_shards": 4,
+    "num_segments_per_shard": 1,
+    "mine_num_processes": 0,
+    "lang_whitelist": ["de", "it", "fr"],
+    "pipeline": [
+        "dedup",
+        "lid",
+        "keep_lang",
+        "sp",
+        "lm",
+        "pp_bucket",
+        "minify",
+        "split_by_segment"
+    ],
+    "execution": "debug",
+    "output_dir": "test_data2",
+    "mined_dir": "mined_by_segment",
+    "target_size": "32M",
+    "cache_dir": "test_data/wet_cache"
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/compile_wrapper_consider_clang-cl.patch b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/compile_wrapper_consider_clang-cl.patch
new file mode 100644
index 0000000000000000000000000000000000000000..c3666ecc9b680d6f8e6565add105de2fc44f774e
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/compile_wrapper_consider_clang-cl.patch
@@ -0,0 +1,12 @@
+diff --git a/usr/share/automake-1.16/compile b/usr/share/automake-1.16/compile
+index 2078fc833..dfc946593 100755
+--- a/usr/share/automake-1.16/compile
++++ b/usr/share/automake-1.16/compile
+@@ -256,6 +256,7 @@ EOF
+     exit $?
+     ;;
+   cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \
++  clang-cl | *[/\\]clang-cl | clang-cl.exe | *[/\\]clang-cl.exe | \
+   icl | *[/\\]icl | icl.exe | *[/\\]icl.exe )
+     func_cl_wrapper "$@"      # Doesn't return...
+     ;;
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/execute_process.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/execute_process.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a338dda361bb3aff21a57b7fa15ac7cdc6917e2c
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/execute_process.cmake
@@ -0,0 +1,12 @@
+if (NOT DEFINED Z_VCPKG_OVERRIDEN_EXECUTE_PROCESS)
+  set(Z_VCPKG_OVERRIDEN_EXECUTE_PROCESS ON)
+
+  if (DEFINED VCPKG_DOWNLOAD_MODE)
+    function(execute_process)
+      message(FATAL_ERROR "This command cannot be executed in Download Mode.\nHalting portfile execution.\n")
+    endfunction()
+    set(Z_VCPKG_EXECUTE_PROCESS_NAME "_execute_process")
+  else()
+    set(Z_VCPKG_EXECUTE_PROCESS_NAME "execute_process")
+  endif()
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_apply_patches.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_apply_patches.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1a3756ec58f948f60d93f3694ec9ae1bb95a7f52
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_apply_patches.cmake
@@ -0,0 +1,17 @@
+function(vcpkg_apply_patches)
+    z_vcpkg_deprecation_message("vcpkg_apply_patches has been deprecated in favor of the `PATCHES` argument to `vcpkg_from_*`.")
+
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "QUIET" "SOURCE_PATH" "PATCHES")
+
+    if(arg_QUIET)
+        set(quiet "QUIET")
+    else()
+        set(quiet)
+    endif()
+
+    z_vcpkg_apply_patches(
+        SOURCE_PATH "${arg_SOURCE_PATH}"
+        ${quiet}
+        PATCHES ${arg_PATCHES}
+    )
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_cmake.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_cmake.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8a8c25ebc50414338aec8a4a44feca35084c99d7
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_cmake.cmake
@@ -0,0 +1,95 @@
+function(vcpkg_build_cmake)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        "DISABLE_PARALLEL;ADD_BIN_TO_PATH"
+        "TARGET;LOGFILE_ROOT"
+        ""
+    )
+
+    if(Z_VCPKG_CMAKE_BUILD_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_build_cmake in the same port is unsupported.")
+    endif()
+
+    if(NOT DEFINED arg_LOGFILE_ROOT)
+        set(arg_LOGFILE_ROOT "build")
+    endif()
+
+    vcpkg_list(SET build_param)
+    vcpkg_list(SET parallel_param)
+    vcpkg_list(SET no_parallel_param)
+
+    if("${Z_VCPKG_CMAKE_GENERATOR}" STREQUAL "Ninja")
+        vcpkg_list(SET build_param "-v") # verbose output
+        vcpkg_list(SET parallel_param "-j${VCPKG_CONCURRENCY}")
+        vcpkg_list(SET no_parallel_param "-j1")
+    elseif("${Z_VCPKG_CMAKE_GENERATOR}" MATCHES "^Visual Studio")
+        vcpkg_list(SET build_param
+            "/p:VCPkgLocalAppDataDisabled=true"
+            "/p:UseIntelMKL=No"
+        )
+        vcpkg_list(SET parallel_param "/m")
+    elseif("${Z_VCPKG_CMAKE_GENERATOR}" STREQUAL "NMake Makefiles")
+        # No options are currently added for nmake builds
+    elseif(Z_VCPKG_CMAKE_GENERATOR STREQUAL "Unix Makefiles")
+        vcpkg_list(SET build_param "VERBOSE=1")
+        vcpkg_list(SET parallel_param "-j${VCPKG_CONCURRENCY}")
+        vcpkg_list(SET no_parallel_param "")
+    elseif(Z_VCPKG_CMAKE_GENERATOR STREQUAL "Xcode")
+        vcpkg_list(SET parallel_param -jobs "${VCPKG_CONCURRENCY}")
+        vcpkg_list(SET no_parallel_param -jobs 1)
+    else()
+        message(FATAL_ERROR "Unrecognized GENERATOR setting from vcpkg_configure_cmake(). Valid generators are: Ninja, Visual Studio, and NMake Makefiles")
+    endif()
+
+    vcpkg_list(SET target_param)
+    if(arg_TARGET)
+        vcpkg_list(SET target_param "--target" "${arg_TARGET}")
+    endif()
+
+    foreach(build_type IN ITEMS debug release)
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "${build_type}")
+            if("${build_type}" STREQUAL "debug")
+                set(short_build_type "dbg")
+                set(config "Debug")
+            else()
+                set(short_build_type "rel")
+                set(config "Release")
+            endif()
+
+            message(STATUS "Building ${TARGET_TRIPLET}-${short_build_type}")
+
+            if(arg_ADD_BIN_TO_PATH)
+                vcpkg_backup_env_variables(VARS PATH)
+                if("${build_type}" STREQUAL "debug")
+                    vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
+                else()
+                    vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/bin")
+                endif()
+            endif()
+
+            if(arg_DISABLE_PARALLEL)
+                vcpkg_execute_build_process(
+                    COMMAND
+                        "${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
+                        -- ${build_param} ${no_parallel_param}
+                    WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_build_type}"
+                    LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_build_type}"
+                )
+            else()
+                vcpkg_execute_build_process(
+                    COMMAND
+                        "${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
+                        -- ${build_param} ${parallel_param}
+                    NO_PARALLEL_COMMAND
+                        "${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
+                        -- ${build_param} ${no_parallel_param}
+                    WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_build_type}"
+                    LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_build_type}"
+                )
+            endif()
+
+            if(arg_ADD_BIN_TO_PATH)
+                vcpkg_restore_env_variables(VARS PATH)
+            endif()
+        endif()
+    endforeach()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_make.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_make.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ddf56f4f6e01de3f3f49862a51af0888a4fac83e
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_make.cmake
@@ -0,0 +1,193 @@
+function(vcpkg_build_make)
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    include("${cmake_vars_file}")
+
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "ADD_BIN_TO_PATH;ENABLE_INSTALL;DISABLE_PARALLEL"
+        "LOGFILE_ROOT;BUILD_TARGET;SUBPATH;MAKEFILE;INSTALL_TARGET"
+        "OPTIONS"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_make_build was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_LOGFILE_ROOT)
+        set(arg_LOGFILE_ROOT "build")
+    endif()
+
+    if(NOT DEFINED arg_BUILD_TARGET)
+        set(arg_BUILD_TARGET "all")
+    endif()
+
+    if (NOT DEFINED arg_MAKEFILE)
+        set(arg_MAKEFILE Makefile)
+    endif()
+
+    if(NOT DEFINED arg_INSTALL_TARGET)
+        set(arg_INSTALL_TARGET "install")
+    endif()
+
+    if(WIN32)
+        set(Z_VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR})
+    else()
+        string(REPLACE " " "\ " Z_VCPKG_INSTALLED "${CURRENT_INSTALLED_DIR}")
+    endif()
+
+    vcpkg_list(SET make_opts)
+    vcpkg_list(SET install_opts)
+    if (CMAKE_HOST_WIN32)
+        set(path_backup "$ENV{PATH}")
+        vcpkg_add_to_path(PREPEND "${SCRIPTS}/buildsystems/make_wrapper")
+        if(NOT DEFINED Z_VCPKG_MAKE)
+            vcpkg_acquire_msys(MSYS_ROOT)
+            find_program(Z_VCPKG_MAKE make PATHS "${MSYS_ROOT}/usr/bin" NO_DEFAULT_PATH REQUIRED)
+        endif()
+        set(make_command "${Z_VCPKG_MAKE}")
+        vcpkg_list(SET make_opts ${arg_OPTIONS} -j ${VCPKG_CONCURRENCY} --trace -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+        vcpkg_list(SET no_parallel_make_opts ${arg_OPTIONS} -j 1 --trace -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+
+        string(REPLACE " " [[\ ]] vcpkg_package_prefix "${CURRENT_PACKAGES_DIR}")
+        string(REGEX REPLACE [[([a-zA-Z]):/]] [[/\1/]] vcpkg_package_prefix "${vcpkg_package_prefix}")
+        vcpkg_list(SET install_opts -j ${VCPKG_CONCURRENCY} --trace -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${vcpkg_package_prefix})
+        vcpkg_list(SET no_parallel_install_opts -j 1 --trace -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${vcpkg_package_prefix})
+        #TODO: optimize for install-data (release) and install-exec (release/debug)
+
+    else()
+        if(VCPKG_HOST_IS_FREEBSD OR VCPKG_HOST_IS_OPENBSD)
+            find_program(Z_VCPKG_MAKE gmake REQUIRED)
+        else()
+            find_program(Z_VCPKG_MAKE make REQUIRED)
+        endif()
+        set(make_command "${Z_VCPKG_MAKE}")
+        vcpkg_list(SET make_opts ${arg_OPTIONS} V=1 -j ${VCPKG_CONCURRENCY} -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+        vcpkg_list(SET no_parallel_make_opts ${arg_OPTIONS} V=1 -j 1 -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+        vcpkg_list(SET install_opts -j ${VCPKG_CONCURRENCY} -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${CURRENT_PACKAGES_DIR})
+        vcpkg_list(SET no_parallel_install_opts -j 1 -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${CURRENT_PACKAGES_DIR})
+    endif()
+
+    # Since includes are buildtype independent those are setup by vcpkg_configure_make
+    vcpkg_backup_env_variables(VARS LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH CPPFLAGS CFLAGS CXXFLAGS RCFLAGS)
+
+    z_vcpkg_configure_make_common_definitions()
+
+    foreach(buildtype IN ITEMS "debug" "release")
+        if (buildtype STREQUAL "debug" AND _VCPKG_MAKE_NO_DEBUG)
+            continue()
+        endif()
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "${buildtype}")
+            string(TOUPPER "${buildtype}" cmake_buildtype)
+            set(short_buildtype "${short_name_${cmake_buildtype}}")
+            set(path_suffix "${path_suffix_${cmake_buildtype}}")
+
+            set(working_directory "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_buildtype}/${arg_SUBPATH}")
+            message(STATUS "Building ${TARGET_TRIPLET}-${short_buildtype}")
+
+            if("libtool-link-pass-target" IN_LIST VCPKG_BUILD_MAKE_FIXUP)
+                # Pass --target to the linker, e.g. for Android
+                file(GLOB_RECURSE libtool_files "${working_directory}/libtool")
+                foreach(file IN LISTS libtool_files)
+                    vcpkg_replace_string("${file}" [[-xtarget=*|]] [[-xtarget=*|--target=*|]])
+                endforeach()
+            endif()
+
+            z_vcpkg_configure_make_process_flags("${cmake_buildtype}")
+
+            # Setup environment
+            set(ENV{CPPFLAGS} "${CPPFLAGS_${cmake_buildtype}}")
+            set(ENV{CFLAGS} "${CFLAGS_${cmake_buildtype}}")
+            set(ENV{CXXFLAGS} "${CXXFLAGS_${cmake_buildtype}}")
+            set(ENV{RCFLAGS} "${VCPKG_DETECTED_CMAKE_RC_FLAGS_${cmake_buildtype}}")
+            set(ENV{LDFLAGS} "${LDFLAGS_${cmake_buildtype}}")
+            vcpkg_list(APPEND lib_env_vars LIB LIBPATH LIBRARY_PATH) # LD_LIBRARY_PATH)
+            foreach(lib_env_var IN LISTS lib_env_vars)
+                if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib")
+                    vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${Z_VCPKG_INSTALLED}${path_suffix}/lib")
+                endif()
+                if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
+                    vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
+                endif()
+            endforeach()
+            unset(lib_env_vars)
+
+            if(LINK_ENV_${cmake_buildtype})
+                set(config_link_backup "$ENV{_LINK_}")
+                set(ENV{_LINK_} "${LINK_ENV_${cmake_buildtype}}")
+            else()
+                unset(config_link_backup)
+            endif()
+
+            if(arg_ADD_BIN_TO_PATH)
+                set(env_backup_path "$ENV{PATH}")
+                vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}${path_suffix}/bin")
+            endif()
+
+            vcpkg_list(SET make_cmd_line ${make_command} ${make_opts})
+            vcpkg_list(SET no_parallel_make_cmd_line ${make_command} ${no_parallel_make_opts})
+
+            if (arg_DISABLE_PARALLEL)
+                vcpkg_execute_build_process(
+                        COMMAND ${no_parallel_make_cmd_line}
+                        WORKING_DIRECTORY "${working_directory}"
+                        LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_buildtype}"
+                )
+            else()
+                vcpkg_execute_build_process(
+                        COMMAND ${make_cmd_line}
+                        NO_PARALLEL_COMMAND ${no_parallel_make_cmd_line}
+                        WORKING_DIRECTORY "${working_directory}"
+                        LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_buildtype}"
+                )
+            endif()
+
+            file(READ "${CURRENT_BUILDTREES_DIR}/${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_buildtype}-out.log" logdata) 
+            if(logdata MATCHES "Warning: linker path does not have real file for library")
+                message(FATAL_ERROR "libtool could not find a file being linked against!")
+            endif()
+
+            if (arg_ENABLE_INSTALL)
+                message(STATUS "Installing ${TARGET_TRIPLET}-${short_buildtype}")
+                vcpkg_list(SET make_cmd_line ${make_command} ${install_opts})
+                vcpkg_list(SET no_parallel_make_cmd_line ${make_command} ${no_parallel_install_opts})
+                vcpkg_execute_build_process(
+                    COMMAND ${make_cmd_line}
+                    NO_PARALLEL_COMMAND ${no_parallel_make_cmd_line}
+                    WORKING_DIRECTORY "${working_directory}"
+                    LOGNAME "install-${TARGET_TRIPLET}-${short_buildtype}"
+                )
+            endif()
+
+            if(DEFINED config_link_backup)
+                set(ENV{_LINK_} "${config_link_backup}")
+            endif()
+
+            if(arg_ADD_BIN_TO_PATH)
+                set(ENV{PATH} "${env_backup_path}")
+            endif()
+        endif()
+
+        vcpkg_restore_env_variables(VARS LIB LIBPATH LIBRARY_PATH)
+    endforeach()
+
+    if (arg_ENABLE_INSTALL)
+        string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" Z_VCPKG_INSTALL_PREFIX "${CURRENT_INSTALLED_DIR}")
+        file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp")
+        file(RENAME "${CURRENT_PACKAGES_DIR}" "${CURRENT_PACKAGES_DIR}_tmp")
+        file(RENAME "${CURRENT_PACKAGES_DIR}_tmp${Z_VCPKG_INSTALL_PREFIX}" "${CURRENT_PACKAGES_DIR}")
+        file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp")
+    endif()
+
+    # Remove libtool files since they contain absolute paths and are not necessary. 
+    file(GLOB_RECURSE libtool_files "${CURRENT_PACKAGES_DIR}/**/*.la")
+    if(libtool_files)
+        file(REMOVE ${libtool_files})
+    endif()
+
+    if (CMAKE_HOST_WIN32)
+        set(ENV{PATH} "${path_backup}")
+    endif()
+
+    vcpkg_restore_env_variables(VARS LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH CPPFLAGS CFLAGS CXXFLAGS RCFLAGS)
+    unset(_VCPKG_MAKE_NO_DEBUG PARENT_SCOPE)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_msbuild.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_msbuild.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..90fb313c90fecb37727f0bddeb1dc1152f9893d0
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_msbuild.cmake
@@ -0,0 +1,87 @@
+function(vcpkg_build_msbuild)
+    cmake_parse_arguments(
+        PARSE_ARGV 0
+        arg
+        "USE_VCPKG_INTEGRATION"
+        "PROJECT_PATH;RELEASE_CONFIGURATION;DEBUG_CONFIGURATION;PLATFORM;PLATFORM_TOOLSET;TARGET_PLATFORM_VERSION;TARGET"
+        "OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_build_msbuild was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_RELEASE_CONFIGURATION)
+        set(arg_RELEASE_CONFIGURATION Release)
+    endif()
+    if(NOT DEFINED arg_DEBUG_CONFIGURATION)
+        set(arg_DEBUG_CONFIGURATION Debug)
+    endif()
+    if(NOT DEFINED arg_PLATFORM)
+        set(arg_PLATFORM "${TRIPLET_SYSTEM_ARCH}")
+    endif()
+    if(NOT DEFINED arg_PLATFORM_TOOLSET)
+        set(arg_PLATFORM_TOOLSET "${VCPKG_PLATFORM_TOOLSET}")
+    endif()
+    if(NOT DEFINED arg_TARGET_PLATFORM_VERSION)
+        vcpkg_get_windows_sdk(arg_TARGET_PLATFORM_VERSION)
+    endif()
+    if(NOT DEFINED arg_TARGET)
+        set(arg_TARGET Rebuild)
+    endif()
+
+    list(APPEND arg_OPTIONS
+        "/t:${arg_TARGET}"
+        "/p:Platform=${arg_PLATFORM}"
+        "/p:PlatformToolset=${arg_PLATFORM_TOOLSET}"
+        "/p:VCPkgLocalAppDataDisabled=true"
+        "/p:UseIntelMKL=No"
+        "/p:WindowsTargetPlatformVersion=${arg_TARGET_PLATFORM_VERSION}"
+        "/p:VcpkgManifestInstall=false"
+        "/p:VcpkgManifestEnabled=false"
+        "/m"
+    )
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
+        # Disable LTCG for static libraries because this setting introduces ABI incompatibility between minor compiler versions
+        # TODO: Add a way for the user to override this if they want to opt-in to incompatibility
+        list(APPEND arg_OPTIONS "/p:WholeProgramOptimization=false")
+    endif()
+
+    if(arg_USE_VCPKG_INTEGRATION)
+        list(
+            APPEND arg_OPTIONS
+            "/p:ForceImportBeforeCppTargets=${SCRIPTS}/buildsystems/msbuild/vcpkg.targets"
+            "/p:VcpkgTriplet=${TARGET_TRIPLET}"
+            "/p:VcpkgInstalledDir=${_VCPKG_INSTALLED_DIR}"
+        )
+    else()
+        list(APPEND arg_OPTIONS "/p:VcpkgEnabled=false")
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        message(STATUS "Building ${arg_PROJECT_PATH} for Release")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+        vcpkg_execute_required_process(
+            COMMAND msbuild "${arg_PROJECT_PATH}"
+                "/p:Configuration=${arg_RELEASE_CONFIGURATION}"
+                ${arg_OPTIONS}
+                ${arg_OPTIONS_RELEASE}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+            LOGNAME "build-${TARGET_TRIPLET}-rel"
+        )
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        message(STATUS "Building ${arg_PROJECT_PATH} for Debug")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+        vcpkg_execute_required_process(
+            COMMAND msbuild "${arg_PROJECT_PATH}"
+                "/p:Configuration=${arg_DEBUG_CONFIGURATION}"
+                ${arg_OPTIONS}
+                ${arg_OPTIONS_DEBUG}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+            LOGNAME "build-${TARGET_TRIPLET}-dbg"
+        )
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_qmake.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_qmake.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..248af60260e97fab5355428852efb337d71f0513
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_qmake.cmake
@@ -0,0 +1,82 @@
+function(z_run_jom_build invoke_command targets log_prefix log_suffix)
+    message(STATUS "Package ${log_prefix}-${TARGET_TRIPLET}-${log_suffix}")
+    vcpkg_execute_build_process(
+        COMMAND "${invoke_command}" -j ${VCPKG_CONCURRENCY} ${targets}
+        NO_PARALLEL_COMMAND "${invoke_command}" -j 1 ${targets}
+        WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${log_suffix}"
+        LOGNAME "package-${log_prefix}-${TARGET_TRIPLET}-${log_suffix}"
+    )
+endfunction()
+
+function(vcpkg_build_qmake)
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "SKIP_MAKEFILES"
+        "BUILD_LOGNAME"
+        "TARGETS;RELEASE_TARGETS;DEBUG_TARGETS"
+    )
+
+    # Make sure that the linker finds the libraries used
+    vcpkg_backup_env_variables(VARS PATH LD_LIBRARY_PATH CL _CL_)
+
+    # This fixes issues on machines with default codepages that are not ASCII compatible, such as some CJK encodings
+    set(ENV{_CL_} "/utf-8")
+
+    if(CMAKE_HOST_WIN32)
+        if(VCPKG_TARGET_IS_MINGW)
+            find_program(MINGW32_MAKE mingw32-make REQUIRED)
+            set(invoke_command "${MINGW32_MAKE}")
+        elseif (VCPKG_QMAKE_USE_NMAKE)
+            find_program(NMAKE nmake)
+            set(invoke_command "${NMAKE}")
+            get_filename_component(nmake_exe_path "${NMAKE}" DIRECTORY)
+            vcpkg_host_path_list(APPEND ENV{PATH} "${nmake_exe_path}")
+            set(ENV{CL} "$ENV{CL} /MP${VCPKG_CONCURRENCY}")
+        else()
+            vcpkg_find_acquire_program(JOM)
+            set(invoke_command "${JOM}")
+        endif()
+    else()
+        find_program(MAKE make)
+        set(invoke_command "${MAKE}")
+    endif()
+
+    if(NOT DEFINED arg_BUILD_LOGNAME)
+        set(arg_BUILD_LOGNAME build)
+    endif()
+
+    set(short_name_debug "dbg")
+    set(path_suffix_debug "/debug")
+    set(targets_debug "${arg_DEBUG_TARGETS}")
+
+    set(short_name_release "rel")
+    set(path_suffix_release "")
+    set(targets_release "${arg_RELEASE_TARGETS}")
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE)
+        set(items debug release)
+    else()
+        set(items release)
+    endif()
+    foreach(build_type IN ITEMS ${items})
+        set(current_installed_prefix "${CURRENT_INSTALLED_DIR}${path_suffix_${build_type}}")
+
+        vcpkg_add_to_path(PREPEND "${current_installed_prefix}/lib" "${current_installed_prefix}/bin")
+
+        # We set LD_LIBRARY_PATH ENV variable to allow executing Qt tools (rcc,...) even with dynamic linking
+        if(CMAKE_HOST_UNIX)
+            set(ENV{LD_LIBRARY_PATH} "")
+            vcpkg_host_path_list(APPEND ENV{LD_LIBRARY_PATH} "${current_installed_prefix}/lib" "${current_installed_prefix}/lib/manual-link")
+        endif()
+
+        vcpkg_list(SET targets ${targets_${build_type}} ${arg_TARGETS})
+        if(NOT arg_SKIP_MAKEFILES)
+            z_run_jom_build("${invoke_command}" qmake_all makefiles "${short_name_${build_type}}")
+        endif()
+        z_run_jom_build("${invoke_command}" "${targets}" "${arg_BUILD_LOGNAME}" "${short_name_${build_type}}")
+
+        vcpkg_restore_env_variables(VARS PATH LD_LIBRARY_PATH)
+    endforeach()
+
+    vcpkg_restore_env_variables(VARS CL _CL_)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_clean_msbuild.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_clean_msbuild.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..904f40ae89c04972ae0079c4883ac3a59ef19c5e
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_clean_msbuild.cmake
@@ -0,0 +1,9 @@
+function(vcpkg_clean_msbuild)
+    if(NOT ARGC EQUAL 0)
+        message(WARNING "vcpkg_clean_msbuild was passed extra arguments: ${ARGV}")
+    endif()
+    file(REMOVE_RECURSE
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+    )
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_common_definitions.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_common_definitions.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b248208a2fb8e9be684c3b929792249bdd195b6c
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_common_definitions.cmake
@@ -0,0 +1,195 @@
+string(COMPARE NOTEQUAL "${TARGET_TRIPLET}" "${HOST_TRIPLET}" VCPKG_CROSSCOMPILING)
+#Helper variable to identify the Target system. VCPKG_TARGET_IS_<targetname>
+if (NOT DEFINED VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+
+    if(DEFINED VCPKG_XBOX_CONSOLE_TARGET AND NOT "${VCPKG_XBOX_CONSOLE_TARGET}" STREQUAL "")
+        set(VCPKG_TARGET_IS_XBOX ON)
+    endif()
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+    set(VCPKG_TARGET_IS_UWP ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    set(VCPKG_TARGET_IS_OSX ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    set(VCPKG_TARGET_IS_IOS ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(VCPKG_TARGET_IS_LINUX ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android")
+    set(VCPKG_TARGET_IS_ANDROID ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
+    set(VCPKG_TARGET_IS_FREEBSD ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
+    set(VCPKG_TARGET_IS_OPENBSD ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "MinGW")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+    set(VCPKG_TARGET_IS_MINGW ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    set(VCPKG_TARGET_IS_EMSCRIPTEN ON)
+endif()
+
+#Helper variables to identify the host system name
+if (CMAKE_HOST_WIN32)
+    set(VCPKG_HOST_IS_WINDOWS ON)
+elseif (CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+    set(VCPKG_HOST_IS_OSX ON)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+    set(VCPKG_HOST_IS_LINUX ON)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
+    set(VCPKG_HOST_IS_FREEBSD ON)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")
+    set(VCPKG_HOST_IS_OPENBSD ON)
+endif()
+
+#Helper variable to identify the host path separator.
+if(CMAKE_HOST_WIN32)
+    set(VCPKG_HOST_PATH_SEPARATOR ";")
+elseif(CMAKE_HOST_UNIX)
+    set(VCPKG_HOST_PATH_SEPARATOR ":")
+endif()
+
+#Helper variables to identify executables on host/target
+if(CMAKE_HOST_WIN32)
+    set(VCPKG_HOST_EXECUTABLE_SUFFIX ".exe")
+else()
+    set(VCPKG_HOST_EXECUTABLE_SUFFIX "")
+endif()
+#set(CMAKE_EXECUTABLE_SUFFIX ${VCPKG_HOST_EXECUTABLE_SUFFIX}) not required by find_program
+
+if(VCPKG_TARGET_IS_WINDOWS)
+    set(VCPKG_TARGET_EXECUTABLE_SUFFIX ".exe")
+else()
+    set(VCPKG_TARGET_EXECUTABLE_SUFFIX "")
+endif()
+
+#Helper variables to identify bundles on host/target
+if(VCPKG_HOST_IS_OSX)
+    set(VCPKG_HOST_BUNDLE_SUFFIX ".app")
+else()
+    set(VCPKG_HOST_BUNDLE_SUFFIX "")
+endif()
+
+if(VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_IOS)
+    set(VCPKG_TARGET_BUNDLE_SUFFIX ".app")
+else()
+    set(VCPKG_TARGET_BUNDLE_SUFFIX "")
+endif()
+
+#Helper variables for libraries
+if(VCPKG_TARGET_IS_MINGW)
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".dll.a")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dll")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".dll" ".dll.a" ".a" ".lib")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
+elseif(VCPKG_TARGET_IS_WINDOWS)
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".lib")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dll")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".lib")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".lib" ".dll") #This is a slight modification to CMakes value which does not include ".dll".
+    set(VCPKG_FIND_LIBRARY_PREFIXES "" "lib") #This is a slight modification to CMakes value which does not include "lib".
+elseif(VCPKG_TARGET_IS_OSX)
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX "")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dylib")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".tbd" ".dylib" ".so" ".a")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
+else()
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX "")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".so")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".so" ".a")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
+endif()
+#Setting these variables allows find_library to work in script mode and thus in portfiles!
+#This allows us scale down on hardcoded target dependent paths in portfiles
+set(CMAKE_STATIC_LIBRARY_SUFFIX "${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX}")
+set(CMAKE_SHARED_LIBRARY_SUFFIX "${VCPKG_TARGET_SHARED_LIBRARY_SUFFIX}")
+set(CMAKE_IMPORT_LIBRARY_SUFFIX "${VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX}")
+set(CMAKE_STATIC_LIBRARY_PREFIX "${VCPKG_TARGET_STATIC_LIBRARY_PREFIX}")
+set(CMAKE_SHARED_LIBRARY_PREFIX "${VCPKG_TARGET_SHARED_LIBRARY_PREFIX}")
+set(CMAKE_IMPORT_LIBRARY_PREFIX "${VCPKG_TARGET_IMPORT_LIBRARY_PREFIX}")
+
+set(CMAKE_FIND_LIBRARY_SUFFIXES "${VCPKG_FIND_LIBRARY_SUFFIXES}" CACHE INTERNAL "") # Required by find_library
+set(CMAKE_FIND_LIBRARY_PREFIXES "${VCPKG_FIND_LIBRARY_PREFIXES}" CACHE INTERNAL "") # Required by find_library
+
+# Append platform libraries to VCPKG_SYSTEM_LIBRARIES
+# The variable are just appended to permit to custom triplets define the variable
+
+# Platforms with libdl
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES dl)
+endif()
+
+# Platforms with libm
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES m)
+endif()
+
+# Platforms with pthread
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES pthread)
+endif()
+
+# Platforms with libstdc++
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES [[stdc\+\+]])
+endif()
+
+# Platforms with libc++
+if(VCPKG_TARGET_IS_OSX)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES [[c\+\+]])
+endif()
+
+# Platforms with librt
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES rt)
+endif()
+
+# Platforms with GCC libs
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES gcc)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES gcc_s)
+endif()
+
+# Platforms with system iconv
+if(VCPKG_TARGET_IS_OSX)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES iconv)
+endif()
+
+# Windows system libs
+if(VCPKG_TARGET_IS_WINDOWS)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES advapi32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES bcrypt)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES dinput8)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES gdi32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES imm32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES oleaut32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES ole32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES psapi)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES secur32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES setupapi)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES shell32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES shlwapi)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES strmiids)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES user32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES uuid)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES version)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES vfw32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES winmm)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES wsock32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES Ws2_32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES wldap32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES crypt32)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_gn.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_gn.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9fbcd4c9e552a4d8ccce929515bc5dc5317f9bd7
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_gn.cmake
@@ -0,0 +1,52 @@
+function(z_vcpkg_configure_gn_generate)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;CONFIG;ARGS" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: generate was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    message(STATUS "Generating build (${arg_CONFIG})...")
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${arg_CONFIG}")
+    vcpkg_execute_required_process(
+        COMMAND "${GN}" gen "${CURRENT_BUILDTREES_DIR}/${arg_CONFIG}" "${arg_ARGS}"
+        WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+        LOGNAME "generate-${arg_CONFIG}"
+    )
+endfunction()
+
+function(vcpkg_configure_gn)
+    if(Z_VCPKG_GN_CONFIGURE_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-gn; using both vcpkg-gn and vcpkg_configure_gn in the same port is unsupported.")
+    else()
+        message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "This function 'vcpkg_configure_gn' is obsolete. Use 'vcpkg_gn_configure' in port 'vcpkg-gn'.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_configure_gn was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_SOURCE_PATH)
+        message(FATAL_ERROR "SOURCE_PATH must be specified.")
+    endif()
+
+    vcpkg_find_acquire_program(PYTHON3)
+    get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
+    vcpkg_add_to_path(PREPEND "${PYTHON3_DIR}")
+
+    vcpkg_find_acquire_program(GN)
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        z_vcpkg_configure_gn_generate(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            CONFIG "${TARGET_TRIPLET}-dbg"
+            ARGS "--args=${arg_OPTIONS} ${arg_OPTIONS_DEBUG}"
+        )
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        z_vcpkg_configure_gn_generate(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            CONFIG "${TARGET_TRIPLET}-rel"
+            ARGS "--args=${arg_OPTIONS} ${arg_OPTIONS_RELEASE}"
+        )
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_meson.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_meson.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3a3a6ed3a345786b14e7eb384175f345fa5d7126
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_meson.cmake
@@ -0,0 +1,452 @@
+function(z_vcpkg_meson_set_proglist_variables config_type)
+    if(VCPKG_TARGET_IS_WINDOWS)
+        set(proglist MT AR)
+    else()
+        set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
+    endif()
+    foreach(prog IN LISTS proglist)
+        if(VCPKG_DETECTED_CMAKE_${prog})
+            if(meson_${prog})
+                string(TOUPPER "MESON_${meson_${prog}}" var_to_set)
+                set("${var_to_set}" "${meson_${prog}} = ['${VCPKG_DETECTED_CMAKE_${prog}}']" PARENT_SCOPE)
+            elseif(${prog} STREQUAL AR AND VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${config_type})
+                # Probably need to move AR somewhere else
+                string(TOLOWER "${prog}" proglower)
+                z_vcpkg_meson_convert_compiler_flags_to_list(ar_flags "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${config_type}}")
+                list(PREPEND ar_flags "${VCPKG_DETECTED_CMAKE_${prog}}")
+                z_vcpkg_meson_convert_list_to_python_array(ar_flags ${ar_flags})
+                set("MESON_AR" "${proglower} = ${ar_flags}" PARENT_SCOPE)
+            else()
+                string(TOUPPER "MESON_${prog}" var_to_set)
+                string(TOLOWER "${prog}" proglower)
+                set("${var_to_set}" "${proglower} = ['${VCPKG_DETECTED_CMAKE_${prog}}']" PARENT_SCOPE)
+            endif()
+        endif()
+    endforeach()
+    set(compilers "${arg_LANGUAGES}")
+    if(VCPKG_TARGET_IS_WINDOWS)
+        list(APPEND compilers RC)
+    endif()
+    set(meson_RC windres)
+    set(meson_Fortran fc)
+    set(meson_CXX cpp)
+    foreach(prog IN LISTS compilers)
+        if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
+            string(TOUPPER "MESON_${prog}" var_to_set)
+            if(meson_${prog})
+                if(VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type})
+                    # Need compiler flags in prog vars for sanity check.
+                    z_vcpkg_meson_convert_compiler_flags_to_list(${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type}}")
+                endif()
+                list(PREPEND ${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}")
+                list(FILTER ${prog}flags EXCLUDE REGEX "(-|/)nologo") # Breaks compiler detection otherwise
+                z_vcpkg_meson_convert_list_to_python_array(${prog}flags ${${prog}flags})
+                set("${var_to_set}" "${meson_${prog}} = ${${prog}flags}" PARENT_SCOPE)
+                if (DEFINED VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID AND NOT VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID MATCHES "^(GNU|Intel)$")
+                    string(TOUPPER "MESON_${prog}_LD" var_to_set)
+                    set(${var_to_set} "${meson_${prog}}_ld = ['${VCPKG_DETECTED_CMAKE_LINKER}']" PARENT_SCOPE)
+                endif()
+            else()
+                if(VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type})
+                     # Need compiler flags in prog vars for sanity check.
+                    z_vcpkg_meson_convert_compiler_flags_to_list(${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type}}")
+                endif()
+                list(PREPEND ${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}")
+                list(FILTER ${prog}flags EXCLUDE REGEX "(-|/)nologo") # Breaks compiler detection otherwise
+                z_vcpkg_meson_convert_list_to_python_array(${prog}flags ${${prog}flags})
+                string(TOLOWER "${prog}" proglower)
+                set("${var_to_set}" "${proglower} = ${${prog}flags}" PARENT_SCOPE)
+                if (DEFINED VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID AND NOT VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID MATCHES "^(GNU|Intel)$")
+                    string(TOUPPER "MESON_${prog}_LD" var_to_set)
+                    set(${var_to_set} "${proglower}_ld = ['${VCPKG_DETECTED_CMAKE_LINKER}']" PARENT_SCOPE)
+                endif()
+            endif()
+        endif()
+    endforeach()
+endfunction()
+
+function(z_vcpkg_meson_convert_compiler_flags_to_list out_var compiler_flags)
+    separate_arguments(cmake_list NATIVE_COMMAND "${compiler_flags}")
+    list(TRANSFORM cmake_list REPLACE ";" [[\\;]])
+    set("${out_var}" "${cmake_list}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_meson_convert_list_to_python_array out_var)
+    z_vcpkg_function_arguments(flag_list 1)
+    vcpkg_list(REMOVE_ITEM flag_list "") # remove empty elements if any
+    vcpkg_list(JOIN flag_list "', '" flag_list)
+    set("${out_var}" "['${flag_list}']" PARENT_SCOPE)
+endfunction()
+
+# Generates the required compiler properties for meson
+function(z_vcpkg_meson_set_flags_variables config_type)
+    if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        set(libpath_flag /LIBPATH:)
+    else()
+        set(libpath_flag -L)
+    endif()
+    if(config_type STREQUAL "DEBUG")
+        set(path_suffix "/debug")
+    else()
+        set(path_suffix "")
+    endif()
+
+    set(includepath "-I${CURRENT_INSTALLED_DIR}/include")
+    set(libpath "${libpath_flag}${CURRENT_INSTALLED_DIR}${path_suffix}/lib")
+
+    foreach(lang IN LISTS arg_LANGUAGES)
+        z_vcpkg_meson_convert_compiler_flags_to_list(${lang}flags "${VCPKG_DETECTED_CMAKE_${lang}_FLAGS_${config_type}}")
+        if(lang MATCHES "^(C|CXX)$")
+            vcpkg_list(APPEND ${lang}flags "${includepath}")
+        endif()
+        z_vcpkg_meson_convert_list_to_python_array(${lang}flags ${${lang}flags})
+        set(lang_mapping "${lang}")
+        if(lang STREQUAL "Fortran")
+            set(lang_mapping "FC")
+        endif()
+        string(TOLOWER "${lang_mapping}" langlower)
+        if(lang STREQUAL "CXX")
+            set(langlower cpp)
+        endif()
+        set(MESON_${lang_mapping}FLAGS "${langlower}_args = ${${lang}flags}\n")
+        set(linker_flags "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${config_type}}")
+        z_vcpkg_meson_convert_compiler_flags_to_list(linker_flags "${linker_flags}")
+        vcpkg_list(APPEND linker_flags "${libpath}")
+        z_vcpkg_meson_convert_list_to_python_array(linker_flags ${linker_flags})
+        string(APPEND MESON_${lang_mapping}FLAGS "${langlower}_link_args = ${linker_flags}\n")
+        set(MESON_${lang_mapping}FLAGS "${MESON_${lang_mapping}FLAGS}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+function(z_vcpkg_get_build_and_host_system build_system host_system is_cross) #https://mesonbuild.com/Cross-compilation.html
+    set(build_unknown FALSE)
+    if(CMAKE_HOST_WIN32)
+        if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+            set(build_arch $ENV{PROCESSOR_ARCHITEW6432})
+        else()
+            set(build_arch $ENV{PROCESSOR_ARCHITECTURE})
+        endif()
+        if(build_arch MATCHES "(amd|AMD)64")
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
+        elseif(build_arch MATCHES "(x|X)86")
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
+        elseif(build_arch MATCHES "^(ARM|arm)64$")
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
+        elseif(build_arch MATCHES "^(ARM|arm)$")
+            set(build_cpu_fam arm)
+            set(build_cpu armv7hl)
+        else()
+            if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+                message(WARNING "Unsupported build architecture ${build_arch}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+            endif()
+            set(build_unknown TRUE)
+        endif()
+    elseif(CMAKE_HOST_UNIX)
+        # at this stage, CMAKE_HOST_SYSTEM_PROCESSOR is not defined
+        execute_process(
+            COMMAND uname -m
+            OUTPUT_VARIABLE MACHINE
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            COMMAND_ERROR_IS_FATAL ANY)
+
+        # Show real machine architecture to visually understand whether we are in a native Apple Silicon terminal or running under Rosetta emulation
+        debug_message("Machine: ${MACHINE}")
+
+        if(MACHINE MATCHES "arm64|aarch64")
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
+        elseif(MACHINE MATCHES "armv7h?l")
+            set(build_cpu_fam arm)
+            set(build_cpu ${MACHINE})
+        elseif(MACHINE MATCHES "x86_64|amd64")
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
+        elseif(MACHINE MATCHES "x86|i686")
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
+        elseif(MACHINE MATCHES "i386")
+            set(build_cpu_fam x86)
+            set(build_cpu i386)
+        elseif(MACHINE MATCHES "loongarch64")
+            set(build_cpu_fam loongarch64)
+            set(build_cpu loongarch64)
+        else()
+            # https://github.com/mesonbuild/meson/blob/master/docs/markdown/Reference-tables.md#cpu-families
+            if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+                message(WARNING "Unhandled machine: ${MACHINE}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+            endif()
+            set(build_unknown TRUE)
+        endif()
+    else()
+        if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+            message(WARNING "Failed to detect the build architecture! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+        endif()
+        set(build_unknown TRUE)
+    endif()
+
+    set(build "[build_machine]\n") # Machine the build is performed on
+    string(APPEND build "endian = 'little'\n")
+    if(WIN32)
+        string(APPEND build "system = 'windows'\n")
+    elseif(DARWIN)
+        string(APPEND build "system = 'darwin'\n")
+    elseif(CYGWIN)
+        string(APPEND build "system = 'cygwin'\n")
+    elseif(UNIX)
+        string(APPEND build "system = 'linux'\n")
+    else()
+        set(build_unknown TRUE)
+    endif()
+
+    if(DEFINED build_cpu_fam)
+        string(APPEND build "cpu_family = '${build_cpu_fam}'\n")
+    endif()
+    if(DEFINED build_cpu)
+        string(APPEND build "cpu = '${build_cpu}'")
+    endif()
+    if(NOT build_unknown)
+        set(${build_system} "${build}" PARENT_SCOPE)
+    endif()
+
+    set(host_unkown FALSE)
+    if(VCPKG_TARGET_ARCHITECTURE MATCHES "(amd|AMD|x|X)64")
+        set(host_cpu_fam x86_64)
+        set(host_cpu x86_64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
+        set(host_cpu_fam x86)
+        set(host_cpu i686)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
+        set(host_cpu_fam aarch64)
+        set(host_cpu armv8)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
+        set(host_cpu_fam arm)
+        set(host_cpu armv7hl)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "loongarch64")
+        set(host_cpu_fam loongarch64)
+        set(host_cpu loongarch64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "wasm32")
+        set(host_cpu_fam wasm32)
+        set(host_cpu wasm32)
+    else()
+        if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+            message(WARNING "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the host_machine entry!" )
+        endif()
+        set(host_unkown TRUE)
+    endif()
+
+    set(host "[host_machine]\n") # host=target in vcpkg. 
+    string(APPEND host "endian = 'little'\n")
+    if(NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_TARGET_IS_MINGW OR VCPKG_TARGET_IS_UWP)
+        set(meson_system_name "windows")
+    else()
+        string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" meson_system_name)
+    endif()
+    string(APPEND host "system = '${meson_system_name}'\n")
+    string(APPEND host "cpu_family = '${host_cpu_fam}'\n")
+    string(APPEND host "cpu = '${host_cpu}'")
+    if(NOT host_unkown)
+        set(${host_system} "${host}" PARENT_SCOPE)
+    endif()
+
+    if(NOT build_cpu_fam MATCHES "${host_cpu_fam}"
+       OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_IOS OR VCPKG_TARGET_IS_UWP
+       OR (VCPKG_TARGET_IS_MINGW AND NOT WIN32))
+        set(${is_cross} TRUE PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(z_vcpkg_meson_setup_extra_windows_variables config_type)
+    ## b_vscrt
+    if(VCPKG_CRT_LINKAGE STREQUAL "static")
+        set(crt_type "mt")
+    else()
+        set(crt_type "md")
+    endif()
+    if(config_type STREQUAL "DEBUG")
+        set(crt_type "${crt_type}d")
+    endif()
+    set(MESON_VSCRT_LINKAGE "b_vscrt = '${crt_type}'" PARENT_SCOPE)
+    ## winlibs
+    separate_arguments(c_winlibs NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
+    separate_arguments(cpp_winlibs NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+    z_vcpkg_meson_convert_list_to_python_array(c_winlibs ${c_winlibs})
+    z_vcpkg_meson_convert_list_to_python_array(cpp_winlibs ${cpp_winlibs})
+    set(MESON_WINLIBS "c_winlibs = ${c_winlibs}\n")
+    string(APPEND MESON_WINLIBS "cpp_winlibs = ${cpp_winlibs}")
+    set(MESON_WINLIBS "${MESON_WINLIBS}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_meson_setup_variables config_type)
+    set(meson_var_list VSCRT_LINKAGE WINLIBS MT AR RC C C_LD CXX CXX_LD OBJC OBJC_LD OBJCXX OBJCXX_LD FC FC_LD WINDRES CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS FCFLAGS SHARED_LINKER_FLAGS)
+    foreach(var IN LISTS meson_var_list)
+        set(MESON_${var} "")
+    endforeach()
+
+    if(VCPKG_TARGET_IS_WINDOWS)
+        z_vcpkg_meson_setup_extra_windows_variables("${config_type}")
+    endif()
+
+    z_vcpkg_meson_set_proglist_variables("${config_type}")
+    z_vcpkg_meson_set_flags_variables("${config_type}")
+
+    foreach(var IN LISTS meson_var_list)
+        set(MESON_${var} "${MESON_${var}}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+function(vcpkg_configure_meson)
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "NO_PKG_CONFIG"
+        "SOURCE_PATH"
+        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;LANGUAGES;ADDITIONAL_BINARIES;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES"
+    )
+
+    if(NOT arg_LANGUAGES)
+        set(arg_LANGUAGES C CXX)
+    endif()
+
+    if(DEFINED arg_ADDITIONAL_NATIVE_BINARIES OR DEFINED arg_ADDITIONAL_CROSS_BINARIES)
+        message(WARNING "Options ADDITIONAL_(NATIVE|CROSS)_BINARIES have been deprecated. Only use ADDITIONAL_BINARIES!")
+    endif()
+
+    vcpkg_list(APPEND arg_ADDITIONAL_BINARIES ${arg_ADDITIONAL_NATIVE_BINARIES} ${arg_ADDITIONAL_CROSS_BINARIES})
+    vcpkg_list(REMOVE_DUPLICATES arg_ADDITIONAL_BINARIES)
+    vcpkg_list(JOIN arg_ADDITIONAL_BINARIES "\n" MESON_ADDITIONAL_BINARIES)
+
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+
+    if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+        z_vcpkg_select_default_vcpkg_chainload_toolchain()
+    endif()
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    debug_message("Including cmake vars from: ${cmake_vars_file}")
+    include("${cmake_vars_file}")
+
+    vcpkg_find_acquire_program(MESON)
+
+    get_filename_component(CMAKE_PATH "${CMAKE_COMMAND}" DIRECTORY)
+    vcpkg_add_to_path("${CMAKE_PATH}" PREPEND) # Make CMake invokeable for Meson
+
+    vcpkg_find_acquire_program(PYTHON3)
+    get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
+    vcpkg_add_to_path("${PYTHON3_DIR}")
+
+    vcpkg_find_acquire_program(NINJA)
+    get_filename_component(NINJA_PATH ${NINJA} DIRECTORY)
+    vcpkg_add_to_path(PREPEND "${NINJA_PATH}") # Prepend to use the correct ninja.
+
+    set(buildtypes "")
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        set(buildname "DEBUG")
+        vcpkg_list(APPEND buildtypes "${buildname}")
+        set(path_suffix_${buildname} "debug/")
+        set(suffix_${buildname} "dbg")
+        set(meson_input_file_${buildname} "${CURRENT_BUILDTREES_DIR}/meson-${TARGET_TRIPLET}-${suffix_${buildname}}.log")
+    endif()
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        set(buildname "RELEASE")
+        vcpkg_list(APPEND buildtypes "${buildname}")
+        set(path_suffix_${buildname} "")
+        set(suffix_${buildname} "rel")
+        set(meson_input_file_${buildname} "${CURRENT_BUILDTREES_DIR}/meson-${TARGET_TRIPLET}-${suffix_${buildname}}.log")
+    endif()
+
+    vcpkg_list(APPEND arg_OPTIONS --backend ninja --wrap-mode nodownload -Dbuildtype=plain)
+
+    z_vcpkg_get_build_and_host_system(MESON_HOST_MACHINE MESON_BUILD_MACHINE IS_CROSS)
+
+    if(IS_CROSS)
+        # VCPKG_CROSSCOMPILING is not used since it regresses a lot of ports in x64-windows-x triplets
+        # For consistency this should proably be changed in the future?
+        vcpkg_list(APPEND arg_OPTIONS --native "${SCRIPTS}/buildsystems/meson/none.txt")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --cross "${meson_input_file_DEBUG}")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${meson_input_file_RELEASE}")
+    else()
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --native "${meson_input_file_DEBUG}")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${meson_input_file_RELEASE}")
+    endif()
+
+    # User provided cross/native files
+    if(VCPKG_MESON_NATIVE_FILE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${VCPKG_MESON_NATIVE_FILE}")
+    endif()
+    if(VCPKG_MESON_NATIVE_FILE_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${VCPKG_MESON_NATIVE_FILE_RELEASE}")
+    endif()
+    if(VCPKG_MESON_NATIVE_FILE_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --native "${VCPKG_MESON_NATIVE_FILE_DEBUG}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE_RELEASE}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --cross "${VCPKG_MESON_CROSS_FILE_DEBUG}")
+    endif()
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
+        set(MESON_DEFAULT_LIBRARY shared)
+    else()
+        set(MESON_DEFAULT_LIBRARY static)
+    endif()
+
+    vcpkg_list(APPEND arg_OPTIONS --libdir lib) # else meson install into an architecture describing folder
+    vcpkg_list(APPEND arg_OPTIONS_DEBUG -Ddebug=true --prefix "${CURRENT_PACKAGES_DIR}/debug" --includedir ../include)
+    vcpkg_list(APPEND arg_OPTIONS_RELEASE -Ddebug=false --prefix "${CURRENT_PACKAGES_DIR}")
+
+    # select meson cmd-line options
+    if(VCPKG_TARGET_IS_WINDOWS)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']")
+    else()
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']")
+    endif()
+
+    # Allow overrides / additional configuration variables from triplets
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS)
+        vcpkg_list(APPEND arg_OPTIONS ${VCPKG_MESON_CONFIGURE_OPTIONS})
+    endif()
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE ${VCPKG_MESON_CONFIGURE_OPTIONS_RELEASE})
+    endif()
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG ${VCPKG_MESON_CONFIGURE_OPTIONS_DEBUG})
+    endif()
+
+    # configure build
+    foreach(buildtype IN LISTS buildtypes)
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}}")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}")
+        #setting up PKGCONFIG
+        if(NOT arg_NO_PKG_CONFIG)
+            z_vcpkg_setup_pkgconfig_path(CONFIG "${buildtype}")
+        endif()
+
+        z_vcpkg_meson_setup_variables(${buildtype})
+        configure_file("${SCRIPTS}/buildsystems/meson/meson.template.in" "${meson_input_file_${buildtype}}" @ONLY)
+
+        vcpkg_execute_required_process(
+            COMMAND ${MESON} ${arg_OPTIONS} ${arg_OPTIONS_${buildtype}} ${arg_SOURCE_PATH}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}"
+            LOGNAME config-${TARGET_TRIPLET}-${suffix_${buildtype}}
+            SAVE_LOG_FILES
+                meson-logs/meson-log.txt
+                meson-info/intro-dependencies.json
+                meson-logs/install-log.txt
+        )
+
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}} done")
+
+        if(NOT arg_NO_PKG_CONFIG)
+            z_vcpkg_restore_pkgconfig_path()
+        endif()
+    endforeach()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_pdbs.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_pdbs.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ce26c8d1ffa77a718d97a7f3a49b4b5bb92abf41
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_pdbs.cmake
@@ -0,0 +1,49 @@
+function(vcpkg_copy_pdbs)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "" "BUILD_PATHS")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_BUILD_PATHS)
+        set(arg_BUILD_PATHS
+            "${CURRENT_PACKAGES_DIR}/bin/*.dll"
+            "${CURRENT_PACKAGES_DIR}/debug/bin/*.dll"
+        )
+    endif()
+
+    set(dlls_without_matching_pdbs "")
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic" AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        file(GLOB_RECURSE dlls ${arg_BUILD_PATHS})
+
+        set(vslang_backup "$ENV{VSLANG}")
+        set(ENV{VSLANG} 1033)
+
+        foreach(dll IN LISTS dlls)
+            execute_process(COMMAND dumpbin /PDBPATH "${dll}"
+                            COMMAND findstr PDB
+                OUTPUT_VARIABLE pdb_line
+                ERROR_QUIET
+                RESULT_VARIABLE error_code
+            )
+
+            if(error_code EQUAL "0" AND pdb_line MATCHES "PDB file found at.*'(.*)'")
+                set(pdb_path "${CMAKE_MATCH_1}")
+                cmake_path(GET dll PARENT_PATH dll_dir)
+                file(COPY "${pdb_path}" DESTINATION "${dll_dir}")
+            else()
+                list(APPEND dlls_without_matching_pdbs "${dll}")
+            endif()
+        endforeach()
+
+        set(ENV{VSLANG} "${vslang_backup}")
+
+        if(NOT dlls_without_matching_pdbs STREQUAL "")
+            list(JOIN dlls_without_matching_pdbs "\n    " message)
+            message(WARNING "Could not find a matching pdb file for:
+    ${message}\n")
+        endif()
+    endif()
+
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_tools.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_tools.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d9b3b9523200e1563b6ab816a7b506792686059d
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_tools.cmake
@@ -0,0 +1,49 @@
+function(vcpkg_copy_tools)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "AUTO_CLEAN" "SEARCH_DIR;DESTINATION" "TOOL_NAMES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_TOOL_NAMES)
+        message(FATAL_ERROR "TOOL_NAMES must be specified.")
+    endif()
+
+    if(NOT DEFINED arg_DESTINATION)
+        set(arg_DESTINATION "${CURRENT_PACKAGES_DIR}/tools/${PORT}")
+    endif()
+
+    if(NOT DEFINED arg_SEARCH_DIR)
+        set(arg_SEARCH_DIR "${CURRENT_PACKAGES_DIR}/bin")
+    elseif(NOT IS_DIRECTORY "${arg_SEARCH_DIR}")
+        message(FATAL_ERROR "SEARCH_DIR (${arg_SEARCH_DIR}) must be a directory")
+    endif()
+
+    foreach(tool_name IN LISTS arg_TOOL_NAMES)
+        set(tool_path "${arg_SEARCH_DIR}/${tool_name}${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
+        set(tool_pdb "${arg_SEARCH_DIR}/${tool_name}.pdb")
+        if(EXISTS "${tool_path}")
+            file(COPY "${tool_path}" DESTINATION "${arg_DESTINATION}")
+        elseif(NOT "${VCPKG_TARGET_BUNDLE_SUFFIX}" STREQUAL "" AND NOT "${VCPKG_TARGET_BUNDLE_SUFFIX}" STREQUAL "${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
+            set(bundle_path "${arg_SEARCH_DIR}/${tool_name}${VCPKG_TARGET_BUNDLE_SUFFIX}")
+            if(EXISTS "${bundle_path}")
+                file(COPY "${bundle_path}" DESTINATION "${arg_DESTINATION}")
+            else()
+                message(FATAL_ERROR "Couldn't find tool \"${tool_name}\":
+    neither \"${tool_path}\" nor \"${bundle_path}\" exists")
+            endif()
+        else()
+            message(FATAL_ERROR "Couldn't find tool \"${tool_name}\":
+    \"${tool_path}\" does not exist")
+        endif()
+        if(EXISTS "${tool_pdb}")
+            file(COPY "${tool_pdb}" DESTINATION "${arg_DESTINATION}")
+        endif()
+    endforeach()
+
+    if(arg_AUTO_CLEAN)
+        vcpkg_clean_executables_in_bin(FILE_NAMES ${arg_TOOL_NAMES})
+    endif()
+
+    vcpkg_copy_tool_dependencies("${arg_DESTINATION}")
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_download_sourceforge.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_download_sourceforge.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ad10ad690f86b01563c76abb62c3314bd88092e3
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_download_sourceforge.cmake
@@ -0,0 +1,85 @@
+function(vcpkg_download_sourceforge out_var)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg"
+        ""
+        "REPO;REF;SHA512;FILENAME"
+        "")
+
+    foreach(arg_name IN ITEMS REPO SHA512 FILENAME)
+        if(NOT DEFINED "arg_${arg_name}")
+            message(FATAL_ERROR "${arg_name} is required.")
+        endif()
+    endforeach()
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unrecognized arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    set(sourceforge_host "https://sourceforge.net/projects")
+
+    if(arg_REPO MATCHES "^([^/]*)$") # just one element
+        set(org_name "${CMAKE_MATCH_1}")
+        set(repo_name "")
+    elseif(arg_REPO MATCHES "^([^/]*)/([^/]*)$") # two elements
+        set(org_name "${CMAKE_MATCH_1}")
+        set(repo_name "${CMAKE_MATCH_2}")
+    else()
+        message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name. It must be:
+    - an organization name without any slashes, or
+    - an organization name followed by a repository name separated by a single slash")
+    endif()
+    
+    if(DEFINED arg_REF)
+        set(url "${sourceforge_host}/${org_name}/files/${repo_name}/${arg_REF}/${arg_FILENAME}")
+    elseif(DEFINED repo_name)
+        set(url "${sourceforge_host}/${org_name}/${repo_name}/files/${arg_FILENAME}")
+    else()
+        set(url "${sourceforge_host}/${org_name}/files/${arg_FILENAME}")
+    endif()
+        
+    string(SUBSTRING "${arg_SHA512}" 0 10 sanitized_ref)
+
+    set(sourceforge_mirrors
+        cfhcable        # United States
+        pilotfiber      # New York, NY
+        gigenet         # Chicago, IL
+        versaweb        # Las Vegas, NV
+        ayera           # Modesto, CA
+        netactuate      # Durham, NC
+        phoenixnap      # Tempe, AZ
+        astuteinternet  # Vancouver, BC
+        freefr          # Paris, France
+        netcologne      # Cologne, Germany
+        deac-riga       # Latvia
+        excellmedia     # Hyderabad, India
+        iweb            # Montreal, QC
+        jaist           # Nomi, Japan
+        jztkft          # Mezotur, Hungary
+        managedway      # Detroit, MI
+        nchc            # Taipei, Taiwan
+        netix           # Bulgaria
+        ufpr            # Curitiba, Brazil
+        tenet           # Wynberg, South Africa
+    )
+    if(DEFINED SOURCEFORGE_MIRRORS AND NOT DEFINED VCPKG_SOURCEFORGE_EXTRA_MIRRORS)
+        message(WARNING "Extension point SOURCEFORGE_MIRRORS has been deprecated.
+    Please use the replacement VCPKG_SOURCEFORGE_EXTRA_MIRRORS variable instead.")
+        list(APPEND sourceforge_mirrors "${SOURCEFORGE_MIRRORS}")
+        list(REMOVE_DUPLICATES sourceforge_mirrors)
+    elseif(DEFINED VCPKG_SOURCEFORGE_EXTRA_MIRRORS)
+        list(APPEND sourceforge_mirrors "${VCPKG_SOURCEFORGE_EXTRA_MIRRORS}")
+        list(REMOVE_DUPLICATES sourceforge_mirrors)
+    endif()
+
+    set(all_urls "${url}/download")
+    foreach(mirror IN LISTS sourceforge_mirrors)
+        list(APPEND all_urls "${url}/download?use_mirror=${mirror}")
+    endforeach()
+    
+    vcpkg_download_distfile(archive
+        URLS ${all_urls}
+        SHA512 "${arg_SHA512}"
+        FILENAME "${arg_FILENAME}"
+    )
+
+    set("${out_var}" "${archive}" PARENT_SCOPE)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_build_process.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_build_process.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..60fd5b587a650f356034d7e8a5bf774f1dacbdd0
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_build_process.cmake
@@ -0,0 +1,141 @@
+set(Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES
+    "LINK : fatal error LNK1102:"
+    " fatal error C1060: "
+    # The linker ran out of memory during execution. We will try continuing once more, with parallelism disabled.
+    "LINK : fatal error LNK1318:"
+    "LINK : fatal error LNK1104:"
+    "LINK : fatal error LNK1201:"
+    "ld terminated with signal 9"
+    "Killed signal terminated program"
+    # Multiple threads using the same directory at the same time cause conflicts, will try again.
+    "Cannot create parent directory"
+    "Cannot write file"
+    # Multiple threads caused the wrong order of creating folders and creating files in folders
+    "Can't open"
+    # `make install` may stumble over concurrency, in particular with `mkdir` on osx.
+    "mkdir [^:]*: File exists"
+)
+list(JOIN Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES "|" Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES)
+
+function(vcpkg_execute_build_process)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "WORKING_DIRECTORY;LOGNAME" "COMMAND;NO_PARALLEL_COMMAND")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    foreach(required_arg IN ITEMS WORKING_DIRECTORY COMMAND)
+        if(NOT DEFINED arg_${required_arg})
+            message(FATAL_ERROR "${required_arg} must be specified.")
+        endif()
+    endforeach()
+
+    if(NOT DEFINED arg_LOGNAME)
+        message(WARNING "LOGNAME should be specified.")
+        set(arg_LOGNAME "build")
+    endif()
+
+    set(log_prefix "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}")
+    set(log_out "${log_prefix}-out.log")
+    set(log_err "${log_prefix}-err.log")
+    set(all_logs "${log_out}" "${log_err}")
+
+    if(X_PORT_PROFILE)
+        vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
+        if(DEFINED arg_NO_PARALLEL_COMMAND)
+            vcpkg_list(PREPEND arg_NO_PARALLEL_COMMAND "${CMAKE_COMMAND}" "-E" "time")
+        endif()
+    endif()
+
+    execute_process(
+        COMMAND ${arg_COMMAND}
+        WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+        OUTPUT_FILE "${log_out}"
+        ERROR_FILE "${log_err}"
+        RESULT_VARIABLE error_code
+    )
+    if (NOT error_code MATCHES "^[0-9]+$")
+        list(JOIN arg_COMMAND " " command)
+        message(FATAL_ERROR "Failed to execute command \"${command}\" in working directory \"${arg_WORKING_DIRECTORY}\": ${error_code}")
+    endif()
+    if(NOT error_code EQUAL "0")
+        file(READ "${log_out}" out_contents)
+        file(READ "${log_err}" err_contents)
+        set(all_contents "${out_contents}${err_contents}")
+        if(all_contents MATCHES "${Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES}")
+            message(WARNING "Please ensure your system has sufficient memory.")
+            set(log_out "${log_prefix}-out-1.log")
+            set(log_err "${log_prefix}-err-1.log")
+            list(APPEND all_logs "${log_out}" "${log_err}")
+
+            if(DEFINED arg_NO_PARALLEL_COMMAND)
+                message(STATUS "Restarting build without parallelism")
+                execute_process(
+                    COMMAND ${arg_NO_PARALLEL_COMMAND}
+                    WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+                    OUTPUT_FILE "${log_out}"
+                    ERROR_FILE "${log_err}"
+                    RESULT_VARIABLE error_code
+                )
+            else()
+                message(STATUS "Restarting build")
+                execute_process(
+                    COMMAND ${arg_COMMAND}
+                    WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+                    OUTPUT_FILE "${log_out}"
+                    ERROR_FILE "${log_err}"
+                    RESULT_VARIABLE error_code
+                )
+            endif()
+        elseif(all_contents MATCHES "mt(\\.exe)? : general error c101008d: ")
+            # Antivirus workaround - occasionally files are locked and cause mt.exe to fail
+            message(STATUS "mt.exe has failed. This may be the result of anti-virus. Disabling anti-virus on the buildtree folder may improve build speed")
+            foreach(iteration RANGE 1 3)
+                message(STATUS "Restarting Build ${TARGET_TRIPLET}-${SHORT_BUILDTYPE} because of mt.exe file locking issue. Iteration: ${iteration}")
+
+                set(log_out "${log_prefix}-out-${iteration}.log")
+                set(log_err "${log_prefix}-err-${iteration}.log")
+                list(APPEND all_logs "${log_out}" "${log_err}")
+                execute_process(
+                    COMMAND ${arg_COMMAND}
+                    WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+                    OUTPUT_FILE "${log_out}"
+                    ERROR_FILE "${log_err}"
+                    RESULT_VARIABLE error_code
+                )
+
+                if(error_code EQUAL "0")
+                    break()
+                endif()
+
+                file(READ "${log_out}" out_contents)
+                file(READ "${log_err}" err_contents)
+                set(all_contents "${out_contents}${err_contents}")
+                if(NOT all_contents MATCHES "mt : general error c101008d: ")
+                    break()
+                endif()
+            endforeach()
+        endif()
+    endif()
+
+    if(NOT error_code EQUAL "0")
+        set(stringified_logs "")
+        foreach(log IN LISTS all_logs)
+            if(NOT EXISTS "${log}")
+                continue()
+            endif()
+            file(SIZE "${log}" log_size)
+            if(NOT log_size EQUAL "0")
+                file(TO_NATIVE_PATH "${log}" native_log)
+                string(APPEND stringified_logs "    ${native_log}\n")
+                file(APPEND "${Z_VCPKG_ERROR_LOG_COLLECTION_FILE}" "${native_log}\n")
+            endif()
+        endforeach()
+        z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
+        message(FATAL_ERROR
+            "  Command failed: ${pretty_command}\n"
+            "  Working Directory: ${arg_WORKING_DIRECTORY}\n"
+            "  See logs for more information:\n"
+            "${stringified_logs}"
+        )
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_in_download_mode.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_in_download_mode.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..2ad1481f8b5642e07af8e521cd569aea9f284dae
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_in_download_mode.cmake
@@ -0,0 +1,46 @@
+function(vcpkg_execute_in_download_mode)
+    # this allows us to grab the value of the output variables, but pass through the rest of the arguments
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "RESULT_VARIABLE;RESULTS_VARIABLE;OUTPUT_VARIABLE;ERROR_VARIABLE" "")
+
+    set(output_and_error_same OFF)
+    set(output_variable_param "")
+    set(error_variable_param "")
+    set(result_variable_param "")
+    set(results_variable_param "")
+    if(DEFINED arg_OUTPUT_VARIABLE AND DEFINED arg_ERROR_VARIABLE AND arg_OUTPUT_VARIABLE STREQUAL arg_ERROR_VARIABLE)
+        set(output_variable_param OUTPUT_VARIABLE out_err_var)
+        set(error_variable_param ERROR_VARIABLE out_err_var)
+        set(output_and_error_same ON)
+    else()
+        if(DEFINED arg_OUTPUT_VARIABLE)
+            set(output_variable_param OUTPUT_VARIABLE out_var)
+        endif()
+        if(DEFINED arg_ERROR_VARIABLE)
+            set(error_variable_param ERROR_VARIABLE err_var)
+        endif()
+    endif()
+    if(DEFINED arg_RESULT_VARIABLE)
+        set(result_variable_param RESULT_VARIABLE result_var)
+    endif()
+    if(DEFINED arg_RESULTS_VARIABLE)
+        set(results_variable_param RESULTS_VARIABLE results_var)
+    endif()
+
+    cmake_language(CALL "${Z_VCPKG_EXECUTE_PROCESS_NAME}"
+        ${arg_UNPARSED_ARGUMENTS}
+        ${output_variable_param}
+        ${error_variable_param}
+        ${result_variable_param}
+        ${results_variable_param}
+    )
+
+    if(output_and_error_same)
+        z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_err_var)
+    else()
+        z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_var)
+        z_vcpkg_forward_output_variable(arg_ERROR_VARIABLE err_var)
+    endif()
+
+    z_vcpkg_forward_output_variable(arg_RESULT_VARIABLE result_var)
+    z_vcpkg_forward_output_variable(arg_RESULTS_VARIABLE results_var)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_required_process_repeat.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_required_process_repeat.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a13f8fa6e09599ab38370d6423f47eca192f0907
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_required_process_repeat.cmake
@@ -0,0 +1,71 @@
+function(vcpkg_execute_required_process_repeat)
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "ALLOW_IN_DOWNLOAD_MODE"
+        "COUNT;WORKING_DIRECTORY;LOGNAME"
+        "COMMAND"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    foreach(required_arg IN ITEMS COUNT WORKING_DIRECTORY LOGNAME COMMAND)
+        if(NOT DEFINED arg_${required_arg})
+            message(FATAL_ERROR "${required_arg} must be specified.")
+        endif()
+    endforeach()
+
+    # also checks for COUNT being an integer
+    if(NOT arg_COUNT GREATER_EQUAL "1")
+        message(FATAL_ERROR "COUNT (${arg_COUNT}) must be greater than or equal to 1.")
+    endif()
+
+    if (DEFINED VCPKG_DOWNLOAD_MODE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
+        message(FATAL_ERROR
+[[
+This command cannot be executed in Download Mode.
+Halting portfile execution.
+]])
+    endif()
+
+    if(X_PORT_PROFILE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
+        vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
+    endif()
+
+    set(all_logs "")
+    foreach(loop_count RANGE 1 ${arg_COUNT})
+        set(out_log "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out-${loop_count}.log")
+        set(err_log "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out-${loop_count}.log")
+        list(APPEND all_logs "${out_log}" "${err_log}")
+
+        vcpkg_execute_in_download_mode(
+            COMMAND ${arg_COMMAND}
+            OUTPUT_FILE "${out_log}"
+            ERROR_FILE "${err_log}"
+            RESULT_VARIABLE error_code
+            WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+        )
+        if(error_code EQUAL "0")
+            return()
+        endif()
+    endforeach()
+
+    set(stringified_logs "")
+    foreach(log IN LISTS all_logs)
+        if(NOT EXISTS "${log}")
+            continue()
+        endif()
+        file(SIZE "${log}" log_size)
+        if(NOT log_size EQUAL "0")
+            file(TO_NATIVE_PATH "${log}" native_log)
+            string(APPEND stringified_logs "    ${native_log}\n")
+        endif()
+    endforeach()
+
+    z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
+    message(FATAL_ERROR
+        "  Command failed: ${pretty_command}\n"
+        "  Working Directory: ${arg_WORKING_DIRECTORY}\n"
+        "  See logs for more information:\n"
+        "${stringified_logs}"
+    )
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_extract_archive.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_extract_archive.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b6bc86847969f8bc1a6be49cb46c859e85b1c666
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_extract_archive.cmake
@@ -0,0 +1,51 @@
+function(vcpkg_extract_archive)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "ARCHIVE;DESTINATION"
+        ""
+    )
+
+    foreach(arg_name IN ITEMS ARCHIVE DESTINATION)
+        if(NOT DEFINED "arg_${arg_name}")
+            message(FATAL_ERROR "${arg_name} is required.")
+        endif()
+    endforeach()
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unrecognized arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(EXISTS "${arg_DESTINATION}")
+        message(FATAL_ERROR "${arg_DESTINATION} was an extraction target, but it already exists.")
+    endif()
+
+    file(MAKE_DIRECTORY "${arg_DESTINATION}")
+
+    cmake_path(GET arg_ARCHIVE EXTENSION archive_extension)
+    string(TOLOWER "${archive_extension}" archive_extension)
+    if("${archive_extension}" MATCHES [[\.msi$]])
+        cmake_path(NATIVE_PATH arg_ARCHIVE archive_native_path)
+        cmake_path(NATIVE_PATH arg_DESTINATION destination_native_path)
+        cmake_path(GET arg_ARCHIVE PARENT_PATH archive_directory)
+        vcpkg_execute_in_download_mode(
+            COMMAND msiexec
+                /a "${archive_native_path}"
+                /qn "TARGETDIR=${destination_native_path}"
+            WORKING_DIRECTORY "${archive_directory}"
+        )
+    elseif("${archive_extension}" MATCHES [[\.7z\.exe$]])
+        vcpkg_find_acquire_program(7Z)
+        vcpkg_execute_in_download_mode(
+            COMMAND ${7Z} x
+                "${arg_ARCHIVE}"
+                "-o${arg_DESTINATION}"
+                -y -bso0 -bsp0
+            WORKING_DIRECTORY "${arg_DESTINATION}"
+        )
+    else()
+        vcpkg_execute_in_download_mode(
+            COMMAND "${CMAKE_COMMAND}" -E tar xzf "${arg_ARCHIVE}"
+            WORKING_DIRECTORY "${arg_DESTINATION}"
+        )
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_fail_port_install.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_fail_port_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a5cb105f923f006d9f8469100a7710c2b164a2d4
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_fail_port_install.cmake
@@ -0,0 +1,78 @@
+function(vcpkg_fail_port_install)
+    message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "vcpkg_fail_port_install has been removed and all values should be moved by adding `supports` field to manifest file or directly adding `${PORT}:${FAILED_TRIPLET}=fail` to _scripts/ci.baseline.txt_.\nPlease remove `vcpkg_fail_port_install(...)`.\n")
+
+    set(multi_args "ON_TARGET;ON_ARCH;ON_CRT_LINKAGE;ON_LIBRARY_LINKAGE")
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "ALWAYS" "MESSAGE" "${multi_args}")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_fail_port_install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(arg_ALWAYS)
+        vcpkg_list(SET extra_args)
+        foreach(arg IN LISTS multi_args)
+            if(DEFINED "arg_${arg}")
+                vcpkg_list(APPEND extra_args "${arg}" "${arg_${arg}}")
+            endif()
+        endforeach()
+        if(NOT "${extra_args}" STREQUAL "")
+            message(WARNING "vcpkg_fail_port_install set to fail both unconditionally and conditionally on ${extra_args}. This is likely to be an error.")
+        endif()
+        if(NOT DEFINED arg_MESSAGE)
+            message(FATAL_ERROR "vcpkg_fail_port_install(ALWAYS) was called without a specific MESSAGE.")
+        endif()
+
+        message(FATAL_ERROR "${arg_MESSAGE}")
+    endif()
+
+    if(DEFINED arg_MESSAGE)
+        string(APPEND arg_MESSAGE "\n")
+    else()
+        set(arg_MESSAGE "")
+    endif()
+
+    set(fail_port OFF)
+    # Target fail check
+    if(DEFINED arg_ON_TARGET)
+        foreach(target IN LISTS arg_ON_TARGET)
+            string(TOUPPER "${target}" target_upper)
+            if(VCPKG_TARGET_IS_${target_upper})
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "Target '${target}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    # Architecture fail check
+    if(DEFINED arg_ON_ARCH)
+        foreach(arch IN LISTS arg_ON_ARCH)
+            if(VCPKG_TARGET_ARCHITECTURE STREQUAL arch)
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "Architecture '${arch}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    # CRT linkage fail check
+    if(DEFINED arg_ON_CRT_LINKAGE)
+        foreach(crt_linkage IN LISTS arg_ON_CRT_LINKAGE)
+            if(VCPKG_CRT_LINKAGE STREQUAL crt_linkage)
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "CRT linkage '${VCPKG_CRT_LINKAGE}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    # Library linkage fail check
+    if(DEFINED arg_ON_LIBRARY_LINKAGE)
+        foreach(library_linkage IN LISTS arg_ON_LIBRARY_LINKAGE)
+            if(VCPKG_LIBRARY_LINKAGE STREQUAL library_linkage)
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "Library linkage '${VCPKG_LIBRARY_LINKAGE}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    if(fail_port)
+        message(FATAL_ERROR "${arg_MESSAGE}")
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(7Z).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(7Z).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..53e6f66d734c41d714f50e217a3689726713979f
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(7Z).cmake
@@ -0,0 +1,9 @@
+set(program_name 7z)
+if(CMAKE_HOST_WIN32)
+    set(tool_subdirectory "23.01")
+    set(paths_to_search "${DOWNLOADS}/tools/7zip_msi-${tool_subdirectory}-windows/Files/7-Zip") # vcpkg fetch 7zip_msi path
+    list(APPEND paths_to_search "${DOWNLOADS}/tools/7z/${tool_subdirectory}/Files/7-Zip")
+    set(download_urls "https://github.com/ip7z/7zip/releases/download/23.01/7z2301.msi" "https://7-zip.org/a/7z2301.msi")
+    set(download_filename "7z2301.msi")
+    set(download_sha512 002c8ab30be802fa5fa90896d2bdf710bfbd89e39487af25af9d63821986e6d11c42b1c4f4acc79d325719b10193cd31c38f648403ef16f0580609afa8da9596)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(ARIA2).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(ARIA2).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..16153deffa5aa74f89fb77994a0a6cf4f057f24b
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(ARIA2).cmake
@@ -0,0 +1,8 @@
+set(program_name aria2c)
+set(program_version 1.35.0)
+if(CMAKE_HOST_WIN32)
+    set(paths_to_search "${DOWNLOADS}/tools/aria2c/aria2-${program_version}-win-32bit-build1")
+    set(download_urls "https://github.com/aria2/aria2/releases/download/release-${program_version}/aria2-${program_version}-win-32bit-build1.zip")
+    set(download_filename "aria2-${program_version}-win-32bit-build1.zip")
+    set(download_sha512 933537cad820b1cecf43a9eeca7e1b241dd7b1c902ee942441a166f2c38845f16046321efbdfa2f83c7e9fc50c7ecc5da6fd00e0c6e2124c07d3b783aa5092a4)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BAZEL).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BAZEL).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..59153af6eb8615e670ec0bba0f3b7db9c4fc88d0
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BAZEL).cmake
@@ -0,0 +1,21 @@
+set(program_name bazel)
+set(program_version 4.2.2)
+set(rename_binary_to "bazel")
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+    set(tool_subdirectory "${program_version}-linux")
+    set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64")
+    set(download_filename "bazel-${tool_subdirectory}-x86_64")
+    set(raw_executable ON)
+    set(download_sha512 f38619e054df78cab38278a5901b2798f2e25b5cec53358d98278002e713d225fd3df96a209b7f22a2357835a279cee8ef1768e10561b3e9fe6361f324563bb9)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+    set(tool_subdirectory "${program_version}-darwin")
+    set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64")
+    set(download_filename "bazel-${tool_subdirectory}-x86_64")
+    set(raw_executable ON)
+    set(download_sha512 a3fd8f9d71b0669d742439200f27ee0a3891c1f248df62c841ebb2b416a47534562f429f8a08793b074e9b74f2ede3d97a7e13ac9921c7ee2dc6a2dca8b7f275)
+else()
+    set(tool_subdirectory "${program_version}-windows")
+    set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64.zip")
+    set(download_filename "bazel-${tool_subdirectory}-x86_64.zip")
+    set(download_sha512 8a8196e242964114316232818cb81bfa19ebfd3a029ebf550a241e33b22a6e9ed636dade06411a8706c05c4e73def0bc8d7f45ff0ec5478bcc5de21b5638204d)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BISON).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BISON).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..10f9a7d7a36a878dfa034594d97b87a9438a854b
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BISON).cmake
@@ -0,0 +1,20 @@
+if(CMAKE_HOST_WIN32)
+    # This download shall be the same as in vcpkg_find_acquire_program(FLEX).cmake
+    set(program_version 2.5.25)
+    set(download_urls "https://github.com/lexxmark/winflexbison/releases/download/v${program_version}/win_flex_bison-${program_version}.zip")
+    set(download_filename "win_flex_bison-${program_version}.zip")
+    set(download_sha512 2a829eb05003178c89f891dd0a67add360c112e74821ff28e38feb61dac5b66e9d3d5636ff9eef055616aaf282ee8d6be9f14c6ae4577f60bdcec96cec9f364e)
+    set(tool_subdirectory "${program_version}")
+    set(program_name win_bison)
+    set(paths_to_search "${DOWNLOADS}/tools/win_flex/${program_version}")
+    if(NOT EXISTS "${paths_to_search}/data/m4sugar/m4sugar.m4")
+        file(REMOVE_RECURSE "${paths_to_search}")
+    endif()
+else()
+    set(program_name bison)
+    set(apt_package_name bison)
+    set(brew_package_name bison)
+    if (APPLE)
+        set(paths_to_search /opt/homebrew/opt/bison/bin /usr/local/opt/bison/bin)
+    endif()
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(CLANG).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(CLANG).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0826c875126b7cf9bc19bd11a7ddfee6ad5893bd
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(CLANG).cmake
@@ -0,0 +1,31 @@
+set(program_name clang)
+set(tool_subdirectory "clang-15.0.6")
+set(program_version 15.0.6)
+if(CMAKE_HOST_WIN32)
+    set(paths_to_search
+        # Support LLVM in Visual Studio 2019
+        "$ENV{LLVMInstallDir}/x64/bin"
+        "$ENV{LLVMInstallDir}/bin"
+        "$ENV{VCINSTALLDIR}/Tools/Llvm/x64/bin"
+        "$ENV{VCINSTALLDIR}/Tools/Llvm/bin"
+        "${DOWNLOADS}/tools/${tool_subdirectory}-windows/bin"
+        "${DOWNLOADS}/tools/clang/${tool_subdirectory}/bin")
+
+    if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(host_arch "$ENV{PROCESSOR_ARCHITEW6432}")
+    else()
+        set(host_arch "$ENV{PROCESSOR_ARCHITECTURE}")
+    endif()
+
+    if(host_arch MATCHES "64")
+        set(download_urls "https://github.com/llvm/llvm-project/releases/download/llvmorg-${program_version}/LLVM-${program_version}-win64.exe")
+        set(download_filename "LLVM-${program_version}-win64.7z.exe")
+        set(download_sha512 2dd6f3eea106f2b905e6658ea5ea12856d17285adbfba055edc2d6b6389c4c2f7aa001df5cb0d8fb84fa7fa47d5035a7fddf276523b472dd55f150ae25938768)
+    else()
+        set(download_urls "https://github.com/llvm/llvm-project/releases/download/llvmorg-${program_version}/LLVM-${program_version}-win32.exe")
+        set(download_filename "LLVM-${program_version}-win32.7z.exe")
+        set(download_sha512 90225D650EADB0E590A9912B479B46A575D41A19EB5F2DA03C4DC8B032DC0790222F0E3706DFE2A35C0E7747941972AC26CB47D3EB13730DB76168931F37E5F1)
+    endif()
+endif()
+set(brew_package_name "llvm")
+set(apt_package_name "clang")
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(DARK).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(DARK).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9362a7ed28000a71d4773b0ed0ed68a9cccce946
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(DARK).cmake
@@ -0,0 +1,8 @@
+set(program_name dark)
+if(CMAKE_HOST_WIN32)
+    set(tool_subdirectory "wix311-binaries")
+    set(paths_to_search "${DOWNLOADS}/tools/dark/${tool_subdirectory}")
+    set(download_urls "https://github.com/wixtoolset/wix3/releases/download/wix311rtm/wix311-binaries.zip")
+    set(download_filename "wix311-binaries.zip")
+    set(download_sha512 74f0fa29b5991ca655e34a9d1000d47d4272e071113fada86727ee943d913177ae96dc3d435eaf494d2158f37560cd4c2c5274176946ebdb17bf2354ced1c516)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(FLEX).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(FLEX).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b686c7fd754c14ee3c691993a7938cc18daffa15
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(FLEX).cmake
@@ -0,0 +1,17 @@
+if(CMAKE_HOST_WIN32)
+    # This download shall be the same as in vcpkg_find_acquire_program(BISON).cmake
+    set(program_version 2.5.25)
+    set(download_urls "https://github.com/lexxmark/winflexbison/releases/download/v${program_version}/win_flex_bison-${program_version}.zip")
+    set(download_filename "win_flex_bison-${program_version}.zip")
+    set(download_sha512 2a829eb05003178c89f891dd0a67add360c112e74821ff28e38feb61dac5b66e9d3d5636ff9eef055616aaf282ee8d6be9f14c6ae4577f60bdcec96cec9f364e)
+    set(tool_subdirectory "${program_version}")
+    set(program_name win_flex)
+    set(paths_to_search "${DOWNLOADS}/tools/win_flex/${program_version}")
+    if(NOT EXISTS "${paths_to_search}/data/m4sugar/m4sugar.m4")
+        file(REMOVE_RECURSE "${paths_to_search}")
+    endif()
+else()
+    set(program_name flex)
+    set(apt_package_name flex)
+    set(brew_package_name flex)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GASPREPROCESSOR).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GASPREPROCESSOR).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b20086447094311eb395d87a0c216dc9f72b5684
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GASPREPROCESSOR).cmake
@@ -0,0 +1,11 @@
+set(raw_executable true)
+set(program_name gas-preprocessor)
+set(interpreter PERL)
+set(search_names "gas-preprocessor.pl")
+set(paths_to_search "${DOWNLOADS}/tools/gas-preprocessor/${tool_subdirectory}")
+set(rename_binary_to "gas-preprocessor.pl")
+set(commit_id 9309c67acb535ca6248f092e96131d8eb07eefc1)
+set(download_urls "https://raw.githubusercontent.com/FFmpeg/gas-preprocessor/${commit_id}/gas-preprocessor.pl")
+string(SUBSTRING ${commit_id} 0 8 tool_subdirectory)
+set(download_filename "gas-preprocessor-${tool_subdirectory}.pl")
+set(download_sha512 b4749cf8aa758e3f28d4b21803422a5c2588f5fc48cfd317564606b374f8d739c636067cf7a4956d7365d63b055bc6e7626c304857e6c9013d6b4a0db9d8ad4f)
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GN).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GN).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..94b5690226cc53784194193797f464de73665fbb
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GN).cmake
@@ -0,0 +1,45 @@
+set(program_name gn)
+set(rename_binary_to "gn")
+if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/gn/version.txt")
+    file(READ "${CURRENT_HOST_INSTALLED_DIR}/share/gn/version.txt" program_version)
+    set(paths_to_search "${CURRENT_HOST_INSTALLED_DIR}/tools/gn")
+else() # Old behavior
+    message("Consider adding vcpkg-tool-gn as a host dependency of this port or create an issue at https://github.com/microsoft/vcpkg/issues")
+    set(cipd_download_gn "https://chrome-infra-packages.appspot.com/dl/gn/gn")
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+        EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE HOST_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(HOST_ARCH STREQUAL "aarch64")
+            set(program_version "GkfFAfAUyE-qfeWkdUMaeM1Ov64Fk3SjSj9pwKqZX7gC")
+            set(gn_platform "linux-arm64")
+            set(download_sha512 "E88201309A12C00CE60137261B8E1A759780C81D1925B819583B16D2095A16A7D32EFB2AF36C1E1D6EAA142BF6A6A811847D3140E4E94967EE28F4ADF6373E4B")
+        else()
+            set(program_version "Fv1ENXodhXmEXy_xpZr2gQkVJh57w_IsbsrEJOU0_EoC")
+            set(gn_platform "linux-amd64")
+            set(download_sha512 "A7A5CD5633C5547EC1B1A95958486DDAAC91F1A65881EDC0AD8F74DF44E82F08BA74358E9A72DFCDDE6F534A6B9C9A430D3E16ACE2E4346C4D2E9113F7654B3F")
+        endif()
+    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+        EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE HOST_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(HOST_ARCH STREQUAL "arm64")
+            set(program_version "qMPtGq7xZlpb-lHjP-SK27ftT4X71WIvguuyx6X14DEC")
+            set(gn_platform "mac-arm64")
+            set(download_sha512 "D096FB958D017807427911089AB5A7655AED117F6851C0491AC8063CEDB544423122EF64DF4264ECA86C20A2BDE9E64D7B72DA7ED8C95C2BA79A68B8247D36B8")
+        else()
+            set(program_version "0x2juPLNfP9603GIyZrUfflxK6LiMcppLAoxEpYuIYoC")
+            set(gn_platform "mac-amd64")
+            set(download_sha512 "2696ECE7B2C8008CABDDF10024017E2ECF875F8679424E77052252BDDC83A2096DF3C61D89CD25120EF27E0458C8914BEEED9D418593BDBC4F6ED33A8D4C3DC5")
+        endif()
+    else()
+        if("$ENV{PROCESSOR_ARCHITECTURE}" STREQUAL "ARM64")
+            set(program_version "q5ExVHmXyD34Q_Tzb-aRxsPipO-e37-csVRhVM7IJh0C")
+            set(gn_platform "windows-amd64")
+            set(download_sha512 "FA764AA44EB6F48ED50E855B4DC1DD1ABE35E45FD4AAC7F059A35293A14894C1B591215E34FB0CE9362E646EA9463BA3B489EFB7EBBAA2693D14238B50E4E686")
+        else() # AMD64
+            set(program_version "q5ExVHmXyD34Q_Tzb-aRxsPipO-e37-csVRhVM7IJh0C")
+            set(gn_platform "windows-amd64")
+            set(download_sha512 "FA764AA44EB6F48ED50E855B4DC1DD1ABE35E45FD4AAC7F059A35293A14894C1B591215E34FB0CE9362E646EA9463BA3B489EFB7EBBAA2693D14238B50E4E686")
+        endif()
+    endif()
+endif()
+set(tool_subdirectory "${program_version}")
+set(download_urls "${cipd_download_gn}/${gn_platform}/+/${program_version}")
+set(download_filename "gn-${gn_platform}.zip")
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GO).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GO).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d2e59abd88c725832fd669bb9b606a1b927bc9d9
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GO).cmake
@@ -0,0 +1,10 @@
+set(program_name go)
+set(brew_package_name "go")
+set(apt_package_name "golang-go")
+if(CMAKE_HOST_WIN32)
+    set(tool_subdirectory 1.21.1.windows-386)
+    set(paths_to_search "${DOWNLOADS}/tools/go/${tool_subdirectory}/go/bin")
+    set(download_urls "https://dl.google.com/go/go${tool_subdirectory}.zip")
+    set(download_filename "go${tool_subdirectory}.zip")
+    set(download_sha512 417a4bd95a10f21c2166badd2303e1956d91d0e783e334c99ea0176a323e815729c8c3af3f7ec68f057b757d06bcc75be82584031c4069c89a2db62bbfa902e8)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(NASM).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(NASM).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8e76bede81e69c2b397d9c0a2184b52ee89903e8
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(NASM).cmake
@@ -0,0 +1,13 @@
+set(program_name nasm)
+set(program_version 2.16.01)
+set(brew_package_name "nasm")
+set(apt_package_name "nasm")
+if(CMAKE_HOST_WIN32)
+    set(download_urls
+        "https://www.nasm.us/pub/nasm/releasebuilds/${program_version}/win64/nasm-${program_version}-win64.zip"
+        "https://gstreamer.freedesktop.org/src/mirror/nasm-${program_version}-win64.zip"
+    )
+    set(download_filename "nasm-${program_version}-win64.zip")
+    set(download_sha512 ce4d02f530dc3376b4513f219bbcec128ee5bebd8a5c332599b48d8071f803d1538d7258fec7c2e9b4d725b8d7314cea2696289d0493017eb13bfe70e5cb5062)
+    set(paths_to_search "${DOWNLOADS}/tools/nasm/nasm-${program_version}")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PERL).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PERL).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..aba77e4b046381284934929986c9118bc19dfcdd
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PERL).cmake
@@ -0,0 +1,13 @@
+set(program_name perl)
+set(program_version 5.38.0.1)
+set(brew_package_name "perl")
+set(apt_package_name "perl")
+if(CMAKE_HOST_WIN32)
+    set(download_urls
+        "https://github.com/StrawberryPerl/Perl-Dist-Strawberry/releases/download/SP_5380_5361/strawberry-perl-5.38.0.1-64bit-portable.zip"
+    )
+    set(download_filename "strawberry-perl-5.38.0.1-64bit-portable.zip")
+    set(download_sha512 9b604f19e245a809bd18857bd91ebaec81ca031394ec69a3369df64d3590d2c9d557326d8aa10f91e78b1f1d56689aa57a8ec3a8cad4d2e542c96eb714a3831d)
+    set(tool_subdirectory ${program_version})
+    set(paths_to_search ${DOWNLOADS}/tools/perl/${tool_subdirectory}/perl/bin)
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON2).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON2).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7e7905b175df18e0548aa09af8d75a6f61e8f40e
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON2).cmake
@@ -0,0 +1,27 @@
+if(CMAKE_HOST_WIN32)
+    set(program_name python)
+    set(program_version 2.7.18)
+    if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/vcpkg-tool-python2/details.cmake")
+        include("${CURRENT_HOST_INSTALLED_DIR}/share/vcpkg-tool-python2/details.cmake")
+    else() # Old behavior
+        if (VCPKG_TARGET_ARCHITECTURE STREQUAL x86)
+            set(tool_subdirectory "python-${program_version}-x86")
+            set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}.msi")
+            set(download_filename "python-${program_version}.msi")
+            set(download_sha512 2c112733c777ddbf189b0a54047a9d5851ebce0564cc38b9687d79ce6c7a09006109dbad8627fb1a60c3ad55e261db850d9dfa454af0533b460b2afc316fe115)
+        else()
+            set(tool_subdirectory "python-${program_version}-x64")
+            set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}.amd64.msi")
+            set(download_filename "python-${program_version}.amd64.msi")
+            set(download_sha512 6a81a413b80fd39893e7444fd47efa455d240cbb77a456c9d12f7cf64962b38c08cfa244cd9c50a65947c40f936c6c8c5782f7236d7b92445ab3dd01e82af23e)
+        endif()
+        set(paths_to_search "${DOWNLOADS}/tools/python/${tool_subdirectory}")
+    endif()
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+    # macOS includes Python 2.7 built-in as `python`
+    set(program_name python)
+    set(brew_package_name "python2")
+else()
+    set(program_name python2)
+    set(apt_package_name "python")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON3).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON3).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..cd2d4e4a0756754708a2acfa0e4810f9c756763b
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON3).cmake
@@ -0,0 +1,32 @@
+if(CMAKE_HOST_WIN32)
+    set(program_name python)
+    set(program_version 3.11.8)
+    if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(build_arch $ENV{PROCESSOR_ARCHITEW6432})
+    else()
+        set(build_arch $ENV{PROCESSOR_ARCHITECTURE})
+    endif()
+    if(build_arch MATCHES "^(ARM|arm)64$")
+        set(tool_subdirectory "python-${program_version}-arm64")
+        set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-arm64.zip")
+        set(download_filename "python-${program_version}-embed-arm64.zip")
+        set(download_sha512 42b820e34c4a77fe928e0af395292d804dcbf7e1132cf353ce6ce23435a687ec580f03ccbf3cd94d98c9dc5ac951f8ca64dbd65cded7ef1d675a39d63f8ace8d)
+    elseif(build_arch MATCHES "(amd|AMD)64")
+        set(tool_subdirectory "python-${program_version}-x64")
+        set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-amd64.zip")
+        set(download_filename "python-${program_version}-embed-amd64.zip")
+        set(download_sha512 da5f01e94d3505eebdfd4d2e70d9cf494925199024479cc29ef144567906b2e8ad55a855b199a755318f5fb9a260f21b987a5fc85f31acf631af4b677921251d)
+    else()
+        set(tool_subdirectory "python-${program_version}-x86")
+        set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-win32.zip")
+        set(download_filename "python-${program_version}-embed-win32.zip")
+        set(download_sha512 c88ef02f0860000dbc59361cfe051e3e8dc7d208ed39bb5bc20a3e8b8711b578926e281a11941787ea61b2ef05b945ab3133322dcb85b916f79ac4ada57f6309)
+    endif()
+
+    set(paths_to_search "${DOWNLOADS}/tools/python/${tool_subdirectory}")
+    vcpkg_list(SET post_install_command "${CMAKE_COMMAND}" -E rm python311._pth)
+else()
+    set(program_name python3)
+    set(brew_package_name "python")
+    set(apt_package_name "python3")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(RUBY).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(RUBY).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c955e6ad65b1887e0202402b291afa2a494da76f
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(RUBY).cmake
@@ -0,0 +1,8 @@
+set(program_name "ruby")
+set(program_version 2.7.4-1)
+if(CMAKE_HOST_WIN32)
+    set(download_urls "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-${program_version}/rubyinstaller-${program_version}-x86.7z")
+    set(download_filename "rubyinstaller-${program_version}-x86.7z")
+    set(download_sha512 4bf459c987b407bdda328c52d95060bf6ad48fc3e5ed5f64d4b205c5b4153c7a00cb6f9da6c0bcd5f2e001e9dc3dda0b72269ec4afdeffd658b93c085cd1d859)
+    set(paths_to_search "${DOWNLOADS}/tools/ruby/rubyinstaller-${program_version}-x86/bin")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SCONS).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SCONS).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e5056a9e76b3b229bc290019d2c311cdbaf57f87
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SCONS).cmake
@@ -0,0 +1,10 @@
+set(program_name scons)
+set(program_version 4.1.0)
+set(interpreter PYTHON2)
+set(search_names "scons.py")
+if(CMAKE_HOST_WIN32)
+    set(download_urls "https://sourceforge.net/projects/scons/files/scons-local-${program_version}.zip/download")
+    set(download_filename "scons-local-${program_version}.zip")
+    set(download_sha512 b173176ce8aca25039c64fcc68ec1b9ad31e03a926fd545e7631b3f9b374d914adffc593f505e3e7e2867b0ffe85e8deb0b39afe314edf05d02974ce5db1badb)
+    set(tool_subdirectory "${program_version}")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SWIG).cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SWIG).cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5189eda22b0fdfa2a96e06da9da58631ee2eb458
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SWIG).cmake
@@ -0,0 +1,16 @@
+set(program_version 4.0.2)
+set(program_name swig)
+if(CMAKE_HOST_WIN32)
+    set(download_filename "swigwin-${program_version}.zip")
+    set(download_sha512 "b8f105f9b9db6acc1f6e3741990915b533cd1bc206eb9645fd6836457fd30789b7229d2e3219d8e35f2390605ade0fbca493ae162ec3b4bc4e428b57155db03d")
+    vcpkg_list(SET sourceforge_args
+        REPO swig/swigwin
+        REF "swigwin-${program_version}"
+    )
+
+    set(tool_subdirectory "b8f105f9b9-f0518bc3b7")
+    set(paths_to_search "${DOWNLOADS}/tools/swig/b8f105f9b9-f0518bc3b7/swigwin-${program_version}")
+else()
+    set(apt_package_name "swig")
+    set(brew_package_name "swig")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_bitbucket.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_bitbucket.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..2cd9c998a84ee3f955f3ee09480b8c937798e542
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_bitbucket.cmake
@@ -0,0 +1,93 @@
+function(vcpkg_from_bitbucket)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "OUT_SOURCE_PATH;REPO;REF;SHA512;HEAD_REF"
+        "PATCHES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_from_bitbucket was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(DEFINED arg_REF AND NOT DEFINED arg_SHA512)
+        message(FATAL_ERROR "SHA512 must be specified if REF is specified.")
+    endif()
+    if(NOT DEFINED arg_REF AND DEFINED arg_SHA512)
+        message(FATAL_ERROR "REF must be specified if SHA512 is specified.")
+    endif()
+
+    if(NOT DEFINED arg_OUT_SOURCE_PATH)
+        message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
+    endif()
+    if(NOT DEFINED arg_REPO)
+        message(FATAL_ERROR "The Bitbucket repository must be specified.")
+    endif()
+
+    if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
+        message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified.")
+    endif()
+
+    if(NOT arg_REPO MATCHES "^([^/]*)/([^/]*)$")
+        message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name:
+    must be an organization name followed by a repository name separated by a single slash.")
+    endif()
+    set(org_name "${CMAKE_MATCH_1}")
+    set(repo_name "${CMAKE_MATCH_2}")
+
+    set(redownload_param "")
+    set(working_directory_param "")
+    set(sha512_param "SHA512" "${arg_SHA512}")
+    set(ref_to_use "${arg_REF}")
+    if(VCPKG_USE_HEAD_VERSION)
+        if(DEFINED arg_HEAD_REF)
+            set(redownload_param "ALWAYS_REDOWNLOAD")
+            set(sha512_param "SKIP_SHA512")
+            set(working_directory_param "WORKING_DIRECTORY" "${CURRENT_BUILDTREES_DIR}/src/head")
+            set(ref_to_use "${arg_HEAD_REF}")
+        else()
+            message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
+        endif()
+    elseif(NOT DEFINED arg_REF)
+        message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
+    endif()
+
+    # avoid using either - or _, to allow both `foo/bar` and `foo-bar` to coexist
+    # we assume that no one will name a ref "foo_-bar"
+    string(REPLACE "/" "_-" sanitized_ref "${ref_to_use}")
+    set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}.tar.gz")
+
+    # exports VCPKG_HEAD_VERSION to the caller. This will get picked up by ports.cmake after the build.
+    if(VCPKG_USE_HEAD_VERSION)
+        vcpkg_download_distfile(archive_version
+            URLS "https://api.bitbucket.com/2.0/repositories/${org_name}/${repo_name}/refs/branches/${arg_HEAD_REF}"
+            FILENAME "${downloaded_file_name}.version"
+            SKIP_SHA512
+            ALWAYS_REDOWNLOAD
+        )
+        # Parse the github refs response with regex.
+        # TODO: add json-pointer support to vcpkg
+        file(READ "${archive_version}" version_contents)
+        if(NOT version_contents MATCHES [["hash": "([a-f0-9]+)"]])
+            message(FATAL_ERROR "Failed to parse API response from '${version_url}':
+
+${version_contents}
+")
+        endif()
+        set(VCPKG_HEAD_VERSION "${CMAKE_MATCH_1}" PARENT_SCOPE)
+    endif()
+
+    # download the file information from bitbucket.
+    vcpkg_download_distfile(archive
+        URLS "https://bitbucket.com/${org_name}/${repo_name}/get/${ref_to_use}.tar.gz"
+        FILENAME "${downloaded_file_name}"
+        ${sha512_param}
+        ${redownload_param}
+    )
+    vcpkg_extract_source_archive_ex(
+        OUT_SOURCE_PATH SOURCE_PATH
+        ARCHIVE "${archive}"
+        REF "${sanitized_ref}"
+        PATCHES ${arg_PATCHES}
+        ${working_directory_param}
+    )
+    set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_git.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_git.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0b477acb822f09e980cca37ce12161c2ff68b2a0
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_git.cmake
@@ -0,0 +1,189 @@
+function(vcpkg_from_git)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "OUT_SOURCE_PATH;URL;REF;FETCH_REF;HEAD_REF;TAG;LFS"
+        "PATCHES"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_from_git was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(DEFINED arg_TAG)
+        message(WARNING "The TAG argument to vcpkg_from_git has been deprecated and has no effect.")
+    endif()
+
+    if(NOT DEFINED arg_OUT_SOURCE_PATH)
+        message(FATAL_ERROR "OUT_SOURCE_PATH must be specified")
+    endif()
+    if(NOT DEFINED arg_URL)
+        message(FATAL_ERROR "URL must be specified")
+    endif()
+    if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
+        message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified")
+    endif()
+    if(DEFINED arg_FETCH_REF AND NOT DEFINED arg_REF)
+        message(FATAL_ERROR "REF must be specified if FETCH_REF is specified")
+    endif()
+    if(NOT DEFINED arg_LFS AND "LFS" IN_LIST arg_KEYWORDS_MISSING_VALUES)
+        set(arg_LFS "${arg_URL}")
+    endif()
+
+    vcpkg_list(SET git_fetch_shallow_param --depth 1)
+    vcpkg_list(SET extract_working_directory_param)
+    vcpkg_list(SET skip_patch_check_param)
+    set(git_working_directory "${DOWNLOADS}/git-tmp")
+    set(do_download OFF)
+
+    if(VCPKG_USE_HEAD_VERSION AND DEFINED arg_HEAD_REF)
+        vcpkg_list(SET working_directory_param "WORKING_DIRECTORY" "${CURRENT_BUILDTREES_DIR}/src/head")
+        vcpkg_list(SET git_fetch_shallow_param --depth 1)
+        vcpkg_list(SET skip_patch_check_param SKIP_PATCH_CHECK)
+        set(ref_to_fetch "${arg_HEAD_REF}")
+        set(git_working_directory "${CURRENT_BUILDTREES_DIR}/src/git-tmp")
+        string(REPLACE "/" "_-" sanitized_ref "${arg_HEAD_REF}")
+
+        if(NOT _VCPKG_NO_DOWNLOADS)
+            set(do_download ON)
+        endif()
+    else()
+        if(NOT DEFINED arg_REF)
+            message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
+        endif()
+        if(VCPKG_USE_HEAD_VERSION)
+            message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
+        endif()
+
+        if(DEFINED arg_FETCH_REF)
+            set(ref_to_fetch "${arg_FETCH_REF}")
+            vcpkg_list(SET git_fetch_shallow_param)
+        else()
+            set(ref_to_fetch "${arg_REF}")
+        endif()
+        string(REPLACE "/" "_-" sanitized_ref "${arg_REF}")
+    endif()
+
+    set(temp_archive "${DOWNLOADS}/temp/${PORT}-${sanitized_ref}.tar.gz")
+    set(archive "${DOWNLOADS}/${PORT}-${sanitized_ref}.tar.gz")
+
+    if(NOT EXISTS "${archive}")
+        if(_VCPKG_NO_DOWNLOADS)
+            message(FATAL_ERROR "Downloads are disabled, but '${archive}' does not exist.")
+        endif()
+        set(do_download ON)
+    endif()
+
+    if(do_download)
+        message(STATUS "Fetching ${arg_URL} ${ref_to_fetch}...")
+        find_program(GIT NAMES git git.cmd)
+        file(MAKE_DIRECTORY "${DOWNLOADS}")
+        # Note: git init is safe to run multiple times
+        vcpkg_execute_required_process(
+            ALLOW_IN_DOWNLOAD_MODE
+            COMMAND "${GIT}" init "${git_working_directory}"
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}"
+            LOGNAME "git-init-${TARGET_TRIPLET}"
+        )
+        vcpkg_execute_required_process(
+            ALLOW_IN_DOWNLOAD_MODE
+            COMMAND "${GIT}" fetch "${arg_URL}" "${ref_to_fetch}" ${git_fetch_shallow_param} -n
+            WORKING_DIRECTORY "${git_working_directory}"
+            LOGNAME "git-fetch-${TARGET_TRIPLET}"
+        )
+        if(arg_LFS)
+            # Running "git lfs" searches for "git-lfs[.exe]" on the path
+            vcpkg_execute_in_download_mode(
+                COMMAND "${GIT}" lfs --version
+                OUTPUT_VARIABLE lfs_version_output
+                ERROR_VARIABLE lfs_version_error
+                RESULT_VARIABLE lfs_version_result
+                WORKING_DIRECTORY "${git_working_directory}"
+            )
+            if(lfs_version_result)
+                message(FATAL_ERROR "Git LFS is required for ${PORT}")
+            endif()
+
+            vcpkg_execute_required_process(
+                ALLOW_IN_DOWNLOAD_MODE
+                COMMAND "${GIT}" lfs install --local --force
+                WORKING_DIRECTORY "${git_working_directory}"
+                LOGNAME "git-lfs-install-${TARGET_TRIPLET}"
+            )
+            vcpkg_execute_required_process(
+                ALLOW_IN_DOWNLOAD_MODE
+                COMMAND "${GIT}" lfs fetch "${arg_LFS}" "${ref_to_fetch}"
+                WORKING_DIRECTORY "${git_working_directory}"
+                LOGNAME "git-lfs-fetch-${TARGET_TRIPLET}"
+            )
+        endif()
+
+        if(VCPKG_USE_HEAD_VERSION)
+            set(expected_rev_parse FETCH_HEAD)
+        else()
+            set(expected_rev_parse "${arg_REF}")
+        endif()
+
+        vcpkg_execute_in_download_mode(
+            COMMAND "${GIT}" rev-parse "${expected_rev_parse}"
+            OUTPUT_VARIABLE rev_parse_ref
+            ERROR_VARIABLE rev_parse_ref
+            RESULT_VARIABLE error_code
+            WORKING_DIRECTORY "${git_working_directory}"
+        )
+
+        if(error_code)
+            if(VCPKG_USE_HEAD_VERSION)
+                message(FATAL_ERROR "Unable to determine the commit SHA of the HEAD version to use after \
+fetching ${ref_to_fetch} from the git repository. (git rev-parse ${expected_rev_parse} failed)")
+            elseif(DEFINED arg_FETCH_REF)
+                message(FATAL_ERROR "After fetching ${ref_to_fetch}, the target ref ${expected_rev_parse} appears \
+inaccessible. A common cause of this failure is setting REF to a named branch or tag rather than a commit SHA. REF \
+must be a commit SHA. (git rev-parse ${expected_rev_parse} failed)")
+            else()
+                message(FATAL_ERROR "After fetching ${ref_to_fetch}, the target ref ${expected_rev_parse} appears \
+inaccessible. A common cause of this failure is setting REF to a named branch or tag rather than a commit SHA. REF \
+must be a commit SHA. If the git server does not advertise commit SHAs \
+(uploadpack.allowReachableSHA1InWant is false), you can set FETCH_REF to a named branch in which the desired commit \
+SHA is in the history. For example, you may be able to fix this error by changing \"REF ${arg_REF}\" to \
+\"REF a-commit-sha FETCH_REF ${arg_REF}\". (git rev-parse ${expected_rev_parse} failed)")
+            endif()
+        endif()
+
+        string(STRIP "${rev_parse_ref}" rev_parse_ref)
+        if(VCPKG_USE_HEAD_VERSION)
+            set(VCPKG_HEAD_VERSION "${rev_parse_ref}" PARENT_SCOPE)
+        elseif(NOT "${rev_parse_ref}" STREQUAL "${arg_REF}")
+                message(FATAL_ERROR "After fetching ${ref_to_fetch}, the requested REF (${arg_REF}) does not match \
+its commit SHA returned by git rev-parse (${rev_parse_ref}). This is usually caused by trying to set REF to a named \
+branch or tag rather than a commit SHA. REF must be a commit SHA. If the  git server does not advertise commit SHAs \
+(uploadpack.allowReachableSHA1InWant is false), you can set FETCH_REF to a named branch in which the desired commit \
+SHA is in the history. For example, you may be able to fix this error by changing \"REF ${arg_REF}\" to \
+\"REF a-commit-sha FETCH_REF ${arg_REF}\".
+    [Expected : ( ${arg_REF} )])
+    [  Actual : ( ${rev_parse_ref} )]"
+            )
+        endif()
+
+        file(MAKE_DIRECTORY "${DOWNLOADS}/temp")
+        vcpkg_execute_required_process(
+            ALLOW_IN_DOWNLOAD_MODE
+            COMMAND "${GIT}" -c core.autocrlf=false archive "${rev_parse_ref}" -o "${temp_archive}"
+            WORKING_DIRECTORY "${git_working_directory}"
+            LOGNAME git-archive
+        )
+        file(RENAME "${temp_archive}" "${archive}")
+    else()
+        message(STATUS "Using cached ${archive}")
+    endif()
+
+    vcpkg_extract_source_archive_ex(
+        OUT_SOURCE_PATH SOURCE_PATH
+        ARCHIVE "${archive}"
+        REF "${sanitized_ref}"
+        PATCHES ${arg_PATCHES}
+        NO_REMOVE_ONE_LEVEL
+        ${extract_working_directory_param}
+        ${skip_patch_check_param}
+    )
+
+    set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_github.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_github.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3b1af1a6210e650734439ec404af06b552274c41
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_github.cmake
@@ -0,0 +1,122 @@
+function(vcpkg_from_github)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "OUT_SOURCE_PATH;REPO;REF;SHA512;HEAD_REF;GITHUB_HOST;AUTHORIZATION_TOKEN;FILE_DISAMBIGUATOR"
+        "PATCHES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_from_github was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(DEFINED arg_REF AND NOT DEFINED arg_SHA512)
+        message(FATAL_ERROR "SHA512 must be specified if REF is specified.")
+    endif()
+    if(NOT DEFINED arg_REF AND DEFINED arg_SHA512)
+        message(FATAL_ERROR "REF must be specified if SHA512 is specified.")
+    endif()
+
+    if(NOT DEFINED arg_OUT_SOURCE_PATH)
+        message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
+    endif()
+    if(NOT DEFINED arg_REPO)
+        message(FATAL_ERROR "The GitHub repository must be specified.")
+    endif()
+
+    if(NOT DEFINED arg_GITHUB_HOST)
+        set(github_host "https://github.com")
+        set(github_api_url "https://api.github.com")
+    else()
+        set(github_host "${arg_GITHUB_HOST}")
+        set(github_api_url "${arg_GITHUB_HOST}/api/v3")
+    endif()
+
+    set(headers_param "")
+    if(DEFINED arg_AUTHORIZATION_TOKEN)
+        set(headers_param "HEADERS" "Authorization: token ${arg_AUTHORIZATION_TOKEN}")
+    endif()
+
+
+    if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
+        message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified.")
+    endif()
+
+    if(NOT arg_REPO MATCHES "^([^/]*)/([^/]*)$")
+        message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name:
+    must be an organization name followed by a repository name separated by a single slash.")
+    endif()
+    set(org_name "${CMAKE_MATCH_1}")
+    set(repo_name "${CMAKE_MATCH_2}")
+
+    if(VCPKG_USE_HEAD_VERSION AND NOT DEFINED arg_HEAD_REF)
+        message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
+        set(VCPKG_USE_HEAD_VERSION OFF)
+    elseif(NOT VCPKG_USE_HEAD_VERSION AND NOT DEFINED arg_REF)
+        message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
+    endif()
+
+    # exports VCPKG_HEAD_VERSION to the caller. This will get picked up by ports.cmake after the build.
+    if(VCPKG_USE_HEAD_VERSION)
+        string(REPLACE "/" "_-" sanitized_head_ref "${arg_HEAD_REF}")
+        vcpkg_download_distfile(archive_version
+            URLS "${github_api_url}/repos/${org_name}/${repo_name}/git/refs/heads/${arg_HEAD_REF}"
+            FILENAME "${org_name}-${repo_name}-${sanitized_head_ref}.version"
+            ${headers_param}
+            SKIP_SHA512
+            ALWAYS_REDOWNLOAD
+        )
+        # Parse the github refs response with regex.
+        file(READ "${archive_version}" version_contents)
+        string(JSON head_version
+            ERROR_VARIABLE head_version_err
+            GET "${version_contents}"
+            "object"
+            "sha"
+        )
+        if(NOT "${head_version_err}" STREQUAL "NOTFOUND")
+            message(FATAL_ERROR "Failed to parse API response from '${version_url}':
+${version_contents}
+
+Error was: ${head_version_err}
+")
+        endif()
+
+        set(VCPKG_HEAD_VERSION "${head_version}" PARENT_SCOPE)
+        set(ref_to_use "${head_version}")
+
+        vcpkg_list(SET redownload_param ALWAYS_REDOWNLOAD)
+        vcpkg_list(SET sha512_param SKIP_SHA512)
+        vcpkg_list(SET working_directory_param WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/src/head")
+        vcpkg_list(SET skip_patch_check_param SKIP_PATCH_CHECK)
+    else()
+        set(ref_to_use "${arg_REF}")
+
+        vcpkg_list(SET redownload_param)
+        vcpkg_list(SET working_directory_param)
+        vcpkg_list(SET skip_patch_check_param)
+        vcpkg_list(SET sha512_param SHA512 "${arg_SHA512}")
+    endif()
+
+    string(REPLACE "/" "_-" sanitized_ref "${ref_to_use}")
+    if(DEFINED arg_FILE_DISAMBIGUATOR AND NOT VCPKG_USE_HEAD_REF)
+        set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}-${arg_FILE_DISAMBIGUATOR}.tar.gz")
+    else()
+        set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}.tar.gz")
+    endif()
+    # Try to download the file information from github
+    vcpkg_download_distfile(archive
+        URLS "${github_host}/${org_name}/${repo_name}/archive/${ref_to_use}.tar.gz"
+        FILENAME "${downloaded_file_name}"
+        ${headers_param}
+        ${sha512_param}
+        ${redownload_param}
+    )
+    vcpkg_extract_source_archive_ex(
+        OUT_SOURCE_PATH SOURCE_PATH
+        ARCHIVE "${archive}"
+        REF "${sanitized_ref}"
+        PATCHES ${arg_PATCHES}
+        ${working_directory_param}
+        ${skip_patch_check_param}
+    )
+    set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_cmake.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_cmake.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..df7d7bf6162f53dcd124e990a53e9263530ac4d1
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_cmake.cmake
@@ -0,0 +1,23 @@
+function(vcpkg_install_cmake)
+    if(Z_VCPKG_CMAKE_INSTALL_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_install_cmake in the same port is unsupported.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "DISABLE_PARALLEL;ADD_BIN_TO_PATH" "" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_cmake_install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    vcpkg_list(SET params)
+    foreach(arg IN ITEMS DISABLE_PARALLEL ADD_BIN_TO_PATH)
+        if(arg_${arg})
+            vcpkg_list(APPEND params "${arg}")
+        endif()
+    endforeach()
+
+    vcpkg_build_cmake(Z_VCPKG_DISABLE_DEPRECATION MESSAGE
+        ${params}
+        LOGFILE_ROOT install
+        TARGET install
+    )
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_gn.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_gn.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5d96cbd9461607e1f482abe547b79f1c71b32928
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_gn.cmake
@@ -0,0 +1,118 @@
+function(z_vcpkg_install_gn_get_target_type out_var)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "SOURCE_PATH;BUILD_DIR;TARGET" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: get_target_type was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    execute_process(
+        COMMAND "${GN}" desc "${arg_BUILD_DIR}" "${arg_TARGET}"
+        WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+        OUTPUT_VARIABLE output
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(output MATCHES [[type: ([A-Za-z0-9_]+)]])
+        set("${out_var}" "${CMAKE_MATCH_1}" PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "invalid result from `gn desc`: ${output}")
+    endif()
+endfunction()
+
+function(z_vcpkg_install_gn_get_desc out_var)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "SOURCE_PATH;BUILD_DIR;TARGET;WHAT_TO_DISPLAY" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: get_desc was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    execute_process(
+        COMMAND "${GN}" desc "${arg_BUILD_DIR}" "${arg_TARGET}" "${arg_WHAT_TO_DISPLAY}"
+        WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+        OUTPUT_VARIABLE output
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    string(REPLACE ";" "\\;" output "${output}")
+    string(REGEX REPLACE "\n|(\r\n)" ";" output "${output}")
+    set("${out_var}" "${output}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_install_gn_install)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;BUILD_DIR;INSTALL_DIR" "TARGETS")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    foreach(target IN LISTS arg_TARGETS)
+        # GN targets must start with a //
+        z_vcpkg_install_gn_get_desc(outputs
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${arg_BUILD_DIR}"
+            TARGET "//${target}"
+            WHAT_TO_DISPLAY outputs
+        )
+        z_vcpkg_install_gn_get_target_type(target_type
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${arg_BUILD_DIR}"
+            TARGET "//${target}"
+        )
+
+        foreach(output IN LISTS outputs)
+            if(output MATCHES "^//")
+                # relative path (e.g. //out/Release/target.lib)
+                string(REGEX REPLACE "^//" "${arg_SOURCE_PATH}/" output "${output}")
+            elseif(output MATCHES "^/" AND CMAKE_HOST_WIN32)
+                # absolute path (e.g. /C:/path/to/target.lib)
+                string(REGEX REPLACE "^/" "" output "${output}")
+            endif()
+
+            if(NOT EXISTS "${output}")
+                message(WARNING "Output for target `${target}` doesn't exist: ${output}.")
+                continue()
+            endif()
+
+            if(target_type STREQUAL "executable")
+                file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/tools")
+            elseif(output MATCHES "(\\.dll|\\.pdb)$")
+                file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/bin")
+            else()
+                file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/lib")
+            endif()
+        endforeach()
+    endforeach()
+endfunction()
+
+function(vcpkg_install_gn)
+    if(Z_VCPKG_GN_INSTALL_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-gn; using both vcpkg-gn and vcpkg_install_gn in the same port is unsupported.")
+    else()
+        message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "This function 'vcpkg_install_gn' is obsolete. Use 'vcpkg_gn_install' in port 'vcpkg-gn'.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "SOURCE_PATH" "TARGETS")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_install_gn was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_SOURCE_PATH)
+        message(FATAL_ERROR "SOURCE_PATH must be specified.")
+    endif()
+
+    vcpkg_build_ninja(TARGETS ${arg_TARGETS})
+
+    vcpkg_find_acquire_program(GN)
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        z_vcpkg_install_gn_install(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+            INSTALL_DIR "${CURRENT_PACKAGES_DIR}/debug"
+            TARGETS ${arg_TARGETS}
+        )
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        z_vcpkg_install_gn_install(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+            INSTALL_DIR "${CURRENT_PACKAGES_DIR}"
+            TARGETS ${arg_TARGETS}
+        )
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_make.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_make.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..281b6237a06c9a3357a048f27efce9c697618ae3
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_make.cmake
@@ -0,0 +1,7 @@
+function(vcpkg_install_make)
+    vcpkg_build_make(
+        ${ARGN}
+        LOGFILE_ROOT
+        ENABLE_INSTALL
+    )
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_qmake.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_qmake.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c665486273106f7383d25b29e745b84ca975d028
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_qmake.cmake
@@ -0,0 +1,45 @@
+function(vcpkg_install_qmake)
+    z_vcpkg_function_arguments(args)
+
+    vcpkg_build_qmake(${args})
+
+    file(GLOB_RECURSE release_libs
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.lib"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.a"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.so"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.so.*"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.dylib"
+    )
+    file(GLOB_RECURSE release_bins
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.dll"
+    )
+    file(GLOB_RECURSE debug_libs
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.lib"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.a"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.so"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.so.*"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.dylib"
+    )
+    file(GLOB_RECURSE debug_bins
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.dll"
+    )
+    if("${release_libs}" STREQUAL "" AND "${debug_libs}" STREQUAL "")
+        message(FATAL_ERROR "Build did not appear to produce any libraries. If this is intended, use `vcpkg_build_qmake()` directly.")
+    endif()
+    if(NOT "${release_libs}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/lib")
+        file(COPY ${release_libs} DESTINATION "${CURRENT_PACKAGES_DIR}/lib")
+    endif()
+    if(NOT "${debug_libs}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/debug/lib")
+        file(COPY ${debug_libs} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/lib")
+    endif()
+    if(NOT "${release_bins}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/bin")
+        file(COPY ${release_bins} DESTINATION "${CURRENT_PACKAGES_DIR}/bin")
+    endif()
+    if(NOT "${debug_bins}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/debug/bin")
+        file(COPY ${debug_bins} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/bin")
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_apply_patches.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_apply_patches.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9a270ba2b36638932bbb7dd9a44207c86743e91a
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_apply_patches.cmake
@@ -0,0 +1,45 @@
+function(z_vcpkg_apply_patches)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "QUIET" "SOURCE_PATH" "PATCHES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "internal error: z_vcpkg_apply_patches was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    find_program(GIT NAMES git git.cmd REQUIRED)
+    if(DEFINED ENV{GIT_CONFIG_NOSYSTEM})
+        set(git_config_nosystem_backup "$ENV{GIT_CONFIG_NOSYSTEM}")
+    else()
+        unset(git_config_nosystem_backup)
+    endif()
+
+    set(ENV{GIT_CONFIG_NOSYSTEM} 1)
+    set(patchnum 0)
+    foreach(patch IN LISTS arg_PATCHES)
+        get_filename_component(absolute_patch "${patch}" ABSOLUTE BASE_DIR "${CURRENT_PORT_DIR}")
+        message(STATUS "Applying patch ${patch}")
+        set(logname "patch-${TARGET_TRIPLET}-${patchnum}")
+        vcpkg_execute_in_download_mode(
+            COMMAND "${GIT}" -c core.longpaths=true -c core.autocrlf=false -c core.filemode=true --work-tree=. --git-dir=.git apply "${absolute_patch}" --ignore-whitespace --whitespace=nowarn --verbose
+            OUTPUT_FILE "${CURRENT_BUILDTREES_DIR}/${logname}-out.log"
+            ERROR_VARIABLE error
+            WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+            RESULT_VARIABLE error_code
+        )
+        file(WRITE "${CURRENT_BUILDTREES_DIR}/${logname}-err.log" "${error}")
+
+        if(error_code)
+            if(arg_QUIET)
+                message(STATUS "Applying patch ${patch} - failure silenced")
+            else()
+                message(FATAL_ERROR "Applying patch failed: ${error}")
+            endif()
+        endif()
+
+        math(EXPR patchnum "${patchnum} + 1")
+    endforeach()
+    if(DEFINED git_config_nosystem_backup)
+        set(ENV{GIT_CONFIG_NOSYSTEM} "${git_config_nosystem_backup}")
+    else()
+        unset(ENV{GIT_CONFIG_NOSYSTEM})
+    endif()
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_escape_regex_control_characters.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_escape_regex_control_characters.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b238f0088d5221d99c101e8aff105733ff436312
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_escape_regex_control_characters.cmake
@@ -0,0 +1,8 @@
+function(z_vcpkg_escape_regex_control_characters out_var string)
+    if(ARGC GREATER "2")
+        message(FATAL_ERROR "z_vcpkg_escape_regex_control_characters passed extra arguments: ${ARGN}")
+    endif()
+    # uses | instead of [] to avoid confusion; additionally, CMake doesn't support `]` in a `[]`
+    string(REGEX REPLACE [[\[|\]|\(|\)|\.|\+|\*|\^|\\|\$|\?|\|]] [[\\\0]] escaped_content "${string}")
+    set("${out_var}" "${escaped_content}" PARENT_SCOPE)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_forward_output_variable.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_forward_output_variable.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1177ef36cf763a4daab51664eeb385f3a7c3a5ac
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_forward_output_variable.cmake
@@ -0,0 +1,12 @@
+macro(z_vcpkg_forward_output_variable ptr_to_parent_var var_to_forward)
+    if("${ARGC}" GREATER "2")
+        message(FATAL_ERROR "z_vcpkg_forward_output_variable was passed extra arguments: ${ARGN}")
+    endif()
+    if(DEFINED "${ptr_to_parent_var}")
+        if(DEFINED "${var_to_forward}")
+            set("${${ptr_to_parent_var}}" "${${var_to_forward}}" PARENT_SCOPE)
+        else()
+            unset("${${ptr_to_parent_var}}" PARENT_SCOPE)
+        endif()
+    endif()
+endmacro()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_get_cmake_vars.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_get_cmake_vars.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..51e0f03a9142e0c851cadaf956ac8d8d84e1fb79
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/cmake/z_vcpkg_get_cmake_vars.cmake
@@ -0,0 +1,38 @@
+function(z_vcpkg_get_cmake_vars out_file)
+    cmake_parse_arguments(PARSE_ARGV 1 arg "" "" "")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(DEFINED VCPKG_BUILD_TYPE)
+        set(cmake_vars_file "${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-${VCPKG_BUILD_TYPE}.cmake.log")
+        set(cache_var "Z_VCPKG_GET_CMAKE_VARS_FILE_${VCPKG_BUILD_TYPE}")
+    else()
+        set(cmake_vars_file "${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}.cmake.log")
+        set(cache_var Z_VCPKG_GET_CMAKE_VARS_FILE)
+    endif()
+    if(NOT DEFINED CACHE{${cache_var}})
+        set(${cache_var}  "${cmake_vars_file}"
+            CACHE PATH "The file to include to access the CMake variables from a generated project.")
+        vcpkg_configure_cmake(
+            SOURCE_PATH "${SCRIPTS}/get_cmake_vars"
+            OPTIONS_DEBUG "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-dbg.cmake.log"
+            OPTIONS_RELEASE "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-rel.cmake.log"
+            PREFER_NINJA
+            LOGNAME get-cmake-vars-${TARGET_TRIPLET}
+            Z_GET_CMAKE_VARS_USAGE # ignore vcpkg_cmake_configure, be quiet, don't set variables...
+        )
+
+        set(include_string "")
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+            string(APPEND include_string "include(\"\${CMAKE_CURRENT_LIST_DIR}/cmake-vars-${TARGET_TRIPLET}-rel.cmake.log\")\n")
+        endif()
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+            string(APPEND include_string "include(\"\${CMAKE_CURRENT_LIST_DIR}/cmake-vars-${TARGET_TRIPLET}-dbg.cmake.log\")\n")
+        endif()
+        file(WRITE "${cmake_vars_file}" "${include_string}")
+    endif()
+
+    set("${out_file}" "${${cache_var}}" PARENT_SCOPE)
+endfunction()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/outcome-run-tests/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/outcome-run-tests/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..065116c276adcf960cd9ad806097da3f199e2241
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/outcome-run-tests/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/outcome-run-tests/vcpkg.json b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/outcome-run-tests/vcpkg.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a203953af182f663a801b3b324411025caf11a8
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/outcome-run-tests/vcpkg.json
@@ -0,0 +1,15 @@
+{
+  "name": "outcome-run-tests",
+  "version-string": "0",
+  "port-version": 1,
+  "description": "Ensures that outcome built with vcpkg version of dependencies produces working executables.",
+  "supports": "x64",
+  "dependencies": [
+    {
+      "name": "outcome",
+      "features": [
+        "run-tests"
+      ]
+    }
+  ]
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..976357a5a3f4d6ef1aeddf735239c92ed6f6b2fd
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/portfile.cmake
@@ -0,0 +1,194 @@
+function(set_fatal_error err)
+    set(Z_VCPKG_UNIT_TEST_HAS_FATAL_ERROR "ON" CACHE BOOL "" FORCE)
+    set(Z_VCPKG_UNIT_TEST_FATAL_ERROR "${err}" CACHE STRING "" FORCE)
+endfunction()
+function(unset_fatal_error)
+    set(Z_VCPKG_UNIT_TEST_HAS_FATAL_ERROR "OFF" CACHE BOOL "" FORCE)
+endfunction()
+function(set_has_error)
+    set(Z_VCPKG_UNIT_TEST_HAS_ERROR ON CACHE BOOL "" FORCE)
+endfunction()
+
+macro(message level msg)
+    if("${level}" STREQUAL "FATAL_ERROR")
+        set_fatal_error("${msg}")
+        return()
+    else()
+        _message("${level}" "${msg}") # note: this results in incorrect printing, but that's fine
+        # message(STATUS "\${asdf}") will result in
+        # message(STATUS "${asdf}"), since that's how macro arguments work.
+    endif()
+endmacro()
+
+set(Z_VCPKG_UNIT_TEST_HAS_ERROR OFF CACHE BOOL "" FORCE)
+unset_fatal_error()
+
+# in order to allow namespacing
+function(unit_test_match namespace value regex)
+    if("${value}" MATCHES "${regex}")
+        set("${namespace}_MATCHED" ON PARENT_SCOPE)
+        if("${CMAKE_MATCH_COUNT}" EQUAL "0")
+            return()
+        endif()
+
+        foreach(match RANGE 1 "${CMAKE_MATCH_COUNT}")
+            set("${namespace}_CMAKE_MATCH_${match}" "${CMAKE_MATCH_${match}}" PARENT_SCOPE)
+        endforeach()
+    else()
+        set("${namespace}_MATCHED" OFF PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(unit_test_check_variable_unset utcvu_test utcvu_variable)
+    cmake_language(EVAL CODE "${utcvu_test}")
+    if(Z_VCPKG_UNIT_TEST_HAS_FATAL_ERROR)
+        unset_fatal_error()
+        set_has_error()
+        message(SEND_ERROR "${utcvu_test} had an unexpected FATAL_ERROR;
+    expected: \"${utcvu_value}\"")
+        message(SEND_ERROR "FATAL_ERROR: ${Z_VCPKG_UNIT_TEST_FATAL_ERROR}")
+        return()
+    endif()
+
+    unit_test_match(utcvu "${utcvu_variable}" [[^(ENV|CACHE)\{(.*)\}$]])
+    if(utcvu_MATCHED)
+        message(STATUS "utcvu_variable: ${utcvu_CMAKE_MATCH_2}")
+        if("${utcvu_CMAKE_MATCH_1}" STREQUAL "ENV")
+            set(utcvu_actual_value "$ENV{${utcvu_CMAKE_MATCH_2}}")
+        elseif("${utcvu_CMAKE_MATCH_1}" STREQUAL "CACHE")
+            set(utcvu_actual_value "$CACHE{${utcvu_CMAKE_MATCH_2}}")
+        else()
+            _message(FATAL_ERROR "unexpected value for CMAKE_MATCH_1: ${utcvu_CMAKE_MATCH_1}")
+        endif()
+    else()
+        set(utcvu_actual_value "${${utcvu_variable}}")
+    endif()
+
+    if(DEFINED "${utcvu_variable}")
+        message(SEND_ERROR "${utcvu_test} set ${utcvu_variable};
+    expected: \"${utcvu_variable}\" unset
+    actual  : \"${utcvu_actual_value}\"")
+        set_has_error()
+        return()
+    endif()
+endfunction()
+
+function(unit_test_check_variable_equal utcve_test utcve_variable utcve_value)
+    cmake_language(EVAL CODE "${utcve_test}")
+    if(Z_VCPKG_UNIT_TEST_HAS_FATAL_ERROR)
+        unset_fatal_error()
+        set_has_error()
+        message(SEND_ERROR "${utcve_test} had an unexpected FATAL_ERROR;
+    expected: \"${utcve_value}\"")
+        message(SEND_ERROR "FATAL_ERROR: ${Z_VCPKG_UNIT_TEST_FATAL_ERROR}")
+        return()
+    endif()
+
+    if(NOT DEFINED "${utcve_variable}" AND NOT "${utcve_variable}" MATCHES "^ENV\\{")
+        message(SEND_ERROR "${utcve_test} failed to set ${utcve_variable};
+    expected: \"${utcve_value}\"")
+        set_has_error()
+        return()
+    endif()
+
+    unit_test_match(utcve "${utcve_variable}" [[^(ENV|CACHE)\{(.*)\}$]])
+    if(utcve_MATCHED)
+        if("${utcve_CMAKE_MATCH_1}" STREQUAL "ENV")
+            set(utcve_actual_value "$ENV{${utcve_CMAKE_MATCH_2}}")
+        elseif("${utcve_CMAKE_MATCH_1}" STREQUAL "CACHE")
+            set(utcve_actual_value "$CACHE{${utcve_CMAKE_MATCH_2}}")
+        else()
+            _message(FATAL_ERROR "unexpected value for CMAKE_MATCH_1: ${utcve_CMAKE_MATCH_1}")
+        endif()
+    else()
+        set(utcve_actual_value "${${utcve_variable}}")
+    endif()
+
+    if(NOT "${utcve_actual_value}" STREQUAL "${utcve_value}")
+        message(SEND_ERROR "${utcve_test} resulted in the wrong value for ${utcve_variable};
+    expected: \"${utcve_value}\"
+    actual  : \"${utcve_actual_value}\"")
+        set_has_error()
+        return()
+    endif()
+endfunction()
+
+function(unit_test_check_variable_not_equal utcve_test utcve_variable utcve_value)
+    cmake_language(EVAL CODE "${utcve_test}")
+    if(Z_VCPKG_UNIT_TEST_HAS_FATAL_ERROR)
+        unset_fatal_error()
+        set_has_error()
+        message(SEND_ERROR "${utcve_test} had an unexpected FATAL_ERROR;
+    expected: \"${utcve_value}\"")
+        message(SEND_ERROR "FATAL_ERROR: ${Z_VCPKG_UNIT_TEST_FATAL_ERROR}")
+        return()
+    endif()
+
+    unit_test_match(utcve "${utcve_variable}" [[^(ENV|CACHE)\{(.*)\}$]])
+    if(utcve_MATCHED)
+        if("${utcve_CMAKE_MATCH_1}" STREQUAL "ENV")
+            set(utcve_actual_value "$ENV{${utcve_CMAKE_MATCH_2}}")
+        elseif("${utcve_CMAKE_MATCH_1}" STREQUAL "CACHE")
+            set(utcve_actual_value "$CACHE{${utcve_CMAKE_MATCH_2}}")
+        else()
+            _message(FATAL_ERROR "unexpected value for CMAKE_MATCH_1: ${utcve_CMAKE_MATCH_1}")
+        endif()
+    else()
+        set(utcve_actual_value "${${utcve_variable}}")
+    endif()
+
+    if("${utcve_actual_value}" STREQUAL "${utcve_value}")
+        message(SEND_ERROR "${utcve_test} failed to change ${utcve_variable};
+    unchanged: \"${utcve_value}\"")
+        set_has_error()
+        return()
+    endif()
+endfunction()
+
+function(unit_test_ensure_success utcve_test)
+    cmake_language(EVAL CODE "${utcve_test}")
+    if(Z_VCPKG_UNIT_TEST_HAS_FATAL_ERROR)
+        set_has_error()
+        message(SEND_ERROR "${utcve_test} was expected to be successful.")
+    endif()
+    unset_fatal_error()
+endfunction()
+function(unit_test_ensure_fatal_error utcve_test)
+    cmake_language(EVAL CODE "${utcve_test}")
+    if(NOT Z_VCPKG_UNIT_TEST_HAS_FATAL_ERROR)
+        set_has_error()
+        message(SEND_ERROR "${utcve_test} was expected to be a FATAL_ERROR.")
+    endif()
+    unset_fatal_error()
+endfunction()
+
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
+
+if("minimum-required" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-vcpkg_minimum_required.cmake")
+endif()
+if("list" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-vcpkg_list.cmake")
+endif()
+if("host-path-list" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-vcpkg_host_path_list.cmake")
+endif()
+if("function-arguments" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-z_vcpkg_function_arguments.cmake")
+endif()
+if("merge-libs" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-z_vcpkg_cmake_config_fixup_merge.cmake")
+endif()
+if("backup-restore-env-vars" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-vcpkg_backup_restore_env_vars.cmake")
+endif()
+if("setup-pkgconfig-path" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-z_vcpkg_setup_pkgconfig_path.cmake")
+endif()
+if("fixup-pkgconfig" IN_LIST FEATURES)
+    include("${CMAKE_CURRENT_LIST_DIR}/test-vcpkg_fixup_pkgconfig.cmake")
+endif()
+
+if(Z_VCPKG_UNIT_TEST_HAS_ERROR)
+    _message(FATAL_ERROR "At least one test failed")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_backup_restore_env_vars.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_backup_restore_env_vars.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ae010b3c6d8d9052872dcca278dbf858d168d55d
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_backup_restore_env_vars.cmake
@@ -0,0 +1,38 @@
+# vcpkg_backup_env_variables(VARS <list>)
+# vcpkg_restore_env_variables(VARS <list>)
+# These functions used scoped variables and cannot be called in unit_test_check_*.
+
+set(ENV{A} [[::a;::b]])
+set(ENV{B} [[]])
+
+# Backup doesn't change variables.
+vcpkg_backup_env_variables(VARS A B)
+unit_test_check_variable_equal([[]] ENV{A} [[::a;::b]])
+unit_test_check_variable_equal([[]] ENV{B} [[]])
+
+# Restore restores.
+set(ENV{A} [[::a;::b;::c]])
+set(ENV{B} [[::1]])
+vcpkg_restore_env_variables(VARS A B)
+unit_test_check_variable_equal([[]] ENV{A} [[::a;::b]])
+unit_test_check_variable_equal([[]] ENV{B} [[]])
+
+# Restore can be called more than once.
+set(ENV{A} [[::a;::b;::c]])
+set(ENV{B} [[::1]])
+vcpkg_restore_env_variables(VARS A B)
+unit_test_check_variable_equal([[]] ENV{A} [[::a;::b]])
+unit_test_check_variable_equal([[]] ENV{B} [[]])
+
+# Backups are scoped.
+function(change_and_backup)
+    set(ENV{A} [[::a;::b;::c]])
+    set(ENV{B} [[::1]])
+    vcpkg_backup_env_variables(VARS A B)
+    # no further change, no restore, in this scope
+endfunction()
+vcpkg_backup_env_variables(VARS A B)
+change_and_backup()
+vcpkg_restore_env_variables(VARS A B)
+unit_test_check_variable_equal([[]] ENV{A} [[::a;::b]])
+unit_test_check_variable_equal([[]] ENV{B} [[]])
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_host_path_list.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_host_path_list.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..01d34da8232d268a86ccc190c1eb7a4479bf6622
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_host_path_list.cmake
@@ -0,0 +1,281 @@
+# CACHE{var} is a fatal error
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(APPEND CACHE{var})]])
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(PREPEND CACHE{var})]])
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(APPEND CACHE{var} c d)]])
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(PREPEND CACHE{var} c d)]])
+
+# regular variable, HOST_PATH_SEPARATOR = ';'
+set(VCPKG_HOST_PATH_SEPARATOR ";")
+
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(APPEND var "a;b")]])
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(PREPEND var "a;b")]])
+
+set(var "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND var d e)]]
+    var "a;b;d;e"
+)
+set(var "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND var)]]
+    var "a;b"
+)
+set(var "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND var d e)]]
+    var "d;e;a;b"
+)
+set(var "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND var)]]
+    var "a;b"
+)
+
+set(var "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND var d e)]]
+    var "d;e"
+)
+set(var "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND var)]]
+    var ""
+)
+set(var "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND var d e)]]
+    var "d;e"
+)
+set(var "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND var)]]
+    var ""
+)
+
+unset(var)
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND var d e)]]
+    var "d;e"
+)
+unset(var)
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND var)]]
+    var ""
+)
+unset(var)
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND var d e)]]
+    var "d;e"
+)
+unset(var)
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND var)]]
+    var ""
+)
+
+# regular variable, HOST_PATH_SEPARATOR = ':'
+set(VCPKG_HOST_PATH_SEPARATOR ":")
+
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(APPEND var "a:b")]])
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(PREPEND var "a:b")]])
+
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var} d e)]]
+    ENV{var} "a:b:d:e"
+)
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var})]]
+    ENV{var} "a:b"
+)
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var} d e)]]
+    ENV{var} "d:e:a:b"
+)
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var})]]
+    ENV{var} "a:b"
+)
+
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var})]]
+    ENV{var} ""
+)
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var})]]
+    ENV{var} ""
+)
+
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var})]]
+    ENV{var} ""
+)
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var})]]
+    ENV{var} ""
+)
+
+# environment ENV{var}iable, HOST_PATH_SEPARATOR = ';'
+set(VCPKG_HOST_PATH_SEPARATOR ";")
+
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(APPEND ENV{ENV{var}} "a;b")]])
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(PREPEND ENV{ENV{var}} "a;b")]])
+
+set(ENV{ENV{var}} "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{ENV{var}} d e)]]
+    ENV{ENV{var}} "a;b;d;e"
+)
+set(ENV{ENV{var}} "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{ENV{var}})]]
+    ENV{ENV{var}} "a;b"
+)
+set(ENV{ENV{var}} "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{ENV{var}} d e)]]
+    ENV{ENV{var}} "d;e;a;b"
+)
+set(ENV{ENV{var}} "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{ENV{var}})]]
+    ENV{ENV{var}} "a;b"
+)
+
+set(ENV{ENV{var}} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{ENV{var}} d e)]]
+    ENV{ENV{var}} "d;e"
+)
+set(ENV{ENV{var}} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{ENV{var}})]]
+    ENV{ENV{var}} ""
+)
+set(ENV{ENV{var}} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{ENV{var}} d e)]]
+    ENV{ENV{var}} "d;e"
+)
+set(ENV{ENV{var}} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var})]]
+    ENV{ENV{var}} ""
+)
+
+unset(ENV{ENV{var}})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{ENV{var}} d e)]]
+    ENV{ENV{var}} "d;e"
+)
+unset(ENV{ENV{var}})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{ENV{var}})]]
+    ENV{ENV{var}} ""
+)
+unset(ENV{ENV{var}})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{ENV{var}} d e)]]
+    ENV{ENV{var}} "d;e"
+)
+unset(ENV{ENV{var}})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{ENV{var}})]]
+    ENV{ENV{var}} ""
+)
+
+# regular ENV{var}iable, HOST_PATH_SEPARATOR = ':'
+set(VCPKG_HOST_PATH_SEPARATOR ":")
+
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(APPEND ENV{var} "a:b")]])
+unit_test_ensure_fatal_error([[vcpkg_host_path_list(PREPEND ENV{var} "a:b")]])
+
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var} d e)]]
+    ENV{var} "a:b:d:e"
+)
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var})]]
+    ENV{var} "a:b"
+)
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var} d e)]]
+    ENV{var} "d:e:a:b"
+)
+set(ENV{var} "a:b")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var})]]
+    ENV{var} "a:b"
+)
+
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var})]]
+    ENV{var} ""
+)
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+set(ENV{var} "")
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var})]]
+    ENV{var} ""
+)
+
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(APPEND ENV{var})]]
+    ENV{var} ""
+)
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var} d e)]]
+    ENV{var} "d:e"
+)
+unset(ENV{var})
+unit_test_check_variable_equal(
+    [[vcpkg_host_path_list(PREPEND ENV{var})]]
+    ENV{var} ""
+)
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_list.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_list.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c0f3ac8c07ecbdd3daa10c1db231a1d0c1c6cd27
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-vcpkg_list.cmake
@@ -0,0 +1,813 @@
+# vcpkg_list(SET <list> <elements>...)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SET lst)]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SET lst "")]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SET lst "" "")]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SET lst a)]]
+    lst "a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SET lst a b)]]
+    lst "a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SET lst "a;b")]]
+    lst [[a\;b]]
+)
+unit_test_check_variable_equal(
+    [=[vcpkg_list(SET lst "a;b" "c" [[d\;e]])]=]
+    lst [[a\;b;c;d\\;e]]
+)
+
+# vcpkg_list(LENGTH <list> <out-var>)
+set(lst [[]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(LENGTH lst out)]]
+    out 0
+)
+set(lst [[;]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(LENGTH lst out)]]
+    out 2
+)
+set(lst [[a]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(LENGTH lst out)]]
+    out 1
+)
+set(lst [[a;b]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(LENGTH lst out)]]
+    out 2
+)
+set(lst [[a\\;b]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(LENGTH lst out)]]
+    out 1
+)
+set(lst [[a\;b;c\\;d]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(LENGTH lst out)]]
+    out 2
+)
+
+# vcpkg_list(GET <list> <element-index> <out-var>)
+set(lst "")
+unit_test_ensure_fatal_error([[vcpkg_list(GET lst 0 out)]])
+
+set(lst "a")
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst 0 out)]]
+    out "a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst -1 out)]]
+    out "a"
+)
+unit_test_ensure_fatal_error([[vcpkg_list(GET lst 2 out)]])
+unit_test_ensure_fatal_error([[vcpkg_list(GET lst -2 out)]])
+
+set(lst ";b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst 0 out)]]
+    out ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst -1 out)]]
+    out "b"
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst 0 out)]]
+    out "a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst -1 out)]]
+    out "b"
+)
+
+set(lst [[a\;b;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst 0 out)]]
+    out "a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst -1 out)]]
+    out "c"
+)
+
+set(lst [[a;b\;c;d\\;e]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst 1 out)]]
+    out "b;c"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(GET lst -1 out)]]
+    out [[d\;e]]
+)
+
+# vcpkg_list(JOIN <list> <glue> <out-var>)
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(JOIN lst "-" out)]]
+    out ""
+)
+
+set(lst "a")
+unit_test_check_variable_equal(
+    [[vcpkg_list(JOIN lst "-" out)]]
+    out "a"
+)
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(JOIN lst "-" out)]]
+    out "-"
+)
+
+set(lst [[a;b]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(JOIN lst "-" out)]]
+    out [[a-b]]
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(JOIN lst "+" out)]]
+    out [[a+b]]
+)
+
+set(lst [[a;b\;c\\;d]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(JOIN lst "-" out)]]
+    out [[a-b;c\;d]]
+)
+
+# vcpkg_list(SUBLIST <list> <begin> <length> <out-var>)
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 0 out)]]
+    out ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 1 out)]]
+    out ""
+)
+unit_test_ensure_fatal_error([[vcpkg_list(SUBLIST lst 1 0 out)]])
+
+set(lst "a")
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 0 out)]]
+    out ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 1 out)]]
+    out "a"
+)
+unit_test_ensure_fatal_error([[vcpkg_list(SUBLIST lst 2 0 out)]])
+unit_test_ensure_fatal_error([[vcpkg_list(SUBLIST lst 2 1 out)]])
+
+set(lst ";;")
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 0 out)]]
+    out ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 1 out)]]
+    out ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 2 out)]]
+    out ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 0 3 out)]]
+    out ";;"
+)
+
+set(lst "a;b;c;d")
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 1 2 out)]]
+    out "b;c"
+)
+
+set(lst [[a\;b;c\;d;e]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 1 2 out)]]
+    out [[c\;d;e]]
+)
+
+set(lst [[a\;b;c\\;d;e;f;g;h]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(SUBLIST lst 1 -1 out)]]
+    out [[c\\;d;e;f;g;h]]
+)
+
+# vcpkg_list(FIND <list> <value> <out-var>)
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst "a" out)]]
+    out -1
+)
+
+set(lst "b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst "a" out)]]
+    out -1
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst "a" out)]]
+    out 0
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst b out)]]
+    out 1
+)
+
+set(lst ";b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst "" out)]]
+    out 0
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst b out)]]
+    out 1
+)
+
+set(lst [[a\;b;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst "a;b" out)]]
+    out 0
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst c out)]]
+    out 1
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(FIND lst a out)]]
+    out -1
+)
+
+set(lst [[a\\;b;c]])
+unit_test_check_variable_equal(
+    [=[vcpkg_list(FIND lst [[a\;b]] out)]=]
+    out 0
+)
+
+# vcpkg_list(APPEND <list> [<element>...])
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst)]]
+    lst [[]]
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "")]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "" "")]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst a)]]
+    lst "a"
+)
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst)]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "")]]
+    lst ";;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst b)]]
+    lst ";;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "b;c" d)]]
+    lst [[;;b\;c;d]]
+)
+
+set(lst "a")
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst)]]
+    lst "a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "")]]
+    lst "a;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst b)]]
+    lst "a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "b;c" d)]]
+    lst [[a;b\;c;d]]
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst)]]
+    lst "a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "")]]
+    lst "a;b;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst c)]]
+    lst "a;b;c"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(APPEND lst "c;d" e)]]
+    lst [[a;b;c\;d;e]]
+)
+unit_test_check_variable_equal(
+    [=[vcpkg_list(APPEND lst [[c\;d]])]=]
+    lst [[a;b;c\\;d]]
+)
+
+# vcpkg_list(PREPEND <list> [<element>...])
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst)]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "")]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "" "")]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst a)]]
+    lst "a"
+)
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst)]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "")]]
+    lst ";;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst b)]]
+    lst "b;;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "b;c" d)]]
+    lst [[b\;c;d;;]]
+)
+
+set(lst "a")
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst)]]
+    lst "a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "")]]
+    lst ";a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst b)]]
+    lst "b;a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "b;c" d)]]
+    lst [[b\;c;d;a]]
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst)]]
+    lst "a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "")]]
+    lst ";a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst c)]]
+    lst "c;a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(PREPEND lst "c;d" e)]]
+    lst [[c\;d;e;a;b]]
+)
+unit_test_check_variable_equal(
+    [=[vcpkg_list(PREPEND lst [[c\;d]])]=]
+    lst [[c\\;d;a;b]]
+)
+
+# list(INSERT <list> <index> [<element>...])
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 0)]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 0 "")]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 0 "" "")]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 0 "a")]]
+    lst "a"
+)
+unit_test_ensure_fatal_error([[vcpkg_list(INSERT lst 1 "")]])
+unit_test_ensure_fatal_error([[vcpkg_list(INSERT lst -1 "")]])
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 0)]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 1)]]
+    lst ";"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 1 "")]]
+    lst ";;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 0 b)]]
+    lst "b;;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 1 b)]]
+    lst ";b;"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 2 b)]]
+    lst ";;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst -1 "b;c" d)]]
+    lst [[;b\;c;d;]]
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst -2 "b;c" d)]]
+    lst [[b\;c;d;;]]
+)
+unit_test_ensure_fatal_error([[vcpkg_list(INSERT lst 3 "")]])
+unit_test_ensure_fatal_error([[vcpkg_list(INSERT lst -3 "")]])
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst -1 c)]]
+    lst "a;c;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 1 c)]]
+    lst "a;c;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 2 c)]]
+    lst "a;b;c"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst -2 c)]]
+    lst "c;a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(INSERT lst 1 "c;d")]]
+    lst [[a;c\;d;b]]
+)
+unit_test_check_variable_equal(
+    [=[vcpkg_list(INSERT lst 1 [[c\;d]] e)]=]
+    lst [[a;c\\;d;e;b]]
+)
+
+# vcpkg_list(POP_BACK <list>)
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_BACK lst)]]
+    lst ""
+)
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_BACK lst)]]
+    lst ""
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_BACK lst)]]
+    lst "a"
+)
+
+set(lst "a;;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_BACK lst)]]
+    lst "a;"
+)
+
+set(lst [[a\;b]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_BACK lst)]]
+    lst ""
+)
+
+set(lst [[c;a\;b;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_BACK lst)]]
+    lst [[c;a\;b]]
+)
+
+# vcpkg_list(POP_FRONT <list>)
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_BACK lst)]]
+    lst ""
+)
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_FRONT lst)]]
+    lst ""
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_FRONT lst)]]
+    lst "b"
+)
+
+set(lst "a;;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_FRONT lst)]]
+    lst ";b"
+)
+
+set(lst [[a\;b]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_FRONT lst)]]
+    lst ""
+)
+
+set(lst [[c;a\;b;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(POP_FRONT lst)]]
+    lst [[a\;b;c]]
+)
+
+# vcpkg_list(REMOVE_DUPLICATES <list>)
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst ""
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst "a;b"
+)
+
+set(lst "a;a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst "a;b"
+)
+
+set(lst "a;b;a")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst "a;b"
+)
+
+set(lst "c;a;b;a;c")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst "c;a;b"
+)
+
+set(lst "a;;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst "a;;b"
+)
+
+set(lst [[a\;b;a\;b]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst [[a\;b]] 
+)
+
+set(lst [[c;a\;b;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_DUPLICATES lst)]]
+    lst [[c;a\;b]]
+)
+
+# vcpkg_list(REVERSE <list>)
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REVERSE lst)]]
+    lst ""
+)
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REVERSE lst)]]
+    lst ";"
+)
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REVERSE lst)]]
+    lst "b;a"
+)
+set(lst "a;b;c;d;e;f;g")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REVERSE lst)]]
+    lst "g;f;e;d;c;b;a"
+)
+
+set(lst [[a\;b;a\;b\\;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REVERSE lst)]]
+    lst [[a\;b\\;c;a\;b]] 
+)
+set(lst [[c;a\;b]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REVERSE lst)]]
+    lst [[a\;b;c]]
+)
+
+# vcpkg_list(REMOVE_ITEM <list> <value>)
+set(lst "")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst "a")]]
+    lst ""
+)
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst "")]]
+    lst ""
+)
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst a)]]
+    lst "b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst b)]]
+    lst "a"
+)
+
+set(lst "a;a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst a)]]
+    lst "b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst b)]]
+    lst "a;a"
+)
+
+set(lst "a;b;c;a;d")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst b)]]
+    lst "a;c;a;d"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst a)]]
+    lst "b;c;d"
+)
+
+set(lst "a;;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst "")]]
+    lst "a;b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst a)]]
+    lst ";b"
+)
+
+set(lst [[e;a\;b;c\;d]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst "a;b")]]
+    lst [[e;c\;d]] 
+)
+
+set(lst [[c;a\;b;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst "c")]]
+    lst [[a\;b]]
+)
+
+set(lst [[c;a\\;b;c]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_ITEM lst "a\\;b")]]
+    lst [[c;c]]
+)
+
+# vcpkg_list(REMOVE_AT <list> <index>)
+set(lst "")
+unit_test_ensure_fatal_error([[vcpkg_list(REMOVE_AT lst 0)]])
+
+set(lst ";")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 0)]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 1)]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst -1)]]
+    lst ""
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst -2)]]
+    lst ""
+)
+unit_test_ensure_fatal_error([[vcpkg_list(REMOVE_AT lst 2)]])
+unit_test_ensure_fatal_error([[vcpkg_list(REMOVE_AT lst -3)]])
+
+set(lst "a;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 0)]]
+    lst "b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 1)]]
+    lst "a"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst -1)]]
+    lst "a"
+)
+
+set(lst "a;;b")
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 0)]]
+    lst ";b"
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 1)]]
+    lst "a;b"
+)
+
+set(lst [[e;a\;b;c\;d]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 0)]]
+    lst [[a\;b;c\;d]] 
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 1)]]
+    lst [[e;c\;d]] 
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst -1)]]
+    lst [[e;a\;b]] 
+)
+
+set(lst [[c;a\\;b;c\;d;e]])
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 0)]]
+    lst [[a\\;b;c\;d;e]]
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 1)]]
+    lst [[c;c\;d;e]]
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 2)]]
+    lst [[c;a\\;b;e]]
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst 3)]]
+    lst [[c;a\\;b;c\;d]]
+)
+unit_test_check_variable_equal(
+    [[vcpkg_list(REMOVE_AT lst -1)]]
+    lst [[c;a\\;b;c\;d]]
+)
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-z_vcpkg_function_arguments.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-z_vcpkg_function_arguments.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e88eb683f9b497e67f3523e067cb2cc95ab4e090
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-z_vcpkg_function_arguments.cmake
@@ -0,0 +1,63 @@
+# these both set `args` in the top level
+function(check_function_args start)
+    z_vcpkg_function_arguments(out "${start}")
+    set(args "${out}" PARENT_SCOPE)
+endfunction()
+function(check_all_function_args)
+    z_vcpkg_function_arguments(out)
+    set(args "${out}" PARENT_SCOPE)
+endfunction()
+
+unit_test_ensure_fatal_error([[check_function_args(-1)]])
+unit_test_ensure_fatal_error([[check_function_args(3)]])
+unit_test_ensure_fatal_error([[check_function_args(notanumber)]])
+unit_test_check_variable_equal(
+    [[check_all_function_args()]]
+    args ""
+)
+unit_test_check_variable_equal(
+    [[check_all_function_args("")]]
+    args ""
+)
+unit_test_check_variable_equal(
+    [[check_all_function_args("" "")]]
+    args ";"
+)
+unit_test_check_variable_equal(
+    [[check_all_function_args("" "" "" "")]]
+    args ";;;"
+)
+
+unit_test_check_variable_equal(
+    [[check_all_function_args(a b c)]]
+    args "a;b;c"
+)
+unit_test_check_variable_equal(
+    [[check_function_args(2 a b c)]]
+    args "b;c"
+)
+unit_test_check_variable_equal(
+    [[check_function_args(3 a b c)]]
+    args "c"
+)
+
+unit_test_check_variable_equal(
+    [=[check_all_function_args("a;b" [[c\;d]] e)]=]
+    args [[a\;b;c\\;d;e]]
+)
+unit_test_check_variable_equal(
+    [=[check_all_function_args("a;b" [[c\;d]] [[e\\;f]])]=]
+    args [[a\;b;c\\;d;e\\\;f]]
+)
+unit_test_check_variable_equal(
+    [=[check_function_args(2 "a;b" [[c\;d]] e)]=]
+    args [[c\\;d;e]]
+)
+unit_test_check_variable_equal(
+    [=[check_function_args(3 "a;b" [[c\;d]] e)]=]
+    args "e"
+)
+unit_test_check_variable_equal(
+    [=[check_function_args(4 "a;b" [[c\;d]] e)]=]
+    args ""
+)
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-z_vcpkg_setup_pkgconfig_path.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-z_vcpkg_setup_pkgconfig_path.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e173b0b9c1254298108af0174e12b7ba8cbb64af
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/unit-test-cmake/test-z_vcpkg_setup_pkgconfig_path.cmake
@@ -0,0 +1,41 @@
+# z_vcpkg_setup_pkgconfig_path(BASE_DIR <list>)
+# z_vcpkg_restore_pkgconfig_path()
+
+# These functions use vcpkg_backup/restore_env_variables which use scoped variables
+# and cannot be called in unit_test_check_*.
+
+set(ENV{PKG_CONFIG} "/a/pkgconf")
+set(ENV{PKG_CONFIG_PATH} "1")
+set(saved_path "$ENV{PATH}")
+
+block(SCOPE_FOR VARIABLES)
+
+set(CURRENT_PACKAGES_DIR "P")
+set(CURRENT_INSTALLED_DIR "I")
+
+z_vcpkg_setup_pkgconfig_path(CONFIG RELEASE)
+unit_test_check_variable_equal([[]] ENV{PKG_CONFIG} [[/a/pkgconf]])
+unit_test_match([[]] ENV{PKG_CONFIG_PATH} "^P.lib.pkgconfig.P.share.pkgconfig.I.lib.pkgconfig.I.share.pkgconfig.1\$")
+
+z_vcpkg_restore_pkgconfig_path()
+unit_test_check_variable_equal([[]] ENV{PKG_CONFIG} [[/a/pkgconf]])
+unit_test_check_variable_equal([[]] ENV{PKG_CONFIG_PATH} "1")
+
+z_vcpkg_setup_pkgconfig_path(CONFIG DEBUG)
+unit_test_check_variable_equal([[]] ENV{PKG_CONFIG} [[/a/pkgconf]])
+unit_test_check_variable_not_equal([[]] ENV{PKG_CONFIG_PATH} "1")
+unit_test_match([[]] ENV{PKG_CONFIG_PATH} "^P.debug.lib.pkgconfig.P.share.pkgconfig.I.debug.lib.pkgconfig.I.share.pkgconfig.1\$")
+
+z_vcpkg_restore_pkgconfig_path()
+unit_test_check_variable_equal([[]] ENV{PKG_CONFIG} [[/a/pkgconf]])
+unit_test_check_variable_equal([[]] ENV{PKG_CONFIG_PATH} "1")
+
+# z_vcpkg_setup_pkgconfig_path changes PATH but it is not restored.
+# It is hard to see which side effects a restore would have, so
+# this is expected behaviour for now.
+unit_test_check_variable_not_equal([[]] ENV{PATH} "${saved_path}")
+
+unit_test_ensure_fatal_error([[ z_vcpkg_setup_pkgconfig_path() ]])
+unit_test_ensure_fatal_error([[ z_vcpkg_setup_pkgconfig_path(CONFIG unknown) ]])
+
+endblock()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-ffmpeg/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-ffmpeg/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0015715fb66c72d00816219213a54ae283d41746
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-ffmpeg/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
\ No newline at end of file
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-ffmpeg/vcpkg.json b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-ffmpeg/vcpkg.json
new file mode 100644
index 0000000000000000000000000000000000000000..b43b1048c99717aa910e325dc2cff980cb18ad23
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-ffmpeg/vcpkg.json
@@ -0,0 +1,154 @@
+{
+  "name": "vcpkg-ci-ffmpeg",
+  "version-string": "1",
+  "port-version": 2,
+  "description": "Port to force features of certain ports within CI",
+  "homepage": "https://github.com/microsoft/vcpkg",
+  "dependencies": [
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "avcodec",
+        "avdevice",
+        "avfilter",
+        "avformat",
+        "avresample",
+        "bzip2",
+        "fdk-aac",
+        "freetype",
+        "gpl",
+        "iconv",
+        "lzma",
+        "mp3lame",
+        "nonfree",
+        "openjpeg",
+        "openmpt",
+        "openssl",
+        "opus",
+        "postproc",
+        "snappy",
+        "soxr",
+        "speex",
+        "swresample",
+        "swscale",
+        "theora",
+        "vorbis",
+        "vpx",
+        "webp",
+        "xml2",
+        "zlib"
+      ]
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "alsa"
+      ],
+      "platform": "linux"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "sdl2"
+      ],
+      "platform": "!osx"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "ass",
+        "fontconfig",
+        "fribidi",
+        "modplug",
+        "opencl",
+        "openh264",
+        "srt"
+      ],
+      "platform": "!uwp"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "ilbc"
+      ],
+      "platform": "!(arm & uwp)"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "ssh"
+      ],
+      "platform": "!(uwp | arm)"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "x264"
+      ],
+      "platform": "!(arm & windows)"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "aom"
+      ],
+      "platform": "!(windows & arm & !uwp)"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "dav1d"
+      ],
+      "platform": "!(uwp | arm | x86 | osx)"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "x265"
+      ],
+      "platform": "!uwp & !(arm & windows)"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "opengl"
+      ],
+      "platform": "!uwp & !(arm64 & windows)"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "avisynthplus"
+      ],
+      "platform": "windows & !arm & !uwp & !static"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "tesseract"
+      ],
+      "platform": "!(windows & arm) & !static & !uwp"
+    },
+    {
+      "name": "ffmpeg",
+      "default-features": false,
+      "features": [
+        "nvcodec"
+      ],
+      "platform": "linux | (!osx & !uwp & !(arm64 & windows))"
+    }
+  ]
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-freerdp/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-freerdp/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..065116c276adcf960cd9ad806097da3f199e2241
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-freerdp/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-freerdp/vcpkg.json b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-freerdp/vcpkg.json
new file mode 100644
index 0000000000000000000000000000000000000000..8f7055e5ea7681a3f2251ea43667157ecda3dc79
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-freerdp/vcpkg.json
@@ -0,0 +1,32 @@
+{
+  "name": "vcpkg-ci-freerdp",
+  "version-string": "ci",
+  "description": "Force non-default features of freerdp within vcpkg CI",
+  "homepage": "https://github.com/microsoft/vcpkg",
+  "dependencies": [
+    {
+      "name": "freerdp",
+      "features": [
+        "wayland",
+        "x11"
+      ],
+      "platform": "linux"
+    },
+    {
+      "name": "freerdp",
+      "features": [
+        "ffmpeg"
+      ],
+      "platform": "linux | osx"
+    },
+    {
+      "name": "freerdp",
+      "features": [
+        "server",
+        "urbdrc",
+        "winpr-tools"
+      ],
+      "platform": "linux | osx | windows"
+    }
+  ]
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-llvm/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-llvm/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0015715fb66c72d00816219213a54ae283d41746
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-llvm/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
\ No newline at end of file
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-llvm/vcpkg.json b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-llvm/vcpkg.json
new file mode 100644
index 0000000000000000000000000000000000000000..afa1a3eb731b189341194c0c1bb42838bfd542ce
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-llvm/vcpkg.json
@@ -0,0 +1,48 @@
+{
+  "name": "vcpkg-ci-llvm",
+  "version-string": "0",
+  "description": "LLVM features testing within CI.",
+  "license": null,
+  "supports": "!uwp & !(arm & windows)",
+  "dependencies": [
+    {
+      "name": "llvm",
+      "default-features": false,
+      "features": [
+        "clang",
+        "compiler-rt",
+        "default-targets",
+        "enable-abi-breaking-checks",
+        "enable-bindings",
+        "enable-eh",
+        "enable-rtti",
+        "enable-terminfo",
+        "enable-zlib",
+        "lld",
+        "lldb",
+        "tools"
+      ]
+    },
+    {
+      "$comment": "Platform restriction due to CI artifact upload quirks; features which need utils",
+      "name": "llvm",
+      "default-features": false,
+      "features": [
+        "bolt",
+        "openmp",
+        "polly",
+        "utils"
+      ],
+      "platform": "!static"
+    },
+    {
+      "$comment": "Platform restriction due to CI artifact upload quirks; libc",
+      "name": "llvm",
+      "default-features": false,
+      "features": [
+        "libc"
+      ],
+      "platform": "linux"
+    }
+  ]
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-opencv/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-opencv/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0015715fb66c72d00816219213a54ae283d41746
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-opencv/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
\ No newline at end of file
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-opencv/vcpkg.json b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-opencv/vcpkg.json
new file mode 100644
index 0000000000000000000000000000000000000000..83bbc51bc70bc12ebf758a59d09d93591863bc29
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-opencv/vcpkg.json
@@ -0,0 +1,73 @@
+{
+  "name": "vcpkg-ci-opencv",
+  "version-string": "1",
+  "port-version": 5,
+  "description": "Port to force features of certain ports within CI",
+  "homepage": "https://github.com/microsoft/vcpkg",
+  "dependencies": [
+    {
+      "name": "opencv",
+      "default-features": false,
+      "features": [
+        "ade",
+        "contrib",
+        "dnn",
+        "eigen",
+        "ffmpeg",
+        "jpeg",
+        "nonfree",
+        "png",
+        "quirc",
+        "tiff",
+        "webp"
+      ]
+    },
+    {
+      "name": "opencv",
+      "default-features": false,
+      "features": [
+        "gtk",
+        "dc1394"
+      ],
+      "platform": "linux"
+    },
+    {
+      "name": "opencv",
+      "default-features": false,
+      "features": [
+        "cuda",
+        "cudnn",
+        "gstreamer",
+        "ovis",
+        "tbb"
+      ],
+      "platform": "windows & x64 & !static & !uwp"
+    },
+    {
+      "name": "opencv",
+      "default-features": false,
+      "features": [
+        "freetype",
+        "gdcm",
+        "ipp",
+        "jasper",
+        "lapack",
+        "openexr",
+        "opengl",
+        "openmp",
+        "qt",
+        "sfm",
+        "vtk"
+      ],
+      "platform": "!uwp & !(windows & (arm | arm64))"
+    },
+    {
+      "name": "opencv",
+      "default-features": false,
+      "features": [
+        "python"
+      ],
+      "platform": "!uwp"
+    }
+  ]
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-wxwidgets/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-wxwidgets/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d301fa74a150380c9dc8cb2932e41d65fe033934
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-wxwidgets/portfile.cmake
@@ -0,0 +1,34 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
+
+vcpkg_check_features(OUT_FEATURE_OPTIONS OPTIONS
+    FEATURES
+        wxrc    USE_WXRC
+)
+
+vcpkg_cmake_configure(
+    SOURCE_PATH "${CURRENT_INSTALLED_DIR}/share/wxwidgets/example"
+    DISABLE_PARALLEL_CONFIGURE # Need separate dbg log for following test
+    OPTIONS
+        ${OPTIONS}
+        -DCMAKE_CONFIG_RUN=1
+        "-DPRINT_VARS=CMAKE_CONFIG_RUN;wxWidgets_LIBRARIES"
+)
+vcpkg_cmake_build()
+
+if(NOT VCPKG_BUILD_TYPE)
+    # Check that debug libs are still used after re-configuration, #24489
+    set(config_log "config-${TARGET_TRIPLET}-dbg")
+    vcpkg_execute_required_process(
+        COMMAND "${CMAKE_COMMAND}" -DCMAKE_CONFIG_RUN=2 .
+        WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+        LOGNAME "${config_log}-2"
+    )
+    file(STRINGS "${CURRENT_BUILDTREES_DIR}/${config_log}-out.log" expected REGEX "wxWidgets_LIBRARIES:=")
+    file(STRINGS "${CURRENT_BUILDTREES_DIR}/${config_log}-2-out.log" actual REGEX "wxWidgets_LIBRARIES:=")
+    if(NOT actual STREQUAL expected)
+        message(FATAL_ERROR "wxWidgets libraries changed after CMake re-run\n"
+            "actual:\n${actual}\n"
+            "expected:\n ${expected}\n"
+        )
+    endif()
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-wxwidgets/vcpkg.json b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-wxwidgets/vcpkg.json
new file mode 100644
index 0000000000000000000000000000000000000000..989d47a579027a00fd0fc07a0bc60b3ae6c67ceb
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-ci-wxwidgets/vcpkg.json
@@ -0,0 +1,39 @@
+{
+  "name": "vcpkg-ci-wxwidgets",
+  "version-date": "2022-04-05",
+  "description": "Builds a GUI app in order to validate the wxwidgets port.",
+  "dependencies": [
+    {
+      "name": "vcpkg-cmake",
+      "host": true
+    },
+    {
+      "name": "wxwidgets",
+      "default-features": false,
+      "features": [
+        "example"
+      ]
+    }
+  ],
+  "default-features": [
+    "default-features"
+  ],
+  "features": {
+    "default-features": {
+      "description": "Default features depending on system",
+      "dependencies": [
+        {
+          "name": "vcpkg-ci-wxwidgets",
+          "default-features": false,
+          "features": [
+            "wxrc"
+          ],
+          "platform": "native"
+        }
+      ]
+    },
+    "wxrc": {
+      "description": "Test wxrc"
+    }
+  }
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-find-acquire-program/portfile.cmake b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-find-acquire-program/portfile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..af8a834dc8c7f2e6969aa290f4bb0e317d89c31f
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-find-acquire-program/portfile.cmake
@@ -0,0 +1,63 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
+
+# For each vcpkg_find_acquire_program(NAME).cmake script,
+# there must be a literal call to vcpkg_find_acquire_program(NAME).cmake
+
+set(variables BAZEL BISON FLEX GIT GN NINJA PERL PKGCONFIG PYTHON3 YASM)
+vcpkg_find_acquire_program(BAZEL)
+vcpkg_find_acquire_program(BISON)
+vcpkg_find_acquire_program(FLEX)
+vcpkg_find_acquire_program(GIT)
+vcpkg_find_acquire_program(GN)
+vcpkg_find_acquire_program(NINJA)
+vcpkg_find_acquire_program(PERL)
+vcpkg_find_acquire_program(PKGCONFIG)
+vcpkg_find_acquire_program(PYTHON3)
+vcpkg_find_acquire_program(YASM)
+
+if(NOT VCPKG_TARGET_IS_OSX)
+    # System python too old (3.9; meson needs 3.10)
+    list(APPEND variables MESON)
+    vcpkg_find_acquire_program(MESON)
+endif()
+
+if(VCPKG_HOST_IS_LINUX)
+    list(APPEND variables PATCHELF)
+    vcpkg_find_acquire_program(PATCHELF)
+endif()
+
+if(VCPKG_HOST_IS_WINDOWS)
+    list(APPEND variables 7Z ARIA2 CLANG DARK DOXYGEN GASPREPROCESSOR GO GPERF JOM NASM NUGET PYTHON2 RUBY SCONS SWIG)
+    vcpkg_find_acquire_program(7Z)
+    vcpkg_find_acquire_program(ARIA2)
+    vcpkg_find_acquire_program(CLANG)
+    vcpkg_find_acquire_program(DARK)
+    vcpkg_find_acquire_program(DOXYGEN)
+    vcpkg_find_acquire_program(GASPREPROCESSOR)
+    vcpkg_find_acquire_program(GO)
+    vcpkg_find_acquire_program(GPERF)
+    vcpkg_find_acquire_program(JOM)
+    vcpkg_find_acquire_program(NASM)
+    vcpkg_find_acquire_program(NUGET)
+    vcpkg_find_acquire_program(PYTHON2)
+    vcpkg_find_acquire_program(RUBY)
+    vcpkg_find_acquire_program(SCONS)
+    vcpkg_find_acquire_program(SWIG)
+endif()
+
+set(missing "")
+foreach(variable IN LISTS variables)
+    set(var_contents "${${variable}}")
+    list(POP_BACK var_contents program)
+    if(NOT EXISTS "${program}")
+        list(APPEND missing "${variable}: ${program}")
+    endif()
+    list(POP_FRONT var_contents interpreter)
+    if(interpreter AND NOT EXISTS "${interpreter}")
+        list(APPEND missing "${variable} (interpreter): ${interpreter}")
+    endif()
+endforeach()
+if(missing)
+    list(JOIN missing "\n   " missing)
+    message(FATAL_ERROR "The following programs do not exist:\n   ${missing}")
+endif()
diff --git a/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-find-acquire-program/vcpkg.json b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-find-acquire-program/vcpkg.json
new file mode 100644
index 0000000000000000000000000000000000000000..0b622ebbbf5470707880545ff15047723c33cc1b
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/scripts/test_ports/vcpkg-find-acquire-program/vcpkg.json
@@ -0,0 +1,7 @@
+{
+  "name": "vcpkg-find-acquire-program",
+  "version-string": "0",
+  "port-version": 2,
+  "description": "Test port to exercise vcpkg_find_acquire_program",
+  "supports": "native"
+}
diff --git a/cc-multilingual-main/cc_net/vcpkg/toolsrc/VERSION.txt b/cc-multilingual-main/cc_net/vcpkg/toolsrc/VERSION.txt
new file mode 100644
index 0000000000000000000000000000000000000000..275e5a6e071c4bd46f63a75fc7bd5832f961c0fa
--- /dev/null
+++ b/cc-multilingual-main/cc_net/vcpkg/toolsrc/VERSION.txt
@@ -0,0 +1 @@
+"9999.99.99"