2025-07-04 22:11:26 +12:00
1334 changed files with 126530 additions and 97626 deletions
--- a/.ci/build-freebsd.sh
+++ b/.ci/build-freebsd.sh
@ -1,10 +1,23 @@
 #!/bin/sh -ex
-# Pull all the submodules except some
+# Pull all the submodules except llvm
 # Note: Tried to use git submodule status, but it takes over 20 seconds
 # shellcheck disable=SC2046
-git config --global --add safe.directory .
+git submodule -q update --init --depth 1 $(awk '/path/ && !/llvm/ && !/SPIRV/ { print $3 }' .gitmodules)
-git submodule -q update --init --depth 1 $(awk '/path/ && !/llvm/ && !/opencv/ && !/libpng/ && !/libsdl-org/ && !/curl/ && !/zlib/ && !/libusb/ { print $3 }' .gitmodules)
+
 # Prefer newer Clang than in base system (see also .ci/install-freebsd.sh)
 # libc++ isn't in llvm* packages, so download manually
 fetch https://github.com/llvm/llvm-project/releases/download/llvmorg-16.0.1/llvm-project-16.0.1.src.tar.xz
 tar xf llvm*.tar.xz
 export CC=clang16 CXX=clang++16
 cmake -B libcxx_build -G Ninja -S llvm*/libcxx \
      -DLLVM_CCACHE_BUILD=ON \
      -DLIBCXX_INCLUDE_BENCHMARKS=OFF \
      -DCMAKE_INSTALL_PREFIX:PATH=libcxx_prefix
 cmake --build libcxx_build
 cmake --install libcxx_build
 export CXXFLAGS="$CXXFLAGS -nostdinc++ -isystem$PWD/libcxx_prefix/include/c++/v1"
 export LDFLAGS="$LDFLAGS -nostdlib++ -L$PWD/libcxx_prefix/lib -l:libc++.a -lcxxrt"
 CONFIGURE_ARGS="
 	-DWITH_LLVM=ON
@ -14,13 +27,8 @@ CONFIGURE_ARGS="
 	-DUSE_SYSTEM_FFMPEG=ON
 	-DUSE_SYSTEM_CURL=ON
 	-DUSE_SYSTEM_LIBPNG=ON
 	-DUSE_SYSTEM_LIBUSB=ON
 	-DUSE_SYSTEM_OPENCV=ON
 "
 # base Clang workaround (missing clang-scan-deps)
 CONFIGURE_ARGS="$CONFIGURE_ARGS -DCMAKE_CXX_SCAN_FOR_MODULES=OFF"
 # shellcheck disable=SC2086
 cmake -B build -G Ninja $CONFIGURE_ARGS
 cmake --build build
--- a/.ci/build-linux-aarch64.sh
+++ b/.ci/build-linux-aarch64.sh
@ -1,55 +0,0 @@
 #!/bin/sh -ex
 cd rpcs3 || exit 1
 shellcheck .ci/*.sh
 git config --global --add safe.directory '*'
 # Pull all the submodules except some
 # shellcheck disable=SC2046
 git submodule -q update --init $(awk '/path/ && !/llvm/ && !/opencv/ && !/libsdl-org/ && !/curl/ && !/zlib/ { print $3 }' .gitmodules)
 mkdir build && cd build || exit 1
 if [ "$COMPILER" = "gcc" ]; then
    # These are set in the dockerfile
    export CC="${GCC_BINARY}"
    export CXX="${GXX_BINARY}"
    export LINKER=gold
 else
    export CC="${CLANG_BINARY}"
    export CXX="${CLANGXX_BINARY}"
    export LINKER="${LLD_BINARY}"
 fi
 export LINKER_FLAG="-fuse-ld=${LINKER}"
 cmake ..                                               \
    -DCMAKE_INSTALL_PREFIX=/usr                        \
    -DUSE_NATIVE_INSTRUCTIONS=OFF                      \
    -DUSE_PRECOMPILED_HEADERS=OFF                      \
    -DCMAKE_EXE_LINKER_FLAGS="${LINKER_FLAG}"          \
    -DCMAKE_MODULE_LINKER_FLAGS="${LINKER_FLAG}"       \
    -DCMAKE_SHARED_LINKER_FLAGS="${LINKER_FLAG}"       \
    -DUSE_SYSTEM_CURL=ON                               \
    -DUSE_SDL=ON                                       \
    -DUSE_SYSTEM_SDL=ON                                \
    -DUSE_SYSTEM_FFMPEG=OFF                            \
    -DUSE_SYSTEM_OPENCV=ON                             \
    -DUSE_DISCORD_RPC=ON                               \
    -DOpenGL_GL_PREFERENCE=LEGACY                      \
    -DLLVM_DIR=/opt/llvm/lib/cmake/llvm                \
    -DSTATIC_LINK_LLVM=ON                              \
    -DBUILD_RPCS3_TESTS="${RUN_UNIT_TESTS}"            \
    -DRUN_RPCS3_TESTS="${RUN_UNIT_TESTS}"              \
    -G Ninja
 ninja; build_status=$?;
 cd ..
 # If it compiled succesfully let's deploy.
 if [ "$build_status" -eq 0 ]; then
    .ci/deploy-linux.sh "aarch64"
 fi
--- a/.ci/build-linux.sh
+++ b/.ci/build-linux.sh
@ -1,15 +1,15 @@
 #!/bin/sh -ex
-cd rpcs3 || exit 1
+if [ -z "$CIRRUS_CI" ]; then
-
+   cd rpcs3 || exit 1
-shellcheck .ci/*.sh
+fi
 git config --global --add safe.directory '*'
-# Pull all the submodules except some
+# Pull all the submodules except llvm
 # Note: Tried to use git submodule status, but it takes over 20 seconds
 # shellcheck disable=SC2046
-git submodule -q update --init $(awk '/path/ && !/llvm/ && !/opencv/ && !/libsdl-org/ && !/curl/ && !/zlib/ { print $3 }' .gitmodules)
+git submodule -q update --init $(awk '/path/ && !/llvm/ && !/SPIRV/ { print $3 }' .gitmodules)
 mkdir build && cd build || exit 1
@ -30,7 +30,7 @@ else
    export RANLIB=/usr/bin/llvm-ranlib-"$LLVMVER"
 fi
-export LINKER_FLAG="-fuse-ld=${LINKER}"
+export CFLAGS="$CFLAGS -fuse-ld=${LINKER}"
 cmake ..                                               \
    -DCMAKE_INSTALL_PREFIX=/usr                        \
@ -38,29 +38,28 @@ cmake ..                                               \
    -DUSE_PRECOMPILED_HEADERS=OFF                      \
    -DCMAKE_C_FLAGS="$CFLAGS"                          \
    -DCMAKE_CXX_FLAGS="$CFLAGS"                        \
    -DCMAKE_EXE_LINKER_FLAGS="${LINKER_FLAG}"          \
    -DCMAKE_MODULE_LINKER_FLAGS="${LINKER_FLAG}"       \
    -DCMAKE_SHARED_LINKER_FLAGS="${LINKER_FLAG}"       \
    -DCMAKE_AR="$AR"                                   \
    -DCMAKE_RANLIB="$RANLIB"                           \
    -DUSE_SYSTEM_CURL=ON                               \
    -DUSE_SDL=ON                                       \
    -DUSE_SYSTEM_SDL=ON                                \
    -DUSE_SYSTEM_FFMPEG=OFF                            \
    -DUSE_SYSTEM_OPENCV=ON                             \
    -DUSE_DISCORD_RPC=ON                               \
    -DOpenGL_GL_PREFERENCE=LEGACY                      \
    -DLLVM_DIR=/opt/llvm/lib/cmake/llvm                \
    -DSTATIC_LINK_LLVM=ON                              \
    -DBUILD_RPCS3_TESTS="${RUN_UNIT_TESTS}"            \
    -DRUN_RPCS3_TESTS="${RUN_UNIT_TESTS}"              \
    -G Ninja
 ninja; build_status=$?;
 cd ..
 shellcheck .ci/*.sh
 # If it compiled succesfully let's deploy.
-if [ "$build_status" -eq 0 ]; then
+# Azure and Cirrus publish PRs as artifacts only.
-    .ci/deploy-linux.sh "x86_64"
+{   [ "$CI_HAS_ARTIFACTS" = "true" ];
 } && SHOULD_DEPLOY="true" || SHOULD_DEPLOY="false"
 if [ "$build_status" -eq 0 ] && [ "$SHOULD_DEPLOY" = "true" ]; then
    .ci/deploy-linux.sh
 fi
--- a/.ci/build-mac-arm64.sh
+++ b/.ci/build-mac-arm64.sh
@ -1,121 +0,0 @@
 #!/bin/sh -ex
 # shellcheck disable=SC2086
 export HOMEBREW_NO_AUTO_UPDATE=1
 export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1
 export HOMEBREW_NO_ENV_HINTS=1
 export HOMEBREW_NO_INSTALL_CLEANUP=1
 /opt/homebrew/bin/brew install -f --overwrite --quiet nasm ninja p7zip ccache pipenv gnutls freetype googletest #create-dmg
 /opt/homebrew/bin/brew install -f --quiet ffmpeg@5
 /opt/homebrew/bin/brew install --quiet "llvm@$LLVM_COMPILER_VER" glew cmake sdl3 vulkan-headers coreutils
 /opt/homebrew/bin/brew link -f --quiet "llvm@$LLVM_COMPILER_VER" ffmpeg@5
 # moltenvk based on commit for 1.3.0 release
 wget https://raw.githubusercontent.com/Homebrew/homebrew-core/7255441cbcafabaa8950f67c7ec55ff499dbb2d3/Formula/m/molten-vk.rb
 /opt/homebrew/bin/brew install -f --overwrite --formula --quiet ./molten-vk.rb
 export CXX=clang++
 export CC=clang
 export BREW_PATH;
 BREW_PATH="$(brew --prefix)"
 export BREW_BIN="/opt/homebrew/bin"
 export BREW_SBIN="/opt/homebrew/sbin"
 export CMAKE_EXTRA_OPTS='-DLLVM_TARGETS_TO_BUILD=arm64'
 export WORKDIR;
 WORKDIR="$(pwd)"
 # Get Qt
 if [ ! -d "/tmp/Qt/$QT_VER" ]; then
  mkdir -p "/tmp/Qt"
  git clone https://github.com/engnr/qt-downloader.git
  cd qt-downloader
  git checkout f52efee0f18668c6d6de2dec0234b8c4bc54c597
  # nested Qt 6.9.1 URL workaround
  # sed -i '' "s/'qt{0}_{0}{1}{2}'.format(major, minor, patch)]))/'qt{0}_{0}{1}{2}'.format(major, minor, patch), 'qt{0}_{0}{1}{2}'.format(major, minor, patch)]))/g" qt-downloader
  # sed -i '' "s/'{}\/{}\/qt{}_{}\/'/'{0}\/{1}\/qt{2}_{3}\/qt{2}_{3}\/'/g" qt-downloader
  # archived Qt 6.7.3 URL workaround
  sed -i '' "s/official_releases/archive/g" qt-downloader
  cd "/tmp/Qt"
  arch -arm64 "$BREW_PATH/bin/pipenv" run pip3 uninstall py7zr requests semantic_version lxml
  arch -arm64 "$BREW_PATH/bin/pipenv" run pip3 install py7zr requests semantic_version lxml  --no-cache
  mkdir -p "$QT_VER/macos" ; ln -s "macos" "$QT_VER/clang_64"
  # sed -i '' 's/args\.version \/ derive_toolchain_dir(args) \/ //g' "$WORKDIR/qt-downloader/qt-downloader" # Qt 6.9.1 workaround
  arch -arm64 "$BREW_PATH/bin/pipenv" run "$WORKDIR/qt-downloader/qt-downloader" macos desktop "$QT_VER" clang_64 --opensource --addons qtmultimedia qtimageformats # -o "$QT_VER/clang_64"
 fi
 cd "$WORKDIR"
 ditto "/tmp/Qt/$QT_VER" "qt-downloader/$QT_VER"
 export Qt6_DIR="$WORKDIR/qt-downloader/$QT_VER/clang_64/lib/cmake/Qt$QT_VER_MAIN"
 export SDL3_DIR="$BREW_PATH/opt/sdl3/lib/cmake/SDL3"
 export PATH="$BREW_PATH/opt/llvm@$LLVM_COMPILER_VER/bin:$WORKDIR/qt-downloader/$QT_VER/clang_64/bin:$BREW_BIN:$BREW_SBIN:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/Library/Apple/usr/bin:$PATH"
 export LDFLAGS="-L$BREW_PATH/lib $BREW_PATH/opt/ffmpeg@5/lib/libavcodec.dylib $BREW_PATH/opt/ffmpeg@5/lib/libavformat.dylib $BREW_PATH/opt/ffmpeg@5/lib/libavutil.dylib $BREW_PATH/opt/ffmpeg@5/lib/libswscale.dylib $BREW_PATH/opt/ffmpeg@5/lib/libswresample.dylib $BREW_PATH/opt/llvm@$LLVM_COMPILER_VER/lib/c++/libc++.1.dylib $BREW_PATH/lib/libSDL3.dylib $BREW_PATH/lib/libGLEW.dylib $BREW_PATH/opt/llvm@$LLVM_COMPILER_VER/lib/unwind/libunwind.1.dylib -Wl,-rpath,$BREW_PATH/lib"
 export CPPFLAGS="-I$BREW_PATH/include -I$BREW_PATH/include -no-pie -D__MAC_OS_X_VERSION_MIN_REQUIRED=140000"
 export CFLAGS="-D__MAC_OS_X_VERSION_MIN_REQUIRED=140000"
 export LIBRARY_PATH="$BREW_PATH/lib"
 export LD_LIBRARY_PATH="$BREW_PATH/lib"
 export VULKAN_SDK
 VULKAN_SDK="$BREW_PATH/opt/molten-vk"
 ln -s "$VULKAN_SDK/lib/libMoltenVK.dylib" "$VULKAN_SDK/lib/libvulkan.dylib" || true
 export VK_ICD_FILENAMES="$VULKAN_SDK/share/vulkan/icd.d/MoltenVK_icd.json"
 export LLVM_DIR
 LLVM_DIR="$BREW_PATH/opt/llvm@$LLVM_COMPILER_VER"
 # exclude ffmpeg, LLVM, opencv, and sdl from submodule update
 # shellcheck disable=SC2046
 git submodule -q update --init --depth=1 --jobs=8 $(awk '/path/ && !/ffmpeg/ && !/llvm/ && !/opencv/ && !/SDL/ { print $3 }' .gitmodules)
 # 3rdparty fixes
 sed -i '' "s/extern const double NSAppKitVersionNumber;/const double NSAppKitVersionNumber = 1343;/g" 3rdparty/hidapi/hidapi/mac/hid.c
 mkdir build && cd build || exit 1
 export MACOSX_DEPLOYMENT_TARGET=14.0
 "$BREW_PATH/bin/cmake" .. \
    -DBUILD_RPCS3_TESTS="${RUN_UNIT_TESTS}" \
    -DRUN_RPCS3_TESTS="${RUN_UNIT_TESTS}" \
    -DUSE_SDL=ON \
    -DUSE_DISCORD_RPC=ON \
    -DUSE_VULKAN=ON \
    -DUSE_ALSA=OFF \
    -DUSE_PULSE=OFF \
    -DUSE_AUDIOUNIT=ON \
    -DUSE_SYSTEM_FFMPEG=ON \
    -DLLVM_CCACHE_BUILD=OFF \
    -DLLVM_BUILD_RUNTIME=OFF \
    -DLLVM_BUILD_TOOLS=OFF \
    -DLLVM_INCLUDE_DOCS=OFF \
    -DLLVM_INCLUDE_EXAMPLES=OFF \
    -DLLVM_INCLUDE_TESTS=OFF \
    -DLLVM_INCLUDE_TOOLS=OFF \
    -DLLVM_INCLUDE_UTILS=OFF \
    -DLLVM_USE_PERF=OFF \
    -DLLVM_ENABLE_Z3_SOLVER=OFF \
    -DUSE_NATIVE_INSTRUCTIONS=OFF \
    -DUSE_SYSTEM_MVK=ON \
    -DUSE_SYSTEM_FAUDIO=OFF \
    -DUSE_SYSTEM_SDL=ON \
    -DUSE_SYSTEM_OPENCV=ON \
    "$CMAKE_EXTRA_OPTS" \
    -DLLVM_TARGET_ARCH=arm64 \
    -DCMAKE_OSX_ARCHITECTURES=arm64 \
    -DCMAKE_IGNORE_PATH="$BREW_PATH/lib" \
    -DCMAKE_IGNORE_PREFIX_PATH=/opt/homebrew/opt \
    -DCMAKE_CXX_FLAGS="-D__MAC_OS_X_VERSION_MIN_REQUIRED=140000" \
    -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
    -DCMAKE_OSX_SYSROOT="$(xcrun --sdk macosx --show-sdk-path)" \
    -G Ninja
 "$BREW_PATH/bin/ninja"; build_status=$?;
 cd ..
 # If it compiled succesfully let's deploy.
 if [ "$build_status" -eq 0 ]; then
    .ci/deploy-mac-arm64.sh
 fi
--- a/.ci/build-mac.sh
+++ b/.ci/build-mac.sh
@ -1,26 +1,27 @@
 #!/bin/sh -ex
 # shellcheck disable=SC2086
 export HOMEBREW_NO_AUTO_UPDATE=1
-export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1
+brew install -f --overwrite nasm ninja git p7zip ccache pipenv #create-dmg
 export HOMEBREW_NO_ENV_HINTS=1
 export HOMEBREW_NO_INSTALL_CLEANUP=1
 #/usr/sbin/softwareupdate --install-rosetta --agree-to-license
 arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
 arch -x86_64 /usr/local/bin/brew install -f --overwrite python@3.12 || arch -x86_64 /usr/local/bin/brew link --overwrite python@3.12
 arch -x86_64 /usr/local/bin/brew update
-arch -x86_64 /usr/local/bin/brew install -f --overwrite --quiet python || arch -x86_64 /usr/local/bin/brew link --overwrite python
+arch -x86_64 /usr/local/bin/brew uninstall -f --ignore-dependencies ffmpeg
-arch -x86_64 /usr/local/bin/brew install -f --overwrite --quiet nasm ninja p7zip ccache pipenv gnutls freetype #create-dmg
+arch -x86_64 /usr/local/bin/brew install -f --build-from-source ffmpeg@5
-arch -x86_64 /usr/local/bin/brew install -f --quiet ffmpeg@5
+arch -x86_64 /usr/local/bin/brew reinstall -f --build-from-source gnutls freetype
-arch -x86_64 /usr/local/bin/brew install --quiet "llvm@$LLVM_COMPILER_VER" glew cmake sdl3 vulkan-headers coreutils
+arch -x86_64 /usr/local/bin/brew install llvm@16 glew cmake sdl2 vulkan-headers coreutils
-arch -x86_64 /usr/local/bin/brew link -f --quiet "llvm@$LLVM_COMPILER_VER" ffmpeg@5
+arch -x86_64 /usr/local/bin/brew link -f llvm@16 ffmpeg@5
-# moltenvk based on commit for 1.3.0 release
+# moltenvk based on commit for 1.2.7 release
-wget https://raw.githubusercontent.com/Homebrew/homebrew-core/7255441cbcafabaa8950f67c7ec55ff499dbb2d3/Formula/m/molten-vk.rb
+wget https://raw.githubusercontent.com/Homebrew/homebrew-core/05a8770c483cfddf5b077667a392d846bc2ad719/Formula/m/molten-vk.rb
-arch -x86_64 /usr/local/bin/brew install -f --overwrite --formula --quiet ./molten-vk.rb
+arch -x86_64 /usr/local/bin/brew install -f --overwrite ./molten-vk.rb
 #export MACOSX_DEPLOYMENT_TARGET=12.0
 export CXX=clang++
 export CC=clang
 export BREW_PATH;
 BREW_PATH="$(brew --prefix)"
 export BREW_X64_PATH;
 BREW_X64_PATH="$("/usr/local/bin/brew" --prefix)"
 export BREW_BIN="/usr/local/bin"
@ -36,28 +37,21 @@ if [ ! -d "/tmp/Qt/$QT_VER" ]; then
  git clone https://github.com/engnr/qt-downloader.git
  cd qt-downloader
  git checkout f52efee0f18668c6d6de2dec0234b8c4bc54c597
  # nested Qt 6.9.1 URL workaround
  # sed -i '' "s/'qt{0}_{0}{1}{2}'.format(major, minor, patch)]))/'qt{0}_{0}{1}{2}'.format(major, minor, patch), 'qt{0}_{0}{1}{2}'.format(major, minor, patch)]))/g" qt-downloader
  # sed -i '' "s/'{}\/{}\/qt{}_{}\/'/'{0}\/{1}\/qt{2}_{3}\/qt{2}_{3}\/'/g" qt-downloader
  # archived Qt 6.7.3 URL workaround
  sed -i '' "s/official_releases/archive/g" qt-downloader
  cd "/tmp/Qt"
-  arch -x86_64 "$BREW_X64_PATH/bin/pipenv" --python "$BREW_X64_PATH/bin/python3" run pip3 install py7zr requests semantic_version lxml
+  "$BREW_X64_PATH/bin/pipenv" run pip3 install py7zr requests semantic_version lxml
  mkdir -p "$QT_VER/macos" ; ln -s "macos" "$QT_VER/clang_64"
-  # sed -i '' 's/args\.version \/ derive_toolchain_dir(args) \/ //g' "$WORKDIR/qt-downloader/qt-downloader" # Qt 6.9.1 workaround
+  "$BREW_X64_PATH/bin/pipenv" run "$WORKDIR/qt-downloader/qt-downloader" macos desktop "$QT_VER" clang_64 --opensource --addons qtmultimedia
  arch -x86_64 "$BREW_X64_PATH/bin/pipenv"  --python "$BREW_X64_PATH/bin/python3" run "$WORKDIR/qt-downloader/qt-downloader" macos desktop "$QT_VER" clang_64 --opensource --addons qtmultimedia qtimageformats # -o "$QT_VER/clang_64"
 fi
 cd "$WORKDIR"
 ditto "/tmp/Qt/$QT_VER" "qt-downloader/$QT_VER"
 export Qt6_DIR="$WORKDIR/qt-downloader/$QT_VER/clang_64/lib/cmake/Qt$QT_VER_MAIN"
-export SDL3_DIR="$BREW_X64_PATH/opt/sdl3/lib/cmake/SDL3"
+export SDL2_DIR="$BREW_X64_PATH/opt/sdl2/lib/cmake/SDL2"
-export PATH="$BREW_X64_PATH/opt/llvm@$LLVM_COMPILER_VER/bin:$WORKDIR/qt-downloader/$QT_VER/clang_64/bin:$BREW_BIN:$BREW_SBIN:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/Library/Apple/usr/bin:$PATH"
+export PATH="$BREW_X64_PATH/opt/llvm@16/bin:$WORKDIR/qt-downloader/$QT_VER/clang_64/bin:$BREW_BIN:$BREW_SBIN:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/Library/Apple/usr/bin:$PATH"
 export LDFLAGS="-L$BREW_X64_PATH/lib -Wl,-rpath,$BREW_X64_PATH/lib"
-export CPPFLAGS="-I$BREW_X64_PATH/include -msse -msse2 -mcx16 -no-pie -D__MAC_OS_X_VERSION_MIN_REQUIRED=140000"
+export CPPFLAGS="-I$BREW_X64_PATH/include -msse -msse2 -mcx16 -no-pie"
 export CFLAGS="-D__MAC_OS_X_VERSION_MIN_REQUIRED=140000"
 export LIBRARY_PATH="$BREW_X64_PATH/lib"
 export LD_LIBRARY_PATH="$BREW_X64_PATH/lib"
@ -67,21 +61,17 @@ ln -s "$VULKAN_SDK/lib/libMoltenVK.dylib" "$VULKAN_SDK/lib/libvulkan.dylib"
 export VK_ICD_FILENAMES="$VULKAN_SDK/share/vulkan/icd.d/MoltenVK_icd.json"
 export LLVM_DIR
-LLVM_DIR="BREW_X64_PATH/opt/llvm@$LLVM_COMPILER_VER"
+LLVM_DIR="BREW_X64_PATH/opt/llvm@16"
-# exclude ffmpeg, LLVM, opencv, and sdl from submodule update
+# exclude ffmpeg, SPIRV and LLVM, and sdl from submodule update
 # shellcheck disable=SC2046
-git submodule -q update --init --depth=1 --jobs=8 $(awk '/path/ && !/ffmpeg/ && !/llvm/ && !/opencv/ && !/SDL/ { print $3 }' .gitmodules)
+git submodule -q update --init --depth=1 --jobs=8 $(awk '/path/ && !/ffmpeg/ && !/llvm/ && !/SPIRV/ && !/SDL/ { print $3 }' .gitmodules)
 # 3rdparty fixes
 sed -i '' "s/extern const double NSAppKitVersionNumber;/const double NSAppKitVersionNumber = 1343;/g" 3rdparty/hidapi/hidapi/mac/hid.c
 mkdir build && cd build || exit 1
 export MACOSX_DEPLOYMENT_TARGET=14.0
 "$BREW_X64_PATH/bin/cmake" .. \
    -DBUILD_RPCS3_TESTS=OFF \
    -DRUN_RPCS3_TESTS=OFF \
    -DUSE_SDL=ON \
    -DUSE_DISCORD_RPC=ON \
    -DUSE_VULKAN=ON \
@ -103,22 +93,19 @@ export MACOSX_DEPLOYMENT_TARGET=14.0
    -DUSE_SYSTEM_MVK=ON \
    -DUSE_SYSTEM_FAUDIO=OFF \
    -DUSE_SYSTEM_SDL=ON \
-    -DUSE_SYSTEM_OPENCV=ON \
+    $CMAKE_EXTRA_OPTS \
    "$CMAKE_EXTRA_OPTS" \
    -DLLVM_TARGET_ARCH=X86_64 \
    -DCMAKE_OSX_ARCHITECTURES=x86_64 \
-    -DCMAKE_IGNORE_PATH="$BREW_X64_PATH/lib" \
+    -DCMAKE_IGNORE_PATH="$BREW_PATH/lib" \
    -DCMAKE_IGNORE_PREFIX_PATH=/usr/local/opt \
    -DCMAKE_CXX_FLAGS="-D__MAC_OS_X_VERSION_MIN_REQUIRED=140000" \
    -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
    -DCMAKE_OSX_SYSROOT="$(xcrun --sdk macosx --show-sdk-path)" \
    -G Ninja
-"$BREW_X64_PATH/bin/ninja"; build_status=$?;
+"$BREW_PATH/bin/ninja"; build_status=$?;
 cd ..
-# If it compiled succesfully let's deploy.
+{   [ "$CI_HAS_ARTIFACTS" = "true" ];
-if [ "$build_status" -eq 0 ]; then
+} && SHOULD_DEPLOY="true" || SHOULD_DEPLOY="false"
 if [ "$build_status" -eq 0 ] && [ "$SHOULD_DEPLOY" = "true" ]; then
    .ci/deploy-mac.sh
 fi
--- a/.ci/build-windows-clang.sh
+++ b/.ci/build-windows-clang.sh
@ -1,61 +0,0 @@
 #!/bin/sh -ex
 git config --global --add safe.directory '*'
 # Pull all the submodules except some
 # Note: Tried to use git submodule status, but it takes over 20 seconds
 # shellcheck disable=SC2046
 git submodule -q update --init $(awk '/path/ && !/llvm/ && !/opencv/ && !/ffmpeg/ && !/curl/ && !/FAudio/ && !/zlib/ { print $3 }' .gitmodules)
 mkdir build && cd build || exit 1
 export CC="clang"
 export CXX="clang++"
 export LINKER=lld
 export LINKER_FLAG="-fuse-ld=${LINKER}"
 if [ -n "$LLVMVER" ]; then
  export AR="llvm-ar-$LLVMVER"
  export RANLIB="llvm-ranlib-$LLVMVER"
 else
  export AR="llvm-ar"
  export RANLIB="llvm-ranlib"
 fi
 cmake ..                                               \
    -DCMAKE_PREFIX_PATH=/clang64                       \
    -DCMAKE_INSTALL_PREFIX=/usr                        \
    -DUSE_NATIVE_INSTRUCTIONS=OFF                      \
    -DUSE_PRECOMPILED_HEADERS=OFF                      \
    -DCMAKE_C_FLAGS="$CFLAGS"                          \
    -DCMAKE_CXX_FLAGS="$CFLAGS"                        \
    -DCMAKE_EXE_LINKER_FLAGS="${LINKER_FLAG}"          \
    -DCMAKE_MODULE_LINKER_FLAGS="${LINKER_FLAG}"       \
    -DCMAKE_SHARED_LINKER_FLAGS="${LINKER_FLAG}"       \
    -DCMAKE_AR="$AR"                                   \
    -DCMAKE_RANLIB="$RANLIB"                           \
    -DUSE_SYSTEM_CURL=ON                               \
    -DUSE_FAUDIO=OFF                                   \
    -DUSE_SDL=ON                                       \
    -DUSE_SYSTEM_SDL=OFF                               \
    -DUSE_SYSTEM_FFMPEG=ON                             \
    -DUSE_SYSTEM_OPENCV=ON                             \
    -DUSE_SYSTEM_OPENAL=OFF                            \
    -DUSE_DISCORD_RPC=ON                               \
    -DOpenGL_GL_PREFERENCE=LEGACY                      \
    -DWITH_LLVM=ON                                     \
    -DLLVM_DIR=/clang64/lib/cmake/llvm                 \
    -DVulkan_LIBRARY=/clang64/lib/libvulkan-1.dll.a    \
    -DSTATIC_LINK_LLVM=ON                              \
    -DBUILD_RPCS3_TESTS=OFF                            \
    -DRUN_RPCS3_TESTS=OFF                              \
    -G Ninja
 ninja; build_status=$?;
 cd ..
 # If it compiled succesfully let's deploy.
 if [ "$build_status" -eq 0 ]; then
    .ci/deploy-windows-clang.sh "x86_64"
 fi
--- a/.ci/deploy-linux.sh
+++ b/.ci/deploy-linux.sh
@ -2,51 +2,33 @@
 cd build || exit 1
 CPU_ARCH="${1:-x86_64}"
 if [ "$DEPLOY_APPIMAGE" = "true" ]; then
    DESTDIR=AppDir ninja install
-    curl -fsSLo /usr/bin/linuxdeploy "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-$CPU_ARCH.AppImage"
+    curl -fsSLo /usr/bin/linuxdeploy https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
    chmod +x /usr/bin/linuxdeploy
-    curl -fsSLo /usr/bin/linuxdeploy-plugin-qt "https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-$CPU_ARCH.AppImage"
+    curl -fsSLo /usr/bin/linuxdeploy-plugin-qt https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
    chmod +x /usr/bin/linuxdeploy-plugin-qt
-    curl -fsSLo linuxdeploy-plugin-checkrt.sh https://github.com/darealshinji/linuxdeploy-plugin-checkrt/releases/download/continuous/linuxdeploy-plugin-checkrt.sh
+    curl -fsSLo linuxdeploy-plugin-checkrt.sh https://github.com/linuxdeploy/linuxdeploy-plugin-checkrt/releases/download/continuous/linuxdeploy-plugin-checkrt-x86_64.sh
    chmod +x ./linuxdeploy-plugin-checkrt.sh
-    export EXTRA_PLATFORM_PLUGINS="libqwayland-egl.so;libqwayland-generic.so"
+    EXTRA_QT_PLUGINS="svg;" APPIMAGE_EXTRACT_AND_RUN=1 linuxdeploy --appdir AppDir --plugin qt
    export EXTRA_QT_PLUGINS="svg;wayland-decoration-client;wayland-graphics-integration-client;wayland-shell-integration;waylandcompositor"
    APPIMAGE_EXTRACT_AND_RUN=1 linuxdeploy --appdir AppDir --plugin qt --plugin checkrt
    # Remove libwayland-client because it has platform-dependent exports and breaks other OSes
    rm -f ./AppDir/usr/lib/libwayland-client.so*
    # Remove libvulkan because it causes issues with gamescope
    rm -f ./AppDir/usr/lib/libvulkan.so*
    # Remove unused Qt6 libraries
    rm -f ./AppDir/usr/lib/libQt6VirtualKeyboard.so*
    rm -f ./AppDir/usr/plugins/platforminputcontexts/libqtvirtualkeyboardplugin.so*
    # Remove git directory containing local commit history file
    rm -rf ./AppDir/usr/share/rpcs3/git
-    curl -fsSLo /uruntime "https://github.com/VHSgunzo/uruntime/releases/download/v0.3.4/uruntime-appimage-dwarfs-$CPU_ARCH"
+    ./linuxdeploy-plugin-checkrt.sh --appdir AppDir
    chmod +x /uruntime
    /uruntime --appimage-mkdwarfs -f --set-owner 0 --set-group 0 --no-history --no-create-timestamp \
    --compression zstd:level=22 -S26 -B32 --header /uruntime -i AppDir -o RPCS3.AppImage
-    APPIMAGE_SUFFIX="linux_${CPU_ARCH}"
+    linuxdeploy --appimage-extract
-    if [ "$CPU_ARCH" = "x86_64" ]; then
+    ./squashfs-root/plugins/linuxdeploy-plugin-appimage/usr/bin/appimagetool AppDir -g
        # Preserve back compat. Previous versions never included the full arch.
        APPIMAGE_SUFFIX="linux64"
    fi
    COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ../rpcs3/rpcs3_version.cpp)
    COMM_COUNT="$(git rev-list --count HEAD)"
    COMM_HASH="$(git rev-parse --short=8 HEAD)"
-    RPCS3_APPIMAGE="rpcs3-v${COMM_TAG}-${COMM_COUNT}-${COMM_HASH}_${APPIMAGE_SUFFIX}.AppImage"
+    RPCS3_APPIMAGE="rpcs3-v${COMM_TAG}-${COMM_COUNT}-${COMM_HASH}_linux64.AppImage"
    mv ./RPCS3*.AppImage "$RPCS3_APPIMAGE"
--- a/.ci/deploy-llvm.sh
+++ b/.ci/deploy-llvm.sh
@ -1,20 +0,0 @@
 #!/bin/sh -ex
 # First let's print some info about our caches
 "$(cygpath -u "$CCACHE_BIN_DIR")"/ccache.exe --show-stats -v
 # BUILD_blablabla is Azure specific, so we wrap it for portability
 ARTIFACT_DIR="$BUILD_ARTIFACTSTAGINGDIRECTORY"
 BUILD="llvmlibs_mt.7z"
 # Package artifacts
 7z a -m0=LZMA2 -mx9 "$BUILD" ./build/lib/Release-x64/llvm_build
 # Generate sha256 hashes
 # Write to file for GitHub releases
 sha256sum "$BUILD" | awk '{ print $1 }' | tee "$BUILD.sha256"
 echo "$(cat "$BUILD.sha256");$(stat -c %s "$BUILD")B" > GitHubReleaseMessage.txt
 # Move files to publishing directory
 cp -- "$BUILD" "$ARTIFACT_DIR"
 cp -- "$BUILD.sha256" "$ARTIFACT_DIR"
--- a/.ci/deploy-mac-arm64.sh
+++ b/.ci/deploy-mac-arm64.sh
@ -1,74 +0,0 @@
 #!/bin/sh -ex
 # shellcheck disable=SC2086
 cd build || exit 1
 # Gather explicit version number and number of commits
 COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ../rpcs3/rpcs3_version.cpp)
 COMM_COUNT=$(git rev-list --count HEAD)
 COMM_HASH=$(git rev-parse --short=8 HEAD)
 AVVER="${COMM_TAG}-${COMM_COUNT}"
 # AVVER is used for GitHub releases, it is the version number.
 echo "AVVER=$AVVER" >> ../.ci/ci-vars.env
 cd bin
 mkdir "rpcs3.app/Contents/lib/" || true
 cp "$(realpath /opt/homebrew/opt/llvm@$LLVM_COMPILER_VER/lib/c++/libc++abi.1.0.dylib)" "rpcs3.app/Contents/Frameworks/libc++abi.1.dylib"
 cp "$(realpath /opt/homebrew/lib/libsharpyuv.0.dylib)" "rpcs3.app/Contents/lib/libsharpyuv.0.dylib"
 cp "$(realpath /opt/homebrew/lib/libintl.8.dylib)" "rpcs3.app/Contents/lib/libintl.8.dylib"
 rm -rf "rpcs3.app/Contents/Frameworks/QtPdf.framework" \
 "rpcs3.app/Contents/Frameworks/QtQml.framework" \
 "rpcs3.app/Contents/Frameworks/QtQmlModels.framework" \
 "rpcs3.app/Contents/Frameworks/QtQuick.framework" \
 "rpcs3.app/Contents/Frameworks/QtVirtualKeyboard.framework" \
 "rpcs3.app/Contents/Plugins/platforminputcontexts" \
 "rpcs3.app/Contents/Plugins/virtualkeyboard" \
 "rpcs3.app/Contents/Resources/git"
 ../../.ci/optimize-mac.sh rpcs3.app
 # Hack
 install_name_tool \
 -delete_rpath /opt/homebrew/lib \
 -delete_rpath /opt/homebrew/opt/llvm@$LLVM_COMPILER_VER/lib RPCS3.app/Contents/MacOS/rpcs3
 #-delete_rpath /opt/homebrew1/Cellar/sdl3/3.2.8/lib
 # Need to do this rename hack due to case insensitive filesystem
 mv rpcs3.app RPCS3_.app
 mv RPCS3_.app RPCS3.app
 # NOTE: "--deep" is deprecated
 codesign --deep -fs - RPCS3.app
 echo "[InternetShortcut]" > Quickstart.url
 echo "URL=https://rpcs3.net/quickstart" >> Quickstart.url
 echo "IconIndex=0" >> Quickstart.url
 #DMG_FILEPATH="$BUILD_ARTIFACTSTAGINGDIRECTORY/rpcs3-v${COMM_TAG}-${COMM_COUNT}-${COMM_HASH}_macos_arm64.dmg"
 #"$BREW_X64_PATH/bin/create-dmg" --volname RPCS3 \
 #--window-size 800 400 \
 #--icon-size 100 \
 #--icon rpcs3.app 200 190 \
 #--add-file Quickstart.url Quickstart.url 400 20 \
 #--hide-extension rpcs3.app \
 #--hide-extension Quickstart.url \
 #--app-drop-link 600 185 \
 #--skip-jenkins \
 #--format ULMO \
 #"$DMG_FILEPATH" \
 #RPCS3.app
 #FILESIZE=$(stat -f %z "$DMG_FILEPATH")
 #SHA256SUM=$(shasum -a 256 "$DMG_FILEPATH" | awk '{ print $1 }')
 ARCHIVE_FILEPATH="$BUILD_ARTIFACTSTAGINGDIRECTORY/rpcs3-v${COMM_TAG}-${COMM_COUNT}-${COMM_HASH}_macos_arm64.7z"
 "$BREW_PATH/bin/7z" a -mx9 "$ARCHIVE_FILEPATH" RPCS3.app Quickstart.url
 FILESIZE=$(stat -f %z "$ARCHIVE_FILEPATH")
 SHA256SUM=$(shasum -a 256 "$ARCHIVE_FILEPATH" | awk '{ print $1 }')
 cd ..
 echo "${SHA256SUM};${FILESIZE}B" > "$RELEASE_MESSAGE"
 cd bin
--- a/.ci/deploy-mac.sh
+++ b/.ci/deploy-mac.sh
@ -1,6 +1,5 @@
 #!/bin/sh -ex
 # shellcheck disable=SC2086
 cd build || exit 1
 # Gather explicit version number and number of commits
@ -16,7 +15,7 @@ echo "AVVER=$AVVER" >> ../.ci/ci-vars.env
 cd bin
 mkdir "rpcs3.app/Contents/lib/"
-cp "/usr/local/opt/llvm@$LLVM_COMPILER_VER/lib/c++/libc++abi.1.0.dylib" "rpcs3.app/Contents/lib/libc++abi.1.dylib"
+cp "/usr/local/opt/llvm@16/lib/c++/libc++abi.1.0.dylib" "rpcs3.app/Contents/lib/libc++abi.1.dylib"
 cp "$(realpath /usr/local/lib/libsharpyuv.0.dylib)" "rpcs3.app/Contents/lib/libsharpyuv.0.dylib"
 cp "$(realpath /usr/local/lib/libintl.8.dylib)" "rpcs3.app/Contents/lib/libintl.8.dylib"
@ -29,21 +28,10 @@ rm -rf "rpcs3.app/Contents/Frameworks/QtPdf.framework" \
 "rpcs3.app/Contents/Plugins/virtualkeyboard" \
 "rpcs3.app/Contents/Resources/git"
 ../../.ci/optimize-mac.sh rpcs3.app
 # Need to do this rename hack due to case insensitive filesystem
 mv rpcs3.app RPCS3_.app
 mv RPCS3_.app RPCS3.app
 # Hack
 install_name_tool \
 -delete_rpath /usr/local/lib \
 -delete_rpath /usr/local/opt/llvm@$LLVM_COMPILER_VER/lib RPCS3.app/Contents/MacOS/rpcs3
 #-delete_rpath /usr/local/Cellar/sdl3/3.2.8/lib
 # NOTE: "--deep" is deprecated
 codesign --deep -fs - RPCS3.app
 echo "[InternetShortcut]" > Quickstart.url
 echo "URL=https://rpcs3.net/quickstart" >> Quickstart.url
 echo "IconIndex=0" >> Quickstart.url
--- a/.ci/deploy-windows-clang.sh
+++ b/.ci/deploy-windows-clang.sh
@ -1,38 +0,0 @@
 #!/bin/sh -ex
 # source ci-vars.env
 # shellcheck disable=SC1091
 . .ci/ci-vars.env
 cd build || exit 1
 CPU_ARCH="${1:-x86_64}"
 echo "Deploying rpcs3 windows clang $CPU_ARCH"
 # BUILD_blablabla is CI specific, so we wrap it for portability
 ARTIFACT_DIR=$(cygpath -u "$BUILD_ARTIFACTSTAGINGDIRECTORY")
 MSYS2_CLANG_BIN=$(cygpath -w /clang64/bin)
 MSYS2_USR_BIN=$(cygpath -w /usr/bin)
 echo "Installing dependencies of: ./bin/rpcs3.exe (MSYS2 dir is '$MSYS2_CLANG_BIN', usr dir is '$MSYS2_USR_BIN')"
 cmake -DMSYS2_CLANG_BIN="$MSYS2_CLANG_BIN" -DMSYS2_USR_BIN="$MSYS2_USR_BIN" -Dexe=./bin/rpcs3.exe -P ../buildfiles/cmake/CopyRuntimeDependencies.cmake
 # Prepare compatibility and SDL database for packaging
 mkdir ./bin/config
 mkdir ./bin/config/input_configs
 curl -fsSL 'https://raw.githubusercontent.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt' 1> ./bin/config/input_configs/gamecontrollerdb.txt
 curl -fsSL 'https://rpcs3.net/compatibility?api=v1&export' | iconv -t UTF-8 1> ./bin/GuiConfigs/compat_database.dat
 # Package artifacts
 7z a -m0=LZMA2 -mx9 "$BUILD" ./bin/*
 # Generate sha256 hashes
 # Write to file for GitHub releases
 sha256sum "$BUILD" | awk '{ print $1 }' | tee "$BUILD.sha256"
 echo "$(cat "$BUILD.sha256");$(stat -c %s "$BUILD")B" > GitHubReleaseMessage.txt
 # Move files to publishing directory
 mkdir -p "$ARTIFACT_DIR"
 cp -- "$BUILD" "$ARTIFACT_DIR"
 cp -- "$BUILD.sha256" "$ARTIFACT_DIR"
--- a/.ci/deploy-windows.sh
+++ b/.ci/deploy-windows.sh
@ -1,13 +1,11 @@
 #!/bin/sh -ex
-# First let's print some info about our caches
+# BUILD_blablabla is Azure specific, so we wrap it for portability
 "$(cygpath -u "$CCACHE_BIN_DIR")"/ccache.exe --show-stats -v
 # BUILD_blablabla is CI specific, so we wrap it for portability
 ARTIFACT_DIR="$BUILD_ARTIFACTSTAGINGDIRECTORY"
 # Remove unecessary files
 rm -f ./bin/rpcs3.exp ./bin/rpcs3.lib ./bin/rpcs3.pdb ./bin/vc_redist.x64.exe
 rm -rf ./bin/git
 # Prepare compatibility and SDL database for packaging
 mkdir ./bin/config
--- a/.ci/docker.env
+++ b/.ci/docker.env
@ -1,4 +1,5 @@
-# Variables set by CI
+# Variables set by Azure Pipelines
 CI_HAS_ARTIFACTS
 BUILD_REASON
 BUILD_SOURCEVERSION
 BUILD_ARTIFACTSTAGINGDIRECTORY
@ -7,7 +8,6 @@ BUILD_SOURCEBRANCHNAME
 APPDIR
 ARTDIR
 RELEASE_MESSAGE
 RUN_UNIT_TESTS
 # Variables for build matrix
 COMPILER
 DEPLOY_APPIMAGE
--- a/.ci/export-azure-vars.sh
+++ b/.ci/export-azure-vars.sh
@ -0,0 +1,13 @@
 #!/bin/sh -e
 # Export variables for later stages of the Azure pipeline
 # Values done in this manner will appear as environment variables
 # in later stages.
 # From pure-sh-bible
 # Setting 'IFS' tells 'read' where to split the string.
 while IFS='=' read -r key val; do
    # Skip over lines containing comments.
    [ "${key##\#*}" ] || continue
    echo "##vso[task.setvariable variable=$key]$val"
 done < ".ci/ci-vars.env"
--- a/.ci/export-cirrus-vars.sh
+++ b/.ci/export-cirrus-vars.sh
@ -0,0 +1,13 @@
 #!/bin/sh -e
 # Export variables for later stages of the Cirrus pipeline
 # Values done in this manner will appear as environment variables
 # in later stages.
 # From pure-sh-bible
 # Setting 'IFS' tells 'read' where to split the string.
 while IFS='=' read -r key val; do
    # Skip over lines containing comments.
    [ "${key##\#*}" ] || continue
    export "$key"="$val"
 done < ".ci/ci-vars.env"
--- a/.ci/generate-qt-ts.sh
+++ b/.ci/generate-qt-ts.sh
@ -1,13 +0,0 @@
 #!/bin/sh -ex
 mkdir -p ../translations
 LUPDATE_PATH=$(find /usr -name lupdate -type f 2>/dev/null | head -n 1)
 if [ -z "$LUPDATE_PATH" ]; then
  echo "Error: lupdate not found!"
  exit 1
 else
  echo "lupdate found at: $LUPDATE_PATH"
  $LUPDATE_PATH -recursive . -ts ../translations/rpcs3_template.ts
  sed -i 's|filename="\.\./|filename="./|g' ../translations/rpcs3_template.ts
 fi
--- a/.ci/get_keys-windows.sh
+++ b/.ci/get_keys-windows.sh
@ -1,3 +1,4 @@
 #!/bin/sh -ex
-curl -fLo "./llvm.lock" "https://github.com/RPCS3/llvm-mirror/releases/download/custom-build-win-${LLVM_VER}/llvmlibs_mt.7z.sha256"
+curl -fLo "./llvm.lock" "https://github.com/RPCS3/llvm-mirror/releases/download/custom-build-win-16.0.1/llvmlibs_mt.7z.sha256"
 curl -fLo "./glslang.lock" "https://github.com/RPCS3/glslang/releases/download/custom-build-win/glslanglibs_mt.7z.sha256"
--- a/.ci/install-freebsd.sh
+++ b/.ci/install-freebsd.sh
@ -8,11 +8,11 @@ sed -i '' 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
 export ASSUME_ALWAYS_YES=true
 pkg info # debug
-# WITH_LLVM
+# Prefer newer Clang than in base system (see also .ci/build-freebsd.sh)
-pkg install "llvm$LLVM_COMPILER_VER"
+pkg install llvm16
-# Mandatory dependencies (qtX-base is pulled via qtX-multimedia)
+# Mandatory dependencies (qt6-base is pulled via qt6-multimedia)
-pkg install git ccache cmake ninja "qt$QT_VER_MAIN-multimedia" "qt$QT_VER_MAIN-svg" glew openal-soft ffmpeg
+pkg install git ccache cmake ninja qt6-multimedia qt6-svg glew openal-soft ffmpeg
-# Optional dependencies (libevdev is pulled by qtX-base)
+# Optional dependencies (libevdev is pulled by qt6-base)
-pkg install pkgconf alsa-lib pulseaudio sdl3 evdev-proto vulkan-headers vulkan-loader opencv
+pkg install pkgconf alsa-lib pulseaudio sdl2 evdev-proto vulkan-headers vulkan-loader
--- a/.ci/optimize-mac.sh
+++ b/.ci/optimize-mac.sh
@ -1,21 +0,0 @@
 #!/bin/sh
 file_path=$(find "$1/Contents/MacOS" -type f -print0 | head -n 1)
 if [ -z "$file_path" ]; then
    echo "No executable file found in $1/Contents/MacOS" >&2
    exit 1
 fi
 target_architecture="$(lipo "$file_path" -archs)"
 if [ -z "$target_architecture" ]; then
    exit 1
 fi
 # shellcheck disable=SC3045
 find "$1" -type f -print0 | while IFS= read -r -d '' file; do
    echo Thinning "$file" -> "$target_architecture"
    lipo "$file" -thin "$target_architecture" -output "$file" || true
 done
--- a/.ci/setup-llvm.sh
+++ b/.ci/setup-llvm.sh
@ -1,63 +0,0 @@
 #!/bin/sh -ex
 # Resource/dependency URLs
 CCACHE_URL="https://github.com/ccache/ccache/releases/download/v4.11.2/ccache-4.11.2-windows-x86_64.zip"
 DEP_URLS="         \
    $CCACHE_URL"
 # CI doesn't make a cache dir if it doesn't exist, so we do it manually
 [ -d "$DEPS_CACHE_DIR" ] || mkdir "$DEPS_CACHE_DIR"
 # Pull the llvm submodule
 # shellcheck disable=SC2046
 git submodule -q update --init --depth=1 -- 3rdparty/llvm
 # Git bash doesn't have rev, so here it is
 rev()
 {
    echo "$1" | awk '{ for(i = length($0); i != 0; --i) { a = a substr($0, i, 1); } } END { print a }'
 }
 # Usage: download_and_verify url checksum algo file
 # Check to see if a file is already cached, and the checksum matches. If not, download it.
 # Tries up to 3 times
 download_and_verify()
 {
    url="$1"
    correctChecksum="$2"
    algo="$3"
    fileName="$4"
    for _ in 1 2 3; do
        [ -e "$DEPS_CACHE_DIR/$fileName" ] || curl -fLo "$DEPS_CACHE_DIR/$fileName" "$url"
        fileChecksum=$("${algo}sum" "$DEPS_CACHE_DIR/$fileName" | awk '{ print $1 }')
        [ "$fileChecksum" = "$correctChecksum" ] && return 0
    done
    return 1;
 }
 # Some dependencies install here
 [ -d "./build/lib_ext/Release-x64" ] || mkdir -p "./build/lib_ext/Release-x64"
 for url in $DEP_URLS; do
    # Get the filename from the URL and remove query strings (?arg=something).
    fileName="$(rev "$(rev "$url" | cut -d'/' -f1)" | cut -d'?' -f1)"
    [ -z "$fileName" ] && echo "Unable to parse url: $url" && exit 1
    # shellcheck disable=SC1003
    case "$url" in
    *ccache*) checksum=$CCACHE_SHA; algo="sha256"; outDir="$CCACHE_BIN_DIR" ;;
    *) echo "Unknown url resource: $url"; exit 1 ;;
    esac
    download_and_verify "$url" "$checksum" "$algo" "$fileName"
    7z x -y "$DEPS_CACHE_DIR/$fileName" -aos -o"$outDir"
 done
 # Setup ccache tool
 [ -d "$CCACHE_DIR" ] || mkdir -p "$(cygpath -u "$CCACHE_DIR")"
 CCACHE_SH_DIR=$(cygpath -u "$CCACHE_BIN_DIR")
 mv "$CCACHE_SH_DIR"/ccache-*/* "$CCACHE_SH_DIR"
 cp "$CCACHE_SH_DIR"/ccache.exe "$CCACHE_SH_DIR"/cl.exe
--- a/.ci/setup-windows-ci-vars.sh
+++ b/.ci/setup-windows-ci-vars.sh
@ -1,39 +0,0 @@
 #!/bin/sh -ex
 CPU_ARCH="${1:-win64}"
 COMPILER="${2:-msvc}"
 # These are CI specific, so we wrap them for portability
 REPO_NAME="$BUILD_REPOSITORY_NAME"
 REPO_BRANCH="$BUILD_SOURCEBRANCHNAME"
 PR_NUMBER="$BUILD_PR_NUMBER"
 # Gather explicit version number and number of commits
 COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ./rpcs3/rpcs3_version.cpp)
 COMM_COUNT=$(git rev-list --count HEAD)
 COMM_HASH=$(git rev-parse --short=8 HEAD)
 # Format the above into filenames
 if [ -n "$PR_NUMBER" ]; then
    AVVER="${COMM_TAG}-${COMM_HASH}"
    BUILD_RAW="rpcs3-v${AVVER}_${CPU_ARCH}_${COMPILER}"
    BUILD="${BUILD_RAW}.7z"
 else
    AVVER="${COMM_TAG}-${COMM_COUNT}"
    BUILD_RAW="rpcs3-v${AVVER}-${COMM_HASH}_${CPU_ARCH}_${COMPILER}"
    BUILD="${BUILD_RAW}.7z"
 fi
 # BRANCH is used for experimental build warnings for pr builds, used in main_window.cpp.
 # BUILD is the name of the release artifact
 # BUILD_RAW is just filename
 # AVVER is used for GitHub releases, it is the version number.
 BRANCH="${REPO_NAME}/${REPO_BRANCH}"
 # SC2129
 {
    echo "BRANCH=$BRANCH"
    echo "BUILD=$BUILD"
    echo "BUILD_RAW=$BUILD_RAW"
    echo "AVVER=$AVVER"
 } >> .ci/ci-vars.env
--- a/.ci/setup-windows.sh
+++ b/.ci/setup-windows.sh
@ -1,22 +1,27 @@
 #!/bin/sh -ex
 # These are Azure specific, so we wrap them for portability
 REPO_NAME="$BUILD_REPOSITORY_NAME"
 REPO_BRANCH="$SYSTEM_PULLREQUEST_SOURCEBRANCH"
 PR_NUMBER="$SYSTEM_PULLREQUEST_PULLREQUESTID"
 # Resource/dependency URLs
 # Qt mirrors can be volatile and slow, so we list 2
 #QT_HOST="http://mirrors.ocf.berkeley.edu/qt/"
 QT_HOST="http://qt.mirror.constant.com/"
 QT_URL_VER=$(echo "$QT_VER" | sed "s/\.//g")
 QT_VER_MSVC_UP=$(echo "${QT_VER_MSVC}" | tr '[:lower:]' '[:upper:]')
-QT_PREFIX="online/qtsdkrepository/windows_x86/desktop/qt${QT_VER_MAIN}_${QT_URL_VER}/qt${QT_VER_MAIN}_${QT_URL_VER}/qt.qt${QT_VER_MAIN}.${QT_URL_VER}."
+QT_PREFIX="online/qtsdkrepository/windows_x86/desktop/qt${QT_VER_MAIN}_${QT_URL_VER}/qt.qt${QT_VER_MAIN}.${QT_URL_VER}."
 QT_PREFIX_2="win64_${QT_VER_MSVC}_64/${QT_VER}-0-${QT_DATE}"
-QT_SUFFIX="-Windows-Windows_11_23H2-${QT_VER_MSVC_UP}-Windows-Windows_11_23H2-X86_64.7z"
+QT_SUFFIX="-Windows-Windows_10_22H2-${QT_VER_MSVC_UP}-Windows-Windows_10_22H2-X86_64.7z"
 QT_BASE_URL="${QT_HOST}${QT_PREFIX}${QT_PREFIX_2}qtbase${QT_SUFFIX}"
 QT_DECL_URL="${QT_HOST}${QT_PREFIX}${QT_PREFIX_2}qtdeclarative${QT_SUFFIX}"
 QT_TOOL_URL="${QT_HOST}${QT_PREFIX}${QT_PREFIX_2}qttools${QT_SUFFIX}"
 QT_MM_URL="${QT_HOST}${QT_PREFIX}addons.qtmultimedia.${QT_PREFIX_2}qtmultimedia${QT_SUFFIX}"
 QT_SVG_URL="${QT_HOST}${QT_PREFIX}${QT_PREFIX_2}qtsvg${QT_SUFFIX}"
-LLVMLIBS_URL="https://github.com/RPCS3/llvm-mirror/releases/download/custom-build-win-${LLVM_VER}/llvmlibs_mt.7z"
+LLVMLIBS_URL='https://github.com/RPCS3/llvm-mirror/releases/download/custom-build-win-16.0.1/llvmlibs_mt.7z'
-VULKAN_SDK_URL="https://www.dropbox.com/scl/fi/sjjh0fc4ld281pjbl2xzu/VulkanSDK-${VULKAN_VER}-Installer.exe?rlkey=f6wzc0lvms5vwkt2z3qabfv9d&dl=1"
+GLSLANG_URL='https://github.com/RPCS3/glslang/releases/latest/download/glslanglibs_mt.7z'
-CCACHE_URL="https://github.com/ccache/ccache/releases/download/v4.11.2/ccache-4.11.2-windows-x86_64.zip"
+VULKAN_SDK_URL="https://www.dropbox.com/scl/fi/sjjh0fc4ld281pjbl2xzu/VulkanSDK-1.3.268.0-Installer.exe?rlkey=f6wzc0lvms5vwkt2z3qabfv9d&dl=1"
 DEP_URLS="         \
    $QT_BASE_URL   \
@ -25,16 +30,16 @@ DEP_URLS="         \
    $QT_MM_URL     \
    $QT_SVG_URL    \
    $LLVMLIBS_URL  \
-    $VULKAN_SDK_URL\
+    $GLSLANG_URL   \
-    $CCACHE_URL"
+    $VULKAN_SDK_URL"
-# CI doesn't make a cache dir if it doesn't exist, so we do it manually
+# Azure pipelines doesn't make a cache dir if it doesn't exist, so we do it manually
-[ -d "$DEPS_CACHE_DIR" ] || mkdir "$DEPS_CACHE_DIR"
+[ -d "$CACHE_DIR" ] || mkdir "$CACHE_DIR"
 # Pull all the submodules except llvm, since it is built separately and we just download that build
 # Note: Tried to use git submodule status, but it takes over 20 seconds
 # shellcheck disable=SC2046
-git submodule -q update --init --depth=1 --jobs=8 $(awk '/path/ && !/FAudio/ && !/llvm/ { print $3 }' .gitmodules)
+git submodule -q update --init --depth=1 --jobs=8 $(awk '/path/ && !/FAudio/ && !/llvm/ && !/SPIRV/ { print $3 }' .gitmodules)
 # Git bash doesn't have rev, so here it is
 rev()
@ -53,16 +58,17 @@ download_and_verify()
    fileName="$4"
    for _ in 1 2 3; do
-        [ -e "$DEPS_CACHE_DIR/$fileName" ] || curl -fLo "$DEPS_CACHE_DIR/$fileName" "$url"
+        [ -e "$CACHE_DIR/$fileName" ] || curl -fLo "$CACHE_DIR/$fileName" "$url"
-        fileChecksum=$("${algo}sum" "$DEPS_CACHE_DIR/$fileName" | awk '{ print $1 }')
+        fileChecksum=$("${algo}sum" "$CACHE_DIR/$fileName" | awk '{ print $1 }')
        [ "$fileChecksum" = "$correctChecksum" ] && return 0
        rm "$CACHE_DIR/$fileName"
    done
    return 1;
 }
 # Some dependencies install here
-[ -d "./build/lib_ext/Release-x64" ] || mkdir -p "./build/lib_ext/Release-x64"
+[ -d "./lib" ] || mkdir "./lib"
 for url in $DEP_URLS; do
    # Get the filename from the URL and remove query strings (?arg=something).
@ -71,14 +77,14 @@ for url in $DEP_URLS; do
    # shellcheck disable=SC1003
    case "$url" in
-    *qt*) checksum=$(curl -fL "${url}.sha1"); algo="sha1"; outDir="$QTDIR/" ;;
+    *qt*) checksum=$(curl -fL "${url}.sha1"); algo="sha1"; outDir='C:\Qt\' ;;
-    *llvm*) checksum=$(curl -fL "${url}.sha256"); algo="sha256"; outDir="./build/lib_ext/Release-x64" ;;
+    *llvm*) checksum=$(curl -fL "${url}.sha256"); algo="sha256"; outDir="./3rdparty/llvm" ;;
-    *ccache*) checksum=$CCACHE_SHA; algo="sha256"; outDir="$CCACHE_BIN_DIR" ;;
+    *glslang*) checksum=$(curl -fL "${url}.sha256"); algo="sha256"; outDir="./lib/Release-x64" ;;
    *Vulkan*)
        # Vulkan setup needs to be run in batch environment
        # Need to subshell this or else it doesn't wait
        download_and_verify "$url" "$VULKAN_SDK_SHA" "sha256" "$fileName"
-        cp "$DEPS_CACHE_DIR/$fileName" .
+        cp "$CACHE_DIR/$fileName" .
        _=$(echo "$fileName --accept-licenses --default-answer --confirm-command install" | cmd)
        continue
    ;;
@ -86,11 +92,27 @@ for url in $DEP_URLS; do
    esac
    download_and_verify "$url" "$checksum" "$algo" "$fileName"
-    7z x -y "$DEPS_CACHE_DIR/$fileName" -aos -o"$outDir"
+    7z x -y "$CACHE_DIR/$fileName" -aos -o"$outDir"
 done
-# Setup ccache tool
+# Gather explicit version number and number of commits
-[ -d "$CCACHE_DIR" ] || mkdir -p "$(cygpath -u "$CCACHE_DIR")"
+COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ./rpcs3/rpcs3_version.cpp)
-CCACHE_SH_DIR=$(cygpath -u "$CCACHE_BIN_DIR")
+COMM_COUNT=$(git rev-list --count HEAD)
-mv "$CCACHE_SH_DIR"/ccache-*/* "$CCACHE_SH_DIR"
+COMM_HASH=$(git rev-parse --short=8 HEAD)
-cp "$CCACHE_SH_DIR"/ccache.exe "$CCACHE_SH_DIR"/cl.exe
+
 # Format the above into filenames
 if [ -n "$PR_NUMBER" ]; then
    AVVER="${COMM_TAG}-${COMM_HASH}"
    BUILD="rpcs3-v${AVVER}_win64.7z"
 else
    AVVER="${COMM_TAG}-${COMM_COUNT}"
    BUILD="rpcs3-v${AVVER}-${COMM_HASH}_win64.7z"
 fi
 # BRANCH is used for experimental build warnings for pr builds, used in main_window.cpp.
 # BUILD is the name of the release artifact
 # AVVER is used for GitHub releases, it is the version number.
 BRANCH="${REPO_NAME}/${REPO_BRANCH}"
 echo "BRANCH=$BRANCH" > .ci/ci-vars.env
 echo "BUILD=$BUILD" >> .ci/ci-vars.env
 echo "AVVER=$AVVER" >> .ci/ci-vars.env
--- a/.cirrus.yml
+++ b/.cirrus.yml
@ -0,0 +1,150 @@
 env:
  CIRRUS_CLONE_DEPTH: 0 # Unshallow clone to obtain proper GIT_VERSION
  BUILD_REPOSITORY_NAME: $CIRRUS_REPO_FULL_NAME
  SYSTEM_PULLREQUEST_SOURCEBRANCH: $CIRRUS_BRANCH
  SYSTEM_PULLREQUEST_PULLREQUESTID: $CIRRUS_PR
  BUILD_SOURCEVERSION: $CIRRUS_CHANGE_IN_REPO
  BUILD_SOURCEBRANCHNAME: $CIRRUS_BRANCH
  RPCS3_TOKEN: ENCRYPTED[!a4c3850e29ab150692286a74bec29819d25971a7ec431b86de2a35f7ed90c5b2ab3c93469f9298e30924d843599110e9!]
  QT_VER_MAIN: '6'
  QT_VER: '6.6.2'
 # windows_task:
 #   matrix:
 #     - name: Cirrus Windows
 #       windows_container:
 #         image: cirrusci/windowsservercore:visualstudio2019
 #         cpu: 8
 #         memory: 16G
 #   env:
 #     CIRRUS_SHELL: "bash"
 #     COMPILER: msvc
 #     BUILD_ARTIFACTSTAGINGDIRECTORY: ${CIRRUS_WORKING_DIR}\artifacts\
 #     QT_VER_MSVC: 'msvc2019'
 #     QT_DATE: '202402121135'
 #     QTDIR: C:\Qt\${QT_VER}\${QT_VER_MSVC}_64
 #     VULKAN_VER: '1.3.268.0'
 #     VULKAN_SDK_SHA: '8459ef49bd06b697115ddd3d97c9aec729e849cd775f5be70897718a9b3b9db5'
 #     VULKAN_SDK: C:\VulkanSDK\${VULKAN_VER}
 #     CACHE_DIR: "./cache"
 #     UPLOAD_COMMIT_HASH: 7d09e3be30805911226241afbb14f8cdc2eb054e
 #     UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-win"
 #   deps_cache:
 #     folder: "./cache"
 #   #obj_cache:
 #   #  folder: "./tmp"
 #   #obj2_cache:
 #   #  folder: "./rpcs3/x64"
 #   setup_script:
 #     - './.ci/get_keys-windows.sh'
 #     - './.ci/setup-windows.sh'
 #   rpcs3_script:
 #     - export PATH=${PATH}:"C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\MSBuild\Current\Bin"
 #     - msbuild.exe rpcs3.sln //p:Configuration=Release //m
 #   deploy_script:
 #     - mkdir artifacts
 #     - source './.ci/export-cirrus-vars.sh'
 #     - './.ci/deploy-windows.sh'
 #   artifacts:
 #     name: Artifact
 #     path: "*.7z*"
 #   push_script: |
 #     if [ "$CIRRUS_REPO_OWNER" = "RPCS3" ] && [ -z "$CIRRUS_PR" ] && [ "$CIRRUS_BRANCH" = "master" ]; then
 #       source './.ci/export-cirrus-vars.sh'
 #       './.ci/github-upload.sh'
 #     fi;
 # linux_task:
 #   container:
 #     image: rpcs3/rpcs3-ci-focal:1.6
 #     cpu: 4
 #     memory: 16G
 #   env:
 #     BUILD_ARTIFACTSTAGINGDIRECTORY: ${CIRRUS_WORKING_DIR}/artifacts
 #     ARTDIR: ${CIRRUS_WORKING_DIR}/artifacts/
 #     CCACHE_DIR: "/tmp/ccache_dir"
 #     CCACHE_MAXSIZE: 300M
 #     CI_HAS_ARTIFACTS: true
 #     UPLOAD_COMMIT_HASH: d812f1254a1157c80fd402f94446310560f54e5f
 #     UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-linux"
 #     DEPLOY_APPIMAGE: true
 #     APPDIR: "./appdir"
 #     RELEASE_MESSAGE: "../GitHubReleaseMessage.txt"
 #   ccache_cache:
 #     folder: "/tmp/ccache_dir"
 #   matrix:
 #     - name: Cirrus Linux GCC
 #       env:
 #         COMPILER: gcc
 #       gcc_script:
 #         - mkdir artifacts
 #         - ".ci/build-linux.sh"
 #     - name: Cirrus Linux Clang
 #       env:
 #         COMPILER: clang
 #       clang_script:
 #         - mkdir artifacts
 #         - ".ci/build-linux.sh"
 #   artifacts:
 #     name: Artifact
 #     path: "artifacts/*"
 #   push_script: |
 #     if [ "$CIRRUS_REPO_OWNER" = "RPCS3" ] && [ -z "$CIRRUS_PR" ] && [ "$CIRRUS_BRANCH" = "master" ] && [ "$COMPILER" = "gcc" ]; then
 #       COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ./rpcs3/rpcs3_version.cpp)
 #       COMM_COUNT=$(git rev-list --count HEAD)
 #       COMM_HASH=$(git rev-parse --short=8 HEAD)
 #       export AVVER="${COMM_TAG}-${COMM_COUNT}"
 #       .ci/github-upload.sh
 #     fi;
 freebsd_task:
  matrix:
    - name: Cirrus FreeBSD
      freebsd_instance:
        image_family: freebsd-13-2
        cpu: 8
        memory: 8G
  env:
    CCACHE_MAXSIZE: 300M # 3x clean build, rounded
    CCACHE_DIR: /tmp/ccache_dir
  ccache_cache:
    folder: /tmp/ccache_dir
  install_script: "sh -ex ./.ci/install-freebsd.sh"
  script: "./.ci/build-freebsd.sh"
 # macos_task:
 #   timeout_in: 12000m
 #   homebrew_cache:
 #     folder: /Users/admin/Library/Caches/Homebrew
 #   qt_cache:
 #     folder: /tmp/Qt
 #   ccache_cache:
 #     folder: /tmp/ccache_dir
 #   matrix:
 #     - name: Cirrus macOS
 #       macos_instance:
 #         image: ghcr.io/cirruslabs/macos-monterey-xcode:latest
 #       mac_script:
 #         - mkdir artifacts
 #         - chmod +x ".ci/build-mac.sh"
 #         - chmod +x ".ci/deploy-mac.sh"
 #         - ".ci/build-mac.sh"
 #   env:
 #     BUILD_ARTIFACTSTAGINGDIRECTORY: ${CIRRUS_WORKING_DIR}/artifacts
 #     ARTDIR: ${CIRRUS_WORKING_DIR}/artifacts/
 #     CCACHE_DIR: "/tmp/ccache_dir"
 #     CCACHE_MAXSIZE: 300M
 #     CI_HAS_ARTIFACTS: true
 #     UPLOAD_COMMIT_HASH: 51ae32f468089a8169aaf1567de355ff4a3e0842
 #     UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-mac"
 #     RELEASE_MESSAGE: "../GitHubReleaseMessage.txt"
 #   artifacts:
 #     name: Artifact
 #     path: "artifacts/*"
 #   push_script: |
 #     if [ "$CIRRUS_REPO_OWNER" = "RPCS3" ] && [ -z "$CIRRUS_PR" ] && [ "$CIRRUS_BRANCH" = "master" ]; then
 #       source './.ci/export-cirrus-vars.sh'
 #       .ci/github-upload.sh
 #     fi;
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@ -16,4 +16,4 @@ Submitting your test results for Commercial Games must be done on our forums. Pl
 # Contributing
-Check the [Coding Style Guidelines](https://github.com/RPCS3/rpcs3/wiki/Coding-Style) and [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information). If you have any questions, hit us up on our [Discord Server](https://discord.gg/rpcs3) in the **#development** channel.
+Check the [Coding Style Guidelines](https://github.com/RPCS3/rpcs3/wiki/Coding-Style) and [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information). If you have any questions, hit us up on our [Discord Server](https://discord.me/RPCS3) in the **#development** channel.
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -1 +1,2 @@
 patreon: Nekotekina
 custom: https://rpcs3.net/alipay
--- a/.github/ISSUE_TEMPLATE/1-regression-report.yml
+++ b/.github/ISSUE_TEMPLATE/1-regression-report.yml
@ -7,7 +7,7 @@ body:
    attributes:
      value: |
        # Summary
-        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.gg/rpcs3) or [forums](https://forums.rpcs3.net/) instead.
+        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
  - type: textarea
    id: quick-summary
    attributes:
@ -50,7 +50,7 @@ body:
        * Completely close RPCS3 and locate the log file.
        RPCS3's Log file will be ```RPCS3.log.gz``` (sometimes shows as RPCS3.log with zip icon) or ```RPCS3.log``` (sometimes shows as RPCS3 wtih notepad icon).
-        * On Windows it will be in the ```log``` folder inside your RPCS3 folder.
+        * On Windows it will be in the RPCS3 directory near the executable
        * On Linux it will be in ```~/.cache/rpcs3/```
        * On MacOS it will be in ```~/Library/Caches/rpcs3```. If you're unable to locate it copy paste the path in Spotlight and hit enter.
  - type: textarea
--- a/.github/ISSUE_TEMPLATE/2-bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/2-bug-report.yml
@ -7,7 +7,7 @@ body:
    attributes:
      value: |
        # Summary
-        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.gg/rpcs3) or [forums](https://forums.rpcs3.net/) instead.
+        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
  - type: textarea
    id: quick-summary
    attributes:
@ -36,7 +36,7 @@ body:
        * Completely close RPCS3 and locate the log file.
        RPCS3's Log file will be ```RPCS3.log.gz``` (sometimes shows as RPCS3.log with zip icon) or ```RPCS3.log``` (sometimes shows as RPCS3 wtih notepad icon).
-        * On Windows it will be in the ```log``` folder inside your RPCS3 folder.
+        * On Windows it will be in the RPCS3 directory near the executable
        * On Linux it will be in ```~/.cache/rpcs3/```
        * On MacOS it will be in ```~/Library/Caches/rpcs3```. If you're unable to locate it copy paste the path in Spotlight and hit enter.
  - type: textarea
--- a/.github/ISSUE_TEMPLATE/3-feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/3-feature-request.yml
@ -6,7 +6,7 @@ body:
  - type: markdown
    attributes:
      value: |
-        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.gg/rpcs3) or [forums](https://forums.rpcs3.net/) instead.
+        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
  - type: textarea
    id: quick-summary
    attributes:
@ -31,6 +31,6 @@ body:
        * If this feature is something that a game is trying to use, upload a log file for it.
        RPCS3's Log file will be ```RPCS3.log.gz``` (sometimes shows as RPCS3.log with zip icon) or ```RPCS3.log``` (sometimes shows as RPCS3 wtih notepad icon).
-        * On Windows it will be in the ```log``` folder inside your RPCS3 folder.
+        * On Windows it will be in the RPCS3 directory near the executable
        * On Linux it will be in ```~/.cache/rpcs3/```
        * On MacOS it will be in ```~/Library/Caches/rpcs3```. If you're unable to locate it copy paste the path in Spotlight and hit enter.
--- a/.github/ISSUE_TEMPLATE/4-advanced.md
+++ b/.github/ISSUE_TEMPLATE/4-advanced.md
@ -7,7 +7,7 @@ assignees: ''
 ---
-## Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.gg/rpcs3) or [forums](https://forums.rpcs3.net/) instead.
+## Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
 You're using the advanced template. You're expected to know what to write in order to fill in all the required information for proper report.
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@ -4,7 +4,7 @@ contact_links:
    url: https://rpcs3.net/quickstart
    about: Everything you need to know to install and configure emulator, and add games
  - name: Ask for help
-    url: https://discord.gg/rpcs3
+    url: https://discord.me/RPCS3
    about: If you have some questions or need help, please use our Discord server instead of GitHub
  - name: Report game compatibility
    url: https://forums.rpcs3.net/thread-196671.html
--- a/.github/PR-BUILD.md
+++ b/.github/PR-BUILD.md
@ -0,0 +1,18 @@
 ## How to test a PR build
 Please take into account, that RPCS3 build usually takes some time (about 15 mins), so you can't access a build if a PR was just submitted.
 - Open a PR you want to test
 - Scroll to the very bottom and locate the **Checks** section
 - Click on **Show all checks**
 	You are supposed to see something like this
 	![image](https://user-images.githubusercontent.com/10283761/116630952-2cd99e00-a94c-11eb-933e-986d6020ca92.png)
 - Click on __Details__ on either **Cirrus Linux GCC** or **Cirrus Windows**
 - Click **View more details on Cirrus CI** at the very bottom
 	![image](https://user-images.githubusercontent.com/10283761/116631111-5e526980-a94c-11eb-95f7-751e6f15e1ea.png)
 - Click on the download button for **Artifact** on the **Artifacts** block
 	![image](https://user-images.githubusercontent.com/10283761/116631322-bee1a680-a94c-11eb-89a3-be365783582e.png)
 - Congratulations! You are now downloading an RPCS3 build for that specific PR.
 __Please note that PR builds are not supposed to be stable because they contain new changesets.__
--- a/.github/PULL_REQUEST_TEMPLATE/1-default.md
+++ b/.github/PULL_REQUEST_TEMPLATE/1-default.md
@ -0,0 +1,3 @@
 <!-- Please include a summary of the change and which issue is fixed. -->
 [How to test this PR](.github/PR-BUILD.md)
--- a/.github/workflows/llvm.yml
+++ b/.github/workflows/llvm.yml
@ -1,72 +0,0 @@
 name: Build LLVM
 defaults:
  run:
    shell: bash
 on:
  workflow_dispatch:
 concurrency:
  group: ${{ github.ref }}-${{ github.event_name }}
  cancel-in-progress: true
 env:
  BUILD_ARTIFACTSTAGINGDIRECTORY: ${{ github.workspace }}/artifacts/
 jobs:
  Windows_Build:
    if: github.event_name == 'workflow_dispatch'
    name: LLVM Windows (MSVC)
    runs-on: windows-2025
    env:
      COMPILER: msvc
      CCACHE_SHA: '1f39f3ad5aae3fe915e99ad1302633bc8f6718e58fa7c0de2b0ba7e080f0f08c'
      CCACHE_BIN_DIR: 'C:\ccache_bin'
      CCACHE_DIR: 'C:\ccache'
      CCACHE_INODECACHE: 'true'
      CCACHE_SLOPPINESS: 'time_macros'
      DEPS_CACHE_DIR: ./dependency_cache
    steps:
      - name: Checkout repository
        uses: actions/checkout@main
        with:
          fetch-depth: 0
      - name: Restore Dependencies Cache
        uses: actions/cache/restore@main
        id: restore-dependencies-cache
        with:
          path: ${{ env.DEPS_CACHE_DIR }}
          key: "${{ runner.os }}-${{ env.COMPILER }}-llvm-${{ env.CCACHE_SHA }}"
          restore-keys: ${{ runner.os }}-${{ env.COMPILER }}-llvm
      - name: Download and unpack dependencies
        run: .ci/setup-llvm.sh
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@main
      - name: Compile LLVM
        shell: pwsh
        run: msbuild 3rdparty\llvm\llvm_build.vcxproj /p:SolutionDir="$(pwd)/" /p:Configuration=Release /v:minimal /p:Platform=x64 /p:PreferredToolArchitecture=x64 /p:CLToolPath=${{ env.CCACHE_BIN_DIR }} /p:UseMultiToolTask=true /p:CustomAfterMicrosoftCommonTargets="${{ github.workspace }}\buildfiles\msvc\ci_only.targets"
      - name: Pack up build artifacts
        run: |
          mkdir -p "${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}"
          .ci/deploy-llvm.sh
      - name: Upload artifacts (7z)
        uses: actions/upload-artifact@main
        with:
          name: LLVM for Windows (MSVC)
          path: ${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}
          compression-level: 0
          if-no-files-found: error
      - name: Save Dependencies Cache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: ${{ env.DEPS_CACHE_DIR }}
          key: ${{ steps.restore-dependencies-cache.outputs.cache-primary-key }}
--- a/.github/workflows/qt-ts.yml
+++ b/.github/workflows/qt-ts.yml
@ -1,34 +0,0 @@
 name: Generate Translation Template
 on:
  workflow_dispatch:
  push:
    branches:
      - master
    paths:
      - 'rpcs3/**'
 jobs:
  Generate_Translation_Template:
    name: Generate Translation Template
    runs-on: ubuntu-24.04
    steps:
      - name: Checkout repository
        uses: actions/checkout@main
      - name: Install Qt Tools
        run: |
          sudo apt update
          sudo apt install -y qt6-l10n-tools
      - name: Generate .ts file using lupdate (Qt)
        working-directory: rpcs3
        run: |
          ../.ci/generate-qt-ts.sh
      - name: Upload translation template
        uses: actions/upload-artifact@main
        with:
          name: RPCS3_Translation_Template
          path: translations/rpcs3_template.ts
          compression-level: 0
--- a/.github/workflows/rpcs3.yml
+++ b/.github/workflows/rpcs3.yml
@ -1,444 +0,0 @@
 name: Build RPCS3
 defaults:
  run:
    shell: bash
 on:
  push:
    branches:
      - master # Only trigger push event on 'master' branch
  pull_request:
  workflow_dispatch:
 concurrency:
  group: ${{ github.ref }}-${{ github.event_name }}
  cancel-in-progress: true
 env:
  BUILD_REPOSITORY_NAME: ${{ github.repository }}
  BUILD_SOURCEBRANCHNAME: ${{ github.ref_name }}
  BUILD_PR_NUMBER: ${{ github.event.pull_request.number }}
  BUILD_SOURCEVERSION: ${{ github.sha }}
  BUILD_ARTIFACTSTAGINGDIRECTORY: ${{ github.workspace }}/artifacts/
 jobs:
  Linux_Build:
    # Only run push event on master branch of main repo, but run all PRs
    if: github.event_name != 'push' || (github.repository == 'RPCS3/rpcs3' && github.ref_name == 'master')
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-24.04
            docker_img: "rpcs3/rpcs3-ci-jammy:1.6"
            build_sh: "/rpcs3/.ci/build-linux.sh"
            compiler: clang
            UPLOAD_COMMIT_HASH: d812f1254a1157c80fd402f94446310560f54e5f
            UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-linux"
          - os: ubuntu-24.04
            docker_img: "rpcs3/rpcs3-ci-jammy:1.6"
            build_sh: "/rpcs3/.ci/build-linux.sh"
            compiler: gcc
          - os: ubuntu-24.04-arm
            docker_img: "rpcs3/rpcs3-ci-jammy-aarch64:1.6"
            build_sh: "/rpcs3/.ci/build-linux-aarch64.sh"
            compiler: clang
            UPLOAD_COMMIT_HASH: a1d35836e8d45bfc6f63c26f0a3e5d46ef622fe1
            UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-linux-arm64"
          - os: ubuntu-24.04-arm
            docker_img: "rpcs3/rpcs3-ci-jammy-aarch64:1.6"
            build_sh: "/rpcs3/.ci/build-linux-aarch64.sh"
            compiler: gcc
    name: RPCS3 Linux ${{ matrix.os }} ${{ matrix.compiler }}
    runs-on: ${{ matrix.os }}
    env:
      CCACHE_DIR: ${{ github.workspace }}/ccache
      DEPLOY_APPIMAGE: true
      APPDIR: "/rpcs3/build/appdir"
      ARTDIR: "/root/artifacts"
      RELEASE_MESSAGE: "/rpcs3/GitHubReleaseMessage.txt"
      COMPILER: ${{ matrix.compiler }}
      UPLOAD_COMMIT_HASH: ${{ matrix.UPLOAD_COMMIT_HASH }}
      UPLOAD_REPO_FULL_NAME: ${{ matrix.UPLOAD_REPO_FULL_NAME }}
      RUN_UNIT_TESTS: github.event_name == 'pull_request' && 'ON' || 'OFF'
    steps:
      - name: Checkout repository
        uses: actions/checkout@main
        with:
          fetch-depth: 0
      - name: Restore build Ccache
        uses: actions/cache/restore@main
        id: restore-build-ccache
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ runner.os }}-ccache-${{ matrix.compiler }}-${{ runner.arch }}-${{github.run_id}}
          restore-keys: ${{ runner.os }}-ccache-${{ matrix.compiler }}-${{ runner.arch }}-
      - name: Docker setup and build
        run: |
          docker pull --quiet ${{ matrix.docker_img }}
          docker run \
            -v $PWD:/rpcs3 \
            --env-file .ci/docker.env \
            -v ${{ env.CCACHE_DIR }}:/root/.ccache  \
            -v ${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}:${{ env.ARTDIR }} \
            ${{ matrix.docker_img }} \
            ${{ matrix.build_sh }}
      - name: Upload artifacts
        uses: actions/upload-artifact@main
        with:
          name: RPCS3 for Linux (${{ runner.arch }}, ${{ matrix.compiler }})
          path: ${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}/*.AppImage
          compression-level: 0
      - name: Deploy master build to GitHub Releases
        if: |
          github.event_name != 'pull_request' &&
          github.repository == 'RPCS3/rpcs3' &&
          github.ref == 'refs/heads/master' &&
          matrix.compiler == 'clang'
        env:
          RPCS3_TOKEN: ${{ secrets.RPCS3_TOKEN }}
        run: |
          COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ./rpcs3/rpcs3_version.cpp)
          COMM_COUNT=$(git rev-list --count HEAD)
          COMM_HASH=$(git rev-parse --short=8 HEAD)
          export AVVER="${COMM_TAG}-${COMM_COUNT}"
          .ci/github-upload.sh
      - name: Save build Ccache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ steps.restore-build-ccache.outputs.cache-primary-key }}
  Mac_Build:
    # Only run push event on master branch of main repo, but run all PRs
    if: github.event_name != 'push' || (github.repository == 'RPCS3/rpcs3' && github.ref_name == 'master')
    strategy:
      fail-fast: false
      matrix:
        include:
          - name: Intel
            build_sh: "arch -X86_64 .ci/build-mac.sh"
            UPLOAD_COMMIT_HASH: 51ae32f468089a8169aaf1567de355ff4a3e0842
            UPLOAD_REPO_FULL_NAME: rpcs3/rpcs3-binaries-mac
          - name: Apple Silicon
            build_sh: .ci/build-mac-arm64.sh
            UPLOAD_COMMIT_HASH: 8e21bdbc40711a3fccd18fbf17b742348b0f4281
            UPLOAD_REPO_FULL_NAME: rpcs3/rpcs3-binaries-mac-arm64
    name: RPCS3 Mac ${{ matrix.name }} 
    runs-on: macos-14
    env:
      CCACHE_DIR: /tmp/ccache_dir
      QT_VER: '6.7.3'
      QT_VER_MAIN: '6'
      LLVM_COMPILER_VER: '19'
      RELEASE_MESSAGE: ../GitHubReleaseMessage.txt
      UPLOAD_COMMIT_HASH: ${{ matrix.UPLOAD_COMMIT_HASH }}
      UPLOAD_REPO_FULL_NAME: ${{ matrix.UPLOAD_REPO_FULL_NAME }}
      RUN_UNIT_TESTS: github.event_name == 'pull_request' && 'ON' || 'OFF'
    steps:
      - name: Checkout repository
        uses: actions/checkout@main
        with:
          fetch-depth: 0
      - name: Restore Build Ccache
        uses: actions/cache/restore@main
        id: restore-build-ccache
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ runner.os }}-ccache-${{ matrix.name }}-${{github.run_id}}
          restore-keys: ${{ runner.os }}-ccache-${{ matrix.name }}-
      - name: Restore Qt Cache
        uses: actions/cache/restore@main
        id: restore-qt-cache
        with:
          path: /tmp/Qt
          key: ${{ runner.os }}-qt-${{ matrix.name }}-${{ env.QT_VER }}
          restore-keys: ${{ runner.os }}-qt-${{ matrix.name }}-${{ env.QT_VER }}
      - name: Build
        run: ${{ matrix.build_sh }}
      - name: Upload artifacts
        uses: actions/upload-artifact@main
        with:
          name: RPCS3 for Mac (${{ matrix.name }})
          path: ${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}
          compression-level: 0
      - name: Export Variables
        run: |
          while IFS='=' read -r key val; do
            # Skip lines that are empty or start with '#'
            [[ -z "$key" || "$key" =~ ^# ]] && continue
            echo "$key=$val" >> "${{ github.env }}"
          done < .ci/ci-vars.env
      - name: Deploy master build to GitHub Releases
        if: |
          github.event_name != 'pull_request' &&
          github.repository == 'RPCS3/rpcs3' &&
          github.ref == 'refs/heads/master'
        env:
          RPCS3_TOKEN: ${{ secrets.RPCS3_TOKEN }}
        run: .ci/github-upload.sh
      - name: Save Build Ccache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ steps.restore-build-ccache.outputs.cache-primary-key }}
      - name: Save Qt Cache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: /tmp/Qt
          key: ${{ steps.restore-qt-cache.outputs.cache-primary-key }}
  Windows_Build:
    # Only run push event on master branch of main repo, but run all PRs
    if: github.event_name != 'push' || (github.repository == 'RPCS3/rpcs3' && github.ref_name == 'master')
    name: RPCS3 Windows
    runs-on: windows-2025
    env:
      COMPILER: msvc
      QT_VER_MAIN: '6'
      QT_VER: '6.9.1'
      QT_VER_MSVC: 'msvc2022'
      QT_DATE: '202505291653'
      LLVM_VER: '19.1.7'
      VULKAN_VER: '1.3.268.0'
      VULKAN_SDK_SHA: '8459ef49bd06b697115ddd3d97c9aec729e849cd775f5be70897718a9b3b9db5'
      CCACHE_SHA: '1f39f3ad5aae3fe915e99ad1302633bc8f6718e58fa7c0de2b0ba7e080f0f08c'
      CCACHE_BIN_DIR: 'C:\ccache_bin'
      CCACHE_DIR: 'C:\ccache'
      CCACHE_INODECACHE: 'true'
      CCACHE_SLOPPINESS: 'time_macros'
      DEPS_CACHE_DIR: ./dependency_cache
      UPLOAD_COMMIT_HASH: 7d09e3be30805911226241afbb14f8cdc2eb054e
      UPLOAD_REPO_FULL_NAME: "RPCS3/rpcs3-binaries-win"
    steps:
      - name: Checkout repository
        uses: actions/checkout@main
        with:
          fetch-depth: 0
      - name: Setup NuGet
        uses: nuget/setup-nuget@v2
      - name: Restore NuGet packages
        run: nuget restore rpcs3.sln
      - name: Setup env
        shell: pwsh
        run: |
          echo "QTDIR=C:\Qt\${{ env.QT_VER }}\${{ env.QT_VER_MSVC }}_64" >> ${{ github.env }}
          echo "VULKAN_SDK=C:\VulkanSDK\${{ env.VULKAN_VER }}" >> ${{ github.env }}
      - name: Get Cache Keys
        run: .ci/get_keys-windows.sh
      - name: Restore Build Ccache
        uses: actions/cache/restore@main
        id: restore-build-ccache
        with:
          path: ${{ env.CCACHE_DIR }}
          key: "${{ runner.os }}-ccache-${{ env.COMPILER }}-${{github.run_id}}"
          restore-keys: ${{ runner.os }}-ccache-${{ env.COMPILER }}-
      - name: Restore Dependencies Cache
        uses: actions/cache/restore@main
        id: restore-dependencies-cache
        with:
          path: ${{ env.DEPS_CACHE_DIR }}
          key: "${{ runner.os }}-${{ env.COMPILER }}-${{ env.QT_VER }}-${{ env.VULKAN_SDK_SHA }}-${{ env.CCACHE_SHA }}-${{ hashFiles('llvm.lock') }}"
          restore-keys: ${{ runner.os }}-${{ env.COMPILER }}-
      - name: Download and unpack dependencies
        run: |
          .ci/setup-windows.sh
          .ci/setup-windows-ci-vars.sh win64 msvc
      - name: Export Variables
        run: |
          while IFS='=' read -r key val; do
            # Skip lines that are empty or start with '#'
            [[ -z "$key" || "$key" =~ ^# ]] && continue
            echo "$key=$val" >> "${{ github.env }}"
          done < .ci/ci-vars.env
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@main
      - name: Compile RPCS3
        shell: pwsh
        run: msbuild rpcs3.sln /p:Configuration=Release /v:minimal /p:Platform=x64 /p:PreferredToolArchitecture=x64 /p:CLToolPath=${{ env.CCACHE_BIN_DIR }} /p:UseMultiToolTask=true /p:CustomAfterMicrosoftCommonTargets="${{ github.workspace }}\buildfiles\msvc\ci_only.targets"
      - name: Run Unit Tests
        if: github.event_name == 'pull_request'
        shell: pwsh
        run: build\lib\Release-x64\rpcs3_test.exe
      - name: Pack up build artifacts
        run: |
          mkdir -p "${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}"
          .ci/deploy-windows.sh
      - name: Upload artifacts (7z)
        uses: actions/upload-artifact@main
        with:
          name: RPCS3 for Windows (MSVC)
          path: ${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}
          compression-level: 0
          if-no-files-found: error
      - name: Deploy master build to GitHub Releases
        if: |
          github.event_name != 'pull_request' &&
          github.repository == 'RPCS3/rpcs3' &&
          github.ref == 'refs/heads/master'
        env:
          RPCS3_TOKEN: ${{ secrets.RPCS3_TOKEN }}
        run: .ci/github-upload.sh
      - name: Save Build Ccache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ steps.restore-build-ccache.outputs.cache-primary-key }}
      - name: Save Dependencies Cache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: ${{ env.DEPS_CACHE_DIR }}
          key: ${{ steps.restore-dependencies-cache.outputs.cache-primary-key }}
  Windows_Build_Clang:
    # Only run push event on master branch of main repo, but run all PRs
    if: github.event_name != 'push' || (github.repository == 'RPCS3/rpcs3' && github.ref_name == 'master')
    name: RPCS3 Windows Clang
    runs-on: windows-2025
    strategy:
      matrix:
        include:
          - msys2: clang64
            compiler: clang
            arch: win64
    env:
      CCACHE_DIR: 'C:\ccache'
    steps:
      - name: Checkout repository
        uses: actions/checkout@main
        with:
          fetch-depth: 0
      - name: Setup msys2
        uses: msys2/setup-msys2@v2
        with:
          msystem: ${{ matrix.msys2 }}
          update: true
          cache: true
          install: |
            mingw-w64-clang-x86_64-clang
            mingw-w64-clang-x86_64-ccache
            mingw-w64-clang-x86_64-cmake
            mingw-w64-clang-x86_64-lld
            mingw-w64-clang-x86_64-ninja
            mingw-w64-clang-x86_64-llvm
            mingw-w64-clang-x86_64-ffmpeg
            mingw-w64-clang-x86_64-opencv
            mingw-w64-clang-x86_64-glew
            mingw-w64-clang-x86_64-vulkan
            mingw-w64-clang-x86_64-vulkan-headers
            mingw-w64-clang-x86_64-vulkan-loader
            mingw-w64-clang-x86_64-gtest
            mingw-w64-clang-x86_64-qt6-base
            mingw-w64-clang-x86_64-qt6-declarative
            mingw-w64-clang-x86_64-qt6-multimedia
            mingw-w64-clang-x86_64-qt6-svg
            base-devel
            curl
            git
            p7zip
      - name: Restore build Ccache
        uses: actions/cache/restore@main
        id: restore-build-ccache
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ runner.os }}-ccache-${{ matrix.compiler }}-${{ runner.arch }}-${{ github.run_id }}
          restore-keys: ${{ runner.os }}-ccache-${{ matrix.compiler }}-${{ runner.arch }}-
      - name: Build RPCS3
        shell: msys2 {0}
        run: |
          export CCACHE_DIR=$(cygpath -u "$CCACHE_DIR")
          echo "CCACHE_DIR=$CCACHE_DIR"
          .ci/setup-windows-ci-vars.sh ${{ matrix.arch }} ${{ matrix.compiler }}
          .ci/build-windows-clang.sh
      - name: Save build Ccache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ steps.restore-build-ccache.outputs.cache-primary-key }}
      - name: Upload artifacts
        uses: actions/upload-artifact@main
        with:
          name: RPCS3 for Windows (${{ runner.arch }}, ${{ matrix.compiler }})
          path: ${{ env.BUILD_ARTIFACTSTAGINGDIRECTORY }}
          compression-level: 0
          if-no-files-found: error
  FreeBSD_Build:
      # Only run push event on master branch of main repo, but run all PRs
    if: github.event_name != 'push' || (github.repository == 'RPCS3/rpcs3' && github.ref_name == 'master')
    name: RPCS3 FreeBSD 
    runs-on: ubuntu-latest
    timeout-minutes: 60
    env:
      CCACHE_DIR: ${{ github.workspace }}/ccache
      QT_VER_MAIN: '6'
      LLVM_COMPILER_VER: '19'
    steps:
      - name: Checkout repository
        uses: actions/checkout@main
        with:
          fetch-depth: 0
      - name: Restore Build Ccache
        uses: actions/cache/restore@main
        id: restore-build-ccache
        with:
          path: ${{ env.CCACHE_DIR }}
          key: FreeBSD-ccache-${{github.run_id}}
          restore-keys: FreeBSD-ccache-
      - name: FreeBSD build
        id: root
        uses: vmactions/freebsd-vm@v1
        with:
          envs: 'QT_VER_MAIN LLVM_COMPILER_VER CCACHE_DIR'
          usesh: true
          run: .ci/install-freebsd.sh && .ci/build-freebsd.sh
      - name: Save Build Ccache
        if: github.ref == 'refs/heads/master'
        uses: actions/cache/save@main
        with:
          path: ${{ env.CCACHE_DIR }}
          key: ${{ steps.restore-build-ccache.outputs.cache-primary-key }}
--- a/.gitignore
+++ b/.gitignore
@ -35,7 +35,6 @@
 /lib
 /tmp
 /ipch
 /packages
 /rpcs3/Debug
 /rpcs3/Release
@ -56,6 +55,9 @@
 /bin/GuiConfigs/*.dat
 /bin/GuiConfigs/*.dat.*
 # Some data from git
 !/bin/git/
 # Visual Studio Files
 .vs/*
 .vscode/*
@ -115,9 +117,28 @@ CMakeLists.txt.user
 # macOS
 .DS_Store
 # 7zlib
 /3rdparty/7z/**/*.lib
 # yaml-cpp
 yaml-cpp.pc
 # libusb
 /3rdparty/libusb_cmake/config.h
 /3rdparty/libusb_cmake/libusb-1.0.pc
 # miniupnp
 /3rdparty/miniupnp/x64/*
 # llvm
 /3rdparty/llvm/llvm_build
 # legacy llvm
 /llvm_build
 # ssl certificate
 cacert.pem
 _ReSharper.*/
 CMakeUserPresets.json
--- a/.gitmodules
+++ b/.gitmodules
@ -15,6 +15,14 @@
 	path = 3rdparty/glslang/glslang
 	url = ../../KhronosGroup/glslang.git
 	ignore = dirty
 [submodule "3rdparty/SPIRV-Tools"]
 	path = 3rdparty/SPIRV/SPIRV-Tools
 	url = ../../KhronosGroup/SPIRV-Tools.git
 	ignore = dirty
 [submodule "3rdparty/SPIRV-Headers"]
 	path = 3rdparty/SPIRV/SPIRV-Headers
 	url = ../../KhronosGroup/SPIRV-Headers.git
 	ignore = dirty
 [submodule "3rdparty/zlib"]
 	path = 3rdparty/zlib/zlib
 	url = ../../madler/zlib
@ -28,6 +36,10 @@
 	path = 3rdparty/pugixml
 	url = ../../zeux/pugixml.git
 	ignore = dirty
 [submodule "3rdparty/xxHash"]
 	path = 3rdparty/xxHash
 	url = ../../Cyan4973/xxHash.git
 	ignore = dirty
 [submodule "3rdparty/yaml-cpp"]
 	path = 3rdparty/yaml-cpp/yaml-cpp
 	url = ../../RPCS3/yaml-cpp.git
@ -76,35 +88,3 @@
 	path = 3rdparty/rtmidi/rtmidi
 	url = ../../thestk/rtmidi
 	ignore = dirty
 [submodule "3rdparty/zstd/zstd"]
 	path = 3rdparty/zstd/zstd
 	url = ../../facebook/zstd
 	ignore = dirty
 [submodule "3rdparty/7zip/7zip"]
 	path = 3rdparty/7zip/7zip
 	url = ../../ip7z/7zip.git
 	ignore = dirty
 [submodule "3rdparty/OpenAL/openal-soft"]
 	path = 3rdparty/OpenAL/openal-soft
 	url = ../../kcat/openal-soft.git
 	ignore = dirty
 [submodule "3rdparty/stblib/stb"]
 	path = 3rdparty/stblib/stb
 	url = ../../nothings/stb.git
 	ignore = dirty
 [submodule "3rdparty/opencv/opencv"]
 	path = 3rdparty/opencv/opencv
 	url = ../../Megamouse/opencv_minimal.git
 	ignore = dirty
 [submodule "3rdparty/fusion/fusion"]
 	path = 3rdparty/fusion/fusion
 	url = ../../xioTechnologies/Fusion.git
 	ignore = dirty
 [submodule "3rdparty/discord-rpc/discord-rpc"]
 	path = 3rdparty/discord-rpc/discord-rpc
 	url = ../../Vestrel/discord-rpc
 	ignore = dirty
 [submodule "3rdparty/GPUOpen/VulkanMemoryAllocator"]
 	path = 3rdparty/GPUOpen/VulkanMemoryAllocator
 	url = ../../GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
 	ignore = dirty
--- a/3rdparty/7zip/7zip.vcxproj
+++ b/3rdparty/7zip/7zip.vcxproj
@ -19,112 +19,108 @@
    </ProjectConfiguration>
  </ItemGroup>
  <ItemGroup>
-    <ClInclude Include="7zip\C\7z.h" />
+    <ClInclude Include="src\7z.h" />
-    <ClInclude Include="7zip\C\7zAlloc.h" />
+    <ClInclude Include="src\7zAlloc.h" />
-    <ClInclude Include="7zip\C\7zBuf.h" />
+    <ClInclude Include="src\7zBuf.h" />
-    <ClInclude Include="7zip\C\7zCrc.h" />
+    <ClInclude Include="src\7zCrc.h" />
-    <ClInclude Include="7zip\C\7zFile.h" />
+    <ClInclude Include="src\7zFile.h" />
-    <ClInclude Include="7zip\C\7zTypes.h" />
+    <ClInclude Include="src\7zTypes.h" />
-    <ClInclude Include="7zip\C\7zVersion.h" />
+    <ClInclude Include="src\7zVersion.h" />
-    <ClInclude Include="7zip\C\7zWindows.h" />
+    <ClInclude Include="src\7zWindows.h" />
-    <ClInclude Include="7zip\C\Aes.h" />
+    <ClInclude Include="src\Aes.h" />
-    <ClInclude Include="7zip\C\Alloc.h" />
+    <ClInclude Include="src\Alloc.h" />
-    <ClInclude Include="7zip\C\Bcj2.h" />
+    <ClInclude Include="src\Bcj2.h" />
-    <ClInclude Include="7zip\C\Blake2.h" />
+    <ClInclude Include="src\Blake2.h" />
-    <ClInclude Include="7zip\C\Bra.h" />
+    <ClInclude Include="src\Bra.h" />
-    <ClInclude Include="7zip\C\BwtSort.h" />
+    <ClInclude Include="src\BwtSort.h" />
-    <ClInclude Include="7zip\C\Compiler.h" />
+    <ClInclude Include="src\Compiler.h" />
-    <ClInclude Include="7zip\C\CpuArch.h" />
+    <ClInclude Include="src\CpuArch.h" />
-    <ClInclude Include="7zip\C\Delta.h" />
+    <ClInclude Include="src\Delta.h" />
-    <ClInclude Include="7zip\C\DllSecur.h" />
+    <ClInclude Include="src\DllSecur.h" />
-    <ClInclude Include="7zip\C\HuffEnc.h" />
+    <ClInclude Include="src\HuffEnc.h" />
-    <ClInclude Include="7zip\C\LzFind.h" />
+    <ClInclude Include="src\LzFind.h" />
-    <ClInclude Include="7zip\C\LzFindMt.h" />
+    <ClInclude Include="src\LzFindMt.h" />
-    <ClInclude Include="7zip\C\LzHash.h" />
+    <ClInclude Include="src\LzHash.h" />
-    <ClInclude Include="7zip\C\Lzma2Dec.h" />
+    <ClInclude Include="src\Lzma2Dec.h" />
-    <ClInclude Include="7zip\C\Lzma2DecMt.h" />
+    <ClInclude Include="src\Lzma2DecMt.h" />
-    <ClInclude Include="7zip\C\Lzma2Enc.h" />
+    <ClInclude Include="src\Lzma2Enc.h" />
-    <ClInclude Include="7zip\C\Lzma86.h" />
+    <ClInclude Include="src\Lzma86.h" />
-    <ClInclude Include="7zip\C\LzmaDec.h" />
+    <ClInclude Include="src\LzmaDec.h" />
-    <ClInclude Include="7zip\C\LzmaEnc.h" />
+    <ClInclude Include="src\LzmaEnc.h" />
-    <ClInclude Include="7zip\C\LzmaLib.h" />
+    <ClInclude Include="src\LzmaLib.h" />
-    <ClInclude Include="7zip\C\MtCoder.h" />
+    <ClInclude Include="src\MtCoder.h" />
-    <ClInclude Include="7zip\C\MtDec.h" />
+    <ClInclude Include="src\MtDec.h" />
-    <ClInclude Include="7zip\C\Ppmd.h" />
+    <ClInclude Include="src\Ppmd.h" />
-    <ClInclude Include="7zip\C\Ppmd7.h" />
+    <ClInclude Include="src\Ppmd7.h" />
-    <ClInclude Include="7zip\C\Ppmd8.h" />
+    <ClInclude Include="src\Ppmd8.h" />
-    <ClInclude Include="7zip\C\Precomp.h" />
+    <ClInclude Include="src\Precomp.h" />
-    <ClInclude Include="7zip\C\RotateDefs.h" />
+    <ClInclude Include="src\RotateDefs.h" />
-    <ClInclude Include="7zip\C\Sha1.h" />
+    <ClInclude Include="src\Sha1.h" />
-    <ClInclude Include="7zip\C\Sha256.h" />
+    <ClInclude Include="src\Sha256.h" />
-    <ClInclude Include="7zip\C\Sort.h" />
+    <ClInclude Include="src\Sort.h" />
-    <ClInclude Include="7zip\C\SwapBytes.h" />
+    <ClInclude Include="src\SwapBytes.h" />
-    <ClInclude Include="7zip\C\Threads.h" />
+    <ClInclude Include="src\Threads.h" />
-    <ClInclude Include="7zip\C\Xxh64.h" />
+    <ClInclude Include="src\Xz.h" />
-    <ClInclude Include="7zip\C\Xz.h" />
+    <ClInclude Include="src\XzCrc64.h" />
-    <ClInclude Include="7zip\C\XzCrc64.h" />
+    <ClInclude Include="src\XzEnc.h" />
    <ClInclude Include="7zip\C\XzEnc.h" />
    <ClInclude Include="7zip\C\ZstdDec.h" />
  </ItemGroup>
  <ItemGroup>
-    <ClCompile Include="7zip\C\7zAlloc.c" />
+    <ClCompile Include="src\7zAlloc.c" />
-    <ClCompile Include="7zip\C\7zArcIn.c" />
+    <ClCompile Include="src\7zArcIn.c" />
-    <ClCompile Include="7zip\C\7zBuf.c" />
+    <ClCompile Include="src\7zBuf.c" />
-    <ClCompile Include="7zip\C\7zBuf2.c" />
+    <ClCompile Include="src\7zBuf2.c" />
-    <ClCompile Include="7zip\C\7zCrc.c" />
+    <ClCompile Include="src\7zCrc.c" />
-    <ClCompile Include="7zip\C\7zCrcOpt.c" />
+    <ClCompile Include="src\7zCrcOpt.c" />
-    <ClCompile Include="7zip\C\7zDec.c" />
+    <ClCompile Include="src\7zDec.c" />
-    <ClCompile Include="7zip\C\7zFile.c" />
+    <ClCompile Include="src\7zFile.c" />
-    <ClCompile Include="7zip\C\7zStream.c" />
+    <ClCompile Include="src\7zStream.c" />
-    <ClCompile Include="7zip\C\Aes.c" />
+    <ClCompile Include="src\Aes.c" />
-    <ClCompile Include="7zip\C\AesOpt.c" />
+    <ClCompile Include="src\AesOpt.c" />
-    <ClCompile Include="7zip\C\Alloc.c" />
+    <ClCompile Include="src\Alloc.c" />
-    <ClCompile Include="7zip\C\Bcj2.c" />
+    <ClCompile Include="src\Bcj2.c" />
-    <ClCompile Include="7zip\C\Bcj2Enc.c" />
+    <ClCompile Include="src\Bcj2Enc.c" />
-    <ClCompile Include="7zip\C\Blake2s.c" />
+    <ClCompile Include="src\Blake2s.c" />
-    <ClCompile Include="7zip\C\Bra.c" />
+    <ClCompile Include="src\Bra.c" />
-    <ClCompile Include="7zip\C\Bra86.c" />
+    <ClCompile Include="src\Bra86.c" />
-    <ClCompile Include="7zip\C\BraIA64.c" />
+    <ClCompile Include="src\BraIA64.c" />
-    <ClCompile Include="7zip\C\BwtSort.c" />
+    <ClCompile Include="src\BwtSort.c" />
-    <ClCompile Include="7zip\C\CpuArch.c" />
+    <ClCompile Include="src\CpuArch.c" />
-    <ClCompile Include="7zip\C\Delta.c" />
+    <ClCompile Include="src\Delta.c" />
-    <ClCompile Include="7zip\C\DllSecur.c" />
+    <ClCompile Include="src\DllSecur.c" />
-    <ClCompile Include="7zip\C\HuffEnc.c" />
+    <ClCompile Include="src\HuffEnc.c" />
-    <ClCompile Include="7zip\C\LzFind.c" />
+    <ClCompile Include="src\LzFind.c" />
-    <ClCompile Include="7zip\C\LzFindMt.c" />
+    <ClCompile Include="src\LzFindMt.c" />
-    <ClCompile Include="7zip\C\LzFindOpt.c" />
+    <ClCompile Include="src\LzFindOpt.c" />
-    <ClCompile Include="7zip\C\Lzma2Dec.c" />
+    <ClCompile Include="src\Lzma2Dec.c" />
-    <ClCompile Include="7zip\C\Lzma2DecMt.c" />
+    <ClCompile Include="src\Lzma2DecMt.c" />
-    <ClCompile Include="7zip\C\Lzma2Enc.c" />
+    <ClCompile Include="src\Lzma2Enc.c" />
-    <ClCompile Include="7zip\C\Lzma86Dec.c" />
+    <ClCompile Include="src\Lzma86Dec.c" />
-    <ClCompile Include="7zip\C\Lzma86Enc.c" />
+    <ClCompile Include="src\Lzma86Enc.c" />
-    <ClCompile Include="7zip\C\LzmaDec.c" />
+    <ClCompile Include="src\LzmaDec.c" />
-    <ClCompile Include="7zip\C\LzmaEnc.c" />
+    <ClCompile Include="src\LzmaEnc.c" />
-    <ClCompile Include="7zip\C\LzmaLib.c" />
+    <ClCompile Include="src\LzmaLib.c" />
-    <ClCompile Include="7zip\C\MtCoder.c" />
+    <ClCompile Include="src\MtCoder.c" />
-    <ClCompile Include="7zip\C\MtDec.c" />
+    <ClCompile Include="src\MtDec.c" />
-    <ClCompile Include="7zip\C\Ppmd7.c" />
+    <ClCompile Include="src\Ppmd7.c" />
-    <ClCompile Include="7zip\C\Ppmd7aDec.c" />
+    <ClCompile Include="src\Ppmd7aDec.c" />
-    <ClCompile Include="7zip\C\Ppmd7Dec.c" />
+    <ClCompile Include="src\Ppmd7Dec.c" />
-    <ClCompile Include="7zip\C\Ppmd7Enc.c" />
+    <ClCompile Include="src\Ppmd7Enc.c" />
-    <ClCompile Include="7zip\C\Ppmd8.c" />
+    <ClCompile Include="src\Ppmd8.c" />
-    <ClCompile Include="7zip\C\Ppmd8Dec.c" />
+    <ClCompile Include="src\Ppmd8Dec.c" />
-    <ClCompile Include="7zip\C\Ppmd8Enc.c" />
+    <ClCompile Include="src\Ppmd8Enc.c" />
-    <ClCompile Include="7zip\C\Sha1.c" />
+    <ClCompile Include="src\Sha1.c" />
-    <ClCompile Include="7zip\C\Sha1Opt.c" />
+    <ClCompile Include="src\Sha1Opt.c" />
-    <ClCompile Include="7zip\C\Sha256.c" />
+    <ClCompile Include="src\Sha256.c" />
-    <ClCompile Include="7zip\C\Sha256Opt.c" />
+    <ClCompile Include="src\Sha256Opt.c" />
-    <ClCompile Include="7zip\C\Sort.c" />
+    <ClCompile Include="src\Sort.c" />
-    <ClCompile Include="7zip\C\SwapBytes.c" />
+    <ClCompile Include="src\SwapBytes.c" />
-    <ClCompile Include="7zip\C\Threads.c" />
+    <ClCompile Include="src\Threads.c" />
-    <ClCompile Include="7zip\C\Xxh64.c" />
+    <ClCompile Include="src\Xz.c" />
-    <ClCompile Include="7zip\C\Xz.c" />
+    <ClCompile Include="src\XzCrc64.c" />
-    <ClCompile Include="7zip\C\XzCrc64.c" />
+    <ClCompile Include="src\XzCrc64Opt.c" />
-    <ClCompile Include="7zip\C\XzCrc64Opt.c" />
+    <ClCompile Include="src\XzDec.c" />
-    <ClCompile Include="7zip\C\XzDec.c" />
+    <ClCompile Include="src\XzEnc.c" />
-    <ClCompile Include="7zip\C\XzEnc.c" />
+    <ClCompile Include="src\XzIn.c" />
    <ClCompile Include="7zip\C\XzIn.c" />
    <ClCompile Include="7zip\C\ZstdDec.c" />
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>16.0</VCProjectVersion>
@ -179,8 +175,8 @@
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup>
-    <OutDir>$(SolutionDir)build\lib\$(Configuration)-$(Platform)\</OutDir>
+    <OutDir>$(SolutionDir)lib/$(Configuration)-$(Platform)/</OutDir>
-    <IntDir>$(SolutionDir)build\tmp\$(ProjectName)-$(Configuration)-$(Platform)\</IntDir>
+    <IntDir>$(SolutionDir)tmp\$(ProjectName)-$(Configuration)-$(Platform)/</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
--- a/3rdparty/7z/7zlib.vcxproj.filters
+++ b/3rdparty/7z/7zlib.vcxproj.filters
@ -0,0 +1,107 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <ClInclude Include="src\7z.h" />
    <ClInclude Include="src\7zAlloc.h" />
    <ClInclude Include="src\7zBuf.h" />
    <ClInclude Include="src\7zCrc.h" />
    <ClInclude Include="src\7zFile.h" />
    <ClInclude Include="src\7zTypes.h" />
    <ClInclude Include="src\7zVersion.h" />
    <ClInclude Include="src\7zWindows.h" />
    <ClInclude Include="src\Aes.h" />
    <ClInclude Include="src\Alloc.h" />
    <ClInclude Include="src\Bcj2.h" />
    <ClInclude Include="src\Blake2.h" />
    <ClInclude Include="src\Bra.h" />
    <ClInclude Include="src\BwtSort.h" />
    <ClInclude Include="src\Compiler.h" />
    <ClInclude Include="src\CpuArch.h" />
    <ClInclude Include="src\Delta.h" />
    <ClInclude Include="src\DllSecur.h" />
    <ClInclude Include="src\HuffEnc.h" />
    <ClInclude Include="src\LzFind.h" />
    <ClInclude Include="src\LzFindMt.h" />
    <ClInclude Include="src\LzHash.h" />
    <ClInclude Include="src\Lzma2Dec.h" />
    <ClInclude Include="src\Lzma2DecMt.h" />
    <ClInclude Include="src\Lzma2Enc.h" />
    <ClInclude Include="src\Lzma86.h" />
    <ClInclude Include="src\LzmaDec.h" />
    <ClInclude Include="src\LzmaEnc.h" />
    <ClInclude Include="src\LzmaLib.h" />
    <ClInclude Include="src\MtCoder.h" />
    <ClInclude Include="src\MtDec.h" />
    <ClInclude Include="src\Ppmd.h" />
    <ClInclude Include="src\Ppmd7.h" />
    <ClInclude Include="src\Ppmd8.h" />
    <ClInclude Include="src\Precomp.h" />
    <ClInclude Include="src\RotateDefs.h" />
    <ClInclude Include="src\Sha1.h" />
    <ClInclude Include="src\Sha256.h" />
    <ClInclude Include="src\Sort.h" />
    <ClInclude Include="src\SwapBytes.h" />
    <ClInclude Include="src\Threads.h" />
    <ClInclude Include="src\Xz.h" />
    <ClInclude Include="src\XzCrc64.h" />
    <ClInclude Include="src\XzEnc.h" />
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="src\7zAlloc.c" />
    <ClCompile Include="src\7zArcIn.c" />
    <ClCompile Include="src\7zBuf.c" />
    <ClCompile Include="src\7zBuf2.c" />
    <ClCompile Include="src\7zCrc.c" />
    <ClCompile Include="src\7zCrcOpt.c" />
    <ClCompile Include="src\7zDec.c" />
    <ClCompile Include="src\7zFile.c" />
    <ClCompile Include="src\7zStream.c" />
    <ClCompile Include="src\Aes.c" />
    <ClCompile Include="src\AesOpt.c" />
    <ClCompile Include="src\Alloc.c" />
    <ClCompile Include="src\Bcj2.c" />
    <ClCompile Include="src\Bcj2Enc.c" />
    <ClCompile Include="src\Blake2s.c" />
    <ClCompile Include="src\Bra.c" />
    <ClCompile Include="src\Bra86.c" />
    <ClCompile Include="src\BraIA64.c" />
    <ClCompile Include="src\BwtSort.c" />
    <ClCompile Include="src\CpuArch.c" />
    <ClCompile Include="src\Delta.c" />
    <ClCompile Include="src\DllSecur.c" />
    <ClCompile Include="src\HuffEnc.c" />
    <ClCompile Include="src\LzFind.c" />
    <ClCompile Include="src\LzFindMt.c" />
    <ClCompile Include="src\LzFindOpt.c" />
    <ClCompile Include="src\Lzma2Dec.c" />
    <ClCompile Include="src\Lzma2DecMt.c" />
    <ClCompile Include="src\Lzma2Enc.c" />
    <ClCompile Include="src\Lzma86Dec.c" />
    <ClCompile Include="src\Lzma86Enc.c" />
    <ClCompile Include="src\LzmaDec.c" />
    <ClCompile Include="src\LzmaEnc.c" />
    <ClCompile Include="src\LzmaLib.c" />
    <ClCompile Include="src\MtCoder.c" />
    <ClCompile Include="src\MtDec.c" />
    <ClCompile Include="src\Ppmd7.c" />
    <ClCompile Include="src\Ppmd7aDec.c" />
    <ClCompile Include="src\Ppmd7Dec.c" />
    <ClCompile Include="src\Ppmd7Enc.c" />
    <ClCompile Include="src\Ppmd8.c" />
    <ClCompile Include="src\Ppmd8Dec.c" />
    <ClCompile Include="src\Ppmd8Enc.c" />
    <ClCompile Include="src\Sha1.c" />
    <ClCompile Include="src\Sha1Opt.c" />
    <ClCompile Include="src\Sha256.c" />
    <ClCompile Include="src\Sha256Opt.c" />
    <ClCompile Include="src\Sort.c" />
    <ClCompile Include="src\SwapBytes.c" />
    <ClCompile Include="src\Threads.c" />
    <ClCompile Include="src\Xz.c" />
    <ClCompile Include="src\XzCrc64.c" />
    <ClCompile Include="src\XzCrc64Opt.c" />
    <ClCompile Include="src\XzDec.c" />
    <ClCompile Include="src\XzEnc.c" />
    <ClCompile Include="src\XzIn.c" />
  </ItemGroup>
 </Project>
--- a/3rdparty/7z/CMakeLists.txt
+++ b/3rdparty/7z/CMakeLists.txt
@ -0,0 +1,70 @@
 # 7z sdk
 if(WIN32 OR APPLE)
 	add_library(3rdparty_7z STATIC EXCLUDE_FROM_ALL
 		src/7zAlloc.c
 		src/7zArcIn.c
 		src/7zBuf.c
 		src/7zBuf2.c
 		src/7zCrc.c
 		src/7zCrcOpt.c
 		src/7zDec.c
 		src/7zFile.c
 		src/7zStream.c
 		src/Aes.c
 		src/AesOpt.c
 		src/Alloc.c
 		src/Bcj2.c
 		src/Bcj2Enc.c
 		src/Blake2s.c
 		src/Bra.c
 		src/Bra86.c
 		src/BraIA64.c
 		src/BwtSort.c
 		src/CpuArch.c
 		src/Delta.c
 		src/DllSecur.c
 		src/HuffEnc.c
 		src/LzFind.c
 		src/LzFindMt.c
 		src/LzFindOpt.c
 		src/Lzma2Dec.c
 		src/Lzma2DecMt.c
 		src/Lzma2Enc.c
 		src/Lzma86Dec.c
 		src/Lzma86Enc.c
 		src/LzmaDec.c
 		src/LzmaEnc.c
 		src/LzmaLib.c
 		src/MtCoder.c
 		src/MtDec.c
 		src/Ppmd7.c
 		src/Ppmd7aDec.c
 		src/Ppmd7Dec.c
 		src/Ppmd7Enc.c
 		src/Ppmd8.c
 		src/Ppmd8Dec.c
 		src/Ppmd8Enc.c
 		src/Sha1.c
 		src/Sha1Opt.c
 		src/Sha256.c
 		src/Sha256Opt.c
 		src/Sort.c
 		src/SwapBytes.c
 		src/Threads.c
 		src/Xz.c
 		src/XzCrc64.c
 		src/XzCrc64Opt.c
 		src/XzDec.c
 		src/XzEnc.c
 		src/XzIn.c)
 	target_include_directories(3rdparty_7z INTERFACE
 		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
 		$<INSTALL_INTERFACE:/src>)
 	target_include_directories(3rdparty_7z INTERFACE 7z)
 	set_property(TARGET 3rdparty_7z PROPERTY FOLDER "3rdparty/")
 else()
 	add_library(3rdparty_7z INTERFACE)
 endif()
--- a/3rdparty/7z/src/7z.h
+++ b/3rdparty/7z/src/7z.h
@ -0,0 +1,204 @@
 /* 7z.h -- 7z interface
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_7Z_H
 #define ZIP7_INC_7Z_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #define k7zStartHeaderSize 0x20
 #define k7zSignatureSize 6
 extern const Byte k7zSignature[k7zSignatureSize];
 typedef struct
 {
  const Byte *Data;
  size_t Size;
 } CSzData;
 /* CSzCoderInfo & CSzFolder support only default methods */
 typedef struct
 {
  size_t PropsOffset;
  UInt32 MethodID;
  Byte NumStreams;
  Byte PropsSize;
 } CSzCoderInfo;
 typedef struct
 {
  UInt32 InIndex;
  UInt32 OutIndex;
 } CSzBond;
 #define SZ_NUM_CODERS_IN_FOLDER_MAX 4
 #define SZ_NUM_BONDS_IN_FOLDER_MAX 3
 #define SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX 4
 typedef struct
 {
  UInt32 NumCoders;
  UInt32 NumBonds;
  UInt32 NumPackStreams;
  UInt32 UnpackStream;
  UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];
  CSzBond Bonds[SZ_NUM_BONDS_IN_FOLDER_MAX];
  CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX];
 } CSzFolder;
 SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd);
 typedef struct
 {
  UInt32 Low;
  UInt32 High;
 } CNtfsFileTime;
 typedef struct
 {
  Byte *Defs; /* MSB 0 bit numbering */
  UInt32 *Vals;
 } CSzBitUi32s;
 typedef struct
 {
  Byte *Defs; /* MSB 0 bit numbering */
  // UInt64 *Vals;
  CNtfsFileTime *Vals;
 } CSzBitUi64s;
 #define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
 #define SzBitWithVals_Check(p, i) ((p)->Defs && ((p)->Defs[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
 typedef struct
 {
  UInt32 NumPackStreams;
  UInt32 NumFolders;
  UInt64 *PackPositions;          // NumPackStreams + 1
  CSzBitUi32s FolderCRCs;         // NumFolders
  size_t *FoCodersOffsets;        // NumFolders + 1
  UInt32 *FoStartPackStreamIndex; // NumFolders + 1
  UInt32 *FoToCoderUnpackSizes;   // NumFolders + 1
  Byte *FoToMainUnpackSizeIndex;  // NumFolders
  UInt64 *CoderUnpackSizes;       // for all coders in all folders
  Byte *CodersData;
  UInt64 RangeLimit;
 } CSzAr;
 UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex);
 SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
    ILookInStreamPtr stream, UInt64 startPos,
    Byte *outBuffer, size_t outSize,
    ISzAllocPtr allocMain);
 typedef struct
 {
  CSzAr db;
  UInt64 startPosAfterHeader;
  UInt64 dataPos;
  UInt32 NumFiles;
  UInt64 *UnpackPositions;  // NumFiles + 1
  // Byte *IsEmptyFiles;
  Byte *IsDirs;
  CSzBitUi32s CRCs;
  CSzBitUi32s Attribs;
  // CSzBitUi32s Parents;
  CSzBitUi64s MTime;
  CSzBitUi64s CTime;
  UInt32 *FolderToFile;   // NumFolders + 1
  UInt32 *FileToFolder;   // NumFiles
  size_t *FileNameOffsets; /* in 2-byte steps */
  Byte *FileNames;  /* UTF-16-LE */
 } CSzArEx;
 #define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i))
 #define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i])
 void SzArEx_Init(CSzArEx *p);
 void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc);
 UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
 int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
 /*
 if dest == NULL, the return value specifies the required size of the buffer,
  in 16-bit characters, including the null-terminating character.
 if dest != NULL, the return value specifies the number of 16-bit characters that
  are written to the dest, including the null-terminating character. */
 size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
 /*
 size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);
 UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
 */
 /*
  SzArEx_Extract extracts file from archive
  *outBuffer must be 0 before first call for each new archive.
  Extracting cache:
    If you need to decompress more than one file, you can send
    these values from previous call:
      *blockIndex,
      *outBuffer,
      *outBufferSize
    You can consider "*outBuffer" as cache of solid block. If your archive is solid,
    it will increase decompression speed.
    If you use external function, you can declare these 3 cache variables
    (blockIndex, outBuffer, outBufferSize) as static in that external function.
    Free *outBuffer and set *outBuffer to 0, if you want to flush cache.
 */
 SRes SzArEx_Extract(
    const CSzArEx *db,
    ILookInStreamPtr inStream,
    UInt32 fileIndex,         /* index of file */
    UInt32 *blockIndex,       /* index of solid block */
    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
    size_t *outBufferSize,    /* buffer size for output buffer */
    size_t *offset,           /* offset of stream for required file in *outBuffer */
    size_t *outSizeProcessed, /* size of file in *outBuffer */
    ISzAllocPtr allocMain,
    ISzAllocPtr allocTemp);
 /*
 SzArEx_Open Errors:
 SZ_ERROR_NO_ARCHIVE
 SZ_ERROR_ARCHIVE
 SZ_ERROR_UNSUPPORTED
 SZ_ERROR_MEM
 SZ_ERROR_CRC
 SZ_ERROR_INPUT_EOF
 SZ_ERROR_FAIL
 */
 SRes SzArEx_Open(CSzArEx *p, ILookInStreamPtr inStream,
    ISzAllocPtr allocMain, ISzAllocPtr allocTemp);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/7zAlloc.c
+++ b/3rdparty/7z/src/7zAlloc.c
@ -0,0 +1,89 @@
 /* 7zAlloc.c -- Allocation functions for 7z processing
 2023-03-04 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include <stdlib.h>
 #include "7zAlloc.h"
 /* #define SZ_ALLOC_DEBUG */
 /* use SZ_ALLOC_DEBUG to debug alloc/free operations */
 #ifdef SZ_ALLOC_DEBUG
 /*
 #ifdef _WIN32
 #include "7zWindows.h"
 #endif
 */
 #include <stdio.h>
 static int g_allocCount = 0;
 static int g_allocCountTemp = 0;
 static void Print_Alloc(const char *s, size_t size, int *counter)
 {
  const unsigned size2 = (unsigned)size;
  fprintf(stderr, "\n%s count = %10d : %10u bytes; ", s, *counter, size2);
  (*counter)++;
 }
 static void Print_Free(const char *s, int *counter)
 {
  (*counter)--;
  fprintf(stderr, "\n%s count = %10d", s, *counter);
 }
 #endif
 void *SzAlloc(ISzAllocPtr p, size_t size)
 {
  UNUSED_VAR(p)
  if (size == 0)
    return 0;
  #ifdef SZ_ALLOC_DEBUG
  Print_Alloc("Alloc", size, &g_allocCount);
  #endif
  return malloc(size);
 }
 void SzFree(ISzAllocPtr p, void *address)
 {
  UNUSED_VAR(p)
  #ifdef SZ_ALLOC_DEBUG
  if (address)
    Print_Free("Free ", &g_allocCount);
  #endif
  free(address);
 }
 void *SzAllocTemp(ISzAllocPtr p, size_t size)
 {
  UNUSED_VAR(p)
  if (size == 0)
    return 0;
  #ifdef SZ_ALLOC_DEBUG
  Print_Alloc("Alloc_temp", size, &g_allocCountTemp);
  /*
  #ifdef _WIN32
  return HeapAlloc(GetProcessHeap(), 0, size);
  #endif
  */
  #endif
  return malloc(size);
 }
 void SzFreeTemp(ISzAllocPtr p, void *address)
 {
  UNUSED_VAR(p)
  #ifdef SZ_ALLOC_DEBUG
  if (address)
    Print_Free("Free_temp ", &g_allocCountTemp);
  /*
  #ifdef _WIN32
  HeapFree(GetProcessHeap(), 0, address);
  return;
  #endif
  */
  #endif
  free(address);
 }
--- a/3rdparty/7z/src/7zAlloc.h
+++ b/3rdparty/7z/src/7zAlloc.h
@ -0,0 +1,19 @@
 /* 7zAlloc.h -- Allocation functions
 2023-03-04 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_7Z_ALLOC_H
 #define ZIP7_INC_7Z_ALLOC_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 void *SzAlloc(ISzAllocPtr p, size_t size);
 void SzFree(ISzAllocPtr p, void *address);
 void *SzAllocTemp(ISzAllocPtr p, size_t size);
 void SzFreeTemp(ISzAllocPtr p, void *address);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/7zArcIn.c
+++ b/3rdparty/7z/src/7zArcIn.c
--- a/3rdparty/7z/src/7zBuf.c
+++ b/3rdparty/7z/src/7zBuf.c
@ -0,0 +1,36 @@
 /* 7zBuf.c -- Byte Buffer
 2017-04-03 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "7zBuf.h"
 void Buf_Init(CBuf *p)
 {
  p->data = 0;
  p->size = 0;
 }
 int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc)
 {
  p->size = 0;
  if (size == 0)
  {
    p->data = 0;
    return 1;
  }
  p->data = (Byte *)ISzAlloc_Alloc(alloc, size);
  if (p->data)
  {
    p->size = size;
    return 1;
  }
  return 0;
 }
 void Buf_Free(CBuf *p, ISzAllocPtr alloc)
 {
  ISzAlloc_Free(alloc, p->data);
  p->data = 0;
  p->size = 0;
 }
--- a/3rdparty/7z/src/7zBuf.h
+++ b/3rdparty/7z/src/7zBuf.h
@ -0,0 +1,35 @@
 /* 7zBuf.h -- Byte Buffer
 2023-03-04 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_7Z_BUF_H
 #define ZIP7_INC_7Z_BUF_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 typedef struct
 {
  Byte *data;
  size_t size;
 } CBuf;
 void Buf_Init(CBuf *p);
 int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc);
 void Buf_Free(CBuf *p, ISzAllocPtr alloc);
 typedef struct
 {
  Byte *data;
  size_t size;
  size_t pos;
 } CDynBuf;
 void DynBuf_Construct(CDynBuf *p);
 void DynBuf_SeekToBeg(CDynBuf *p);
 int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc);
 void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/7zBuf2.c
+++ b/3rdparty/7z/src/7zBuf2.c
@ -0,0 +1,52 @@
 /* 7zBuf2.c -- Byte Buffer
 2017-04-03 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include <string.h>
 #include "7zBuf.h"
 void DynBuf_Construct(CDynBuf *p)
 {
  p->data = 0;
  p->size = 0;
  p->pos = 0;
 }
 void DynBuf_SeekToBeg(CDynBuf *p)
 {
  p->pos = 0;
 }
 int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
 {
  if (size > p->size - p->pos)
  {
    size_t newSize = p->pos + size;
    Byte *data;
    newSize += newSize / 4;
    data = (Byte *)ISzAlloc_Alloc(alloc, newSize);
    if (!data)
      return 0;
    p->size = newSize;
    if (p->pos != 0)
      memcpy(data, p->data, p->pos);
    ISzAlloc_Free(alloc, p->data);
    p->data = data;
  }
  if (size != 0)
  {
    memcpy(p->data + p->pos, buf, size);
    p->pos += size;
  }
  return 1;
 }
 void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc)
 {
  ISzAlloc_Free(alloc, p->data);
  p->data = 0;
  p->size = 0;
  p->pos = 0;
 }
--- a/3rdparty/7z/src/7zCrc.c
+++ b/3rdparty/7z/src/7zCrc.c
@ -0,0 +1,340 @@
 /* 7zCrc.c -- CRC32 calculation and init
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "7zCrc.h"
 #include "CpuArch.h"
 #define kCrcPoly 0xEDB88320
 #ifdef MY_CPU_LE
  #define CRC_NUM_TABLES 8
 #else
  #define CRC_NUM_TABLES 9
  UInt32 Z7_FASTCALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
  UInt32 Z7_FASTCALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
 #endif
 #ifndef MY_CPU_BE
  UInt32 Z7_FASTCALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
  UInt32 Z7_FASTCALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
 #endif
 /*
 extern
 CRC_FUNC g_CrcUpdateT4;
 CRC_FUNC g_CrcUpdateT4;
 */
 extern
 CRC_FUNC g_CrcUpdateT8;
 CRC_FUNC g_CrcUpdateT8;
 extern
 CRC_FUNC g_CrcUpdateT0_32;
 CRC_FUNC g_CrcUpdateT0_32;
 extern
 CRC_FUNC g_CrcUpdateT0_64;
 CRC_FUNC g_CrcUpdateT0_64;
 extern
 CRC_FUNC g_CrcUpdate;
 CRC_FUNC g_CrcUpdate;
 UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
 UInt32 Z7_FASTCALL CrcUpdate(UInt32 v, const void *data, size_t size)
 {
  return g_CrcUpdate(v, data, size, g_CrcTable);
 }
 UInt32 Z7_FASTCALL CrcCalc(const void *data, size_t size)
 {
  return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL;
 }
 #if CRC_NUM_TABLES < 4 \
   || (CRC_NUM_TABLES == 4 && defined(MY_CPU_BE)) \
   || (!defined(MY_CPU_LE) && !defined(MY_CPU_BE))
 #define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
 UInt32 Z7_FASTCALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);
 UInt32 Z7_FASTCALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
  const Byte *pEnd = p + size;
  for (; p != pEnd; p++)
    v = CRC_UPDATE_BYTE_2(v, *p);
  return v;
 }
 #endif
 /* ---------- hardware CRC ---------- */
 #ifdef MY_CPU_LE
 #if defined(MY_CPU_ARM_OR_ARM64)
 // #pragma message("ARM*")
  #if defined(_MSC_VER)
    #if defined(MY_CPU_ARM64)
    #if (_MSC_VER >= 1910)
    #ifndef __clang__
        #define USE_ARM64_CRC
        #include <intrin.h>
    #endif
    #endif
    #endif
  #elif (defined(__clang__) && (__clang_major__ >= 3)) \
     || (defined(__GNUC__) && (__GNUC__ > 4))
      #if !defined(__ARM_FEATURE_CRC32)
        #define __ARM_FEATURE_CRC32 1
        #if defined(__clang__)
          #if defined(MY_CPU_ARM64)
            #define ATTRIB_CRC __attribute__((__target__("crc")))
          #else
            #define ATTRIB_CRC __attribute__((__target__("armv8-a,crc")))
          #endif
        #else
          #if defined(MY_CPU_ARM64)
            #define ATTRIB_CRC __attribute__((__target__("+crc")))
          #else
            #define ATTRIB_CRC __attribute__((__target__("arch=armv8-a+crc")))
          #endif
        #endif
      #endif
      #if defined(__ARM_FEATURE_CRC32)
        #define USE_ARM64_CRC
        #include <arm_acle.h>
      #endif
  #endif
 #else
 // no hardware CRC
 // #define USE_CRC_EMU
 #ifdef USE_CRC_EMU
 #pragma message("ARM64 CRC emulation")
 Z7_FORCE_INLINE
 UInt32 __crc32b(UInt32 v, UInt32 data)
 {
  const UInt32 *table = g_CrcTable;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data);
  return v;
 }
 Z7_FORCE_INLINE
 UInt32 __crc32w(UInt32 v, UInt32 data)
 {
  const UInt32 *table = g_CrcTable;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  return v;
 }
 Z7_FORCE_INLINE
 UInt32 __crc32d(UInt32 v, UInt64 data)
 {
  const UInt32 *table = g_CrcTable;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
  return v;
 }
 #endif // USE_CRC_EMU
 #endif // defined(MY_CPU_ARM64) && defined(MY_CPU_LE)
 #if defined(USE_ARM64_CRC) || defined(USE_CRC_EMU)
 #define T0_32_UNROLL_BYTES (4 * 4)
 #define T0_64_UNROLL_BYTES (4 * 8)
 #ifndef ATTRIB_CRC
 #define ATTRIB_CRC
 #endif
 // #pragma message("USE ARM HW CRC")
 ATTRIB_CRC
 UInt32 Z7_FASTCALL CrcUpdateT0_32(UInt32 v, const void *data, size_t size, const UInt32 *table);
 ATTRIB_CRC
 UInt32 Z7_FASTCALL CrcUpdateT0_32(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
  UNUSED_VAR(table);
  for (; size != 0 && ((unsigned)(ptrdiff_t)p & (T0_32_UNROLL_BYTES - 1)) != 0; size--)
    v = __crc32b(v, *p++);
  if (size >= T0_32_UNROLL_BYTES)
  {
    const Byte *lim = p + size;
    size &= (T0_32_UNROLL_BYTES - 1);
    lim -= size;
    do
    {
      v = __crc32w(v, *(const UInt32 *)(const void *)(p));
      v = __crc32w(v, *(const UInt32 *)(const void *)(p + 4)); p += 2 * 4;
      v = __crc32w(v, *(const UInt32 *)(const void *)(p));
      v = __crc32w(v, *(const UInt32 *)(const void *)(p + 4)); p += 2 * 4;
    }
    while (p != lim);
  }
  for (; size != 0; size--)
    v = __crc32b(v, *p++);
  return v;
 }
 ATTRIB_CRC
 UInt32 Z7_FASTCALL CrcUpdateT0_64(UInt32 v, const void *data, size_t size, const UInt32 *table);
 ATTRIB_CRC
 UInt32 Z7_FASTCALL CrcUpdateT0_64(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
  UNUSED_VAR(table);
  for (; size != 0 && ((unsigned)(ptrdiff_t)p & (T0_64_UNROLL_BYTES - 1)) != 0; size--)
    v = __crc32b(v, *p++);
  if (size >= T0_64_UNROLL_BYTES)
  {
    const Byte *lim = p + size;
    size &= (T0_64_UNROLL_BYTES - 1);
    lim -= size;
    do
    {
      v = __crc32d(v, *(const UInt64 *)(const void *)(p));
      v = __crc32d(v, *(const UInt64 *)(const void *)(p + 8)); p += 2 * 8;
      v = __crc32d(v, *(const UInt64 *)(const void *)(p));
      v = __crc32d(v, *(const UInt64 *)(const void *)(p + 8)); p += 2 * 8;
    }
    while (p != lim);
  }
  for (; size != 0; size--)
    v = __crc32b(v, *p++);
  return v;
 }
 #undef T0_32_UNROLL_BYTES
 #undef T0_64_UNROLL_BYTES
 #endif // defined(USE_ARM64_CRC) || defined(USE_CRC_EMU)
 #endif // MY_CPU_LE
 void Z7_FASTCALL CrcGenerateTable(void)
 {
  UInt32 i;
  for (i = 0; i < 256; i++)
  {
    UInt32 r = i;
    unsigned j;
    for (j = 0; j < 8; j++)
      r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));
    g_CrcTable[i] = r;
  }
  for (i = 256; i < 256 * CRC_NUM_TABLES; i++)
  {
    const UInt32 r = g_CrcTable[(size_t)i - 256];
    g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
  }
  #if CRC_NUM_TABLES < 4
    g_CrcUpdate = CrcUpdateT1;
  #elif defined(MY_CPU_LE)
    // g_CrcUpdateT4 = CrcUpdateT4;
    #if CRC_NUM_TABLES < 8
      g_CrcUpdate = CrcUpdateT4;
    #else // CRC_NUM_TABLES >= 8
      g_CrcUpdateT8 = CrcUpdateT8;
      /*
      #ifdef MY_CPU_X86_OR_AMD64
      if (!CPU_Is_InOrder())
      #endif
      */
      g_CrcUpdate = CrcUpdateT8;
    #endif
  #else
  {
   #ifndef MY_CPU_BE
    UInt32 k = 0x01020304;
    const Byte *p = (const Byte *)&k;
    if (p[0] == 4 && p[1] == 3)
    {
      #if CRC_NUM_TABLES < 8
        // g_CrcUpdateT4 = CrcUpdateT4;
        g_CrcUpdate   = CrcUpdateT4;
      #else  // CRC_NUM_TABLES >= 8
        g_CrcUpdateT8 = CrcUpdateT8;
        g_CrcUpdate   = CrcUpdateT8;
      #endif
    }
    else if (p[0] != 1 || p[1] != 2)
      g_CrcUpdate = CrcUpdateT1;
    else
   #endif // MY_CPU_BE
    {
      for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
      {
        const UInt32 x = g_CrcTable[(size_t)i - 256];
        g_CrcTable[i] = Z7_BSWAP32(x);
      }
      #if CRC_NUM_TABLES <= 4
        g_CrcUpdate = CrcUpdateT1;
      #elif CRC_NUM_TABLES <= 8
        // g_CrcUpdateT4 = CrcUpdateT1_BeT4;
        g_CrcUpdate   = CrcUpdateT1_BeT4;
      #else  // CRC_NUM_TABLES > 8
        g_CrcUpdateT8 = CrcUpdateT1_BeT8;
        g_CrcUpdate   = CrcUpdateT1_BeT8;
      #endif
    }
  }
  #endif // CRC_NUM_TABLES < 4
  #ifdef MY_CPU_LE
    #ifdef USE_ARM64_CRC
      if (CPU_IsSupported_CRC32())
      {
        g_CrcUpdateT0_32 = CrcUpdateT0_32;
        g_CrcUpdateT0_64 = CrcUpdateT0_64;
        g_CrcUpdate =
          #if defined(MY_CPU_ARM)
            CrcUpdateT0_32;
          #else
            CrcUpdateT0_64;
          #endif
      }
    #endif
    #ifdef USE_CRC_EMU
      g_CrcUpdateT0_32 = CrcUpdateT0_32;
      g_CrcUpdateT0_64 = CrcUpdateT0_64;
      g_CrcUpdate = CrcUpdateT0_64;
    #endif
  #endif
 }
 #undef kCrcPoly
 #undef CRC64_NUM_TABLES
 #undef CRC_UPDATE_BYTE_2
--- a/3rdparty/7z/src/7zCrc.h
+++ b/3rdparty/7z/src/7zCrc.h
@ -0,0 +1,27 @@
 /* 7zCrc.h -- CRC32 calculation
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_7Z_CRC_H
 #define ZIP7_INC_7Z_CRC_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 extern UInt32 g_CrcTable[];
 /* Call CrcGenerateTable one time before other CRC functions */
 void Z7_FASTCALL CrcGenerateTable(void);
 #define CRC_INIT_VAL 0xFFFFFFFF
 #define CRC_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL)
 #define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
 UInt32 Z7_FASTCALL CrcUpdate(UInt32 crc, const void *data, size_t size);
 UInt32 Z7_FASTCALL CrcCalc(const void *data, size_t size);
 typedef UInt32 (Z7_FASTCALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/7zCrcOpt.c
+++ b/3rdparty/7z/src/7zCrcOpt.c
@ -0,0 +1,117 @@
 /* 7zCrcOpt.c -- CRC32 calculation
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "CpuArch.h"
 #ifndef MY_CPU_BE
 #define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
 UInt32 Z7_FASTCALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
 UInt32 Z7_FASTCALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
    v = CRC_UPDATE_BYTE_2(v, *p);
  for (; size >= 4; size -= 4, p += 4)
  {
    v ^= *(const UInt32 *)(const void *)p;
    v =
          (table + 0x300)[((v      ) & 0xFF)]
        ^ (table + 0x200)[((v >>  8) & 0xFF)]
        ^ (table + 0x100)[((v >> 16) & 0xFF)]
        ^ (table + 0x000)[((v >> 24))];
  }
  for (; size > 0; size--, p++)
    v = CRC_UPDATE_BYTE_2(v, *p);
  return v;
 }
 UInt32 Z7_FASTCALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
 UInt32 Z7_FASTCALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)
    v = CRC_UPDATE_BYTE_2(v, *p);
  for (; size >= 8; size -= 8, p += 8)
  {
    UInt32 d;
    v ^= *(const UInt32 *)(const void *)p;
    v =
          (table + 0x700)[((v      ) & 0xFF)]
        ^ (table + 0x600)[((v >>  8) & 0xFF)]
        ^ (table + 0x500)[((v >> 16) & 0xFF)]
        ^ (table + 0x400)[((v >> 24))];
    d = *((const UInt32 *)(const void *)p + 1);
    v ^=
          (table + 0x300)[((d      ) & 0xFF)]
        ^ (table + 0x200)[((d >>  8) & 0xFF)]
        ^ (table + 0x100)[((d >> 16) & 0xFF)]
        ^ (table + 0x000)[((d >> 24))];
  }
  for (; size > 0; size--, p++)
    v = CRC_UPDATE_BYTE_2(v, *p);
  return v;
 }
 #endif
 #ifndef MY_CPU_LE
 #define CRC_UINT32_SWAP(v)  Z7_BSWAP32(v)
 #define CRC_UPDATE_BYTE_2_BE(crc, b) (table[(((crc) >> 24) ^ (b))] ^ ((crc) << 8))
 UInt32 Z7_FASTCALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
  table += 0x100;
  v = CRC_UINT32_SWAP(v);
  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
    v = CRC_UPDATE_BYTE_2_BE(v, *p);
  for (; size >= 4; size -= 4, p += 4)
  {
    v ^= *(const UInt32 *)(const void *)p;
    v =
          (table + 0x000)[((v      ) & 0xFF)]
        ^ (table + 0x100)[((v >>  8) & 0xFF)]
        ^ (table + 0x200)[((v >> 16) & 0xFF)]
        ^ (table + 0x300)[((v >> 24))];
  }
  for (; size > 0; size--, p++)
    v = CRC_UPDATE_BYTE_2_BE(v, *p);
  return CRC_UINT32_SWAP(v);
 }
 UInt32 Z7_FASTCALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
  table += 0x100;
  v = CRC_UINT32_SWAP(v);
  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)
    v = CRC_UPDATE_BYTE_2_BE(v, *p);
  for (; size >= 8; size -= 8, p += 8)
  {
    UInt32 d;
    v ^= *(const UInt32 *)(const void *)p;
    v =
          (table + 0x400)[((v      ) & 0xFF)]
        ^ (table + 0x500)[((v >>  8) & 0xFF)]
        ^ (table + 0x600)[((v >> 16) & 0xFF)]
        ^ (table + 0x700)[((v >> 24))];
    d = *((const UInt32 *)(const void *)p + 1);
    v ^=
          (table + 0x000)[((d      ) & 0xFF)]
        ^ (table + 0x100)[((d >>  8) & 0xFF)]
        ^ (table + 0x200)[((d >> 16) & 0xFF)]
        ^ (table + 0x300)[((d >> 24))];
  }
  for (; size > 0; size--, p++)
    v = CRC_UPDATE_BYTE_2_BE(v, *p);
  return CRC_UINT32_SWAP(v);
 }
 #endif
--- a/3rdparty/7z/src/7zDec.c
+++ b/3rdparty/7z/src/7zDec.c
@ -0,0 +1,648 @@
 /* 7zDec.c -- Decoding from 7z folder
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include <string.h>
 /* #define Z7_PPMD_SUPPORT */
 #include "7z.h"
 #include "7zCrc.h"
 #include "Bcj2.h"
 #include "Bra.h"
 #include "CpuArch.h"
 #include "Delta.h"
 #include "LzmaDec.h"
 #include "Lzma2Dec.h"
 #ifdef Z7_PPMD_SUPPORT
 #include "Ppmd7.h"
 #endif
 #define k_Copy 0
 #ifndef Z7_NO_METHOD_LZMA2
 #define k_LZMA2 0x21
 #endif
 #define k_LZMA  0x30101
 #define k_BCJ2  0x303011B
 #if !defined(Z7_NO_METHODS_FILTERS)
 #define Z7_USE_BRANCH_FILTER
 #endif
 #if !defined(Z7_NO_METHODS_FILTERS) || \
     defined(Z7_USE_NATIVE_BRANCH_FILTER) && defined(MY_CPU_ARM64)
 #define Z7_USE_FILTER_ARM64
 #ifndef Z7_USE_BRANCH_FILTER
 #define Z7_USE_BRANCH_FILTER
 #endif
 #define k_ARM64 0xa
 #endif
 #if !defined(Z7_NO_METHODS_FILTERS) || \
     defined(Z7_USE_NATIVE_BRANCH_FILTER) && defined(MY_CPU_ARMT)
 #define Z7_USE_FILTER_ARMT
 #ifndef Z7_USE_BRANCH_FILTER
 #define Z7_USE_BRANCH_FILTER
 #endif
 #define k_ARMT  0x3030701
 #endif
 #ifndef Z7_NO_METHODS_FILTERS
 #define k_Delta 3
 #define k_BCJ   0x3030103
 #define k_PPC   0x3030205
 #define k_IA64  0x3030401
 #define k_ARM   0x3030501
 #define k_SPARC 0x3030805
 #endif
 #ifdef Z7_PPMD_SUPPORT
 #define k_PPMD 0x30401
 typedef struct
 {
  IByteIn vt;
  const Byte *cur;
  const Byte *end;
  const Byte *begin;
  UInt64 processed;
  BoolInt extra;
  SRes res;
  ILookInStreamPtr inStream;
 } CByteInToLook;
 static Byte ReadByte(IByteInPtr pp)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CByteInToLook)
  if (p->cur != p->end)
    return *p->cur++;
  if (p->res == SZ_OK)
  {
    size_t size = (size_t)(p->cur - p->begin);
    p->processed += size;
    p->res = ILookInStream_Skip(p->inStream, size);
    size = (1 << 25);
    p->res = ILookInStream_Look(p->inStream, (const void **)&p->begin, &size);
    p->cur = p->begin;
    p->end = p->begin + size;
    if (size != 0)
      return *p->cur++;
  }
  p->extra = True;
  return 0;
 }
 static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStreamPtr inStream,
    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
 {
  CPpmd7 ppmd;
  CByteInToLook s;
  SRes res = SZ_OK;
  s.vt.Read = ReadByte;
  s.inStream = inStream;
  s.begin = s.end = s.cur = NULL;
  s.extra = False;
  s.res = SZ_OK;
  s.processed = 0;
  if (propsSize != 5)
    return SZ_ERROR_UNSUPPORTED;
  {
    unsigned order = props[0];
    UInt32 memSize = GetUi32(props + 1);
    if (order < PPMD7_MIN_ORDER ||
        order > PPMD7_MAX_ORDER ||
        memSize < PPMD7_MIN_MEM_SIZE ||
        memSize > PPMD7_MAX_MEM_SIZE)
      return SZ_ERROR_UNSUPPORTED;
    Ppmd7_Construct(&ppmd);
    if (!Ppmd7_Alloc(&ppmd, memSize, allocMain))
      return SZ_ERROR_MEM;
    Ppmd7_Init(&ppmd, order);
  }
  {
    ppmd.rc.dec.Stream = &s.vt;
    if (!Ppmd7z_RangeDec_Init(&ppmd.rc.dec))
      res = SZ_ERROR_DATA;
    else if (!s.extra)
    {
      Byte *buf = outBuffer;
      const Byte *lim = buf + outSize;
      for (; buf != lim; buf++)
      {
        int sym = Ppmd7z_DecodeSymbol(&ppmd);
        if (s.extra || sym < 0)
          break;
        *buf = (Byte)sym;
      }
      if (buf != lim)
        res = SZ_ERROR_DATA;
      else if (!Ppmd7z_RangeDec_IsFinishedOK(&ppmd.rc.dec))
      {
        /* if (Ppmd7z_DecodeSymbol(&ppmd) != PPMD7_SYM_END || !Ppmd7z_RangeDec_IsFinishedOK(&ppmd.rc.dec)) */
        res = SZ_ERROR_DATA;
      }
    }
    if (s.extra)
      res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
    else if (s.processed + (size_t)(s.cur - s.begin) != inSize)
      res = SZ_ERROR_DATA;
  }
  Ppmd7_Free(&ppmd, allocMain);
  return res;
 }
 #endif
 static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStreamPtr inStream,
    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
 {
  CLzmaDec state;
  SRes res = SZ_OK;
  LzmaDec_CONSTRUCT(&state)
  RINOK(LzmaDec_AllocateProbs(&state, props, propsSize, allocMain))
  state.dic = outBuffer;
  state.dicBufSize = outSize;
  LzmaDec_Init(&state);
  for (;;)
  {
    const void *inBuf = NULL;
    size_t lookahead = (1 << 18);
    if (lookahead > inSize)
      lookahead = (size_t)inSize;
    res = ILookInStream_Look(inStream, &inBuf, &lookahead);
    if (res != SZ_OK)
      break;
    {
      SizeT inProcessed = (SizeT)lookahead, dicPos = state.dicPos;
      ELzmaStatus status;
      res = LzmaDec_DecodeToDic(&state, outSize, (const Byte *)inBuf, &inProcessed, LZMA_FINISH_END, &status);
      lookahead -= inProcessed;
      inSize -= inProcessed;
      if (res != SZ_OK)
        break;
      if (status == LZMA_STATUS_FINISHED_WITH_MARK)
      {
        if (outSize != state.dicPos || inSize != 0)
          res = SZ_ERROR_DATA;
        break;
      }
      if (outSize == state.dicPos && inSize == 0 && status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
        break;
      if (inProcessed == 0 && dicPos == state.dicPos)
      {
        res = SZ_ERROR_DATA;
        break;
      }
      res = ILookInStream_Skip(inStream, inProcessed);
      if (res != SZ_OK)
        break;
    }
  }
  LzmaDec_FreeProbs(&state, allocMain);
  return res;
 }
 #ifndef Z7_NO_METHOD_LZMA2
 static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStreamPtr inStream,
    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
 {
  CLzma2Dec state;
  SRes res = SZ_OK;
  Lzma2Dec_CONSTRUCT(&state)
  if (propsSize != 1)
    return SZ_ERROR_DATA;
  RINOK(Lzma2Dec_AllocateProbs(&state, props[0], allocMain))
  state.decoder.dic = outBuffer;
  state.decoder.dicBufSize = outSize;
  Lzma2Dec_Init(&state);
  for (;;)
  {
    const void *inBuf = NULL;
    size_t lookahead = (1 << 18);
    if (lookahead > inSize)
      lookahead = (size_t)inSize;
    res = ILookInStream_Look(inStream, &inBuf, &lookahead);
    if (res != SZ_OK)
      break;
    {
      SizeT inProcessed = (SizeT)lookahead, dicPos = state.decoder.dicPos;
      ELzmaStatus status;
      res = Lzma2Dec_DecodeToDic(&state, outSize, (const Byte *)inBuf, &inProcessed, LZMA_FINISH_END, &status);
      lookahead -= inProcessed;
      inSize -= inProcessed;
      if (res != SZ_OK)
        break;
      if (status == LZMA_STATUS_FINISHED_WITH_MARK)
      {
        if (outSize != state.decoder.dicPos || inSize != 0)
          res = SZ_ERROR_DATA;
        break;
      }
      if (inProcessed == 0 && dicPos == state.decoder.dicPos)
      {
        res = SZ_ERROR_DATA;
        break;
      }
      res = ILookInStream_Skip(inStream, inProcessed);
      if (res != SZ_OK)
        break;
    }
  }
  Lzma2Dec_FreeProbs(&state, allocMain);
  return res;
 }
 #endif
 static SRes SzDecodeCopy(UInt64 inSize, ILookInStreamPtr inStream, Byte *outBuffer)
 {
  while (inSize > 0)
  {
    const void *inBuf;
    size_t curSize = (1 << 18);
    if (curSize > inSize)
      curSize = (size_t)inSize;
    RINOK(ILookInStream_Look(inStream, &inBuf, &curSize))
    if (curSize == 0)
      return SZ_ERROR_INPUT_EOF;
    memcpy(outBuffer, inBuf, curSize);
    outBuffer += curSize;
    inSize -= curSize;
    RINOK(ILookInStream_Skip(inStream, curSize))
  }
  return SZ_OK;
 }
 static BoolInt IS_MAIN_METHOD(UInt32 m)
 {
  switch (m)
  {
    case k_Copy:
    case k_LZMA:
  #ifndef Z7_NO_METHOD_LZMA2
    case k_LZMA2:
  #endif
  #ifdef Z7_PPMD_SUPPORT
    case k_PPMD:
  #endif
      return True;
  }
  return False;
 }
 static BoolInt IS_SUPPORTED_CODER(const CSzCoderInfo *c)
 {
  return
      c->NumStreams == 1
      /* && c->MethodID <= (UInt32)0xFFFFFFFF */
      && IS_MAIN_METHOD((UInt32)c->MethodID);
 }
 #define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumStreams == 4)
 static SRes CheckSupportedFolder(const CSzFolder *f)
 {
  if (f->NumCoders < 1 || f->NumCoders > 4)
    return SZ_ERROR_UNSUPPORTED;
  if (!IS_SUPPORTED_CODER(&f->Coders[0]))
    return SZ_ERROR_UNSUPPORTED;
  if (f->NumCoders == 1)
  {
    if (f->NumPackStreams != 1 || f->PackStreams[0] != 0 || f->NumBonds != 0)
      return SZ_ERROR_UNSUPPORTED;
    return SZ_OK;
  }
  #if defined(Z7_USE_BRANCH_FILTER)
  if (f->NumCoders == 2)
  {
    const CSzCoderInfo *c = &f->Coders[1];
    if (
        /* c->MethodID > (UInt32)0xFFFFFFFF || */
        c->NumStreams != 1
        || f->NumPackStreams != 1
        || f->PackStreams[0] != 0
        || f->NumBonds != 1
        || f->Bonds[0].InIndex != 1
        || f->Bonds[0].OutIndex != 0)
      return SZ_ERROR_UNSUPPORTED;
    switch ((UInt32)c->MethodID)
    {
    #if !defined(Z7_NO_METHODS_FILTERS)
      case k_Delta:
      case k_BCJ:
      case k_PPC:
      case k_IA64:
      case k_SPARC:
      case k_ARM:
    #endif
    #ifdef Z7_USE_FILTER_ARM64
      case k_ARM64:
    #endif
    #ifdef Z7_USE_FILTER_ARMT
      case k_ARMT:
    #endif
        break;
      default:
        return SZ_ERROR_UNSUPPORTED;
    }
    return SZ_OK;
  }
  #endif
  if (f->NumCoders == 4)
  {
    if (!IS_SUPPORTED_CODER(&f->Coders[1])
        || !IS_SUPPORTED_CODER(&f->Coders[2])
        || !IS_BCJ2(&f->Coders[3]))
      return SZ_ERROR_UNSUPPORTED;
    if (f->NumPackStreams != 4
        || f->PackStreams[0] != 2
        || f->PackStreams[1] != 6
        || f->PackStreams[2] != 1
        || f->PackStreams[3] != 0
        || f->NumBonds != 3
        || f->Bonds[0].InIndex != 5 || f->Bonds[0].OutIndex != 0
        || f->Bonds[1].InIndex != 4 || f->Bonds[1].OutIndex != 1
        || f->Bonds[2].InIndex != 3 || f->Bonds[2].OutIndex != 2)
      return SZ_ERROR_UNSUPPORTED;
    return SZ_OK;
  }
  return SZ_ERROR_UNSUPPORTED;
 }
 static SRes SzFolder_Decode2(const CSzFolder *folder,
    const Byte *propsData,
    const UInt64 *unpackSizes,
    const UInt64 *packPositions,
    ILookInStreamPtr inStream, UInt64 startPos,
    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain,
    Byte *tempBuf[])
 {
  UInt32 ci;
  SizeT tempSizes[3] = { 0, 0, 0};
  SizeT tempSize3 = 0;
  Byte *tempBuf3 = 0;
  RINOK(CheckSupportedFolder(folder))
  for (ci = 0; ci < folder->NumCoders; ci++)
  {
    const CSzCoderInfo *coder = &folder->Coders[ci];
    if (IS_MAIN_METHOD((UInt32)coder->MethodID))
    {
      UInt32 si = 0;
      UInt64 offset;
      UInt64 inSize;
      Byte *outBufCur = outBuffer;
      SizeT outSizeCur = outSize;
      if (folder->NumCoders == 4)
      {
        const UInt32 indices[] = { 3, 2, 0 };
        const UInt64 unpackSize = unpackSizes[ci];
        si = indices[ci];
        if (ci < 2)
        {
          Byte *temp;
          outSizeCur = (SizeT)unpackSize;
          if (outSizeCur != unpackSize)
            return SZ_ERROR_MEM;
          temp = (Byte *)ISzAlloc_Alloc(allocMain, outSizeCur);
          if (!temp && outSizeCur != 0)
            return SZ_ERROR_MEM;
          outBufCur = tempBuf[1 - ci] = temp;
          tempSizes[1 - ci] = outSizeCur;
        }
        else if (ci == 2)
        {
          if (unpackSize > outSize) /* check it */
            return SZ_ERROR_PARAM;
          tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize);
          tempSize3 = outSizeCur = (SizeT)unpackSize;
        }
        else
          return SZ_ERROR_UNSUPPORTED;
      }
      offset = packPositions[si];
      inSize = packPositions[(size_t)si + 1] - offset;
      RINOK(LookInStream_SeekTo(inStream, startPos + offset))
      if (coder->MethodID == k_Copy)
      {
        if (inSize != outSizeCur) /* check it */
          return SZ_ERROR_DATA;
        RINOK(SzDecodeCopy(inSize, inStream, outBufCur))
      }
      else if (coder->MethodID == k_LZMA)
      {
        RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain))
      }
    #ifndef Z7_NO_METHOD_LZMA2
      else if (coder->MethodID == k_LZMA2)
      {
        RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain))
      }
    #endif
    #ifdef Z7_PPMD_SUPPORT
      else if (coder->MethodID == k_PPMD)
      {
        RINOK(SzDecodePpmd(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain))
      }
    #endif
      else
        return SZ_ERROR_UNSUPPORTED;
    }
    else if (coder->MethodID == k_BCJ2)
    {
      const UInt64 offset = packPositions[1];
      const UInt64 s3Size = packPositions[2] - offset;
      if (ci != 3)
        return SZ_ERROR_UNSUPPORTED;
      tempSizes[2] = (SizeT)s3Size;
      if (tempSizes[2] != s3Size)
        return SZ_ERROR_MEM;
      tempBuf[2] = (Byte *)ISzAlloc_Alloc(allocMain, tempSizes[2]);
      if (!tempBuf[2] && tempSizes[2] != 0)
        return SZ_ERROR_MEM;
      RINOK(LookInStream_SeekTo(inStream, startPos + offset))
      RINOK(SzDecodeCopy(s3Size, inStream, tempBuf[2]))
      if ((tempSizes[0] & 3) != 0 ||
          (tempSizes[1] & 3) != 0 ||
          tempSize3 + tempSizes[0] + tempSizes[1] != outSize)
        return SZ_ERROR_DATA;
      {
        CBcj2Dec p;
        p.bufs[0] = tempBuf3;   p.lims[0] = tempBuf3 + tempSize3;
        p.bufs[1] = tempBuf[0]; p.lims[1] = tempBuf[0] + tempSizes[0];
        p.bufs[2] = tempBuf[1]; p.lims[2] = tempBuf[1] + tempSizes[1];
        p.bufs[3] = tempBuf[2]; p.lims[3] = tempBuf[2] + tempSizes[2];
        p.dest = outBuffer;
        p.destLim = outBuffer + outSize;
        Bcj2Dec_Init(&p);
        RINOK(Bcj2Dec_Decode(&p))
        {
          unsigned i;
          for (i = 0; i < 4; i++)
            if (p.bufs[i] != p.lims[i])
              return SZ_ERROR_DATA;
          if (p.dest != p.destLim || !Bcj2Dec_IsMaybeFinished(&p))
            return SZ_ERROR_DATA;
        }
      }
    }
  #if defined(Z7_USE_BRANCH_FILTER)
    else if (ci == 1)
    {
     #if !defined(Z7_NO_METHODS_FILTERS)
      if (coder->MethodID == k_Delta)
      {
        if (coder->PropsSize != 1)
          return SZ_ERROR_UNSUPPORTED;
        {
          Byte state[DELTA_STATE_SIZE];
          Delta_Init(state);
          Delta_Decode(state, (unsigned)(propsData[coder->PropsOffset]) + 1, outBuffer, outSize);
        }
        continue;
      }
     #endif
     #ifdef Z7_USE_FILTER_ARM64
      if (coder->MethodID == k_ARM64)
      {
        UInt32 pc = 0;
        if (coder->PropsSize == 4)
          pc = GetUi32(propsData + coder->PropsOffset);
        else if (coder->PropsSize != 0)
          return SZ_ERROR_UNSUPPORTED;
        z7_BranchConv_ARM64_Dec(outBuffer, outSize, pc);
        continue;
      }
     #endif
     #if !defined(Z7_NO_METHODS_FILTERS) || defined(Z7_USE_FILTER_ARMT)
      {
        if (coder->PropsSize != 0)
          return SZ_ERROR_UNSUPPORTED;
       #define CASE_BRA_CONV(isa) case k_ ## isa: Z7_BRANCH_CONV_DEC(isa)(outBuffer, outSize, 0); break; // pc = 0;
        switch (coder->MethodID)
        {
         #if !defined(Z7_NO_METHODS_FILTERS)
          case k_BCJ:
          {
            UInt32 state = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
            z7_BranchConvSt_X86_Dec(outBuffer, outSize, 0, &state); // pc = 0
            break;
          }
          CASE_BRA_CONV(PPC)
          CASE_BRA_CONV(IA64)
          CASE_BRA_CONV(SPARC)
          CASE_BRA_CONV(ARM)
         #endif
         #if !defined(Z7_NO_METHODS_FILTERS) || defined(Z7_USE_FILTER_ARMT)
          CASE_BRA_CONV(ARMT)
         #endif
          default:
            return SZ_ERROR_UNSUPPORTED;
        }
        continue;
      }
     #endif
    } // (c == 1)
  #endif
    else
      return SZ_ERROR_UNSUPPORTED;
  }
  return SZ_OK;
 }
 SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
    ILookInStreamPtr inStream, UInt64 startPos,
    Byte *outBuffer, size_t outSize,
    ISzAllocPtr allocMain)
 {
  SRes res;
  CSzFolder folder;
  CSzData sd;
  const Byte *data = p->CodersData + p->FoCodersOffsets[folderIndex];
  sd.Data = data;
  sd.Size = p->FoCodersOffsets[(size_t)folderIndex + 1] - p->FoCodersOffsets[folderIndex];
  res = SzGetNextFolderItem(&folder, &sd);
  if (res != SZ_OK)
    return res;
  if (sd.Size != 0
      || folder.UnpackStream != p->FoToMainUnpackSizeIndex[folderIndex]
      || outSize != SzAr_GetFolderUnpackSize(p, folderIndex))
    return SZ_ERROR_FAIL;
  {
    unsigned i;
    Byte *tempBuf[3] = { 0, 0, 0};
    res = SzFolder_Decode2(&folder, data,
        &p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex]],
        p->PackPositions + p->FoStartPackStreamIndex[folderIndex],
        inStream, startPos,
        outBuffer, (SizeT)outSize, allocMain, tempBuf);
    for (i = 0; i < 3; i++)
      ISzAlloc_Free(allocMain, tempBuf[i]);
    if (res == SZ_OK)
      if (SzBitWithVals_Check(&p->FolderCRCs, folderIndex))
        if (CrcCalc(outBuffer, outSize) != p->FolderCRCs.Vals[folderIndex])
          res = SZ_ERROR_CRC;
    return res;
  }
 }
--- a/3rdparty/7z/src/7zFile.c
+++ b/3rdparty/7z/src/7zFile.c
@ -0,0 +1,443 @@
 /* 7zFile.c -- File IO
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "7zFile.h"
 #ifndef USE_WINDOWS_FILE
  #include <errno.h>
  #ifndef USE_FOPEN
    #include <stdio.h>
    #include <fcntl.h>
    #ifdef _WIN32
      #include <io.h>
      typedef int ssize_t;
      typedef int off_t;
    #else
      #include <unistd.h>
    #endif
  #endif
 #else
 /*
   ReadFile and WriteFile functions in Windows have BUG:
   If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)
   from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES
   (Insufficient system resources exist to complete the requested service).
   Probably in some version of Windows there are problems with other sizes:
   for 32 MB (maybe also for 16 MB).
   And message can be "Network connection was lost"
 */
 #endif
 #define kChunkSizeMax (1 << 22)
 void File_Construct(CSzFile *p)
 {
  #ifdef USE_WINDOWS_FILE
  p->handle = INVALID_HANDLE_VALUE;
  #elif defined(USE_FOPEN)
  p->file = NULL;
  #else
  p->fd = -1;
  #endif
 }
 #if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
 static WRes File_Open(CSzFile *p, const char *name, int writeMode)
 {
  #ifdef USE_WINDOWS_FILE
  p->handle = CreateFileA(name,
      writeMode ? GENERIC_WRITE : GENERIC_READ,
      FILE_SHARE_READ, NULL,
      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,
      FILE_ATTRIBUTE_NORMAL, NULL);
  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
  #elif defined(USE_FOPEN)
  p->file = fopen(name, writeMode ? "wb+" : "rb");
  return (p->file != 0) ? 0 :
    #ifdef UNDER_CE
    2; /* ENOENT */
    #else
    errno;
    #endif
  #else
  int flags = (writeMode ? (O_CREAT | O_EXCL | O_WRONLY) : O_RDONLY);
  #ifdef O_BINARY
  flags |= O_BINARY;
  #endif
  p->fd = open(name, flags, 0666);
  return (p->fd != -1) ? 0 : errno;
  #endif
 }
 WRes InFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 0); }
 WRes OutFile_Open(CSzFile *p, const char *name)
 {
  #if defined(USE_WINDOWS_FILE) || defined(USE_FOPEN)
  return File_Open(p, name, 1);
  #else
  p->fd = creat(name, 0666);
  return (p->fd != -1) ? 0 : errno;
  #endif
 }
 #endif
 #ifdef USE_WINDOWS_FILE
 static WRes File_OpenW(CSzFile *p, const WCHAR *name, int writeMode)
 {
  p->handle = CreateFileW(name,
      writeMode ? GENERIC_WRITE : GENERIC_READ,
      FILE_SHARE_READ, NULL,
      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,
      FILE_ATTRIBUTE_NORMAL, NULL);
  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
 }
 WRes InFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 0); }
 WRes OutFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 1); }
 #endif
 WRes File_Close(CSzFile *p)
 {
  #ifdef USE_WINDOWS_FILE
  if (p->handle != INVALID_HANDLE_VALUE)
  {
    if (!CloseHandle(p->handle))
      return GetLastError();
    p->handle = INVALID_HANDLE_VALUE;
  }
  #elif defined(USE_FOPEN)
  if (p->file != NULL)
  {
    int res = fclose(p->file);
    if (res != 0)
    {
      if (res == EOF)
        return errno;
      return res;
    }
    p->file = NULL;
  }
  #else
  if (p->fd != -1)
  {
    if (close(p->fd) != 0)
      return errno;
    p->fd = -1;
  }
  #endif
  return 0;
 }
 WRes File_Read(CSzFile *p, void *data, size_t *size)
 {
  size_t originalSize = *size;
  *size = 0;
  if (originalSize == 0)
    return 0;
  #ifdef USE_WINDOWS_FILE
  do
  {
    const DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
    DWORD processed = 0;
    const BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);
    data = (void *)((Byte *)data + processed);
    originalSize -= processed;
    *size += processed;
    if (!res)
      return GetLastError();
    // debug : we can break here for partial reading mode
    if (processed == 0)
      break;
  }
  while (originalSize > 0);
  #elif defined(USE_FOPEN)
  do
  {
    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
    const size_t processed = fread(data, 1, curSize, p->file);
    data = (void *)((Byte *)data + (size_t)processed);
    originalSize -= processed;
    *size += processed;
    if (processed != curSize)
      return ferror(p->file);
    // debug : we can break here for partial reading mode
    if (processed == 0)
      break;
  }
  while (originalSize > 0);
  #else
  do
  {
    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
    const ssize_t processed = read(p->fd, data, curSize);
    if (processed == -1)
      return errno;
    if (processed == 0)
      break;
    data = (void *)((Byte *)data + (size_t)processed);
    originalSize -= (size_t)processed;
    *size += (size_t)processed;
    // debug : we can break here for partial reading mode
    // break;
  }
  while (originalSize > 0);
  #endif
  return 0;
 }
 WRes File_Write(CSzFile *p, const void *data, size_t *size)
 {
  size_t originalSize = *size;
  *size = 0;
  if (originalSize == 0)
    return 0;
  #ifdef USE_WINDOWS_FILE
  do
  {
    const DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
    DWORD processed = 0;
    const BOOL res = WriteFile(p->handle, data, curSize, &processed, NULL);
    data = (const void *)((const Byte *)data + processed);
    originalSize -= processed;
    *size += processed;
    if (!res)
      return GetLastError();
    if (processed == 0)
      break;
  }
  while (originalSize > 0);
  #elif defined(USE_FOPEN)
  do
  {
    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
    const size_t processed = fwrite(data, 1, curSize, p->file);
    data = (void *)((Byte *)data + (size_t)processed);
    originalSize -= processed;
    *size += processed;
    if (processed != curSize)
      return ferror(p->file);
    if (processed == 0)
      break;
  }
  while (originalSize > 0);
  #else
  do
  {
    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
    const ssize_t processed = write(p->fd, data, curSize);
    if (processed == -1)
      return errno;
    if (processed == 0)
      break;
    data = (const void *)((const Byte *)data + (size_t)processed);
    originalSize -= (size_t)processed;
    *size += (size_t)processed;
  }
  while (originalSize > 0);
  #endif
  return 0;
 }
 WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
 {
  #ifdef USE_WINDOWS_FILE
  DWORD moveMethod;
  UInt32 low = (UInt32)*pos;
  LONG high = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */
  // (int) to eliminate clang warning
  switch ((int)origin)
  {
    case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;
    case SZ_SEEK_CUR: moveMethod = FILE_CURRENT; break;
    case SZ_SEEK_END: moveMethod = FILE_END; break;
    default: return ERROR_INVALID_PARAMETER;
  }
  low = SetFilePointer(p->handle, (LONG)low, &high, moveMethod);
  if (low == (UInt32)0xFFFFFFFF)
  {
    WRes res = GetLastError();
    if (res != NO_ERROR)
      return res;
  }
  *pos = ((Int64)high << 32) | low;
  return 0;
  #else
  int moveMethod; // = origin;
  switch ((int)origin)
  {
    case SZ_SEEK_SET: moveMethod = SEEK_SET; break;
    case SZ_SEEK_CUR: moveMethod = SEEK_CUR; break;
    case SZ_SEEK_END: moveMethod = SEEK_END; break;
    default: return EINVAL;
  }
  #if defined(USE_FOPEN)
  {
    int res = fseek(p->file, (long)*pos, moveMethod);
    if (res == -1)
      return errno;
    *pos = ftell(p->file);
    if (*pos == -1)
      return errno;
    return 0;
  }
  #else
  {
    off_t res = lseek(p->fd, (off_t)*pos, moveMethod);
    if (res == -1)
      return errno;
    *pos = res;
    return 0;
  }
  #endif // USE_FOPEN
  #endif // USE_WINDOWS_FILE
 }
 WRes File_GetLength(CSzFile *p, UInt64 *length)
 {
  #ifdef USE_WINDOWS_FILE
  DWORD sizeHigh;
  DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);
  if (sizeLow == 0xFFFFFFFF)
  {
    DWORD res = GetLastError();
    if (res != NO_ERROR)
      return res;
  }
  *length = (((UInt64)sizeHigh) << 32) + sizeLow;
  return 0;
  #elif defined(USE_FOPEN)
  long pos = ftell(p->file);
  int res = fseek(p->file, 0, SEEK_END);
  *length = ftell(p->file);
  fseek(p->file, pos, SEEK_SET);
  return res;
  #else
  off_t pos;
  *length = 0;
  pos = lseek(p->fd, 0, SEEK_CUR);
  if (pos != -1)
  {
    const off_t len2 = lseek(p->fd, 0, SEEK_END);
    const off_t res2 = lseek(p->fd, pos, SEEK_SET);
    if (len2 != -1)
    {
      *length = (UInt64)len2;
      if (res2 != -1)
        return 0;
    }
  }
  return errno;
  #endif
 }
 /* ---------- FileSeqInStream ---------- */
 static SRes FileSeqInStream_Read(ISeqInStreamPtr pp, void *buf, size_t *size)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileSeqInStream)
  const WRes wres = File_Read(&p->file, buf, size);
  p->wres = wres;
  return (wres == 0) ? SZ_OK : SZ_ERROR_READ;
 }
 void FileSeqInStream_CreateVTable(CFileSeqInStream *p)
 {
  p->vt.Read = FileSeqInStream_Read;
 }
 /* ---------- FileInStream ---------- */
 static SRes FileInStream_Read(ISeekInStreamPtr pp, void *buf, size_t *size)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileInStream)
  const WRes wres = File_Read(&p->file, buf, size);
  p->wres = wres;
  return (wres == 0) ? SZ_OK : SZ_ERROR_READ;
 }
 static SRes FileInStream_Seek(ISeekInStreamPtr pp, Int64 *pos, ESzSeek origin)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileInStream)
  const WRes wres = File_Seek(&p->file, pos, origin);
  p->wres = wres;
  return (wres == 0) ? SZ_OK : SZ_ERROR_READ;
 }
 void FileInStream_CreateVTable(CFileInStream *p)
 {
  p->vt.Read = FileInStream_Read;
  p->vt.Seek = FileInStream_Seek;
 }
 /* ---------- FileOutStream ---------- */
 static size_t FileOutStream_Write(ISeqOutStreamPtr pp, const void *data, size_t size)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CFileOutStream)
  const WRes wres = File_Write(&p->file, data, &size);
  p->wres = wres;
  return size;
 }
 void FileOutStream_CreateVTable(CFileOutStream *p)
 {
  p->vt.Write = FileOutStream_Write;
 }
--- a/3rdparty/7z/src/7zFile.h
+++ b/3rdparty/7z/src/7zFile.h
@ -0,0 +1,92 @@
 /* 7zFile.h -- File IO
 2023-03-05 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_FILE_H
 #define ZIP7_INC_FILE_H
 #ifdef _WIN32
 #define USE_WINDOWS_FILE
 // #include <windows.h>
 #endif
 #ifdef USE_WINDOWS_FILE
 #include "7zWindows.h"
 #else
 // note: USE_FOPEN mode is limited to 32-bit file size
 // #define USE_FOPEN
 // #include <stdio.h>
 #endif
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 /* ---------- File ---------- */
 typedef struct
 {
  #ifdef USE_WINDOWS_FILE
  HANDLE handle;
  #elif defined(USE_FOPEN)
  FILE *file;
  #else
  int fd;
  #endif
 } CSzFile;
 void File_Construct(CSzFile *p);
 #if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
 WRes InFile_Open(CSzFile *p, const char *name);
 WRes OutFile_Open(CSzFile *p, const char *name);
 #endif
 #ifdef USE_WINDOWS_FILE
 WRes InFile_OpenW(CSzFile *p, const WCHAR *name);
 WRes OutFile_OpenW(CSzFile *p, const WCHAR *name);
 #endif
 WRes File_Close(CSzFile *p);
 /* reads max(*size, remain file's size) bytes */
 WRes File_Read(CSzFile *p, void *data, size_t *size);
 /* writes *size bytes */
 WRes File_Write(CSzFile *p, const void *data, size_t *size);
 WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin);
 WRes File_GetLength(CSzFile *p, UInt64 *length);
 /* ---------- FileInStream ---------- */
 typedef struct
 {
  ISeqInStream vt;
  CSzFile file;
  WRes wres;
 } CFileSeqInStream;
 void FileSeqInStream_CreateVTable(CFileSeqInStream *p);
 typedef struct
 {
  ISeekInStream vt;
  CSzFile file;
  WRes wres;
 } CFileInStream;
 void FileInStream_CreateVTable(CFileInStream *p);
 typedef struct
 {
  ISeqOutStream vt;
  CSzFile file;
  WRes wres;
 } CFileOutStream;
 void FileOutStream_CreateVTable(CFileOutStream *p);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/7zStream.c
+++ b/3rdparty/7z/src/7zStream.c
@ -0,0 +1,199 @@
 /* 7zStream.c -- 7z Stream functions
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include <string.h>
 #include "7zTypes.h"
 SRes SeqInStream_ReadMax(ISeqInStreamPtr stream, void *buf, size_t *processedSize)
 {
  size_t size = *processedSize;
  *processedSize = 0;
  while (size != 0)
  {
    size_t cur = size;
    const SRes res = ISeqInStream_Read(stream, buf, &cur);
    *processedSize += cur;
    buf = (void *)((Byte *)buf + cur);
    size -= cur;
    if (res != SZ_OK)
      return res;
    if (cur == 0)
      return SZ_OK;
  }
  return SZ_OK;
 }
 /*
 SRes SeqInStream_Read2(ISeqInStreamPtr stream, void *buf, size_t size, SRes errorType)
 {
  while (size != 0)
  {
    size_t processed = size;
    RINOK(ISeqInStream_Read(stream, buf, &processed))
    if (processed == 0)
      return errorType;
    buf = (void *)((Byte *)buf + processed);
    size -= processed;
  }
  return SZ_OK;
 }
 SRes SeqInStream_Read(ISeqInStreamPtr stream, void *buf, size_t size)
 {
  return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
 }
 */
 SRes SeqInStream_ReadByte(ISeqInStreamPtr stream, Byte *buf)
 {
  size_t processed = 1;
  RINOK(ISeqInStream_Read(stream, buf, &processed))
  return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;
 }
 SRes LookInStream_SeekTo(ILookInStreamPtr stream, UInt64 offset)
 {
  Int64 t = (Int64)offset;
  return ILookInStream_Seek(stream, &t, SZ_SEEK_SET);
 }
 SRes LookInStream_LookRead(ILookInStreamPtr stream, void *buf, size_t *size)
 {
  const void *lookBuf;
  if (*size == 0)
    return SZ_OK;
  RINOK(ILookInStream_Look(stream, &lookBuf, size))
  memcpy(buf, lookBuf, *size);
  return ILookInStream_Skip(stream, *size);
 }
 SRes LookInStream_Read2(ILookInStreamPtr stream, void *buf, size_t size, SRes errorType)
 {
  while (size != 0)
  {
    size_t processed = size;
    RINOK(ILookInStream_Read(stream, buf, &processed))
    if (processed == 0)
      return errorType;
    buf = (void *)((Byte *)buf + processed);
    size -= processed;
  }
  return SZ_OK;
 }
 SRes LookInStream_Read(ILookInStreamPtr stream, void *buf, size_t size)
 {
  return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
 }
 #define GET_LookToRead2  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLookToRead2)
 static SRes LookToRead2_Look_Lookahead(ILookInStreamPtr pp, const void **buf, size_t *size)
 {
  SRes res = SZ_OK;
  GET_LookToRead2
  size_t size2 = p->size - p->pos;
  if (size2 == 0 && *size != 0)
  {
    p->pos = 0;
    p->size = 0;
    size2 = p->bufSize;
    res = ISeekInStream_Read(p->realStream, p->buf, &size2);
    p->size = size2;
  }
  if (*size > size2)
    *size = size2;
  *buf = p->buf + p->pos;
  return res;
 }
 static SRes LookToRead2_Look_Exact(ILookInStreamPtr pp, const void **buf, size_t *size)
 {
  SRes res = SZ_OK;
  GET_LookToRead2
  size_t size2 = p->size - p->pos;
  if (size2 == 0 && *size != 0)
  {
    p->pos = 0;
    p->size = 0;
    if (*size > p->bufSize)
      *size = p->bufSize;
    res = ISeekInStream_Read(p->realStream, p->buf, size);
    size2 = p->size = *size;
  }
  if (*size > size2)
    *size = size2;
  *buf = p->buf + p->pos;
  return res;
 }
 static SRes LookToRead2_Skip(ILookInStreamPtr pp, size_t offset)
 {
  GET_LookToRead2
  p->pos += offset;
  return SZ_OK;
 }
 static SRes LookToRead2_Read(ILookInStreamPtr pp, void *buf, size_t *size)
 {
  GET_LookToRead2
  size_t rem = p->size - p->pos;
  if (rem == 0)
    return ISeekInStream_Read(p->realStream, buf, size);
  if (rem > *size)
    rem = *size;
  memcpy(buf, p->buf + p->pos, rem);
  p->pos += rem;
  *size = rem;
  return SZ_OK;
 }
 static SRes LookToRead2_Seek(ILookInStreamPtr pp, Int64 *pos, ESzSeek origin)
 {
  GET_LookToRead2
  p->pos = p->size = 0;
  return ISeekInStream_Seek(p->realStream, pos, origin);
 }
 void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead)
 {
  p->vt.Look = lookahead ?
      LookToRead2_Look_Lookahead :
      LookToRead2_Look_Exact;
  p->vt.Skip = LookToRead2_Skip;
  p->vt.Read = LookToRead2_Read;
  p->vt.Seek = LookToRead2_Seek;
 }
 static SRes SecToLook_Read(ISeqInStreamPtr pp, void *buf, size_t *size)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSecToLook)
  return LookInStream_LookRead(p->realStream, buf, size);
 }
 void SecToLook_CreateVTable(CSecToLook *p)
 {
  p->vt.Read = SecToLook_Read;
 }
 static SRes SecToRead_Read(ISeqInStreamPtr pp, void *buf, size_t *size)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSecToRead)
  return ILookInStream_Read(p->realStream, buf, size);
 }
 void SecToRead_CreateVTable(CSecToRead *p)
 {
  p->vt.Read = SecToRead_Read;
 }
--- a/3rdparty/7z/src/7zTypes.h
+++ b/3rdparty/7z/src/7zTypes.h
@ -0,0 +1,597 @@
 /* 7zTypes.h -- Basic types
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_7Z_TYPES_H
 #define ZIP7_7Z_TYPES_H
 #ifdef _WIN32
 /* #include <windows.h> */
 #else
 #include <errno.h>
 #endif
 #include <stddef.h>
 #ifndef EXTERN_C_BEGIN
 #ifdef __cplusplus
 #define EXTERN_C_BEGIN extern "C" {
 #define EXTERN_C_END }
 #else
 #define EXTERN_C_BEGIN
 #define EXTERN_C_END
 #endif
 #endif
 EXTERN_C_BEGIN
 #define SZ_OK 0
 #define SZ_ERROR_DATA 1
 #define SZ_ERROR_MEM 2
 #define SZ_ERROR_CRC 3
 #define SZ_ERROR_UNSUPPORTED 4
 #define SZ_ERROR_PARAM 5
 #define SZ_ERROR_INPUT_EOF 6
 #define SZ_ERROR_OUTPUT_EOF 7
 #define SZ_ERROR_READ 8
 #define SZ_ERROR_WRITE 9
 #define SZ_ERROR_PROGRESS 10
 #define SZ_ERROR_FAIL 11
 #define SZ_ERROR_THREAD 12
 #define SZ_ERROR_ARCHIVE 16
 #define SZ_ERROR_NO_ARCHIVE 17
 typedef int SRes;
 #ifdef _MSC_VER
  #if _MSC_VER > 1200
    #define MY_ALIGN(n) __declspec(align(n))
  #else
    #define MY_ALIGN(n)
  #endif
 #else
  /*
  // C11/C++11:
  #include <stdalign.h>
  #define MY_ALIGN(n) alignas(n)
  */
  #define MY_ALIGN(n) __attribute__ ((aligned(n)))
 #endif
 #ifdef _WIN32
 /* typedef DWORD WRes; */
 typedef unsigned WRes;
 #define MY_SRes_HRESULT_FROM_WRes(x) HRESULT_FROM_WIN32(x)
 // #define MY_HRES_ERROR_INTERNAL_ERROR  MY_SRes_HRESULT_FROM_WRes(ERROR_INTERNAL_ERROR)
 #else // _WIN32
 // #define ENV_HAVE_LSTAT
 typedef int WRes;
 // (FACILITY_ERRNO = 0x800) is 7zip's FACILITY constant to represent (errno) errors in HRESULT
 #define MY_FACILITY_ERRNO  0x800
 #define MY_FACILITY_WIN32  7
 #define MY_FACILITY_WRes  MY_FACILITY_ERRNO
 #define MY_HRESULT_FROM_errno_CONST_ERROR(x) ((HRESULT)( \
          ( (HRESULT)(x) & 0x0000FFFF) \
          | (MY_FACILITY_WRes << 16)  \
          | (HRESULT)0x80000000 ))
 #define MY_SRes_HRESULT_FROM_WRes(x) \
  ((HRESULT)(x) <= 0 ? ((HRESULT)(x)) : MY_HRESULT_FROM_errno_CONST_ERROR(x))
 // we call macro HRESULT_FROM_WIN32 for system errors (WRes) that are (errno)
 #define HRESULT_FROM_WIN32(x) MY_SRes_HRESULT_FROM_WRes(x)
 /*
 #define ERROR_FILE_NOT_FOUND             2L
 #define ERROR_ACCESS_DENIED              5L
 #define ERROR_NO_MORE_FILES              18L
 #define ERROR_LOCK_VIOLATION             33L
 #define ERROR_FILE_EXISTS                80L
 #define ERROR_DISK_FULL                  112L
 #define ERROR_NEGATIVE_SEEK              131L
 #define ERROR_ALREADY_EXISTS             183L
 #define ERROR_DIRECTORY                  267L
 #define ERROR_TOO_MANY_POSTS             298L
 #define ERROR_INTERNAL_ERROR             1359L
 #define ERROR_INVALID_REPARSE_DATA       4392L
 #define ERROR_REPARSE_TAG_INVALID        4393L
 #define ERROR_REPARSE_TAG_MISMATCH       4394L
 */
 // we use errno equivalents for some WIN32 errors:
 #define ERROR_INVALID_PARAMETER     EINVAL
 #define ERROR_INVALID_FUNCTION      EINVAL
 #define ERROR_ALREADY_EXISTS        EEXIST
 #define ERROR_FILE_EXISTS           EEXIST
 #define ERROR_PATH_NOT_FOUND        ENOENT
 #define ERROR_FILE_NOT_FOUND        ENOENT
 #define ERROR_DISK_FULL             ENOSPC
 // #define ERROR_INVALID_HANDLE        EBADF
 // we use FACILITY_WIN32 for errors that has no errno equivalent
 // Too many posts were made to a semaphore.
 #define ERROR_TOO_MANY_POSTS        ((HRESULT)0x8007012AL)
 #define ERROR_INVALID_REPARSE_DATA  ((HRESULT)0x80071128L)
 #define ERROR_REPARSE_TAG_INVALID   ((HRESULT)0x80071129L)
 // if (MY_FACILITY_WRes != FACILITY_WIN32),
 // we use FACILITY_WIN32 for COM errors:
 #define E_OUTOFMEMORY               ((HRESULT)0x8007000EL)
 #define E_INVALIDARG                ((HRESULT)0x80070057L)
 #define MY_E_ERROR_NEGATIVE_SEEK    ((HRESULT)0x80070083L)
 /*
 // we can use FACILITY_ERRNO for some COM errors, that have errno equivalents:
 #define E_OUTOFMEMORY             MY_HRESULT_FROM_errno_CONST_ERROR(ENOMEM)
 #define E_INVALIDARG              MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL)
 #define MY_E_ERROR_NEGATIVE_SEEK  MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL)
 */
 #define TEXT(quote) quote
 #define FILE_ATTRIBUTE_READONLY       0x0001
 #define FILE_ATTRIBUTE_HIDDEN         0x0002
 #define FILE_ATTRIBUTE_SYSTEM         0x0004
 #define FILE_ATTRIBUTE_DIRECTORY      0x0010
 #define FILE_ATTRIBUTE_ARCHIVE        0x0020
 #define FILE_ATTRIBUTE_DEVICE         0x0040
 #define FILE_ATTRIBUTE_NORMAL         0x0080
 #define FILE_ATTRIBUTE_TEMPORARY      0x0100
 #define FILE_ATTRIBUTE_SPARSE_FILE    0x0200
 #define FILE_ATTRIBUTE_REPARSE_POINT  0x0400
 #define FILE_ATTRIBUTE_COMPRESSED     0x0800
 #define FILE_ATTRIBUTE_OFFLINE        0x1000
 #define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x2000
 #define FILE_ATTRIBUTE_ENCRYPTED      0x4000
 #define FILE_ATTRIBUTE_UNIX_EXTENSION 0x8000   /* trick for Unix */
 #endif
 #ifndef RINOK
 #define RINOK(x) { const int _result_ = (x); if (_result_ != 0) return _result_; }
 #endif
 #ifndef RINOK_WRes
 #define RINOK_WRes(x) { const WRes _result_ = (x); if (_result_ != 0) return _result_; }
 #endif
 typedef unsigned char Byte;
 typedef short Int16;
 typedef unsigned short UInt16;
 #ifdef Z7_DECL_Int32_AS_long
 typedef long Int32;
 typedef unsigned long UInt32;
 #else
 typedef int Int32;
 typedef unsigned int UInt32;
 #endif
 #ifndef _WIN32
 typedef int INT;
 typedef Int32 INT32;
 typedef unsigned int UINT;
 typedef UInt32 UINT32;
 typedef INT32 LONG;   // LONG, ULONG and DWORD must be 32-bit for _WIN32 compatibility
 typedef UINT32 ULONG;
 #undef DWORD
 typedef UINT32 DWORD;
 #define VOID void
 #define HRESULT LONG
 typedef void *LPVOID;
 // typedef void VOID;
 // typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;
 // gcc / clang on Unix  : sizeof(long==sizeof(void*) in 32 or 64 bits)
 typedef          long  INT_PTR;
 typedef unsigned long  UINT_PTR;
 typedef          long  LONG_PTR;
 typedef unsigned long  DWORD_PTR;
 typedef size_t SIZE_T;
 #endif //  _WIN32
 #define MY_HRES_ERROR_INTERNAL_ERROR  ((HRESULT)0x8007054FL)
 #ifdef Z7_DECL_Int64_AS_long
 typedef long Int64;
 typedef unsigned long UInt64;
 #else
 #if (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(__clang__)
 typedef __int64 Int64;
 typedef unsigned __int64 UInt64;
 #else
 #if defined(__clang__) || defined(__GNUC__)
 #include <stdint.h>
 typedef int64_t Int64;
 typedef uint64_t UInt64;
 #else
 typedef long long int Int64;
 typedef unsigned long long int UInt64;
 // #define UINT64_CONST(n) n ## ULL
 #endif
 #endif
 #endif
 #define UINT64_CONST(n) n
 #ifdef Z7_DECL_SizeT_AS_unsigned_int
 typedef unsigned int SizeT;
 #else
 typedef size_t SizeT;
 #endif
 /*
 #if (defined(_MSC_VER) && _MSC_VER <= 1200)
 typedef size_t MY_uintptr_t;
 #else
 #include <stdint.h>
 typedef uintptr_t MY_uintptr_t;
 #endif
 */
 typedef int BoolInt;
 /* typedef BoolInt Bool; */
 #define True 1
 #define False 0
 #ifdef _WIN32
 #define Z7_STDCALL __stdcall
 #else
 #define Z7_STDCALL
 #endif
 #ifdef _MSC_VER
 #if _MSC_VER >= 1300
 #define Z7_NO_INLINE __declspec(noinline)
 #else
 #define Z7_NO_INLINE
 #endif
 #define Z7_FORCE_INLINE __forceinline
 #define Z7_CDECL      __cdecl
 #define Z7_FASTCALL  __fastcall
 #else //  _MSC_VER
 #if (defined(__GNUC__) && (__GNUC__ >= 4)) \
    || (defined(__clang__) && (__clang_major__ >= 4)) \
    || defined(__INTEL_COMPILER) \
    || defined(__xlC__)
 #define Z7_NO_INLINE      __attribute__((noinline))
 #define Z7_FORCE_INLINE   __attribute__((always_inline)) inline
 #else
 #define Z7_NO_INLINE
 #define Z7_FORCE_INLINE
 #endif
 #define Z7_CDECL
 #if  defined(_M_IX86) \
  || defined(__i386__)
 // #define Z7_FASTCALL __attribute__((fastcall))
 // #define Z7_FASTCALL __attribute__((cdecl))
 #define Z7_FASTCALL
 #elif defined(MY_CPU_AMD64)
 // #define Z7_FASTCALL __attribute__((ms_abi))
 #define Z7_FASTCALL
 #else
 #define Z7_FASTCALL
 #endif
 #endif //  _MSC_VER
 /* The following interfaces use first parameter as pointer to structure */
 // #define Z7_C_IFACE_CONST_QUAL
 #define Z7_C_IFACE_CONST_QUAL const
 #define Z7_C_IFACE_DECL(a) \
  struct a ## _; \
  typedef Z7_C_IFACE_CONST_QUAL struct a ## _ * a ## Ptr; \
  typedef struct a ## _ a; \
  struct a ## _
 Z7_C_IFACE_DECL (IByteIn)
 {
  Byte (*Read)(IByteInPtr p); /* reads one byte, returns 0 in case of EOF or error */
 };
 #define IByteIn_Read(p) (p)->Read(p)
 Z7_C_IFACE_DECL (IByteOut)
 {
  void (*Write)(IByteOutPtr p, Byte b);
 };
 #define IByteOut_Write(p, b) (p)->Write(p, b)
 Z7_C_IFACE_DECL (ISeqInStream)
 {
  SRes (*Read)(ISeqInStreamPtr p, void *buf, size_t *size);
    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
       (output(*size) < input(*size)) is allowed */
 };
 #define ISeqInStream_Read(p, buf, size) (p)->Read(p, buf, size)
 /* try to read as much as avail in stream and limited by (*processedSize) */
 SRes SeqInStream_ReadMax(ISeqInStreamPtr stream, void *buf, size_t *processedSize);
 /* it can return SZ_ERROR_INPUT_EOF */
 // SRes SeqInStream_Read(ISeqInStreamPtr stream, void *buf, size_t size);
 // SRes SeqInStream_Read2(ISeqInStreamPtr stream, void *buf, size_t size, SRes errorType);
 SRes SeqInStream_ReadByte(ISeqInStreamPtr stream, Byte *buf);
 Z7_C_IFACE_DECL (ISeqOutStream)
 {
  size_t (*Write)(ISeqOutStreamPtr p, const void *buf, size_t size);
    /* Returns: result - the number of actually written bytes.
       (result < size) means error */
 };
 #define ISeqOutStream_Write(p, buf, size) (p)->Write(p, buf, size)
 typedef enum
 {
  SZ_SEEK_SET = 0,
  SZ_SEEK_CUR = 1,
  SZ_SEEK_END = 2
 } ESzSeek;
 Z7_C_IFACE_DECL (ISeekInStream)
 {
  SRes (*Read)(ISeekInStreamPtr p, void *buf, size_t *size);  /* same as ISeqInStream::Read */
  SRes (*Seek)(ISeekInStreamPtr p, Int64 *pos, ESzSeek origin);
 };
 #define ISeekInStream_Read(p, buf, size)   (p)->Read(p, buf, size)
 #define ISeekInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)
 Z7_C_IFACE_DECL (ILookInStream)
 {
  SRes (*Look)(ILookInStreamPtr p, const void **buf, size_t *size);
    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
       (output(*size) > input(*size)) is not allowed
       (output(*size) < input(*size)) is allowed */
  SRes (*Skip)(ILookInStreamPtr p, size_t offset);
    /* offset must be <= output(*size) of Look */
  SRes (*Read)(ILookInStreamPtr p, void *buf, size_t *size);
    /* reads directly (without buffer). It's same as ISeqInStream::Read */
  SRes (*Seek)(ILookInStreamPtr p, Int64 *pos, ESzSeek origin);
 };
 #define ILookInStream_Look(p, buf, size)   (p)->Look(p, buf, size)
 #define ILookInStream_Skip(p, offset)      (p)->Skip(p, offset)
 #define ILookInStream_Read(p, buf, size)   (p)->Read(p, buf, size)
 #define ILookInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)
 SRes LookInStream_LookRead(ILookInStreamPtr stream, void *buf, size_t *size);
 SRes LookInStream_SeekTo(ILookInStreamPtr stream, UInt64 offset);
 /* reads via ILookInStream::Read */
 SRes LookInStream_Read2(ILookInStreamPtr stream, void *buf, size_t size, SRes errorType);
 SRes LookInStream_Read(ILookInStreamPtr stream, void *buf, size_t size);
 typedef struct
 {
  ILookInStream vt;
  ISeekInStreamPtr realStream;
  size_t pos;
  size_t size; /* it's data size */
  /* the following variables must be set outside */
  Byte *buf;
  size_t bufSize;
 } CLookToRead2;
 void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead);
 #define LookToRead2_INIT(p) { (p)->pos = (p)->size = 0; }
 typedef struct
 {
  ISeqInStream vt;
  ILookInStreamPtr realStream;
 } CSecToLook;
 void SecToLook_CreateVTable(CSecToLook *p);
 typedef struct
 {
  ISeqInStream vt;
  ILookInStreamPtr realStream;
 } CSecToRead;
 void SecToRead_CreateVTable(CSecToRead *p);
 Z7_C_IFACE_DECL (ICompressProgress)
 {
  SRes (*Progress)(ICompressProgressPtr p, UInt64 inSize, UInt64 outSize);
    /* Returns: result. (result != SZ_OK) means break.
       Value (UInt64)(Int64)-1 for size means unknown value. */
 };
 #define ICompressProgress_Progress(p, inSize, outSize) (p)->Progress(p, inSize, outSize)
 typedef struct ISzAlloc ISzAlloc;
 typedef const ISzAlloc * ISzAllocPtr;
 struct ISzAlloc
 {
  void *(*Alloc)(ISzAllocPtr p, size_t size);
  void (*Free)(ISzAllocPtr p, void *address); /* address can be 0 */
 };
 #define ISzAlloc_Alloc(p, size) (p)->Alloc(p, size)
 #define ISzAlloc_Free(p, a) (p)->Free(p, a)
 /* deprecated */
 #define IAlloc_Alloc(p, size) ISzAlloc_Alloc(p, size)
 #define IAlloc_Free(p, a) ISzAlloc_Free(p, a)
 #ifndef MY_offsetof
  #ifdef offsetof
    #define MY_offsetof(type, m) offsetof(type, m)
    /*
    #define MY_offsetof(type, m) FIELD_OFFSET(type, m)
    */
  #else
    #define MY_offsetof(type, m) ((size_t)&(((type *)0)->m))
  #endif
 #endif
 #ifndef Z7_container_of
 /*
 #define Z7_container_of(ptr, type, m) container_of(ptr, type, m)
 #define Z7_container_of(ptr, type, m) CONTAINING_RECORD(ptr, type, m)
 #define Z7_container_of(ptr, type, m) ((type *)((char *)(ptr) - offsetof(type, m)))
 #define Z7_container_of(ptr, type, m) (&((type *)0)->m == (ptr), ((type *)(((char *)(ptr)) - MY_offsetof(type, m))))
 */
 /*
  GCC shows warning: "perhaps the 'offsetof' macro was used incorrectly"
    GCC 3.4.4 : classes with constructor
    GCC 4.8.1 : classes with non-public variable members"
 */
 #define Z7_container_of(ptr, type, m) \
  ((type *)(void *)((char *)(void *) \
  (1 ? (ptr) : &((type *)NULL)->m) - MY_offsetof(type, m)))
 #define Z7_container_of_CONST(ptr, type, m) \
  ((const type *)(const void *)((const char *)(const void *) \
  (1 ? (ptr) : &((type *)NULL)->m) - MY_offsetof(type, m)))
 /*
 #define Z7_container_of_NON_CONST_FROM_CONST(ptr, type, m) \
  ((type *)(void *)(const void *)((const char *)(const void *) \
  (1 ? (ptr) : &((type *)NULL)->m) - MY_offsetof(type, m)))
 */
 #endif
 #define Z7_CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ((type *)(void *)(ptr))
 // #define Z7_CONTAINER_FROM_VTBL(ptr, type, m) Z7_CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)
 #define Z7_CONTAINER_FROM_VTBL(ptr, type, m) Z7_container_of(ptr, type, m)
 // #define Z7_CONTAINER_FROM_VTBL(ptr, type, m) Z7_container_of_NON_CONST_FROM_CONST(ptr, type, m)
 #define Z7_CONTAINER_FROM_VTBL_CONST(ptr, type, m) Z7_container_of_CONST(ptr, type, m)
 #define Z7_CONTAINER_FROM_VTBL_CLS(ptr, type, m) Z7_CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)
 /*
 #define Z7_CONTAINER_FROM_VTBL_CLS(ptr, type, m) Z7_CONTAINER_FROM_VTBL(ptr, type, m)
 */
 #if defined (__clang__) || defined(__GNUC__)
 #define Z7_DIAGNOSCTIC_IGNORE_BEGIN_CAST_QUAL \
  _Pragma("GCC diagnostic push") \
  _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
 #define Z7_DIAGNOSCTIC_IGNORE_END_CAST_QUAL \
  _Pragma("GCC diagnostic pop")
 #else
 #define Z7_DIAGNOSCTIC_IGNORE_BEGIN_CAST_QUAL
 #define Z7_DIAGNOSCTIC_IGNORE_END_CAST_QUAL
 #endif
 #define Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR(ptr, type, m, p) \
  Z7_DIAGNOSCTIC_IGNORE_BEGIN_CAST_QUAL \
  type *p = Z7_CONTAINER_FROM_VTBL(ptr, type, m); \
  Z7_DIAGNOSCTIC_IGNORE_END_CAST_QUAL
 #define Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(type) \
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR(pp, type, vt, p)
 // #define ZIP7_DECLARE_HANDLE(name)  typedef void *name;
 #define Z7_DECLARE_HANDLE(name)  struct name##_dummy{int unused;}; typedef struct name##_dummy *name;
 #define Z7_memset_0_ARRAY(a)  memset((a), 0, sizeof(a))
 #ifndef Z7_ARRAY_SIZE
 #define Z7_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 #endif
 #ifdef _WIN32
 #define CHAR_PATH_SEPARATOR '\\'
 #define WCHAR_PATH_SEPARATOR L'\\'
 #define STRING_PATH_SEPARATOR "\\"
 #define WSTRING_PATH_SEPARATOR L"\\"
 #else
 #define CHAR_PATH_SEPARATOR '/'
 #define WCHAR_PATH_SEPARATOR L'/'
 #define STRING_PATH_SEPARATOR "/"
 #define WSTRING_PATH_SEPARATOR L"/"
 #endif
 #define k_PropVar_TimePrec_0        0
 #define k_PropVar_TimePrec_Unix     1
 #define k_PropVar_TimePrec_DOS      2
 #define k_PropVar_TimePrec_HighPrec 3
 #define k_PropVar_TimePrec_Base     16
 #define k_PropVar_TimePrec_100ns (k_PropVar_TimePrec_Base + 7)
 #define k_PropVar_TimePrec_1ns   (k_PropVar_TimePrec_Base + 9)
 EXTERN_C_END
 #endif
 /*
 #ifndef Z7_ST
 #ifdef _7ZIP_ST
 #define Z7_ST
 #endif
 #endif
 */
--- a/3rdparty/7z/src/7zVersion.h
+++ b/3rdparty/7z/src/7zVersion.h
@ -0,0 +1,27 @@
 #define MY_VER_MAJOR 23
 #define MY_VER_MINOR 01
 #define MY_VER_BUILD 0
 #define MY_VERSION_NUMBERS "23.01"
 #define MY_VERSION MY_VERSION_NUMBERS
 #ifdef MY_CPU_NAME
  #define MY_VERSION_CPU MY_VERSION " (" MY_CPU_NAME ")"
 #else
  #define MY_VERSION_CPU MY_VERSION
 #endif
 #define MY_DATE "2023-06-20"
 #undef MY_COPYRIGHT
 #undef MY_VERSION_COPYRIGHT_DATE
 #define MY_AUTHOR_NAME "Igor Pavlov"
 #define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
 #define MY_COPYRIGHT_CR "Copyright (c) 1999-2023 Igor Pavlov"
 #ifdef USE_COPYRIGHT_CR
  #define MY_COPYRIGHT MY_COPYRIGHT_CR
 #else
  #define MY_COPYRIGHT MY_COPYRIGHT_PD
 #endif
 #define MY_COPYRIGHT_DATE MY_COPYRIGHT " : " MY_DATE
 #define MY_VERSION_COPYRIGHT_DATE MY_VERSION_CPU " : " MY_COPYRIGHT " : " MY_DATE
--- a/3rdparty/7z/src/7zVersion.rc
+++ b/3rdparty/7z/src/7zVersion.rc
@ -0,0 +1,55 @@
 #define MY_VS_FFI_FILEFLAGSMASK  0x0000003FL
 #define MY_VOS_NT_WINDOWS32  0x00040004L
 #define MY_VOS_CE_WINDOWS32  0x00050004L
 #define MY_VFT_APP  0x00000001L
 #define MY_VFT_DLL  0x00000002L
 // #include <WinVer.h>
 #ifndef MY_VERSION
 #include "7zVersion.h"
 #endif
 #define MY_VER MY_VER_MAJOR,MY_VER_MINOR,MY_VER_BUILD,0
 #ifdef DEBUG
 #define DBG_FL VS_FF_DEBUG
 #else
 #define DBG_FL 0
 #endif
 #define MY_VERSION_INFO(fileType, descr, intName, origName)  \
 LANGUAGE 9, 1 \
 1 VERSIONINFO \
  FILEVERSION MY_VER \
  PRODUCTVERSION MY_VER \
  FILEFLAGSMASK MY_VS_FFI_FILEFLAGSMASK \
  FILEFLAGS DBG_FL \
  FILEOS MY_VOS_NT_WINDOWS32 \
  FILETYPE fileType \
  FILESUBTYPE 0x0L \
 BEGIN \
    BLOCK "StringFileInfo" \
    BEGIN  \
        BLOCK "040904b0" \
        BEGIN \
            VALUE "CompanyName", "Igor Pavlov" \
            VALUE "FileDescription", descr \
            VALUE "FileVersion", MY_VERSION  \
            VALUE "InternalName", intName \
            VALUE "LegalCopyright", MY_COPYRIGHT \
            VALUE "OriginalFilename", origName \
            VALUE "ProductName", "7-Zip" \
            VALUE "ProductVersion", MY_VERSION \
        END \
    END \
    BLOCK "VarFileInfo" \
    BEGIN \
        VALUE "Translation", 0x409, 1200 \
    END \
 END
 #define MY_VERSION_INFO_APP(descr, intName) MY_VERSION_INFO(MY_VFT_APP, descr, intName, intName ".exe")
 #define MY_VERSION_INFO_DLL(descr, intName) MY_VERSION_INFO(MY_VFT_DLL, descr, intName, intName ".dll")
--- a/3rdparty/7z/src/7zWindows.h
+++ b/3rdparty/7z/src/7zWindows.h
@ -0,0 +1,101 @@
 /* 7zWindows.h -- StdAfx
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_7Z_WINDOWS_H
 #define ZIP7_INC_7Z_WINDOWS_H
 #ifdef _WIN32
 #if defined(__clang__)
 # pragma clang diagnostic push
 #endif
 #if defined(_MSC_VER)
 #pragma warning(push)
 #pragma warning(disable : 4668) // '_WIN32_WINNT' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
 #if _MSC_VER == 1900
 // for old kit10 versions
 // #pragma warning(disable : 4255) // winuser.h(13979): warning C4255: 'GetThreadDpiAwarenessContext':
 #endif
 // win10 Windows Kit:
 #endif // _MSC_VER
 #if defined(_MSC_VER) && _MSC_VER <= 1200 && !defined(_WIN64)
 // for msvc6 without sdk2003
 #define RPC_NO_WINDOWS_H
 #endif
 #if defined(__MINGW32__) || defined(__MINGW64__)
 // #if defined(__GNUC__) && !defined(__clang__)
 #include <windows.h>
 #else
 #include <Windows.h>
 #endif
 // #include <basetsd.h>
 // #include <wtypes.h>
 // but if precompiled with clang-cl then we need
 // #include <windows.h>
 #if defined(_MSC_VER)
 #pragma warning(pop)
 #endif
 #if defined(__clang__)
 # pragma clang diagnostic pop
 #endif
 #if defined(_MSC_VER) && _MSC_VER <= 1200 && !defined(_WIN64)
 #ifndef _W64
 typedef long LONG_PTR, *PLONG_PTR;
 typedef unsigned long ULONG_PTR, *PULONG_PTR;
 typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;
 #define Z7_OLD_WIN_SDK
 #endif // _W64
 #endif // _MSC_VER == 1200
 #ifdef Z7_OLD_WIN_SDK
 #ifndef INVALID_FILE_ATTRIBUTES
 #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
 #endif
 #ifndef INVALID_SET_FILE_POINTER
 #define INVALID_SET_FILE_POINTER ((DWORD)-1)
 #endif
 #ifndef FILE_SPECIAL_ACCESS
 #define FILE_SPECIAL_ACCESS    (FILE_ANY_ACCESS)
 #endif
 // ShlObj.h:
 // #define BIF_NEWDIALOGSTYLE     0x0040
 #pragma warning(disable : 4201)
 // #pragma warning(disable : 4115)
 #undef  VARIANT_TRUE
 #define VARIANT_TRUE ((VARIANT_BOOL)-1)
 #endif
 #endif // Z7_OLD_WIN_SDK
 #ifdef UNDER_CE
 #undef  VARIANT_TRUE
 #define VARIANT_TRUE ((VARIANT_BOOL)-1)
 #endif
 #if defined(_MSC_VER)
 #if _MSC_VER >= 1400 && _MSC_VER <= 1600
  // BaseTsd.h(148) : 'HandleToULong' : unreferenced inline function has been removed
  // string.h
  // #pragma warning(disable : 4514)
 #endif
 #endif
 /* #include "7zTypes.h" */
 #endif
--- a/3rdparty/7z/src/Aes.c
+++ b/3rdparty/7z/src/Aes.c
@ -0,0 +1,393 @@
 /* Aes.c -- AES encryption / decryption
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "CpuArch.h"
 #include "Aes.h"
 AES_CODE_FUNC g_AesCbc_Decode;
 #ifndef Z7_SFX
 AES_CODE_FUNC g_AesCbc_Encode;
 AES_CODE_FUNC g_AesCtr_Code;
 UInt32 g_Aes_SupportedFunctions_Flags;
 #endif
 static UInt32 T[256 * 4];
 static const Byte Sbox[256] = {
  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};
 static UInt32 D[256 * 4];
 static Byte InvS[256];
 #define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)
 #define Ui32(a0, a1, a2, a3) ((UInt32)(a0) | ((UInt32)(a1) << 8) | ((UInt32)(a2) << 16) | ((UInt32)(a3) << 24))
 #define gb0(x) ( (x)          & 0xFF)
 #define gb1(x) (((x) >> ( 8)) & 0xFF)
 #define gb2(x) (((x) >> (16)) & 0xFF)
 #define gb3(x) (((x) >> (24)))
 #define gb(n, x) gb ## n(x)
 #define TT(x) (T + (x << 8))
 #define DD(x) (D + (x << 8))
 // #define Z7_SHOW_AES_STATUS
 #ifdef MY_CPU_X86_OR_AMD64
  #define USE_HW_AES
 #elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
  #if defined(__clang__)
    #if (__clang_major__ >= 8) // fix that check
      #define USE_HW_AES
    #endif
  #elif defined(__GNUC__)
    #if (__GNUC__ >= 6) // fix that check
      #define USE_HW_AES
    #endif
  #elif defined(_MSC_VER)
    #if _MSC_VER >= 1910
      #define USE_HW_AES
    #endif
  #endif
 #endif
 #ifdef USE_HW_AES
 #ifdef Z7_SHOW_AES_STATUS
 #include <stdio.h>
 #define PRF(x) x
 #else
 #define PRF(x)
 #endif
 #endif
 void AesGenTables(void)
 {
  unsigned i;
  for (i = 0; i < 256; i++)
    InvS[Sbox[i]] = (Byte)i;
  for (i = 0; i < 256; i++)
  {
    {
      const UInt32 a1 = Sbox[i];
      const UInt32 a2 = xtime(a1);
      const UInt32 a3 = a2 ^ a1;
      TT(0)[i] = Ui32(a2, a1, a1, a3);
      TT(1)[i] = Ui32(a3, a2, a1, a1);
      TT(2)[i] = Ui32(a1, a3, a2, a1);
      TT(3)[i] = Ui32(a1, a1, a3, a2);
    }
    {
      const UInt32 a1 = InvS[i];
      const UInt32 a2 = xtime(a1);
      const UInt32 a4 = xtime(a2);
      const UInt32 a8 = xtime(a4);
      const UInt32 a9 = a8 ^ a1;
      const UInt32 aB = a8 ^ a2 ^ a1;
      const UInt32 aD = a8 ^ a4 ^ a1;
      const UInt32 aE = a8 ^ a4 ^ a2;
      DD(0)[i] = Ui32(aE, a9, aD, aB);
      DD(1)[i] = Ui32(aB, aE, a9, aD);
      DD(2)[i] = Ui32(aD, aB, aE, a9);
      DD(3)[i] = Ui32(a9, aD, aB, aE);
    }
  }
  {
  AES_CODE_FUNC d = AesCbc_Decode;
  #ifndef Z7_SFX
  AES_CODE_FUNC e = AesCbc_Encode;
  AES_CODE_FUNC c = AesCtr_Code;
  UInt32 flags = 0;
  #endif
  #ifdef USE_HW_AES
  if (CPU_IsSupported_AES())
  {
    // #pragma message ("AES HW")
    PRF(printf("\n===AES HW\n"));
    d = AesCbc_Decode_HW;
    #ifndef Z7_SFX
    e = AesCbc_Encode_HW;
    c = AesCtr_Code_HW;
    flags = k_Aes_SupportedFunctions_HW;
    #endif
    #ifdef MY_CPU_X86_OR_AMD64
    if (CPU_IsSupported_VAES_AVX2())
    {
      PRF(printf("\n===vaes avx2\n"));
      d = AesCbc_Decode_HW_256;
      #ifndef Z7_SFX
      c = AesCtr_Code_HW_256;
      flags |= k_Aes_SupportedFunctions_HW_256;
      #endif
    }
    #endif
  }
  #endif
  g_AesCbc_Decode = d;
  #ifndef Z7_SFX
  g_AesCbc_Encode = e;
  g_AesCtr_Code = c;
  g_Aes_SupportedFunctions_Flags = flags;
  #endif
  }
 }
 #define HT(i, x, s) TT(x)[gb(x, s[(i + x) & 3])]
 #define HT4(m, i, s, p) m[i] = \
    HT(i, 0, s) ^ \
    HT(i, 1, s) ^ \
    HT(i, 2, s) ^ \
    HT(i, 3, s) ^ w[p + i]
 #define HT16(m, s, p) \
    HT4(m, 0, s, p); \
    HT4(m, 1, s, p); \
    HT4(m, 2, s, p); \
    HT4(m, 3, s, p); \
 #define FT(i, x) Sbox[gb(x, m[(i + x) & 3])]
 #define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];
 #define HD(i, x, s) DD(x)[gb(x, s[(i - x) & 3])]
 #define HD4(m, i, s, p) m[i] = \
    HD(i, 0, s) ^ \
    HD(i, 1, s) ^ \
    HD(i, 2, s) ^ \
    HD(i, 3, s) ^ w[p + i];
 #define HD16(m, s, p) \
    HD4(m, 0, s, p); \
    HD4(m, 1, s, p); \
    HD4(m, 2, s, p); \
    HD4(m, 3, s, p); \
 #define FD(i, x) InvS[gb(x, m[(i - x) & 3])]
 #define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];
 void Z7_FASTCALL Aes_SetKey_Enc(UInt32 *w, const Byte *key, unsigned keySize)
 {
  unsigned i, m;
  const UInt32 *wLim;
  UInt32 t;
  UInt32 rcon = 1;
  keySize /= 4;
  w[0] = ((UInt32)keySize / 2) + 3;
  w += 4;
  for (i = 0; i < keySize; i++, key += 4)
    w[i] = GetUi32(key);
  t = w[(size_t)keySize - 1];
  wLim = w + (size_t)keySize * 3 + 28;
  m = 0;
  do
  {
    if (m == 0)
    {
      t = Ui32(Sbox[gb1(t)] ^ rcon, Sbox[gb2(t)], Sbox[gb3(t)], Sbox[gb0(t)]);
      rcon <<= 1;
      if (rcon & 0x100)
        rcon = 0x1b;
      m = keySize;
    }
    else if (m == 4 && keySize > 6)
      t = Ui32(Sbox[gb0(t)], Sbox[gb1(t)], Sbox[gb2(t)], Sbox[gb3(t)]);
    m--;
    t ^= w[0];
    w[keySize] = t;
  }
  while (++w != wLim);
 }
 void Z7_FASTCALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)
 {
  unsigned i, num;
  Aes_SetKey_Enc(w, key, keySize);
  num = keySize + 20;
  w += 8;
  for (i = 0; i < num; i++)
  {
    UInt32 r = w[i];
    w[i] =
      DD(0)[Sbox[gb0(r)]] ^
      DD(1)[Sbox[gb1(r)]] ^
      DD(2)[Sbox[gb2(r)]] ^
      DD(3)[Sbox[gb3(r)]];
  }
 }
 /* Aes_Encode and Aes_Decode functions work with little-endian words.
  src and dest are pointers to 4 UInt32 words.
  src and dest can point to same block */
 // Z7_FORCE_INLINE
 static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
 {
  UInt32 s[4];
  UInt32 m[4];
  UInt32 numRounds2 = w[0];
  w += 4;
  s[0] = src[0] ^ w[0];
  s[1] = src[1] ^ w[1];
  s[2] = src[2] ^ w[2];
  s[3] = src[3] ^ w[3];
  w += 4;
  for (;;)
  {
    HT16(m, s, 0)
    if (--numRounds2 == 0)
      break;
    HT16(s, m, 4)
    w += 8;
  }
  w += 4;
  FT4(0)
  FT4(1)
  FT4(2)
  FT4(3)
 }
 Z7_FORCE_INLINE
 static void Aes_Decode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
 {
  UInt32 s[4];
  UInt32 m[4];
  UInt32 numRounds2 = w[0];
  w += 4 + numRounds2 * 8;
  s[0] = src[0] ^ w[0];
  s[1] = src[1] ^ w[1];
  s[2] = src[2] ^ w[2];
  s[3] = src[3] ^ w[3];
  for (;;)
  {
    w -= 8;
    HD16(m, s, 4)
    if (--numRounds2 == 0)
      break;
    HD16(s, m, 0)
  }
  FD4(0)
  FD4(1)
  FD4(2)
  FD4(3)
 }
 void AesCbc_Init(UInt32 *p, const Byte *iv)
 {
  unsigned i;
  for (i = 0; i < 4; i++)
    p[i] = GetUi32(iv + i * 4);
 }
 void Z7_FASTCALL AesCbc_Encode(UInt32 *p, Byte *data, size_t numBlocks)
 {
  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
  {
    p[0] ^= GetUi32(data);
    p[1] ^= GetUi32(data + 4);
    p[2] ^= GetUi32(data + 8);
    p[3] ^= GetUi32(data + 12);
    Aes_Encode(p + 4, p, p);
    SetUi32(data,      p[0])
    SetUi32(data + 4,  p[1])
    SetUi32(data + 8,  p[2])
    SetUi32(data + 12, p[3])
  }
 }
 void Z7_FASTCALL AesCbc_Decode(UInt32 *p, Byte *data, size_t numBlocks)
 {
  UInt32 in[4], out[4];
  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
  {
    in[0] = GetUi32(data);
    in[1] = GetUi32(data + 4);
    in[2] = GetUi32(data + 8);
    in[3] = GetUi32(data + 12);
    Aes_Decode(p + 4, out, in);
    SetUi32(data,      p[0] ^ out[0])
    SetUi32(data + 4,  p[1] ^ out[1])
    SetUi32(data + 8,  p[2] ^ out[2])
    SetUi32(data + 12, p[3] ^ out[3])
    p[0] = in[0];
    p[1] = in[1];
    p[2] = in[2];
    p[3] = in[3];
  }
 }
 void Z7_FASTCALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)
 {
  for (; numBlocks != 0; numBlocks--)
  {
    UInt32 temp[4];
    unsigned i;
    if (++p[0] == 0)
      p[1]++;
    Aes_Encode(p + 4, temp, p);
    for (i = 0; i < 4; i++, data += 4)
    {
      const UInt32 t = temp[i];
      #ifdef MY_CPU_LE_UNALIGN
        *((UInt32 *)(void *)data) ^= t;
      #else
        data[0] = (Byte)(data[0] ^ (t & 0xFF));
        data[1] = (Byte)(data[1] ^ ((t >> 8) & 0xFF));
        data[2] = (Byte)(data[2] ^ ((t >> 16) & 0xFF));
        data[3] = (Byte)(data[3] ^ ((t >> 24)));
      #endif
    }
  }
 }
 #undef xtime
 #undef Ui32
 #undef gb0
 #undef gb1
 #undef gb2
 #undef gb3
 #undef gb
 #undef TT
 #undef DD
 #undef USE_HW_AES
 #undef PRF
--- a/3rdparty/7z/src/Aes.h
+++ b/3rdparty/7z/src/Aes.h
@ -0,0 +1,60 @@
 /* Aes.h -- AES encryption / decryption
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_AES_H
 #define ZIP7_INC_AES_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #define AES_BLOCK_SIZE 16
 /* Call AesGenTables one time before other AES functions */
 void AesGenTables(void);
 /* UInt32 pointers must be 16-byte aligned */
 /* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */
 #define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4)
 /* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */
 /* keySize = 16 or 24 or 32 (bytes) */
 typedef void (Z7_FASTCALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize);
 void Z7_FASTCALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize);
 void Z7_FASTCALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize);
 /* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */
 void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */
 /* data - 16-byte aligned pointer to data */
 /* numBlocks - the number of 16-byte blocks in data array */
 typedef void (Z7_FASTCALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks);
 extern AES_CODE_FUNC g_AesCbc_Decode;
 #ifndef Z7_SFX
 extern AES_CODE_FUNC g_AesCbc_Encode;
 extern AES_CODE_FUNC g_AesCtr_Code;
 #define k_Aes_SupportedFunctions_HW     (1 << 2)
 #define k_Aes_SupportedFunctions_HW_256 (1 << 3)
 extern UInt32 g_Aes_SupportedFunctions_Flags;
 #endif
 #define Z7_DECLARE_AES_CODE_FUNC(funcName) \
    void Z7_FASTCALL funcName(UInt32 *ivAes, Byte *data, size_t numBlocks);
 Z7_DECLARE_AES_CODE_FUNC (AesCbc_Encode)
 Z7_DECLARE_AES_CODE_FUNC (AesCbc_Decode)
 Z7_DECLARE_AES_CODE_FUNC (AesCtr_Code)
 Z7_DECLARE_AES_CODE_FUNC (AesCbc_Encode_HW)
 Z7_DECLARE_AES_CODE_FUNC (AesCbc_Decode_HW)
 Z7_DECLARE_AES_CODE_FUNC (AesCtr_Code_HW)
 Z7_DECLARE_AES_CODE_FUNC (AesCbc_Decode_HW_256)
 Z7_DECLARE_AES_CODE_FUNC (AesCtr_Code_HW_256)
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/AesOpt.c
+++ b/3rdparty/7z/src/AesOpt.c
@ -0,0 +1,840 @@
 /* AesOpt.c -- AES optimized code for x86 AES hardware instructions
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "Aes.h"
 #include "CpuArch.h"
 #ifdef MY_CPU_X86_OR_AMD64
  #if defined(__INTEL_COMPILER)
    #if (__INTEL_COMPILER >= 1110)
      #define USE_INTEL_AES
      #if (__INTEL_COMPILER >= 1900)
        #define USE_INTEL_VAES
      #endif
    #endif
  #elif defined(__clang__) && (__clang_major__ > 3 || __clang_major__ == 3 && __clang_minor__ >= 8) \
       || defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4)
        #define USE_INTEL_AES
        #if !defined(__AES__)
          #define ATTRIB_AES __attribute__((__target__("aes")))
        #endif
      #if defined(__clang__) && (__clang_major__ >= 8) \
          || defined(__GNUC__) && (__GNUC__ >= 8)
        #define USE_INTEL_VAES
        #if !defined(__AES__) || !defined(__VAES__) || !defined(__AVX__) || !defined(__AVX2__)
          #define ATTRIB_VAES __attribute__((__target__("aes,vaes,avx,avx2")))
        #endif
      #endif
  #elif defined(_MSC_VER)
    #if (_MSC_VER > 1500) || (_MSC_FULL_VER >= 150030729)
      #define USE_INTEL_AES
      #if (_MSC_VER >= 1910)
        #define USE_INTEL_VAES
      #endif
    #endif
  #endif
 #ifndef ATTRIB_AES
  #define ATTRIB_AES
 #endif
 #ifndef ATTRIB_VAES
  #define ATTRIB_VAES
 #endif
 #ifdef USE_INTEL_AES
 #include <wmmintrin.h>
 #ifndef USE_INTEL_VAES
 #define AES_TYPE_keys UInt32
 #define AES_TYPE_data Byte
 // #define AES_TYPE_keys __m128i
 // #define AES_TYPE_data __m128i
 #endif
 #define AES_FUNC_START(name) \
    void Z7_FASTCALL name(UInt32 *ivAes, Byte *data8, size_t numBlocks)
    // void Z7_FASTCALL name(__m128i *p, __m128i *data, size_t numBlocks)
 #define AES_FUNC_START2(name) \
 AES_FUNC_START (name); \
 ATTRIB_AES \
 AES_FUNC_START (name)
 #define MM_OP(op, dest, src)  dest = op(dest, src);
 #define MM_OP_m(op, src)      MM_OP(op, m, src)
 #define MM_XOR( dest, src)    MM_OP(_mm_xor_si128,    dest, src)
 #define AVX_XOR(dest, src)    MM_OP(_mm256_xor_si256, dest, src)
 AES_FUNC_START2 (AesCbc_Encode_HW)
 {
  __m128i *p = (__m128i *)(void *)ivAes;
  __m128i *data = (__m128i *)(void *)data8;
  __m128i m = *p;
  const __m128i k0 = p[2];
  const __m128i k1 = p[3];
  const UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
  for (; numBlocks != 0; numBlocks--, data++)
  {
    UInt32 r = numRounds2;
    const __m128i *w = p + 4;
    __m128i temp = *data;
    MM_XOR (temp, k0)
    MM_XOR (m, temp)
    MM_OP_m (_mm_aesenc_si128, k1)
    do
    {
      MM_OP_m (_mm_aesenc_si128, w[0])
      MM_OP_m (_mm_aesenc_si128, w[1])
      w += 2;
    }
    while (--r);
    MM_OP_m (_mm_aesenclast_si128, w[0])
    *data = m;
  }
  *p = m;
 }
 #define WOP_1(op)
 #define WOP_2(op)   WOP_1 (op)  op (m1, 1)
 #define WOP_3(op)   WOP_2 (op)  op (m2, 2)
 #define WOP_4(op)   WOP_3 (op)  op (m3, 3)
 #ifdef MY_CPU_AMD64
 #define WOP_5(op)   WOP_4 (op)  op (m4, 4)
 #define WOP_6(op)   WOP_5 (op)  op (m5, 5)
 #define WOP_7(op)   WOP_6 (op)  op (m6, 6)
 #define WOP_8(op)   WOP_7 (op)  op (m7, 7)
 #endif
 /*
 #define WOP_9(op)   WOP_8 (op)  op (m8, 8);
 #define WOP_10(op)  WOP_9 (op)  op (m9, 9);
 #define WOP_11(op)  WOP_10(op)  op (m10, 10);
 #define WOP_12(op)  WOP_11(op)  op (m11, 11);
 #define WOP_13(op)  WOP_12(op)  op (m12, 12);
 #define WOP_14(op)  WOP_13(op)  op (m13, 13);
 */
 #ifdef MY_CPU_AMD64
  #define NUM_WAYS      8
  #define WOP_M1    WOP_8
 #else
  #define NUM_WAYS      4
  #define WOP_M1    WOP_4
 #endif
 #define WOP(op)  op (m0, 0)  WOP_M1(op)
 #define DECLARE_VAR(reg, ii)  __m128i reg;
 #define LOAD_data(  reg, ii)  reg = data[ii];
 #define STORE_data( reg, ii)  data[ii] = reg;
 #if (NUM_WAYS > 1)
 #define XOR_data_M1(reg, ii)  MM_XOR (reg, data[ii- 1])
 #endif
 #define AVX_DECLARE_VAR(reg, ii)  __m256i reg;
 #define AVX_LOAD_data(  reg, ii)  reg = ((const __m256i *)(const void *)data)[ii];
 #define AVX_STORE_data( reg, ii)  ((__m256i *)(void *)data)[ii] = reg;
 #define AVX_XOR_data_M1(reg, ii)  AVX_XOR (reg, (((const __m256i *)(const void *)(data - 1))[ii]))
 #define MM_OP_key(op, reg)  MM_OP(op, reg, key);
 #define AES_DEC(      reg, ii)   MM_OP_key (_mm_aesdec_si128,     reg)
 #define AES_DEC_LAST( reg, ii)   MM_OP_key (_mm_aesdeclast_si128, reg)
 #define AES_ENC(      reg, ii)   MM_OP_key (_mm_aesenc_si128,     reg)
 #define AES_ENC_LAST( reg, ii)   MM_OP_key (_mm_aesenclast_si128, reg)
 #define AES_XOR(      reg, ii)   MM_OP_key (_mm_xor_si128,        reg)
 #define AVX_AES_DEC(      reg, ii)   MM_OP_key (_mm256_aesdec_epi128,     reg)
 #define AVX_AES_DEC_LAST( reg, ii)   MM_OP_key (_mm256_aesdeclast_epi128, reg)
 #define AVX_AES_ENC(      reg, ii)   MM_OP_key (_mm256_aesenc_epi128,     reg)
 #define AVX_AES_ENC_LAST( reg, ii)   MM_OP_key (_mm256_aesenclast_epi128, reg)
 #define AVX_AES_XOR(      reg, ii)   MM_OP_key (_mm256_xor_si256,         reg)
 #define CTR_START(reg, ii)  MM_OP (_mm_add_epi64, ctr, one)  reg = ctr;
 #define CTR_END(  reg, ii)  MM_XOR (data[ii], reg)
 #define AVX_CTR_START(reg, ii)  MM_OP (_mm256_add_epi64, ctr2, two)  reg = _mm256_xor_si256(ctr2, key);
 #define AVX_CTR_END(  reg, ii)  AVX_XOR (((__m256i *)(void *)data)[ii], reg)
 #define WOP_KEY(op, n) { \
    const __m128i key = w[n]; \
    WOP(op); }
 #define AVX_WOP_KEY(op, n) { \
    const __m256i key = w[n]; \
    WOP(op); }
 #define WIDE_LOOP_START  \
    dataEnd = data + numBlocks;  \
    if (numBlocks >= NUM_WAYS)  \
    { dataEnd -= NUM_WAYS; do {  \
 #define WIDE_LOOP_END  \
    data += NUM_WAYS;  \
    } while (data <= dataEnd);  \
    dataEnd += NUM_WAYS; }  \
 #define SINGLE_LOOP  \
    for (; data < dataEnd; data++)
 #define NUM_AES_KEYS_MAX 15
 #define WIDE_LOOP_START_AVX(OP)  \
    dataEnd = data + numBlocks;  \
    if (numBlocks >= NUM_WAYS * 2)  \
    { __m256i keys[NUM_AES_KEYS_MAX]; \
    UInt32 ii; \
    OP \
    for (ii = 0; ii < numRounds; ii++) \
      keys[ii] = _mm256_broadcastsi128_si256(p[ii]); \
    dataEnd -= NUM_WAYS * 2; do {  \
 #define WIDE_LOOP_END_AVX(OP)  \
    data += NUM_WAYS * 2;  \
    } while (data <= dataEnd);  \
    dataEnd += NUM_WAYS * 2;  \
    OP  \
    _mm256_zeroupper();  \
    }  \
 /* MSVC for x86: If we don't call _mm256_zeroupper(), and -arch:IA32 is not specified,
   MSVC still can insert vzeroupper instruction. */
 AES_FUNC_START2 (AesCbc_Decode_HW)
 {
  __m128i *p = (__m128i *)(void *)ivAes;
  __m128i *data = (__m128i *)(void *)data8;
  __m128i iv = *p;
  const __m128i *wStart = p + *(const UInt32 *)(p + 1) * 2 + 2 - 1;
  const __m128i *dataEnd;
  p += 2;
  WIDE_LOOP_START
  {
    const __m128i *w = wStart;
    WOP (DECLARE_VAR)
    WOP (LOAD_data)
    WOP_KEY (AES_XOR, 1)
    do
    {
      WOP_KEY (AES_DEC, 0)
      w--;
    }
    while (w != p);
    WOP_KEY (AES_DEC_LAST, 0)
    MM_XOR (m0, iv)
    WOP_M1 (XOR_data_M1)
    iv = data[NUM_WAYS - 1];
    WOP (STORE_data)
  }
  WIDE_LOOP_END
  SINGLE_LOOP
  {
    const __m128i *w = wStart - 1;
    __m128i m = _mm_xor_si128 (w[2], *data);
    do
    {
      MM_OP_m (_mm_aesdec_si128, w[1])
      MM_OP_m (_mm_aesdec_si128, w[0])
      w -= 2;
    }
    while (w != p);
    MM_OP_m (_mm_aesdec_si128,     w[1])
    MM_OP_m (_mm_aesdeclast_si128, w[0])
    MM_XOR (m, iv)
    iv = *data;
    *data = m;
  }
  p[-2] = iv;
 }
 AES_FUNC_START2 (AesCtr_Code_HW)
 {
  __m128i *p = (__m128i *)(void *)ivAes;
  __m128i *data = (__m128i *)(void *)data8;
  __m128i ctr = *p;
  UInt32 numRoundsMinus2 = *(const UInt32 *)(p + 1) * 2 - 1;
  const __m128i *dataEnd;
  __m128i one = _mm_cvtsi32_si128(1);
  p += 2;
  WIDE_LOOP_START
  {
    const __m128i *w = p;
    UInt32 r = numRoundsMinus2;
    WOP (DECLARE_VAR)
    WOP (CTR_START)
    WOP_KEY (AES_XOR, 0)
    w += 1;
    do
    {
      WOP_KEY (AES_ENC, 0)
      w += 1;
    }
    while (--r);
    WOP_KEY (AES_ENC_LAST, 0)
    WOP (CTR_END)
  }
  WIDE_LOOP_END
  SINGLE_LOOP
  {
    UInt32 numRounds2 = *(const UInt32 *)(p - 2 + 1) - 1;
    const __m128i *w = p;
    __m128i m;
    MM_OP (_mm_add_epi64, ctr, one)
    m = _mm_xor_si128 (ctr, p[0]);
    w += 1;
    do
    {
      MM_OP_m (_mm_aesenc_si128, w[0])
      MM_OP_m (_mm_aesenc_si128, w[1])
      w += 2;
    }
    while (--numRounds2);
    MM_OP_m (_mm_aesenc_si128,     w[0])
    MM_OP_m (_mm_aesenclast_si128, w[1])
    MM_XOR (*data, m)
  }
  p[-2] = ctr;
 }
 #ifdef USE_INTEL_VAES
 /*
 GCC before 2013-Jun:
  <immintrin.h>:
    #ifdef __AVX__
     #include <avxintrin.h>
    #endif
 GCC after 2013-Jun:
  <immintrin.h>:
    #include <avxintrin.h>
 CLANG 3.8+:
 {
  <immintrin.h>:
    #if !defined(_MSC_VER) || defined(__AVX__)
      #include <avxintrin.h>
    #endif
  if (the compiler is clang for Windows and if global arch is not set for __AVX__)
    [ if (defined(_MSC_VER) && !defined(__AVX__)) ]
  {
    <immintrin.h> doesn't include <avxintrin.h>
    and we have 2 ways to fix it:
      1) we can define required __AVX__ before <immintrin.h>
      or
      2) we can include <avxintrin.h> after <immintrin.h>
  }
 }
 If we include <avxintrin.h> manually for GCC/CLANG, it's
 required that <immintrin.h> must be included before <avxintrin.h>.
 */
 /*
 #if defined(__clang__) && defined(_MSC_VER)
 #define __AVX__
 #define __AVX2__
 #define __VAES__
 #endif
 */
 #include <immintrin.h>
 #if defined(__clang__) && defined(_MSC_VER)
  #if !defined(__AVX__)
    #include <avxintrin.h>
  #endif
  #if !defined(__AVX2__)
    #include <avx2intrin.h>
  #endif
  #if !defined(__VAES__)
    #include <vaesintrin.h>
  #endif
 #endif  // __clang__ && _MSC_VER
 #define VAES_FUNC_START2(name) \
 AES_FUNC_START (name); \
 ATTRIB_VAES \
 AES_FUNC_START (name)
 VAES_FUNC_START2 (AesCbc_Decode_HW_256)
 {
  __m128i *p = (__m128i *)(void *)ivAes;
  __m128i *data = (__m128i *)(void *)data8;
  __m128i iv = *p;
  const __m128i *dataEnd;
  UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
  p += 2;
  WIDE_LOOP_START_AVX(;)
  {
    const __m256i *w = keys + numRounds - 2;
    WOP (AVX_DECLARE_VAR)
    WOP (AVX_LOAD_data)
    AVX_WOP_KEY (AVX_AES_XOR, 1)
    do
    {
      AVX_WOP_KEY (AVX_AES_DEC, 0)
      w--;
    }
    while (w != keys);
    AVX_WOP_KEY (AVX_AES_DEC_LAST, 0)
    AVX_XOR (m0, _mm256_setr_m128i(iv, data[0]))
    WOP_M1 (AVX_XOR_data_M1)
    iv = data[NUM_WAYS * 2 - 1];
    WOP (AVX_STORE_data)
  }
  WIDE_LOOP_END_AVX(;)
  SINGLE_LOOP
  {
    const __m128i *w = p + *(const UInt32 *)(p + 1 - 2) * 2 + 1 - 3;
    __m128i m = _mm_xor_si128 (w[2], *data);
    do
    {
      MM_OP_m (_mm_aesdec_si128, w[1])
      MM_OP_m (_mm_aesdec_si128, w[0])
      w -= 2;
    }
    while (w != p);
    MM_OP_m (_mm_aesdec_si128,     w[1])
    MM_OP_m (_mm_aesdeclast_si128, w[0])
    MM_XOR (m, iv)
    iv = *data;
    *data = m;
  }
  p[-2] = iv;
 }
 /*
 SSE2: _mm_cvtsi32_si128 : movd
 AVX:  _mm256_setr_m128i            : vinsertf128
 AVX2: _mm256_add_epi64             : vpaddq ymm, ymm, ymm
      _mm256_extracti128_si256     : vextracti128
      _mm256_broadcastsi128_si256  : vbroadcasti128
 */
 #define AVX_CTR_LOOP_START  \
    ctr2 = _mm256_setr_m128i(_mm_sub_epi64(ctr, one), ctr); \
    two = _mm256_setr_m128i(one, one); \
    two = _mm256_add_epi64(two, two); \
 // two = _mm256_setr_epi64x(2, 0, 2, 0);
 #define AVX_CTR_LOOP_ENC  \
    ctr = _mm256_extracti128_si256 (ctr2, 1); \
 VAES_FUNC_START2 (AesCtr_Code_HW_256)
 {
  __m128i *p = (__m128i *)(void *)ivAes;
  __m128i *data = (__m128i *)(void *)data8;
  __m128i ctr = *p;
  UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
  const __m128i *dataEnd;
  __m128i one = _mm_cvtsi32_si128(1);
  __m256i ctr2, two;
  p += 2;
  WIDE_LOOP_START_AVX (AVX_CTR_LOOP_START)
  {
    const __m256i *w = keys;
    UInt32 r = numRounds - 2;
    WOP (AVX_DECLARE_VAR)
    AVX_WOP_KEY (AVX_CTR_START, 0)
    w += 1;
    do
    {
      AVX_WOP_KEY (AVX_AES_ENC, 0)
      w += 1;
    }
    while (--r);
    AVX_WOP_KEY (AVX_AES_ENC_LAST, 0)
    WOP (AVX_CTR_END)
  }
  WIDE_LOOP_END_AVX (AVX_CTR_LOOP_ENC)
  SINGLE_LOOP
  {
    UInt32 numRounds2 = *(const UInt32 *)(p - 2 + 1) - 1;
    const __m128i *w = p;
    __m128i m;
    MM_OP (_mm_add_epi64, ctr, one)
    m = _mm_xor_si128 (ctr, p[0]);
    w += 1;
    do
    {
      MM_OP_m (_mm_aesenc_si128, w[0])
      MM_OP_m (_mm_aesenc_si128, w[1])
      w += 2;
    }
    while (--numRounds2);
    MM_OP_m (_mm_aesenc_si128,     w[0])
    MM_OP_m (_mm_aesenclast_si128, w[1])
    MM_XOR (*data, m)
  }
  p[-2] = ctr;
 }
 #endif // USE_INTEL_VAES
 #else // USE_INTEL_AES
 /* no USE_INTEL_AES */
 #pragma message("AES  HW_SW stub was used")
 #define AES_TYPE_keys UInt32
 #define AES_TYPE_data Byte
 #define AES_FUNC_START(name) \
    void Z7_FASTCALL name(UInt32 *p, Byte *data, size_t numBlocks) \
 #define AES_COMPAT_STUB(name) \
    AES_FUNC_START(name); \
    AES_FUNC_START(name ## _HW) \
    { name(p, data, numBlocks); }
 AES_COMPAT_STUB (AesCbc_Encode)
 AES_COMPAT_STUB (AesCbc_Decode)
 AES_COMPAT_STUB (AesCtr_Code)
 #endif // USE_INTEL_AES
 #ifndef USE_INTEL_VAES
 #pragma message("VAES HW_SW stub was used")
 #define VAES_COMPAT_STUB(name) \
    void Z7_FASTCALL name ## _256(UInt32 *p, Byte *data, size_t numBlocks); \
    void Z7_FASTCALL name ## _256(UInt32 *p, Byte *data, size_t numBlocks) \
    { name((AES_TYPE_keys *)(void *)p, (AES_TYPE_data *)(void *)data, numBlocks); }
 VAES_COMPAT_STUB (AesCbc_Decode_HW)
 VAES_COMPAT_STUB (AesCtr_Code_HW)
 #endif // ! USE_INTEL_VAES
 #elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
  #if defined(__clang__)
    #if (__clang_major__ >= 8) // fix that check
      #define USE_HW_AES
    #endif
  #elif defined(__GNUC__)
    #if (__GNUC__ >= 6) // fix that check
      #define USE_HW_AES
    #endif
  #elif defined(_MSC_VER)
    #if _MSC_VER >= 1910
      #define USE_HW_AES
    #endif
  #endif
 #ifdef USE_HW_AES
 // #pragma message("=== AES HW === ")
 #if defined(__clang__) || defined(__GNUC__)
  #ifdef MY_CPU_ARM64
    #define ATTRIB_AES __attribute__((__target__("+crypto")))
  #else
    #define ATTRIB_AES __attribute__((__target__("fpu=crypto-neon-fp-armv8")))
  #endif
 #else
  // _MSC_VER
  // for arm32
  #define _ARM_USE_NEW_NEON_INTRINSICS
 #endif
 #ifndef ATTRIB_AES
  #define ATTRIB_AES
 #endif
 #if defined(_MSC_VER) && defined(MY_CPU_ARM64)
 #include <arm64_neon.h>
 #else
 #include <arm_neon.h>
 #endif
 typedef uint8x16_t v128;
 #define AES_FUNC_START(name) \
    void Z7_FASTCALL name(UInt32 *ivAes, Byte *data8, size_t numBlocks)
    // void Z7_FASTCALL name(v128 *p, v128 *data, size_t numBlocks)
 #define AES_FUNC_START2(name) \
 AES_FUNC_START (name); \
 ATTRIB_AES \
 AES_FUNC_START (name)
 #define MM_OP(op, dest, src)  dest = op(dest, src);
 #define MM_OP_m(op, src)      MM_OP(op, m, src)
 #define MM_OP1_m(op)          m = op(m);
 #define MM_XOR( dest, src)    MM_OP(veorq_u8, dest, src)
 #define MM_XOR_m( src)        MM_XOR(m, src)
 #define AES_E_m(k)     MM_OP_m (vaeseq_u8, k)
 #define AES_E_MC_m(k)  AES_E_m (k)  MM_OP1_m(vaesmcq_u8)
 AES_FUNC_START2 (AesCbc_Encode_HW)
 {
  v128 *p = (v128*)(void*)ivAes;
  v128 *data = (v128*)(void*)data8;
  v128 m = *p;
  const v128 k0 = p[2];
  const v128 k1 = p[3];
  const v128 k2 = p[4];
  const v128 k3 = p[5];
  const v128 k4 = p[6];
  const v128 k5 = p[7];
  const v128 k6 = p[8];
  const v128 k7 = p[9];
  const v128 k8 = p[10];
  const v128 k9 = p[11];
  const UInt32 numRounds2 = *(const UInt32 *)(p + 1);
  const v128 *w = p + ((size_t)numRounds2 * 2);
  const v128 k_z1 = w[1];
  const v128 k_z0 = w[2];
  for (; numBlocks != 0; numBlocks--, data++)
  {
    MM_XOR_m (*data);
    AES_E_MC_m (k0)
    AES_E_MC_m (k1)
    AES_E_MC_m (k2)
    AES_E_MC_m (k3)
    AES_E_MC_m (k4)
    AES_E_MC_m (k5)
    AES_E_MC_m (k6)
    AES_E_MC_m (k7)
    AES_E_MC_m (k8)
    if (numRounds2 >= 6)
    {
      AES_E_MC_m (k9)
      AES_E_MC_m (p[12])
      if (numRounds2 != 6)
      {
        AES_E_MC_m (p[13])
        AES_E_MC_m (p[14])
      }
    }
    AES_E_m  (k_z1)
    MM_XOR_m (k_z0);
    *data = m;
  }
  *p = m;
 }
 #define WOP_1(op)
 #define WOP_2(op)   WOP_1 (op)  op (m1, 1)
 #define WOP_3(op)   WOP_2 (op)  op (m2, 2)
 #define WOP_4(op)   WOP_3 (op)  op (m3, 3)
 #define WOP_5(op)   WOP_4 (op)  op (m4, 4)
 #define WOP_6(op)   WOP_5 (op)  op (m5, 5)
 #define WOP_7(op)   WOP_6 (op)  op (m6, 6)
 #define WOP_8(op)   WOP_7 (op)  op (m7, 7)
  #define NUM_WAYS      8
  #define WOP_M1    WOP_8
 #define WOP(op)  op (m0, 0)   WOP_M1(op)
 #define DECLARE_VAR(reg, ii)  v128 reg;
 #define LOAD_data(  reg, ii)  reg = data[ii];
 #define STORE_data( reg, ii)  data[ii] = reg;
 #if (NUM_WAYS > 1)
 #define XOR_data_M1(reg, ii)  MM_XOR (reg, data[ii- 1])
 #endif
 #define MM_OP_key(op, reg)  MM_OP (op, reg, key)
 #define AES_D_m(k)      MM_OP_m (vaesdq_u8, k)
 #define AES_D_IMC_m(k)  AES_D_m (k)  MM_OP1_m (vaesimcq_u8)
 #define AES_XOR(   reg, ii)  MM_OP_key (veorq_u8,  reg)
 #define AES_D(     reg, ii)  MM_OP_key (vaesdq_u8, reg)
 #define AES_E(     reg, ii)  MM_OP_key (vaeseq_u8, reg)
 #define AES_D_IMC( reg, ii)  AES_D (reg, ii)  reg = vaesimcq_u8(reg);
 #define AES_E_MC(  reg, ii)  AES_E (reg, ii)  reg = vaesmcq_u8(reg);
 #define CTR_START(reg, ii)  MM_OP (vaddq_u64, ctr, one)  reg = vreinterpretq_u8_u64(ctr);
 #define CTR_END(  reg, ii)  MM_XOR (data[ii], reg)
 #define WOP_KEY(op, n) { \
    const v128 key = w[n]; \
    WOP(op) }
 #define WIDE_LOOP_START  \
    dataEnd = data + numBlocks;  \
    if (numBlocks >= NUM_WAYS)  \
    { dataEnd -= NUM_WAYS; do {  \
 #define WIDE_LOOP_END  \
    data += NUM_WAYS;  \
    } while (data <= dataEnd);  \
    dataEnd += NUM_WAYS; }  \
 #define SINGLE_LOOP  \
    for (; data < dataEnd; data++)
 AES_FUNC_START2 (AesCbc_Decode_HW)
 {
  v128 *p = (v128*)(void*)ivAes;
  v128 *data = (v128*)(void*)data8;
  v128 iv = *p;
  const v128 *wStart = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
  const v128 *dataEnd;
  p += 2;
  WIDE_LOOP_START
  {
    const v128 *w = wStart;
    WOP (DECLARE_VAR)
    WOP (LOAD_data)
    WOP_KEY (AES_D_IMC, 2)
    do
    {
      WOP_KEY (AES_D_IMC, 1)
      WOP_KEY (AES_D_IMC, 0)
      w -= 2;
    }
    while (w != p);
    WOP_KEY (AES_D,   1)
    WOP_KEY (AES_XOR, 0)
    MM_XOR (m0, iv);
    WOP_M1 (XOR_data_M1)
    iv = data[NUM_WAYS - 1];
    WOP (STORE_data)
  }
  WIDE_LOOP_END
  SINGLE_LOOP
  {
    const v128 *w = wStart;
    v128 m = *data;
    AES_D_IMC_m (w[2])
    do
    {
      AES_D_IMC_m (w[1]);
      AES_D_IMC_m (w[0]);
      w -= 2;
    }
    while (w != p);
    AES_D_m  (w[1]);
    MM_XOR_m (w[0]);
    MM_XOR_m (iv);
    iv = *data;
    *data = m;
  }
  p[-2] = iv;
 }
 AES_FUNC_START2 (AesCtr_Code_HW)
 {
  v128 *p = (v128*)(void*)ivAes;
  v128 *data = (v128*)(void*)data8;
  uint64x2_t ctr = vreinterpretq_u64_u8(*p);
  const v128 *wEnd = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
  const v128 *dataEnd;
  uint64x2_t one = vdupq_n_u64(0);
  one = vsetq_lane_u64(1, one, 0);
  p += 2;
  WIDE_LOOP_START
  {
    const v128 *w = p;
    WOP (DECLARE_VAR)
    WOP (CTR_START)
    do
    {
      WOP_KEY (AES_E_MC, 0)
      WOP_KEY (AES_E_MC, 1)
      w += 2;
    }
    while (w != wEnd);
    WOP_KEY (AES_E_MC, 0)
    WOP_KEY (AES_E,    1)
    WOP_KEY (AES_XOR,  2)
    WOP (CTR_END)
  }
  WIDE_LOOP_END
  SINGLE_LOOP
  {
    const v128 *w = p;
    v128 m;
    CTR_START (m, 0);
    do
    {
      AES_E_MC_m (w[0]);
      AES_E_MC_m (w[1]);
      w += 2;
    }
    while (w != wEnd);
    AES_E_MC_m (w[0])
    AES_E_m    (w[1])
    MM_XOR_m   (w[2])
    CTR_END (m, 0)
  }
  p[-2] = vreinterpretq_u8_u64(ctr);
 }
 #endif // USE_HW_AES
 #endif // MY_CPU_ARM_OR_ARM64
 #undef NUM_WAYS
 #undef WOP_M1
 #undef WOP
 #undef DECLARE_VAR
 #undef LOAD_data
 #undef STORE_data
 #undef USE_INTEL_AES
 #undef USE_HW_AES
--- a/3rdparty/7z/src/Alloc.c
+++ b/3rdparty/7z/src/Alloc.c
@ -0,0 +1,535 @@
 /* Alloc.c -- Memory allocation functions
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #ifdef _WIN32
 #include "7zWindows.h"
 #endif
 #include <stdlib.h>
 #include "Alloc.h"
 #ifdef _WIN32
 #ifdef Z7_LARGE_PAGES
 #if defined(__clang__) || defined(__GNUC__)
 typedef void (*Z7_voidFunction)(void);
 #define MY_CAST_FUNC (Z7_voidFunction)
 #elif defined(_MSC_VER) && _MSC_VER > 1920
 #define MY_CAST_FUNC  (void *)
 // #pragma warning(disable : 4191) // 'type cast': unsafe conversion from 'FARPROC' to 'void (__cdecl *)()'
 #else
 #define MY_CAST_FUNC
 #endif
 #endif // Z7_LARGE_PAGES
 #endif // _WIN32
 // #define SZ_ALLOC_DEBUG
 /* #define SZ_ALLOC_DEBUG */
 /* use SZ_ALLOC_DEBUG to debug alloc/free operations */
 #ifdef SZ_ALLOC_DEBUG
 #include <string.h>
 #include <stdio.h>
 static int g_allocCount = 0;
 #ifdef _WIN32
 static int g_allocCountMid = 0;
 static int g_allocCountBig = 0;
 #endif
 #define CONVERT_INT_TO_STR(charType, tempSize) \
  char temp[tempSize]; unsigned i = 0; \
  while (val >= 10) { temp[i++] = (char)('0' + (unsigned)(val % 10)); val /= 10; } \
  *s++ = (charType)('0' + (unsigned)val); \
  while (i != 0) { i--; *s++ = temp[i]; } \
  *s = 0;
 static void ConvertUInt64ToString(UInt64 val, char *s)
 {
  CONVERT_INT_TO_STR(char, 24)
 }
 #define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
 static void ConvertUInt64ToHex(UInt64 val, char *s)
 {
  UInt64 v = val;
  unsigned i;
  for (i = 1;; i++)
  {
    v >>= 4;
    if (v == 0)
      break;
  }
  s[i] = 0;
  do
  {
    unsigned t = (unsigned)(val & 0xF);
    val >>= 4;
    s[--i] = GET_HEX_CHAR(t);
  }
  while (i);
 }
 #define DEBUG_OUT_STREAM stderr
 static void Print(const char *s)
 {
  fputs(s, DEBUG_OUT_STREAM);
 }
 static void PrintAligned(const char *s, size_t align)
 {
  size_t len = strlen(s);
  for(;;)
  {
    fputc(' ', DEBUG_OUT_STREAM);
    if (len >= align)
      break;
    ++len;
  }
  Print(s);
 }
 static void PrintLn(void)
 {
  Print("\n");
 }
 static void PrintHex(UInt64 v, size_t align)
 {
  char s[32];
  ConvertUInt64ToHex(v, s);
  PrintAligned(s, align);
 }
 static void PrintDec(int v, size_t align)
 {
  char s[32];
  ConvertUInt64ToString((unsigned)v, s);
  PrintAligned(s, align);
 }
 static void PrintAddr(void *p)
 {
  PrintHex((UInt64)(size_t)(ptrdiff_t)p, 12);
 }
 #define PRINT_REALLOC(name, cnt, size, ptr) { \
    Print(name " "); \
    if (!ptr) PrintDec(cnt++, 10); \
    PrintHex(size, 10); \
    PrintAddr(ptr); \
    PrintLn(); }
 #define PRINT_ALLOC(name, cnt, size, ptr) { \
    Print(name " "); \
    PrintDec(cnt++, 10); \
    PrintHex(size, 10); \
    PrintAddr(ptr); \
    PrintLn(); }
 #define PRINT_FREE(name, cnt, ptr) if (ptr) { \
    Print(name " "); \
    PrintDec(--cnt, 10); \
    PrintAddr(ptr); \
    PrintLn(); }
 #else
 #ifdef _WIN32
 #define PRINT_ALLOC(name, cnt, size, ptr)
 #endif
 #define PRINT_FREE(name, cnt, ptr)
 #define Print(s)
 #define PrintLn()
 #define PrintHex(v, align)
 #define PrintAddr(p)
 #endif
 /*
 by specification:
  malloc(non_NULL, 0)   : returns NULL or a unique pointer value that can later be successfully passed to free()
  realloc(NULL, size)   : the call is equivalent to malloc(size)
  realloc(non_NULL, 0)  : the call is equivalent to free(ptr)
 in main compilers:
  malloc(0)             : returns non_NULL
  realloc(NULL,     0)  : returns non_NULL
  realloc(non_NULL, 0)  : returns NULL
 */
 void *MyAlloc(size_t size)
 {
  if (size == 0)
    return NULL;
  // PRINT_ALLOC("Alloc    ", g_allocCount, size, NULL)
  #ifdef SZ_ALLOC_DEBUG
  {
    void *p = malloc(size);
    if (p)
    {
      PRINT_ALLOC("Alloc    ", g_allocCount, size, p)
    }
    return p;
  }
  #else
  return malloc(size);
  #endif
 }
 void MyFree(void *address)
 {
  PRINT_FREE("Free    ", g_allocCount, address)
  free(address);
 }
 void *MyRealloc(void *address, size_t size)
 {
  if (size == 0)
  {
    MyFree(address);
    return NULL;
  }
  // PRINT_REALLOC("Realloc  ", g_allocCount, size, address)
  #ifdef SZ_ALLOC_DEBUG
  {
    void *p = realloc(address, size);
    if (p)
    {
      PRINT_REALLOC("Realloc    ", g_allocCount, size, address)
    }
    return p;
  }
  #else
  return realloc(address, size);
  #endif
 }
 #ifdef _WIN32
 void *MidAlloc(size_t size)
 {
  if (size == 0)
    return NULL;
  #ifdef SZ_ALLOC_DEBUG
  {
    void *p = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
    if (p)
    {
      PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, p)
    }
    return p;
  }
  #else
  return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
  #endif
 }
 void MidFree(void *address)
 {
  PRINT_FREE("Free-Mid", g_allocCountMid, address)
  if (!address)
    return;
  VirtualFree(address, 0, MEM_RELEASE);
 }
 #ifdef Z7_LARGE_PAGES
 #ifdef MEM_LARGE_PAGES
  #define MY__MEM_LARGE_PAGES  MEM_LARGE_PAGES
 #else
  #define MY__MEM_LARGE_PAGES  0x20000000
 #endif
 extern
 SIZE_T g_LargePageSize;
 SIZE_T g_LargePageSize = 0;
 typedef SIZE_T (WINAPI *Func_GetLargePageMinimum)(VOID);
 void SetLargePageSize(void)
 {
  #ifdef Z7_LARGE_PAGES
  SIZE_T size;
  const
   Func_GetLargePageMinimum fn =
  (Func_GetLargePageMinimum) MY_CAST_FUNC GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
       "GetLargePageMinimum");
  if (!fn)
    return;
  size = fn();
  if (size == 0 || (size & (size - 1)) != 0)
    return;
  g_LargePageSize = size;
  #endif
 }
 #endif // Z7_LARGE_PAGES
 void *BigAlloc(size_t size)
 {
  if (size == 0)
    return NULL;
  PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL)
  #ifdef Z7_LARGE_PAGES
  {
    SIZE_T ps = g_LargePageSize;
    if (ps != 0 && ps <= (1 << 30) && size > (ps / 2))
    {
      size_t size2;
      ps--;
      size2 = (size + ps) & ~ps;
      if (size2 >= size)
      {
        void *p = VirtualAlloc(NULL, size2, MEM_COMMIT | MY__MEM_LARGE_PAGES, PAGE_READWRITE);
        if (p)
        {
          PRINT_ALLOC("Alloc-BM ", g_allocCountMid, size2, p)
          return p;
        }
      }
    }
  }
  #endif
  return MidAlloc(size);
 }
 void BigFree(void *address)
 {
  PRINT_FREE("Free-Big", g_allocCountBig, address)
  MidFree(address);
 }
 #endif // _WIN32
 static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p)  return MyAlloc(size); }
 static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p)  MyFree(address); }
 const ISzAlloc g_Alloc = { SzAlloc, SzFree };
 #ifdef _WIN32
 static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p)  return MidAlloc(size); }
 static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p)  MidFree(address); }
 static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p)  return BigAlloc(size); }
 static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p)  BigFree(address); }
 const ISzAlloc g_MidAlloc = { SzMidAlloc, SzMidFree };
 const ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
 #endif
 /*
  uintptr_t : <stdint.h> C99 (optional)
            : unsupported in VS6
 */
 #ifdef _WIN32
  typedef UINT_PTR UIntPtr;
 #else
  /*
  typedef uintptr_t UIntPtr;
  */
  typedef ptrdiff_t UIntPtr;
 #endif
 #define ADJUST_ALLOC_SIZE 0
 /*
 #define ADJUST_ALLOC_SIZE (sizeof(void *) - 1)
 */
 /*
  Use (ADJUST_ALLOC_SIZE = (sizeof(void *) - 1)), if
     MyAlloc() can return address that is NOT multiple of sizeof(void *).
 */
 /*
 #define MY_ALIGN_PTR_DOWN(p, align) ((void *)((char *)(p) - ((size_t)(UIntPtr)(p) & ((align) - 1))))
 */
 #define MY_ALIGN_PTR_DOWN(p, align) ((void *)((((UIntPtr)(p)) & ~((UIntPtr)(align) - 1))))
 #if !defined(_WIN32) && defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)
  #define USE_posix_memalign
 #endif
 #ifndef USE_posix_memalign
 #define MY_ALIGN_PTR_UP_PLUS(p, align) MY_ALIGN_PTR_DOWN(((char *)(p) + (align) + ADJUST_ALLOC_SIZE), align)
 #endif
 /*
  This posix_memalign() is for test purposes only.
  We also need special Free() function instead of free(),
  if this posix_memalign() is used.
 */
 /*
 static int posix_memalign(void **ptr, size_t align, size_t size)
 {
  size_t newSize = size + align;
  void *p;
  void *pAligned;
  *ptr = NULL;
  if (newSize < size)
    return 12; // ENOMEM
  p = MyAlloc(newSize);
  if (!p)
    return 12; // ENOMEM
  pAligned = MY_ALIGN_PTR_UP_PLUS(p, align);
  ((void **)pAligned)[-1] = p;
  *ptr = pAligned;
  return 0;
 }
 */
 /*
  ALLOC_ALIGN_SIZE >= sizeof(void *)
  ALLOC_ALIGN_SIZE >= cache_line_size
 */
 #define ALLOC_ALIGN_SIZE ((size_t)1 << 7)
 static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
 {
  #ifndef USE_posix_memalign
  void *p;
  void *pAligned;
  size_t newSize;
  UNUSED_VAR(pp)
  /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
     block to prevent cache line sharing with another allocated blocks */
  newSize = size + ALLOC_ALIGN_SIZE * 1 + ADJUST_ALLOC_SIZE;
  if (newSize < size)
    return NULL;
  p = MyAlloc(newSize);
  if (!p)
    return NULL;
  pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE);
  Print(" size="); PrintHex(size, 8);
  Print(" a_size="); PrintHex(newSize, 8);
  Print(" ptr="); PrintAddr(p);
  Print(" a_ptr="); PrintAddr(pAligned);
  PrintLn();
  ((void **)pAligned)[-1] = p;
  return pAligned;
  #else
  void *p;
  UNUSED_VAR(pp)
  if (posix_memalign(&p, ALLOC_ALIGN_SIZE, size))
    return NULL;
  Print(" posix_memalign="); PrintAddr(p);
  PrintLn();
  return p;
  #endif
 }
 static void SzAlignedFree(ISzAllocPtr pp, void *address)
 {
  UNUSED_VAR(pp)
  #ifndef USE_posix_memalign
  if (address)
    MyFree(((void **)address)[-1]);
  #else
  free(address);
  #endif
 }
 const ISzAlloc g_AlignedAlloc = { SzAlignedAlloc, SzAlignedFree };
 #define MY_ALIGN_PTR_DOWN_1(p) MY_ALIGN_PTR_DOWN(p, sizeof(void *))
 /* we align ptr to support cases where CAlignOffsetAlloc::offset is not multiply of sizeof(void *) */
 #define REAL_BLOCK_PTR_VAR(p) ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]
 /*
 #define REAL_BLOCK_PTR_VAR(p) ((void **)(p))[-1]
 */
 static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
 {
  const CAlignOffsetAlloc *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CAlignOffsetAlloc, vt);
  void *adr;
  void *pAligned;
  size_t newSize;
  size_t extra;
  size_t alignSize = (size_t)1 << p->numAlignBits;
  if (alignSize < sizeof(void *))
    alignSize = sizeof(void *);
  if (p->offset >= alignSize)
    return NULL;
  /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
     block to prevent cache line sharing with another allocated blocks */
  extra = p->offset & (sizeof(void *) - 1);
  newSize = size + alignSize + extra + ADJUST_ALLOC_SIZE;
  if (newSize < size)
    return NULL;
  adr = ISzAlloc_Alloc(p->baseAlloc, newSize);
  if (!adr)
    return NULL;
  pAligned = (char *)MY_ALIGN_PTR_DOWN((char *)adr +
      alignSize - p->offset + extra + ADJUST_ALLOC_SIZE, alignSize) + p->offset;
  PrintLn();
  Print("- Aligned: ");
  Print(" size="); PrintHex(size, 8);
  Print(" a_size="); PrintHex(newSize, 8);
  Print(" ptr="); PrintAddr(adr);
  Print(" a_ptr="); PrintAddr(pAligned);
  PrintLn();
  REAL_BLOCK_PTR_VAR(pAligned) = adr;
  return pAligned;
 }
 static void AlignOffsetAlloc_Free(ISzAllocPtr pp, void *address)
 {
  if (address)
  {
    const CAlignOffsetAlloc *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CAlignOffsetAlloc, vt);
    PrintLn();
    Print("- Aligned Free: ");
    PrintLn();
    ISzAlloc_Free(p->baseAlloc, REAL_BLOCK_PTR_VAR(address));
  }
 }
 void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p)
 {
  p->vt.Alloc = AlignOffsetAlloc_Alloc;
  p->vt.Free = AlignOffsetAlloc_Free;
 }
--- a/3rdparty/7z/src/Alloc.h
+++ b/3rdparty/7z/src/Alloc.h
@ -0,0 +1,71 @@
 /* Alloc.h -- Memory allocation functions
 2023-03-04 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_ALLOC_H
 #define ZIP7_INC_ALLOC_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 /*
  MyFree(NULL)        : is allowed, as free(NULL)
  MyAlloc(0)          : returns NULL : but malloc(0)        is allowed to return NULL or non_NULL
  MyRealloc(NULL, 0)  : returns NULL : but realloc(NULL, 0) is allowed to return NULL or non_NULL
 MyRealloc() is similar to realloc() for the following cases:
  MyRealloc(non_NULL, 0)         : returns NULL and always calls MyFree(ptr)
  MyRealloc(NULL, non_ZERO)      : returns NULL, if allocation failed
  MyRealloc(non_NULL, non_ZERO)  : returns NULL, if reallocation failed
 */
 void *MyAlloc(size_t size);
 void MyFree(void *address);
 void *MyRealloc(void *address, size_t size);
 #ifdef _WIN32
 #ifdef Z7_LARGE_PAGES
 void SetLargePageSize(void);
 #endif
 void *MidAlloc(size_t size);
 void MidFree(void *address);
 void *BigAlloc(size_t size);
 void BigFree(void *address);
 #else
 #define MidAlloc(size) MyAlloc(size)
 #define MidFree(address) MyFree(address)
 #define BigAlloc(size) MyAlloc(size)
 #define BigFree(address) MyFree(address)
 #endif
 extern const ISzAlloc g_Alloc;
 #ifdef _WIN32
 extern const ISzAlloc g_BigAlloc;
 extern const ISzAlloc g_MidAlloc;
 #else
 #define g_BigAlloc g_AlignedAlloc
 #define g_MidAlloc g_AlignedAlloc
 #endif
 extern const ISzAlloc g_AlignedAlloc;
 typedef struct
 {
  ISzAlloc vt;
  ISzAllocPtr baseAlloc;
  unsigned numAlignBits; /* ((1 << numAlignBits) >= sizeof(void *)) */
  size_t offset;         /* (offset == (k * sizeof(void *)) && offset < (1 << numAlignBits) */
 } CAlignOffsetAlloc;
 void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Bcj2.c
+++ b/3rdparty/7z/src/Bcj2.c
@ -0,0 +1,290 @@
 /* Bcj2.c -- BCJ2 Decoder (Converter for x86 code)
 2023-03-01 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "Bcj2.h"
 #include "CpuArch.h"
 #define kTopValue ((UInt32)1 << 24)
 #define kNumBitModelTotalBits 11
 #define kBitModelTotal (1 << kNumBitModelTotalBits)
 #define kNumMoveBits 5
 // UInt32 bcj2_stats[256 + 2][2];
 void Bcj2Dec_Init(CBcj2Dec *p)
 {
  unsigned i;
  p->state = BCJ2_STREAM_RC; // BCJ2_DEC_STATE_OK;
  p->ip = 0;
  p->temp = 0;
  p->range = 0;
  p->code = 0;
  for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
    p->probs[i] = kBitModelTotal >> 1;
 }
 SRes Bcj2Dec_Decode(CBcj2Dec *p)
 {
  UInt32 v = p->temp;
  // const Byte *src;
  if (p->range <= 5)
  {
    UInt32 code = p->code;
    p->state = BCJ2_DEC_STATE_ERROR; /* for case if we return SZ_ERROR_DATA; */
    for (; p->range != 5; p->range++)
    {
      if (p->range == 1 && code != 0)
        return SZ_ERROR_DATA;
      if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])
      {
        p->state = BCJ2_STREAM_RC;
        return SZ_OK;
      }
      code = (code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
      p->code = code;
    }
    if (code == 0xffffffff)
      return SZ_ERROR_DATA;
    p->range = 0xffffffff;
  }
  // else
  {
    unsigned state = p->state;
    // we check BCJ2_IS_32BIT_STREAM() here instead of check in the main loop
    if (BCJ2_IS_32BIT_STREAM(state))
    {
      const Byte *cur = p->bufs[state];
      if (cur == p->lims[state])
        return SZ_OK;
      p->bufs[state] = cur + 4;
      {
        const UInt32 ip = p->ip + 4;
        v = GetBe32a(cur) - ip;
        p->ip = ip;
      }
      state = BCJ2_DEC_STATE_ORIG_0;
    }
    if ((unsigned)(state - BCJ2_DEC_STATE_ORIG_0) < 4)
    {
      Byte *dest = p->dest;
      for (;;)
      {
        if (dest == p->destLim)
        {
          p->state = state;
          p->temp = v;
          return SZ_OK;
        }
        *dest++ = (Byte)v;
        p->dest = dest;
        if (++state == BCJ2_DEC_STATE_ORIG_3 + 1)
          break;
        v >>= 8;
      }
    }
  }
  // src = p->bufs[BCJ2_STREAM_MAIN];
  for (;;)
  {
    /*
    if (BCJ2_IS_32BIT_STREAM(p->state))
      p->state = BCJ2_DEC_STATE_OK;
    else
    */
    {
      if (p->range < kTopValue)
      {
        if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])
        {
          p->state = BCJ2_STREAM_RC;
          p->temp = v;
          return SZ_OK;
        }
        p->range <<= 8;
        p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
      }
      {
        const Byte *src = p->bufs[BCJ2_STREAM_MAIN];
        const Byte *srcLim;
        Byte *dest = p->dest;
        {
          const SizeT rem = (SizeT)(p->lims[BCJ2_STREAM_MAIN] - src);
          SizeT num = (SizeT)(p->destLim - dest);
          if (num >= rem)
            num = rem;
        #define NUM_ITERS 4
        #if (NUM_ITERS & (NUM_ITERS - 1)) == 0
          num &= ~((SizeT)NUM_ITERS - 1);   // if (NUM_ITERS == (1 << x))
        #else
          num -= num % NUM_ITERS; // if (NUM_ITERS != (1 << x))
        #endif
          srcLim = src + num;
        }
        #define NUM_SHIFT_BITS  24
        #define ONE_ITER(indx) { \
          const unsigned b = src[indx]; \
          *dest++ = (Byte)b; \
          v = (v << NUM_SHIFT_BITS) | b; \
          if (((b + (0x100 - 0xe8)) & 0xfe) == 0) break; \
          if (((v - (((UInt32)0x0f << (NUM_SHIFT_BITS)) + 0x80)) & \
              ((((UInt32)1 << (4 + NUM_SHIFT_BITS)) - 0x1) << 4)) == 0) break; \
            /* ++dest */; /* v = b; */ }
        if (src != srcLim)
        for (;;)
        {
            /* The dependency chain of 2-cycle for (v) calculation is not big problem here.
               But we can remove dependency chain with v = b in the end of loop. */
          ONE_ITER(0)
          #if (NUM_ITERS > 1)
            ONE_ITER(1)
          #if (NUM_ITERS > 2)
            ONE_ITER(2)
          #if (NUM_ITERS > 3)
            ONE_ITER(3)
          #if (NUM_ITERS > 4)
            ONE_ITER(4)
          #if (NUM_ITERS > 5)
            ONE_ITER(5)
          #if (NUM_ITERS > 6)
            ONE_ITER(6)
          #if (NUM_ITERS > 7)
            ONE_ITER(7)
          #endif
          #endif
          #endif
          #endif
          #endif
          #endif
          #endif
          src += NUM_ITERS;
          if (src == srcLim)
            break;
        }
        if (src == srcLim)
      #if (NUM_ITERS > 1)
        for (;;)
      #endif
        {
        #if (NUM_ITERS > 1)
          if (src == p->lims[BCJ2_STREAM_MAIN] || dest == p->destLim)
        #endif
          {
            const SizeT num = (SizeT)(src - p->bufs[BCJ2_STREAM_MAIN]);
            p->bufs[BCJ2_STREAM_MAIN] = src;
            p->dest = dest;
            p->ip += (UInt32)num;
            /* state BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */
            p->state =
              src == p->lims[BCJ2_STREAM_MAIN] ?
                (unsigned)BCJ2_STREAM_MAIN :
                (unsigned)BCJ2_DEC_STATE_ORIG;
            p->temp = v;
            return SZ_OK;
          }
        #if (NUM_ITERS > 1)
          ONE_ITER(0)
          src++;
        #endif
        }
        {
          const SizeT num = (SizeT)(dest - p->dest);
          p->dest = dest; // p->dest += num;
          p->bufs[BCJ2_STREAM_MAIN] += num; // = src;
          p->ip += (UInt32)num;
        }
        {
          UInt32 bound, ttt;
          CBcj2Prob *prob; // unsigned index;
          /*
          prob = p->probs + (unsigned)((Byte)v == 0xe8 ?
              2 + (Byte)(v >> 8) :
              ((v >> 5) & 1));  // ((Byte)v < 0xe8 ? 0 : 1));
          */
          {
            const unsigned c = ((v + 0x17) >> 6) & 1;
            prob = p->probs + (unsigned)
                (((0 - c) & (Byte)(v >> NUM_SHIFT_BITS)) + c + ((v >> 5) & 1));
                // (Byte)
                // 8x->0     : e9->1     : xxe8->xx+2
                // 8x->0x100 : e9->0x101 : xxe8->xx
                // (((0x100 - (e & ~v)) & (0x100 | (v >> 8))) + (e & v));
                // (((0x101 + (~e | v)) & (0x100 | (v >> 8))) + (e & v));
          }
          ttt = *prob;
          bound = (p->range >> kNumBitModelTotalBits) * ttt;
          if (p->code < bound)
          {
            // bcj2_stats[prob - p->probs][0]++;
            p->range = bound;
            *prob = (CBcj2Prob)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
            continue;
          }
          {
            // bcj2_stats[prob - p->probs][1]++;
            p->range -= bound;
            p->code -= bound;
            *prob = (CBcj2Prob)(ttt - (ttt >> kNumMoveBits));
          }
        }
      }
    }
    {
      /* (v == 0xe8 ? 0 : 1) uses setcc instruction with additional zero register usage in x64 MSVC. */
      // const unsigned cj = ((Byte)v == 0xe8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
      const unsigned cj = (((v + 0x57) >> 6) & 1) + BCJ2_STREAM_CALL;
      const Byte *cur = p->bufs[cj];
      Byte *dest;
      SizeT rem;
      if (cur == p->lims[cj])
      {
        p->state = cj;
        break;
      }
      v = GetBe32a(cur);
      p->bufs[cj] = cur + 4;
      {
        const UInt32 ip = p->ip + 4;
        v -= ip;
        p->ip = ip;
      }
      dest = p->dest;
      rem = (SizeT)(p->destLim - dest);
      if (rem < 4)
      {
        if ((unsigned)rem > 0) { dest[0] = (Byte)v;  v >>= 8;
        if ((unsigned)rem > 1) { dest[1] = (Byte)v;  v >>= 8;
        if ((unsigned)rem > 2) { dest[2] = (Byte)v;  v >>= 8; }}}
        p->temp = v;
        p->dest = dest + rem;
        p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;
        break;
      }
      SetUi32(dest, v)
      v >>= 24;
      p->dest = dest + 4;
    }
  }
  if (p->range < kTopValue && p->bufs[BCJ2_STREAM_RC] != p->lims[BCJ2_STREAM_RC])
  {
    p->range <<= 8;
    p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
  }
  return SZ_OK;
 }
 #undef NUM_ITERS
 #undef ONE_ITER
 #undef NUM_SHIFT_BITS
 #undef kTopValue
 #undef kNumBitModelTotalBits
 #undef kBitModelTotal
 #undef kNumMoveBits
--- a/3rdparty/7z/src/Bcj2.h
+++ b/3rdparty/7z/src/Bcj2.h
@ -0,0 +1,332 @@
 /* Bcj2.h -- BCJ2 converter for x86 code (Branch CALL/JUMP variant2)
 2023-03-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_BCJ2_H
 #define ZIP7_INC_BCJ2_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #define BCJ2_NUM_STREAMS 4
 enum
 {
  BCJ2_STREAM_MAIN,
  BCJ2_STREAM_CALL,
  BCJ2_STREAM_JUMP,
  BCJ2_STREAM_RC
 };
 enum
 {
  BCJ2_DEC_STATE_ORIG_0 = BCJ2_NUM_STREAMS,
  BCJ2_DEC_STATE_ORIG_1,
  BCJ2_DEC_STATE_ORIG_2,
  BCJ2_DEC_STATE_ORIG_3,
  BCJ2_DEC_STATE_ORIG,
  BCJ2_DEC_STATE_ERROR     /* after detected data error */
 };
 enum
 {
  BCJ2_ENC_STATE_ORIG = BCJ2_NUM_STREAMS,
  BCJ2_ENC_STATE_FINISHED  /* it's state after fully encoded stream */
 };
 /* #define BCJ2_IS_32BIT_STREAM(s) ((s) == BCJ2_STREAM_CALL || (s) == BCJ2_STREAM_JUMP) */
 #define BCJ2_IS_32BIT_STREAM(s) ((unsigned)((unsigned)(s) - (unsigned)BCJ2_STREAM_CALL) < 2)
 /*
 CBcj2Dec / CBcj2Enc
 bufs sizes:
  BUF_SIZE(n) = lims[n] - bufs[n]
 bufs sizes for BCJ2_STREAM_CALL and BCJ2_STREAM_JUMP must be multiply of 4:
    (BUF_SIZE(BCJ2_STREAM_CALL) & 3) == 0
    (BUF_SIZE(BCJ2_STREAM_JUMP) & 3) == 0
 */
 // typedef UInt32 CBcj2Prob;
 typedef UInt16 CBcj2Prob;
 /*
 BCJ2 encoder / decoder internal requirements:
  - If last bytes of stream contain marker (e8/e8/0f8x), then
    there is also encoded symbol (0 : no conversion) in RC stream.
  - One case of overlapped instructions is supported,
    if last byte of converted instruction is (0f) and next byte is (8x):
      marker [xx xx xx 0f] 8x
    then the pair (0f 8x) is treated as marker.
 */
 /* ---------- BCJ2 Decoder ---------- */
 /*
 CBcj2Dec:
 (dest) is allowed to overlap with bufs[BCJ2_STREAM_MAIN], with the following conditions:
  bufs[BCJ2_STREAM_MAIN] >= dest &&
  bufs[BCJ2_STREAM_MAIN] - dest >=
        BUF_SIZE(BCJ2_STREAM_CALL) +
        BUF_SIZE(BCJ2_STREAM_JUMP)
  reserve = bufs[BCJ2_STREAM_MAIN] - dest -
      ( BUF_SIZE(BCJ2_STREAM_CALL) +
        BUF_SIZE(BCJ2_STREAM_JUMP) )
  and additional conditions:
  if (it's first call of Bcj2Dec_Decode() after Bcj2Dec_Init())
  {
    (reserve != 1) : if (ver <  v23.00)
  }
  else // if there are more than one calls of Bcj2Dec_Decode() after Bcj2Dec_Init())
  {
    (reserve >= 6) : if (ver <  v23.00)
    (reserve >= 4) : if (ver >= v23.00)
    We need that (reserve) because after first call of Bcj2Dec_Decode(),
    CBcj2Dec::temp can contain up to 4 bytes for writing to (dest).
  }
  (reserve == 0) is allowed, if we decode full stream via single call of Bcj2Dec_Decode().
  (reserve == 0) also is allowed in case of multi-call, if we use fixed buffers,
     and (reserve) is calculated from full (final) sizes of all streams before first call.
 */
 typedef struct
 {
  const Byte *bufs[BCJ2_NUM_STREAMS];
  const Byte *lims[BCJ2_NUM_STREAMS];
  Byte *dest;
  const Byte *destLim;
  unsigned state; /* BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */
  UInt32 ip;      /* property of starting base for decoding */
  UInt32 temp;    /* Byte temp[4]; */
  UInt32 range;
  UInt32 code;
  CBcj2Prob probs[2 + 256];
 } CBcj2Dec;
 /* Note:
   Bcj2Dec_Init() sets (CBcj2Dec::ip = 0)
   if (ip != 0) property is required, the caller must set CBcj2Dec::ip after Bcj2Dec_Init()
 */
 void Bcj2Dec_Init(CBcj2Dec *p);
 /* Bcj2Dec_Decode():
   returns:
     SZ_OK
     SZ_ERROR_DATA : if data in 5 starting bytes of BCJ2_STREAM_RC stream are not correct
 */
 SRes Bcj2Dec_Decode(CBcj2Dec *p);
 /* To check that decoding was finished you can compare
   sizes of processed streams with sizes known from another sources.
   You must do at least one mandatory check from the two following options:
      - the check for size of processed output (ORIG) stream.
      - the check for size of processed input  (MAIN) stream.
   additional optional checks:
      - the checks for processed sizes of all input streams (MAIN, CALL, JUMP, RC)
      - the checks Bcj2Dec_IsMaybeFinished*()
   also before actual decoding you can check that the
   following condition is met for stream sizes:
     ( size(ORIG) == size(MAIN) + size(CALL) + size(JUMP) )
 */
 /* (state == BCJ2_STREAM_MAIN) means that decoder is ready for
      additional input data in BCJ2_STREAM_MAIN stream.
   Note that (state == BCJ2_STREAM_MAIN) is allowed for non-finished decoding.
 */
 #define Bcj2Dec_IsMaybeFinished_state_MAIN(_p_) ((_p_)->state == BCJ2_STREAM_MAIN)
 /* if the stream decoding was finished correctly, then range decoder
   part of CBcj2Dec also was finished, and then (CBcj2Dec::code == 0).
   Note that (CBcj2Dec::code == 0) is allowed for non-finished decoding.
 */
 #define Bcj2Dec_IsMaybeFinished_code(_p_) ((_p_)->code == 0)
 /* use Bcj2Dec_IsMaybeFinished() only as additional check
    after at least one mandatory check from the two following options:
      - the check for size of processed output (ORIG) stream.
      - the check for size of processed input  (MAIN) stream.
 */
 #define Bcj2Dec_IsMaybeFinished(_p_) ( \
        Bcj2Dec_IsMaybeFinished_state_MAIN(_p_) && \
        Bcj2Dec_IsMaybeFinished_code(_p_))
 /* ---------- BCJ2 Encoder ---------- */
 typedef enum
 {
  BCJ2_ENC_FINISH_MODE_CONTINUE,
  BCJ2_ENC_FINISH_MODE_END_BLOCK,
  BCJ2_ENC_FINISH_MODE_END_STREAM
 } EBcj2Enc_FinishMode;
 /*
  BCJ2_ENC_FINISH_MODE_CONTINUE:
     process non finished encoding.
     It notifies the encoder that additional further calls
     can provide more input data (src) than provided by current call.
     In  that case the CBcj2Enc encoder still can move (src) pointer
     up to (srcLim), but CBcj2Enc encoder can store some of the last
     processed bytes (up to 4 bytes) from src to internal CBcj2Enc::temp[] buffer.
   at return:
       (CBcj2Enc::src will point to position that includes
       processed data and data copied to (temp[]) buffer)
       That data from (temp[]) buffer will be used in further calls.
  BCJ2_ENC_FINISH_MODE_END_BLOCK:
     finish encoding of current block (ended at srcLim) without RC flushing.
   at return: if (CBcj2Enc::state == BCJ2_ENC_STATE_ORIG) &&
                  CBcj2Enc::src == CBcj2Enc::srcLim)
        :  it shows that block encoding was finished. And the encoder is
           ready for new (src) data or for stream finish operation.
     finished block means
     {
       CBcj2Enc has completed block encoding up to (srcLim).
       (1 + 4 bytes) or (2 + 4 bytes) CALL/JUMP cortages will
       not cross block boundary at (srcLim).
       temporary CBcj2Enc buffer for (ORIG) src data is empty.
       3 output uncompressed streams (MAIN, CALL, JUMP) were flushed.
       RC stream was not flushed. And RC stream will cross block boundary.
     }
     Note: some possible implementation of BCJ2 encoder could
     write branch marker (e8/e8/0f8x) in one call of Bcj2Enc_Encode(),
     and it could calculate symbol for RC in another call of Bcj2Enc_Encode().
     BCJ2 encoder uses ip/fileIp/fileSize/relatLimit values to calculate RC symbol.
     And these CBcj2Enc variables can have different values in different Bcj2Enc_Encode() calls.
     So caller must finish each block with BCJ2_ENC_FINISH_MODE_END_BLOCK
     to ensure that RC symbol is calculated and written in proper block.
  BCJ2_ENC_FINISH_MODE_END_STREAM
     finish encoding of stream (ended at srcLim) fully including RC flushing.
   at return: if (CBcj2Enc::state == BCJ2_ENC_STATE_FINISHED)
        : it shows that stream encoding was finished fully,
          and all output streams were flushed fully.
     also Bcj2Enc_IsFinished() can be called.
 */
 /*
  32-bit relative offset in JUMP/CALL commands is
    - (mod 4 GiB)  for 32-bit x86 code
    - signed Int32 for 64-bit x86-64 code
  BCJ2 encoder also does internal relative to absolute address conversions.
  And there are 2 possible ways to do it:
    before v23: we used 32-bit variables and (mod 4 GiB) conversion
    since  v23: we use  64-bit variables and (signed Int32 offset) conversion.
  The absolute address condition for conversion in v23:
    ((UInt64)((Int64)ip64 - (Int64)fileIp64 + 5 + (Int32)offset) < (UInt64)fileSize64)
  note that if (fileSize64 > 2 GiB). there is difference between
  old (mod 4 GiB) way (v22) and new (signed Int32 offset) way (v23).
  And new (v23) way is more suitable to encode 64-bit x86-64 code for (fileSize64 > 2 GiB) cases.
 */
 /*
 // for old (v22) way for conversion:
 typedef UInt32 CBcj2Enc_ip_unsigned;
 typedef  Int32 CBcj2Enc_ip_signed;
 #define BCJ2_ENC_FileSize_MAX ((UInt32)1 << 31)
 */
 typedef UInt64 CBcj2Enc_ip_unsigned;
 typedef  Int64 CBcj2Enc_ip_signed;
 /* maximum size of file that can be used for conversion condition */
 #define BCJ2_ENC_FileSize_MAX             ((CBcj2Enc_ip_unsigned)0 - 2)
 /* default value of fileSize64_minus1 variable that means
   that absolute address limitation will not be used */
 #define BCJ2_ENC_FileSizeField_UNLIMITED  ((CBcj2Enc_ip_unsigned)0 - 1)
 /* calculate value that later can be set to CBcj2Enc::fileSize64_minus1 */
 #define BCJ2_ENC_GET_FileSizeField_VAL_FROM_FileSize(fileSize) \
    ((CBcj2Enc_ip_unsigned)(fileSize) - 1)
 /* set CBcj2Enc::fileSize64_minus1 variable from size of file */
 #define Bcj2Enc_SET_FileSize(p, fileSize) \
    (p)->fileSize64_minus1 = BCJ2_ENC_GET_FileSizeField_VAL_FROM_FileSize(fileSize);
 typedef struct
 {
  Byte *bufs[BCJ2_NUM_STREAMS];
  const Byte *lims[BCJ2_NUM_STREAMS];
  const Byte *src;
  const Byte *srcLim;
  unsigned state;
  EBcj2Enc_FinishMode finishMode;
  Byte context;
  Byte flushRem;
  Byte isFlushState;
  Byte cache;
  UInt32 range;
  UInt64 low;
  UInt64 cacheSize;
  // UInt32 context;  // for marker version, it can include marker flag.
  /* (ip64) and (fileIp64) correspond to virtual source stream position
     that doesn't include data in temp[] */
  CBcj2Enc_ip_unsigned ip64;         /* current (ip) position */
  CBcj2Enc_ip_unsigned fileIp64;     /* start (ip) position of current file */
  CBcj2Enc_ip_unsigned fileSize64_minus1;   /* size of current file (for conversion limitation) */
  UInt32 relatLimit;  /* (relatLimit <= ((UInt32)1 << 31)) : 0 means disable_conversion */
  // UInt32 relatExcludeBits;
  UInt32 tempTarget;
  unsigned tempPos; /* the number of bytes that were copied to temp[] buffer
                       (tempPos <= 4) outside of Bcj2Enc_Encode() */
  // Byte temp[4]; // for marker version
  Byte temp[8];
  CBcj2Prob probs[2 + 256];
 } CBcj2Enc;
 void Bcj2Enc_Init(CBcj2Enc *p);
 /*
 Bcj2Enc_Encode(): at exit:
  p->State <  BCJ2_NUM_STREAMS    : we need more buffer space for output stream
                                    (bufs[p->State] == lims[p->State])
  p->State == BCJ2_ENC_STATE_ORIG : we need more data in input src stream
                                    (src == srcLim)
  p->State == BCJ2_ENC_STATE_FINISHED : after fully encoded stream
 */
 void Bcj2Enc_Encode(CBcj2Enc *p);
 /* Bcj2Enc encoder can look ahead for up 4 bytes of source stream.
   CBcj2Enc::tempPos : is the number of bytes that were copied from input stream to temp[] buffer.
   (CBcj2Enc::src) after Bcj2Enc_Encode() is starting position after
   fully processed data and after data copied to temp buffer.
   So if the caller needs to get real number of fully processed input
   bytes (without look ahead data in temp buffer),
   the caller must subtruct (CBcj2Enc::tempPos) value from processed size
   value that is calculated based on current (CBcj2Enc::src):
     cur_processed_pos = Calc_Big_Processed_Pos(enc.src)) -
        Bcj2Enc_Get_AvailInputSize_in_Temp(&enc);
 */
 /* get the size of input data that was stored in temp[] buffer: */
 #define Bcj2Enc_Get_AvailInputSize_in_Temp(p) ((p)->tempPos)
 #define Bcj2Enc_IsFinished(p) ((p)->flushRem == 0)
 /* Note : the decoder supports overlapping of marker (0f 80).
   But we can eliminate such overlapping cases by setting
   the limit for relative offset conversion as
     CBcj2Enc::relatLimit <= (0x0f << 24) == (240 MiB)
 */
 /* default value for CBcj2Enc::relatLimit */
 #define BCJ2_ENC_RELAT_LIMIT_DEFAULT  ((UInt32)0x0f << 24)
 #define BCJ2_ENC_RELAT_LIMIT_MAX      ((UInt32)1 << 31)
 // #define BCJ2_RELAT_EXCLUDE_NUM_BITS 5
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Bcj2Enc.c
+++ b/3rdparty/7z/src/Bcj2Enc.c
@ -0,0 +1,506 @@
 /* Bcj2Enc.c -- BCJ2 Encoder converter for x86 code (Branch CALL/JUMP variant2)
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 /* #define SHOW_STAT */
 #ifdef SHOW_STAT
 #include <stdio.h>
 #define PRF2(s) printf("%s ip=%8x  tempPos=%d  src= %8x\n", s, (unsigned)p->ip64, p->tempPos, (unsigned)(p->srcLim - p->src));
 #else
 #define PRF2(s)
 #endif
 #include "Bcj2.h"
 #include "CpuArch.h"
 #define kTopValue ((UInt32)1 << 24)
 #define kNumBitModelTotalBits 11
 #define kBitModelTotal (1 << kNumBitModelTotalBits)
 #define kNumMoveBits 5
 void Bcj2Enc_Init(CBcj2Enc *p)
 {
  unsigned i;
  p->state = BCJ2_ENC_STATE_ORIG;
  p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
  p->context = 0;
  p->flushRem = 5;
  p->isFlushState = 0;
  p->cache = 0;
  p->range = 0xffffffff;
  p->low = 0;
  p->cacheSize = 1;
  p->ip64 = 0;
  p->fileIp64 = 0;
  p->fileSize64_minus1 = BCJ2_ENC_FileSizeField_UNLIMITED;
  p->relatLimit = BCJ2_ENC_RELAT_LIMIT_DEFAULT;
  // p->relatExcludeBits = 0;
  p->tempPos = 0;
  for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
    p->probs[i] = kBitModelTotal >> 1;
 }
 // Z7_NO_INLINE
 Z7_FORCE_INLINE
 static BoolInt Bcj2_RangeEnc_ShiftLow(CBcj2Enc *p)
 {
  const UInt32 low = (UInt32)p->low;
  const unsigned high = (unsigned)
    #if defined(Z7_MSC_VER_ORIGINAL) \
        && defined(MY_CPU_X86) \
        && defined(MY_CPU_LE) \
        && !defined(MY_CPU_64BIT)
      // we try to rid of __aullshr() call in MSVS-x86
      (((const UInt32 *)&p->low)[1]); // [1] : for little-endian only
    #else
      (p->low >> 32);
    #endif
  if (low < (UInt32)0xff000000 || high != 0)
  {
    Byte *buf = p->bufs[BCJ2_STREAM_RC];
    do
    {
      if (buf == p->lims[BCJ2_STREAM_RC])
      {
        p->state = BCJ2_STREAM_RC;
        p->bufs[BCJ2_STREAM_RC] = buf;
        return True;
      }
      *buf++ = (Byte)(p->cache + high);
      p->cache = 0xff;
    }
    while (--p->cacheSize);
    p->bufs[BCJ2_STREAM_RC] = buf;
    p->cache = (Byte)(low >> 24);
  }
  p->cacheSize++;
  p->low = low << 8;
  return False;
 }
 /*
 We can use 2 alternative versions of code:
 1) non-marker version:
  Byte CBcj2Enc::context
  Byte temp[8];
  Last byte of marker (e8/e9/[0f]8x) can be written to temp[] buffer.
  Encoder writes last byte of marker (e8/e9/[0f]8x) to dest, only in conjunction
  with writing branch symbol to range coder in same Bcj2Enc_Encode_2() call.
 2) marker version:
  UInt32 CBcj2Enc::context
  Byte CBcj2Enc::temp[4];
  MARKER_FLAG in CBcj2Enc::context shows that CBcj2Enc::context contains finded marker.
  it's allowed that
    one call of Bcj2Enc_Encode_2() writes last byte of marker (e8/e9/[0f]8x) to dest,
    and another call of Bcj2Enc_Encode_2() does offset conversion.
    So different values of (fileIp) and (fileSize) are possible
    in these different Bcj2Enc_Encode_2() calls.
 Also marker version requires additional if((v & MARKER_FLAG) == 0) check in main loop.
 So we use non-marker version.
 */
 /*
  Corner cases with overlap in multi-block.
  before v23: there was one corner case, where converted instruction
    could start in one sub-stream and finish in next sub-stream.
  If multi-block (solid) encoding is used,
    and BCJ2_ENC_FINISH_MODE_END_BLOCK is used for each sub-stream.
    and (0f) is last byte of previous sub-stream
    and (8x) is first byte of current sub-stream
  then (0f 8x) pair is treated as marker by BCJ2 encoder and decoder.
  BCJ2 encoder can converts 32-bit offset for that (0f 8x) cortage,
  if that offset meets limit requirements.
  If encoder allows 32-bit offset conversion for such overlap case,
  then the data in 3 uncompressed BCJ2 streams for some sub-stream
  can depend from data of previous sub-stream.
  That corner case is not big problem, and it's rare case.
  Since v23.00 we do additional check to prevent conversions in such overlap cases.
 */
 /*
  Bcj2Enc_Encode_2() output variables at exit:
  {
    if (Bcj2Enc_Encode_2() exits with (p->state == BCJ2_ENC_STATE_ORIG))
    {
      it means that encoder needs more input data.
      if (p->srcLim == p->src) at exit, then
      {
        (p->finishMode != BCJ2_ENC_FINISH_MODE_END_STREAM)
        all input data were read and processed, and we are ready for
        new input data.
      }
      else
      {
        (p->srcLim != p->src)
        (p->finishMode == BCJ2_ENC_FINISH_MODE_CONTINUE)
          The encoder have found e8/e9/0f_8x marker,
          and p->src points to last byte of that marker,
          Bcj2Enc_Encode_2() needs more input data to get totally
          5 bytes (last byte of marker and 32-bit branch offset)
          as continuous array starting from p->src.
        (p->srcLim - p->src < 5) requirement is met after exit.
          So non-processed resedue from p->src to p->srcLim is always less than 5 bytes.
      }
    }
  }
 */
 Z7_NO_INLINE
 static void Bcj2Enc_Encode_2(CBcj2Enc *p)
 {
  if (!p->isFlushState)
  {
    const Byte *src;
    UInt32 v;
    {
      const unsigned state = p->state;
      if (BCJ2_IS_32BIT_STREAM(state))
      {
        Byte *cur = p->bufs[state];
        if (cur == p->lims[state])
          return;
        SetBe32a(cur, p->tempTarget)
        p->bufs[state] = cur + 4;
      }
    }
    p->state = BCJ2_ENC_STATE_ORIG; // for main reason of exit
    src = p->src;
    v = p->context;
    // #define WRITE_CONTEXT  p->context = v; // for marker version
    #define WRITE_CONTEXT           p->context = (Byte)v;
    #define WRITE_CONTEXT_AND_SRC   p->src = src;  WRITE_CONTEXT
    for (;;)
    {
      // const Byte *src;
      // UInt32 v;
      CBcj2Enc_ip_unsigned ip;
      if (p->range < kTopValue)
      {
        // to reduce register pressure and code size: we save and restore local variables.
        WRITE_CONTEXT_AND_SRC
        if (Bcj2_RangeEnc_ShiftLow(p))
          return;
        p->range <<= 8;
        src = p->src;
        v = p->context;
      }
      // src = p->src;
      // #define MARKER_FLAG  ((UInt32)1 << 17)
      // if ((v & MARKER_FLAG) == 0) // for marker version
      {
        const Byte *srcLim;
        Byte *dest = p->bufs[BCJ2_STREAM_MAIN];
        {
          const SizeT remSrc = (SizeT)(p->srcLim - src);
          SizeT rem = (SizeT)(p->lims[BCJ2_STREAM_MAIN] - dest);
          if (rem >= remSrc)
            rem = remSrc;
          srcLim = src + rem;
        }
        /* p->context contains context of previous byte:
           bits [0 : 7]  : src[-1], if (src) was changed in this call
           bits [8 : 31] : are undefined for non-marker version
        */
        // v = p->context;
        #define NUM_SHIFT_BITS  24
        #define CONV_FLAG  ((UInt32)1 << 16)
        #define ONE_ITER { \
          b = src[0]; \
          *dest++ = (Byte)b; \
          v = (v << NUM_SHIFT_BITS) | b; \
          if (((b + (0x100 - 0xe8)) & 0xfe) == 0) break; \
          if (((v - (((UInt32)0x0f << (NUM_SHIFT_BITS)) + 0x80)) & \
              ((((UInt32)1 << (4 + NUM_SHIFT_BITS)) - 0x1) << 4)) == 0) break; \
          src++; if (src == srcLim) { break; } }
        if (src != srcLim)
        for (;;)
        {
          /* clang can generate ineffective code with setne instead of two jcc instructions.
             we can use 2 iterations and external (unsigned b) to avoid that ineffective code genaration. */
          unsigned b;
          ONE_ITER
          ONE_ITER
        }
        ip = p->ip64 + (CBcj2Enc_ip_unsigned)(SizeT)(dest - p->bufs[BCJ2_STREAM_MAIN]);
        p->bufs[BCJ2_STREAM_MAIN] = dest;
        p->ip64 = ip;
        if (src == srcLim)
        {
          WRITE_CONTEXT_AND_SRC
          if (src != p->srcLim)
          {
            p->state = BCJ2_STREAM_MAIN;
            return;
          }
          /* (p->src == p->srcLim)
          (p->state == BCJ2_ENC_STATE_ORIG) */
          if (p->finishMode != BCJ2_ENC_FINISH_MODE_END_STREAM)
            return;
          /* (p->finishMode == BCJ2_ENC_FINISH_MODE_END_STREAM */
          // (p->flushRem == 5);
          p->isFlushState = 1;
          break;
        }
        src++;
        // p->src = src;
      }
      // ip = p->ip; // for marker version
      /* marker was found */
      /* (v) contains marker that was found:
           bits [NUM_SHIFT_BITS : NUM_SHIFT_BITS + 7]
                         : value of src[-2] : xx/xx/0f
           bits [0 : 7]  : value of src[-1] : e8/e9/8x
      */
      {
        {
        #if NUM_SHIFT_BITS != 24
          v &= ~(UInt32)CONV_FLAG;
        #endif
          // UInt32 relat = 0;
          if ((SizeT)(p->srcLim - src) >= 4)
          {
            /*
            if (relat != 0 || (Byte)v != 0xe8)
            BoolInt isBigOffset = True;
            */
            const UInt32 relat = GetUi32(src);
            /*
            #define EXCLUDE_FLAG  ((UInt32)1 << 4)
            #define NEED_CONVERT(rel) ((((rel) + EXCLUDE_FLAG) & (0 - EXCLUDE_FLAG * 2)) != 0)
            if (p->relatExcludeBits != 0)
            {
              const UInt32 flag = (UInt32)1 << (p->relatExcludeBits - 1);
              isBigOffset = (((relat + flag) & (0 - flag * 2)) != 0);
            }
            // isBigOffset = False; // for debug
            */
            ip -= p->fileIp64;
            // Use the following if check, if (ip) is 64-bit:
            if (ip > (((v + 0x20) >> 5) & 1))  // 23.00 : we eliminate milti-block overlap for (Of 80) and (e8/e9)
            if ((CBcj2Enc_ip_unsigned)((CBcj2Enc_ip_signed)ip + 4 + (Int32)relat) <= p->fileSize64_minus1)
            if (((UInt32)(relat + p->relatLimit) >> 1) < p->relatLimit)
              v |= CONV_FLAG;
          }
          else if (p->finishMode == BCJ2_ENC_FINISH_MODE_CONTINUE)
          {
            // (p->srcLim - src < 4)
            // /*
            // for non-marker version
            p->ip64--; // p->ip = ip - 1;
            p->bufs[BCJ2_STREAM_MAIN]--;
            src--;
            v >>= NUM_SHIFT_BITS;
            // (0 < p->srcLim - p->src <= 4)
            // */
            // v |= MARKER_FLAG; // for marker version
            /* (p->state == BCJ2_ENC_STATE_ORIG) */
            WRITE_CONTEXT_AND_SRC
            return;
          }
          {
            const unsigned c = ((v + 0x17) >> 6) & 1;
            CBcj2Prob *prob = p->probs + (unsigned)
                (((0 - c) & (Byte)(v >> NUM_SHIFT_BITS)) + c + ((v >> 5) & 1));
            /*
                ((Byte)v == 0xe8 ? 2 + ((Byte)(v >> 8)) :
                ((Byte)v < 0xe8 ? 0 : 1));  // ((v >> 5) & 1));
            */
            const unsigned ttt = *prob;
            const UInt32 bound = (p->range >> kNumBitModelTotalBits) * ttt;
            if ((v & CONV_FLAG) == 0)
            {
              // static int yyy = 0; yyy++; printf("\n!needConvert = %d\n", yyy);
              // v = (Byte)v; // for marker version
              p->range = bound;
              *prob = (CBcj2Prob)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
              // WRITE_CONTEXT_AND_SRC
              continue;
            }
            p->low += bound;
            p->range -= bound;
            *prob = (CBcj2Prob)(ttt - (ttt >> kNumMoveBits));
          }
          // p->context = src[3];
          {
            // const unsigned cj = ((Byte)v == 0xe8 ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP);
            const unsigned cj = (((v + 0x57) >> 6) & 1) + BCJ2_STREAM_CALL;
            ip = p->ip64;
            v = GetUi32(src); // relat
            ip += 4;
            p->ip64 = ip;
            src += 4;
            // p->src = src;
            {
              const UInt32 absol = (UInt32)ip + v;
              Byte *cur = p->bufs[cj];
              v >>= 24;
              // WRITE_CONTEXT
              if (cur == p->lims[cj])
              {
                p->state = cj;
                p->tempTarget = absol;
                WRITE_CONTEXT_AND_SRC
                return;
              }
              SetBe32a(cur, absol)
              p->bufs[cj] = cur + 4;
            }
          }
        }
      }
    } // end of loop
  }
  for (; p->flushRem != 0; p->flushRem--)
    if (Bcj2_RangeEnc_ShiftLow(p))
      return;
  p->state = BCJ2_ENC_STATE_FINISHED;
 }
 /*
 BCJ2 encoder needs look ahead for up to 4 bytes in (src) buffer.
 So base function Bcj2Enc_Encode_2()
  in BCJ2_ENC_FINISH_MODE_CONTINUE mode can return with
  (p->state == BCJ2_ENC_STATE_ORIG && p->src < p->srcLim)
 Bcj2Enc_Encode() solves that look ahead problem by using p->temp[] buffer.
  so if (p->state == BCJ2_ENC_STATE_ORIG) after Bcj2Enc_Encode(),
    then (p->src == p->srcLim).
  And the caller's code is simpler with Bcj2Enc_Encode().
 */
 Z7_NO_INLINE
 void Bcj2Enc_Encode(CBcj2Enc *p)
 {
  PRF2("\n----")
  if (p->tempPos != 0)
  {
    /* extra: number of bytes that were copied from (src) to (temp) buffer in this call */
    unsigned extra = 0;
    /* We will touch only minimal required number of bytes in input (src) stream.
       So we will add input bytes from (src) stream to temp[] with step of 1 byte.
       We don't add new bytes to temp[] before Bcj2Enc_Encode_2() call
         in first loop iteration because
         - previous call of Bcj2Enc_Encode() could use another (finishMode),
         - previous call could finish with (p->state != BCJ2_ENC_STATE_ORIG).
       the case with full temp[] buffer (p->tempPos == 4) is possible here.
    */
    for (;;)
    {
      // (0 < p->tempPos <= 5) // in non-marker version
      /* p->src : the current src data position including extra bytes
                  that were copied to temp[] buffer in this call */
      const Byte *src = p->src;
      const Byte *srcLim = p->srcLim;
      const EBcj2Enc_FinishMode finishMode = p->finishMode;
      if (src != srcLim)
      {
        /* if there are some src data after the data copied to temp[],
           then we use MODE_CONTINUE for temp data */
        p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
      }
      p->src = p->temp;
      p->srcLim = p->temp + p->tempPos;
      PRF2("    ")
      Bcj2Enc_Encode_2(p);
      {
        const unsigned num = (unsigned)(p->src - p->temp);
        const unsigned tempPos = p->tempPos - num;
        unsigned i;
        p->tempPos = tempPos;
        for (i = 0; i < tempPos; i++)
          p->temp[i] = p->temp[(SizeT)i + num];
        // tempPos : number of bytes in temp buffer
        p->src = src;
        p->srcLim = srcLim;
        p->finishMode = finishMode;
        if (p->state != BCJ2_ENC_STATE_ORIG)
        {
          // (p->tempPos <= 4) // in non-marker version
          /* if (the reason of exit from Bcj2Enc_Encode_2()
                 is not BCJ2_ENC_STATE_ORIG),
             then we exit from Bcj2Enc_Encode() with same reason */
          // optional code begin : we rollback (src) and tempPos, if it's possible:
          if (extra >= tempPos)
            extra = tempPos;
          p->src = src - extra;
          p->tempPos = tempPos - extra;
          // optional code end : rollback of (src) and tempPos
          return;
        }
        /* (p->tempPos <= 4)
           (p->state == BCJ2_ENC_STATE_ORIG)
             so encoder needs more data than in temp[] */
        if (src == srcLim)
          return; // src buffer has no more input data.
        /* (src != srcLim)
           so we can provide more input data from src for Bcj2Enc_Encode_2() */
        if (extra >= tempPos)
        {
          /* (extra >= tempPos) means that temp buffer contains
             only data from src buffer of this call.
             So now we can encode without temp buffer */
          p->src = src - tempPos; // rollback (src)
          p->tempPos = 0;
          break;
        }
        // we append one additional extra byte from (src) to temp[] buffer:
        p->temp[tempPos] = *src;
        p->tempPos = tempPos + 1;
        // (0 < p->tempPos <= 5) // in non-marker version
        p->src = src + 1;
        extra++;
      }
    }
  }
  PRF2("++++")
  // (p->tempPos == 0)
  Bcj2Enc_Encode_2(p);
  PRF2("====")
  if (p->state == BCJ2_ENC_STATE_ORIG)
  {
    const Byte *src = p->src;
    const Byte *srcLim = p->srcLim;
    const unsigned rem = (unsigned)(srcLim - src);
    /* (rem <= 4) here.
       if (p->src != p->srcLim), then
         - we copy non-processed bytes from (p->src) to temp[] buffer,
         - we set p->src equal to p->srcLim.
    */
    if (rem)
    {
      unsigned i = 0;
      p->src = srcLim;
      p->tempPos = rem;
      // (0 < p->tempPos <= 4)
      do
        p->temp[i] = src[i];
      while (++i != rem);
    }
    // (p->tempPos <= 4)
    // (p->src == p->srcLim)
  }
 }
 #undef PRF2
 #undef CONV_FLAG
 #undef MARKER_FLAG
 #undef WRITE_CONTEXT
 #undef WRITE_CONTEXT_AND_SRC
 #undef ONE_ITER
 #undef NUM_SHIFT_BITS
 #undef kTopValue
 #undef kNumBitModelTotalBits
 #undef kBitModelTotal
 #undef kNumMoveBits
--- a/3rdparty/7z/src/Blake2.h
+++ b/3rdparty/7z/src/Blake2.h
@ -0,0 +1,48 @@
 /* Blake2.h -- BLAKE2 Hash
 2023-03-04 : Igor Pavlov : Public domain
 2015 : Samuel Neves : Public domain */
 #ifndef ZIP7_INC_BLAKE2_H
 #define ZIP7_INC_BLAKE2_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #define BLAKE2S_BLOCK_SIZE 64
 #define BLAKE2S_DIGEST_SIZE 32
 #define BLAKE2SP_PARALLEL_DEGREE 8
 typedef struct
 {
  UInt32 h[8];
  UInt32 t[2];
  UInt32 f[2];
  Byte buf[BLAKE2S_BLOCK_SIZE];
  UInt32 bufPos;
  UInt32 lastNode_f1;
  UInt32 dummy[2]; /* for sizeof(CBlake2s) alignment */
 } CBlake2s;
 /* You need to xor CBlake2s::h[i] with input parameter block after Blake2s_Init0() */
 /*
 void Blake2s_Init0(CBlake2s *p);
 void Blake2s_Update(CBlake2s *p, const Byte *data, size_t size);
 void Blake2s_Final(CBlake2s *p, Byte *digest);
 */
 typedef struct
 {
  CBlake2s S[BLAKE2SP_PARALLEL_DEGREE];
  unsigned bufPos;
 } CBlake2sp;
 void Blake2sp_Init(CBlake2sp *p);
 void Blake2sp_Update(CBlake2sp *p, const Byte *data, size_t size);
 void Blake2sp_Final(CBlake2sp *p, Byte *digest);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Blake2s.c
+++ b/3rdparty/7z/src/Blake2s.c
@ -0,0 +1,250 @@
 /* Blake2s.c -- BLAKE2s and BLAKE2sp Hash
 2023-03-04 : Igor Pavlov : Public domain
 2015 : Samuel Neves : Public domain */
 #include "Precomp.h"
 #include <string.h>
 #include "Blake2.h"
 #include "CpuArch.h"
 #include "RotateDefs.h"
 #define rotr32 rotrFixed
 #define BLAKE2S_NUM_ROUNDS 10
 #define BLAKE2S_FINAL_FLAG (~(UInt32)0)
 static const UInt32 k_Blake2s_IV[8] =
 {
  0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
  0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
 };
 static const Byte k_Blake2s_Sigma[BLAKE2S_NUM_ROUNDS][16] =
 {
  {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 } ,
  { 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 } ,
  { 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4 } ,
  {  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8 } ,
  {  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13 } ,
  {  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 } ,
  { 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11 } ,
  { 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10 } ,
  {  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5 } ,
  { 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 } ,
 };
 static void Blake2s_Init0(CBlake2s *p)
 {
  unsigned i;
  for (i = 0; i < 8; i++)
    p->h[i] = k_Blake2s_IV[i];
  p->t[0] = 0;
  p->t[1] = 0;
  p->f[0] = 0;
  p->f[1] = 0;
  p->bufPos = 0;
  p->lastNode_f1 = 0;
 }
 static void Blake2s_Compress(CBlake2s *p)
 {
  UInt32 m[16];
  UInt32 v[16];
  {
    unsigned i;
    for (i = 0; i < 16; i++)
      m[i] = GetUi32(p->buf + i * sizeof(m[i]));
    for (i = 0; i < 8; i++)
      v[i] = p->h[i];
  }
  v[ 8] = k_Blake2s_IV[0];
  v[ 9] = k_Blake2s_IV[1];
  v[10] = k_Blake2s_IV[2];
  v[11] = k_Blake2s_IV[3];
  v[12] = p->t[0] ^ k_Blake2s_IV[4];
  v[13] = p->t[1] ^ k_Blake2s_IV[5];
  v[14] = p->f[0] ^ k_Blake2s_IV[6];
  v[15] = p->f[1] ^ k_Blake2s_IV[7];
  #define G(r,i,a,b,c,d) \
    a += b + m[sigma[2*i+0]];  d ^= a; d = rotr32(d, 16);  c += d;  b ^= c; b = rotr32(b, 12); \
    a += b + m[sigma[2*i+1]];  d ^= a; d = rotr32(d,  8);  c += d;  b ^= c; b = rotr32(b,  7); \
  #define R(r) \
    G(r,0,v[ 0],v[ 4],v[ 8],v[12]) \
    G(r,1,v[ 1],v[ 5],v[ 9],v[13]) \
    G(r,2,v[ 2],v[ 6],v[10],v[14]) \
    G(r,3,v[ 3],v[ 7],v[11],v[15]) \
    G(r,4,v[ 0],v[ 5],v[10],v[15]) \
    G(r,5,v[ 1],v[ 6],v[11],v[12]) \
    G(r,6,v[ 2],v[ 7],v[ 8],v[13]) \
    G(r,7,v[ 3],v[ 4],v[ 9],v[14]) \
  {
    unsigned r;
    for (r = 0; r < BLAKE2S_NUM_ROUNDS; r++)
    {
      const Byte *sigma = k_Blake2s_Sigma[r];
      R(r)
    }
    /* R(0); R(1); R(2); R(3); R(4); R(5); R(6); R(7); R(8); R(9); */
  }
  #undef G
  #undef R
  {
    unsigned i;
    for (i = 0; i < 8; i++)
      p->h[i] ^= v[i] ^ v[i + 8];
  }
 }
 #define Blake2s_Increment_Counter(S, inc) \
  { p->t[0] += (inc); p->t[1] += (p->t[0] < (inc)); }
 #define Blake2s_Set_LastBlock(p) \
  { p->f[0] = BLAKE2S_FINAL_FLAG; p->f[1] = p->lastNode_f1; }
 static void Blake2s_Update(CBlake2s *p, const Byte *data, size_t size)
 {
  while (size != 0)
  {
    unsigned pos = (unsigned)p->bufPos;
    unsigned rem = BLAKE2S_BLOCK_SIZE - pos;
    if (size <= rem)
    {
      memcpy(p->buf + pos, data, size);
      p->bufPos += (UInt32)size;
      return;
    }
    memcpy(p->buf + pos, data, rem);
    Blake2s_Increment_Counter(S, BLAKE2S_BLOCK_SIZE)
    Blake2s_Compress(p);
    p->bufPos = 0;
    data += rem;
    size -= rem;
  }
 }
 static void Blake2s_Final(CBlake2s *p, Byte *digest)
 {
  unsigned i;
  Blake2s_Increment_Counter(S, (UInt32)p->bufPos)
  Blake2s_Set_LastBlock(p)
  memset(p->buf + p->bufPos, 0, BLAKE2S_BLOCK_SIZE - p->bufPos);
  Blake2s_Compress(p);
  for (i = 0; i < 8; i++)
  {
    SetUi32(digest + sizeof(p->h[i]) * i, p->h[i])
  }
 }
 /* ---------- BLAKE2s ---------- */
 /* we need to xor CBlake2s::h[i] with input parameter block after Blake2s_Init0() */
 /*
 typedef struct
 {
  Byte  digest_length;
  Byte  key_length;
  Byte  fanout;
  Byte  depth;
  UInt32 leaf_length;
  Byte  node_offset[6];
  Byte  node_depth;
  Byte  inner_length;
  Byte  salt[BLAKE2S_SALTBYTES];
  Byte  personal[BLAKE2S_PERSONALBYTES];
 } CBlake2sParam;
 */
 static void Blake2sp_Init_Spec(CBlake2s *p, unsigned node_offset, unsigned node_depth)
 {
  Blake2s_Init0(p);
  p->h[0] ^= (BLAKE2S_DIGEST_SIZE | ((UInt32)BLAKE2SP_PARALLEL_DEGREE << 16) | ((UInt32)2 << 24));
  p->h[2] ^= ((UInt32)node_offset);
  p->h[3] ^= ((UInt32)node_depth << 16) | ((UInt32)BLAKE2S_DIGEST_SIZE << 24);
  /*
  P->digest_length = BLAKE2S_DIGEST_SIZE;
  P->key_length = 0;
  P->fanout = BLAKE2SP_PARALLEL_DEGREE;
  P->depth = 2;
  P->leaf_length = 0;
  store48(P->node_offset, node_offset);
  P->node_depth = node_depth;
  P->inner_length = BLAKE2S_DIGEST_SIZE;
  */
 }
 void Blake2sp_Init(CBlake2sp *p)
 {
  unsigned i;
  p->bufPos = 0;
  for (i = 0; i < BLAKE2SP_PARALLEL_DEGREE; i++)
    Blake2sp_Init_Spec(&p->S[i], i, 0);
  p->S[BLAKE2SP_PARALLEL_DEGREE - 1].lastNode_f1 = BLAKE2S_FINAL_FLAG;
 }
 void Blake2sp_Update(CBlake2sp *p, const Byte *data, size_t size)
 {
  unsigned pos = p->bufPos;
  while (size != 0)
  {
    unsigned index = pos / BLAKE2S_BLOCK_SIZE;
    unsigned rem = BLAKE2S_BLOCK_SIZE - (pos & (BLAKE2S_BLOCK_SIZE - 1));
    if (rem > size)
      rem = (unsigned)size;
    Blake2s_Update(&p->S[index], data, rem);
    size -= rem;
    data += rem;
    pos += rem;
    pos &= (BLAKE2S_BLOCK_SIZE * BLAKE2SP_PARALLEL_DEGREE - 1);
  }
  p->bufPos = pos;
 }
 void Blake2sp_Final(CBlake2sp *p, Byte *digest)
 {
  CBlake2s R;
  unsigned i;
  Blake2sp_Init_Spec(&R, 0, 1);
  R.lastNode_f1 = BLAKE2S_FINAL_FLAG;
  for (i = 0; i < BLAKE2SP_PARALLEL_DEGREE; i++)
  {
    Byte hash[BLAKE2S_DIGEST_SIZE];
    Blake2s_Final(&p->S[i], hash);
    Blake2s_Update(&R, hash, BLAKE2S_DIGEST_SIZE);
  }
  Blake2s_Final(&R, digest);
 }
 #undef rotr32
--- a/3rdparty/7z/src/Bra.c
+++ b/3rdparty/7z/src/Bra.c
@ -0,0 +1,420 @@
 /* Bra.c -- Branch converters for RISC code
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "Bra.h"
 #include "CpuArch.h"
 #include "RotateDefs.h"
 #if defined(MY_CPU_SIZEOF_POINTER) \
    && ( MY_CPU_SIZEOF_POINTER == 4 \
      || MY_CPU_SIZEOF_POINTER == 8)
  #define BR_CONV_USE_OPT_PC_PTR
 #endif
 #ifdef BR_CONV_USE_OPT_PC_PTR
 #define BR_PC_INIT  pc -= (UInt32)(SizeT)p;
 #define BR_PC_GET   (pc + (UInt32)(SizeT)p)
 #else
 #define BR_PC_INIT  pc += (UInt32)size;
 #define BR_PC_GET   (pc - (UInt32)(SizeT)(lim - p))
 // #define BR_PC_INIT
 // #define BR_PC_GET   (pc + (UInt32)(SizeT)(p - data))
 #endif
 #define BR_CONVERT_VAL(v, c) if (encoding) v += c; else v -= c;
 // #define BR_CONVERT_VAL(v, c) if (!encoding) c = (UInt32)0 - c; v += c;
 #define Z7_BRANCH_CONV(name) z7_BranchConv_ ## name
 #define Z7_BRANCH_FUNC_MAIN(name) \
 static \
 Z7_FORCE_INLINE \
 Z7_ATTRIB_NO_VECTOR \
 Byte *Z7_BRANCH_CONV(name)(Byte *p, SizeT size, UInt32 pc, int encoding)
 #define Z7_BRANCH_FUNC_IMP(name, m, encoding) \
 Z7_NO_INLINE \
 Z7_ATTRIB_NO_VECTOR \
 Byte *m(name)(Byte *data, SizeT size, UInt32 pc) \
  { return Z7_BRANCH_CONV(name)(data, size, pc, encoding); } \
 #ifdef Z7_EXTRACT_ONLY
 #define Z7_BRANCH_FUNCS_IMP(name) \
  Z7_BRANCH_FUNC_IMP(name, Z7_BRANCH_CONV_DEC, 0)
 #else
 #define Z7_BRANCH_FUNCS_IMP(name) \
  Z7_BRANCH_FUNC_IMP(name, Z7_BRANCH_CONV_DEC, 0) \
  Z7_BRANCH_FUNC_IMP(name, Z7_BRANCH_CONV_ENC, 1)
 #endif
 #if defined(__clang__)
 #define BR_EXTERNAL_FOR
 #define BR_NEXT_ITERATION  continue;
 #else
 #define BR_EXTERNAL_FOR    for (;;)
 #define BR_NEXT_ITERATION  break;
 #endif
 #if defined(__clang__) && (__clang_major__ >= 8) \
  || defined(__GNUC__) && (__GNUC__ >= 1000) \
  // GCC is not good for __builtin_expect() here
  /* || defined(_MSC_VER) && (_MSC_VER >= 1920) */
  // #define Z7_unlikely [[unlikely]]
  // #define Z7_LIKELY(x)   (__builtin_expect((x), 1))
  #define Z7_UNLIKELY(x) (__builtin_expect((x), 0))
  // #define Z7_likely [[likely]]
 #else
  // #define Z7_LIKELY(x)   (x)
  #define Z7_UNLIKELY(x) (x)
  // #define Z7_likely
 #endif
 Z7_BRANCH_FUNC_MAIN(ARM64)
 {
  // Byte *p = data;
  const Byte *lim;
  const UInt32 flag = (UInt32)1 << (24 - 4);
  const UInt32 mask = ((UInt32)1 << 24) - (flag << 1);
  size &= ~(SizeT)3;
  // if (size == 0) return p;
  lim = p + size;
  BR_PC_INIT
  pc -= 4;  // because (p) will point to next instruction
  BR_EXTERNAL_FOR
  {
    // Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
    for (;;)
    {
      UInt32 v;
      if Z7_UNLIKELY(p == lim)
        return p;
      v = GetUi32a(p);
      p += 4;
      if Z7_UNLIKELY(((v - 0x94000000) & 0xfc000000) == 0)
      {
        UInt32 c = BR_PC_GET >> 2;
        BR_CONVERT_VAL(v, c)
        v &= 0x03ffffff;
        v |= 0x94000000;
        SetUi32a(p - 4, v)
        BR_NEXT_ITERATION
      }
      // v = rotlFixed(v, 8);  v += (flag << 8) - 0x90;  if Z7_UNLIKELY((v & ((mask << 8) + 0x9f)) == 0)
      v -= 0x90000000;  if Z7_UNLIKELY((v & 0x9f000000) == 0)
      {
        UInt32 z, c;
        // v = rotrFixed(v, 8);
        v += flag; if Z7_UNLIKELY(v & mask) continue;
        z = (v & 0xffffffe0) | (v >> 26);
        c = (BR_PC_GET >> (12 - 3)) & ~(UInt32)7;
        BR_CONVERT_VAL(z, c)
        v &= 0x1f;
        v |= 0x90000000;
        v |= z << 26;
        v |= 0x00ffffe0 & ((z & (((flag << 1) - 1))) - flag);
        SetUi32a(p - 4, v)
      }
    }
  }
 }
 Z7_BRANCH_FUNCS_IMP(ARM64)
 Z7_BRANCH_FUNC_MAIN(ARM)
 {
  // Byte *p = data;
  const Byte *lim;
  size &= ~(SizeT)3;
  lim = p + size;
  BR_PC_INIT
  /* in ARM: branch offset is relative to the +2 instructions from current instruction.
     (p) will point to next instruction */
  pc += 8 - 4;
  for (;;)
  {
    for (;;)
    {
      if Z7_UNLIKELY(p >= lim) { return p; }  p += 4;  if Z7_UNLIKELY(p[-1] == 0xeb) break;
      if Z7_UNLIKELY(p >= lim) { return p; }  p += 4;  if Z7_UNLIKELY(p[-1] == 0xeb) break;
    }
    {
      UInt32 v = GetUi32a(p - 4);
      UInt32 c = BR_PC_GET >> 2;
      BR_CONVERT_VAL(v, c)
      v &= 0x00ffffff;
      v |= 0xeb000000;
      SetUi32a(p - 4, v)
    }
  }
 }
 Z7_BRANCH_FUNCS_IMP(ARM)
 Z7_BRANCH_FUNC_MAIN(PPC)
 {
  // Byte *p = data;
  const Byte *lim;
  size &= ~(SizeT)3;
  lim = p + size;
  BR_PC_INIT
  pc -= 4;  // because (p) will point to next instruction
  for (;;)
  {
    UInt32 v;
    for (;;)
    {
      if Z7_UNLIKELY(p == lim)
        return p;
      // v = GetBe32a(p);
      v = *(UInt32 *)(void *)p;
      p += 4;
      // if ((v & 0xfc000003) == 0x48000001) break;
      // if ((p[-4] & 0xFC) == 0x48 && (p[-1] & 3) == 1) break;
      if Z7_UNLIKELY(
          ((v - Z7_CONV_BE_TO_NATIVE_CONST32(0x48000001))
              & Z7_CONV_BE_TO_NATIVE_CONST32(0xfc000003)) == 0) break;
    }
    {
      v = Z7_CONV_NATIVE_TO_BE_32(v);
      {
        UInt32 c = BR_PC_GET;
        BR_CONVERT_VAL(v, c)
      }
      v &= 0x03ffffff;
      v |= 0x48000000;
      SetBe32a(p - 4, v)
    }
  }
 }
 Z7_BRANCH_FUNCS_IMP(PPC)
 #ifdef Z7_CPU_FAST_ROTATE_SUPPORTED
 #define BR_SPARC_USE_ROTATE
 #endif
 Z7_BRANCH_FUNC_MAIN(SPARC)
 {
  // Byte *p = data;
  const Byte *lim;
  const UInt32 flag = (UInt32)1 << 22;
  size &= ~(SizeT)3;
  lim = p + size;
  BR_PC_INIT
  pc -= 4;  // because (p) will point to next instruction
  for (;;)
  {
    UInt32 v;
    for (;;)
    {
      if Z7_UNLIKELY(p == lim)
        return p;
      /* // the code without GetBe32a():
      { const UInt32 v = GetUi16a(p) & 0xc0ff; p += 4; if (v == 0x40 || v == 0xc07f) break; }
      */
      v = GetBe32a(p);
      p += 4;
    #ifdef BR_SPARC_USE_ROTATE
      v = rotlFixed(v, 2);
      v += (flag << 2) - 1;
      if Z7_UNLIKELY((v & (3 - (flag << 3))) == 0)
    #else
      v += (UInt32)5 << 29;
      v ^= (UInt32)7 << 29;
      v += flag;
      if Z7_UNLIKELY((v & (0 - (flag << 1))) == 0)
    #endif
        break;
    }
    {
      // UInt32 v = GetBe32a(p - 4);
    #ifndef BR_SPARC_USE_ROTATE
      v <<= 2;
    #endif
      {
        UInt32 c = BR_PC_GET;
        BR_CONVERT_VAL(v, c)
      }
      v &= (flag << 3) - 1;
    #ifdef BR_SPARC_USE_ROTATE
      v -= (flag << 2) - 1;
      v = rotrFixed(v, 2);
    #else
      v -= (flag << 2);
      v >>= 2;
      v |= (UInt32)1 << 30;
    #endif
      SetBe32a(p - 4, v)
    }
  }
 }
 Z7_BRANCH_FUNCS_IMP(SPARC)
 Z7_BRANCH_FUNC_MAIN(ARMT)
 {
  // Byte *p = data;
  Byte *lim;
  size &= ~(SizeT)1;
  // if (size == 0) return p;
  if (size <= 2) return p;
  size -= 2;
  lim = p + size;
  BR_PC_INIT
  /* in ARM: branch offset is relative to the +2 instructions from current instruction.
     (p) will point to the +2 instructions from current instruction */
  // pc += 4 - 4;
  // if (encoding) pc -= 0xf800 << 1; else pc += 0xf800 << 1;
  // #define ARMT_TAIL_PROC { goto armt_tail; }
  #define ARMT_TAIL_PROC { return p; }
  do
  {
    /* in MSVC 32-bit x86 compilers:
       UInt32 version : it loads value from memory with movzx
       Byte   version : it loads value to 8-bit register (AL/CL)
       movzx version is slightly faster in some cpus
    */
    unsigned b1;
    // Byte / unsigned
    b1 = p[1];
    // optimized version to reduce one (p >= lim) check:
    // unsigned a1 = p[1];  b1 = p[3];  p += 2;  if Z7_LIKELY((b1 & (a1 ^ 8)) < 0xf8)
    for (;;)
    {
      unsigned b3; // Byte / UInt32
      /* (Byte)(b3) normalization can use low byte computations in MSVC.
         It gives smaller code, and no loss of speed in some compilers/cpus.
         But new MSVC 32-bit x86 compilers use more slow load
         from memory to low byte register in that case.
         So we try to use full 32-bit computations for faster code.
      */
      // if (p >= lim) { ARMT_TAIL_PROC }  b3 = b1 + 8;  b1 = p[3];  p += 2;  if ((b3 & b1) >= 0xf8) break;
      if Z7_UNLIKELY(p >= lim) { ARMT_TAIL_PROC }  b3 = p[3];  p += 2;  if Z7_UNLIKELY((b3 & (b1 ^ 8)) >= 0xf8) break;
      if Z7_UNLIKELY(p >= lim) { ARMT_TAIL_PROC }  b1 = p[3];  p += 2;  if Z7_UNLIKELY((b1 & (b3 ^ 8)) >= 0xf8) break;
    }
    {
      /* we can adjust pc for (0xf800) to rid of (& 0x7FF) operation.
         But gcc/clang for arm64 can use bfi instruction for full code here */
      UInt32 v =
          ((UInt32)GetUi16a(p - 2) << 11) |
          ((UInt32)GetUi16a(p) & 0x7FF);
      /*
      UInt32 v =
            ((UInt32)p[1 - 2] << 19)
          + (((UInt32)p[1] & 0x7) << 8)
          + (((UInt32)p[-2] << 11))
          + (p[0]);
      */
      p += 2;
      {
        UInt32 c = BR_PC_GET >> 1;
        BR_CONVERT_VAL(v, c)
      }
      SetUi16a(p - 4, (UInt16)(((v >> 11) & 0x7ff) | 0xf000))
      SetUi16a(p - 2, (UInt16)(v | 0xf800))
      /*
      p[-4] = (Byte)(v >> 11);
      p[-3] = (Byte)(0xf0 | ((v >> 19) & 0x7));
      p[-2] = (Byte)v;
      p[-1] = (Byte)(0xf8 | (v >> 8));
      */
    }
  }
  while (p < lim);
  return p;
  // armt_tail:
  // if ((Byte)((lim[1] & 0xf8)) != 0xf0) { lim += 2; }  return lim;
  // return (Byte *)(lim + ((Byte)((lim[1] ^ 0xf0) & 0xf8) == 0 ? 0 : 2));
  // return (Byte *)(lim + (((lim[1] ^ ~0xfu) & ~7u) == 0 ? 0 : 2));
  // return (Byte *)(lim + 2 - (((((unsigned)lim[1] ^ 8) + 8) >> 7) & 2));
 }
 Z7_BRANCH_FUNCS_IMP(ARMT)
 // #define BR_IA64_NO_INLINE
 Z7_BRANCH_FUNC_MAIN(IA64)
 {
  // Byte *p = data;
  const Byte *lim;
  size &= ~(SizeT)15;
  lim = p + size;
  pc -= 1 << 4;
  pc >>= 4 - 1;
  // pc -= 1 << 1;
  for (;;)
  {
    unsigned m;
    for (;;)
    {
      if Z7_UNLIKELY(p == lim)
        return p;
      m = (unsigned)((UInt32)0x334b0000 >> (*p & 0x1e));
      p += 16;
      pc += 1 << 1;
      if (m &= 3)
        break;
    }
    {
      p += (ptrdiff_t)m * 5 - 20; // negative value is expected here.
      do
      {
        const UInt32 t =
          #if defined(MY_CPU_X86_OR_AMD64)
            // we use 32-bit load here to reduce code size on x86:
            GetUi32(p);
          #else
            GetUi16(p);
          #endif
        UInt32 z = GetUi32(p + 1) >> m;
        p += 5;
        if (((t >> m) & (0x70 << 1)) == 0
            && ((z - (0x5000000 << 1)) & (0xf000000 << 1)) == 0)
        {
          UInt32 v = (UInt32)((0x8fffff << 1) | 1) & z;
          z ^= v;
        #ifdef BR_IA64_NO_INLINE
          v |= (v & ((UInt32)1 << (23 + 1))) >> 3;
          {
            UInt32 c = pc;
            BR_CONVERT_VAL(v, c)
          }
          v &= (0x1fffff << 1) | 1;
        #else
          {
            if (encoding)
            {
              // pc &= ~(0xc00000 << 1); // we just need to clear at least 2 bits
              pc &= (0x1fffff << 1) | 1;
              v += pc;
            }
            else
            {
              // pc |= 0xc00000 << 1; // we need to set at least 2 bits
              pc |= ~(UInt32)((0x1fffff << 1) | 1);
              v -= pc;
            }
          }
          v &= ~(UInt32)(0x600000 << 1);
        #endif
          v += (0x700000 << 1);
          v &= (0x8fffff << 1) | 1;
          z |= v;
          z <<= m;
          SetUi32(p + 1 - 5, z)
        }
        m++;
      }
      while (m &= 3); // while (m < 4);
    }
  }
 }
 Z7_BRANCH_FUNCS_IMP(IA64)
--- a/3rdparty/7z/src/Bra.h
+++ b/3rdparty/7z/src/Bra.h
@ -0,0 +1,99 @@
 /* Bra.h -- Branch converters for executables
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_BRA_H
 #define ZIP7_INC_BRA_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #define Z7_BRANCH_CONV_DEC(name)    z7_BranchConv_   ## name ## _Dec
 #define Z7_BRANCH_CONV_ENC(name)    z7_BranchConv_   ## name ## _Enc
 #define Z7_BRANCH_CONV_ST_DEC(name) z7_BranchConvSt_ ## name ## _Dec
 #define Z7_BRANCH_CONV_ST_ENC(name) z7_BranchConvSt_ ## name ## _Enc
 #define Z7_BRANCH_CONV_DECL(name)    Byte * name(Byte *data, SizeT size, UInt32 pc)
 #define Z7_BRANCH_CONV_ST_DECL(name) Byte * name(Byte *data, SizeT size, UInt32 pc, UInt32 *state)
 typedef Z7_BRANCH_CONV_DECL(   (*z7_Func_BranchConv));
 typedef Z7_BRANCH_CONV_ST_DECL((*z7_Func_BranchConvSt));
 #define Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL 0
 Z7_BRANCH_CONV_ST_DECL(Z7_BRANCH_CONV_ST_DEC(X86));
 Z7_BRANCH_CONV_ST_DECL(Z7_BRANCH_CONV_ST_ENC(X86));
 #define Z7_BRANCH_FUNCS_DECL(name) \
 Z7_BRANCH_CONV_DECL(Z7_BRANCH_CONV_DEC(name)); \
 Z7_BRANCH_CONV_DECL(Z7_BRANCH_CONV_ENC(name));
 Z7_BRANCH_FUNCS_DECL(ARM64)
 Z7_BRANCH_FUNCS_DECL(ARM)
 Z7_BRANCH_FUNCS_DECL(ARMT)
 Z7_BRANCH_FUNCS_DECL(PPC)
 Z7_BRANCH_FUNCS_DECL(SPARC)
 Z7_BRANCH_FUNCS_DECL(IA64)
 /*
 These functions convert data that contain CPU instructions.
 Each such function converts relative addresses to absolute addresses in some
 branch instructions: CALL (in all converters) and JUMP (X86 converter only).
 Such conversion allows to increase compression ratio, if we compress that data.
 There are 2 types of converters:
  Byte * Conv_RISC (Byte *data, SizeT size, UInt32 pc);
  Byte * ConvSt_X86(Byte *data, SizeT size, UInt32 pc, UInt32 *state);
 Each Converter supports 2 versions: one for encoding
 and one for decoding (_Enc/_Dec postfixes in function name).
 In params:
  data  : data buffer
  size  : size of data
  pc    : current virtual Program Counter (Instruction Pinter) value
 In/Out param:
  state : pointer to state variable (for X86 converter only)
 Return:
  The pointer to position in (data) buffer after last byte that was processed.
  If the caller calls converter again, it must call it starting with that position.
  But the caller is allowed to move data in buffer. so pointer to
  current processed position also will be changed for next call.
  Also the caller must increase internal (pc) value for next call.
 Each converter has some characteristics: Endian, Alignment, LookAhead.
  Type   Endian  Alignment  LookAhead
  X86    little      1          4
  ARMT   little      2          2
  ARM    little      4          0
  ARM64  little      4          0
  PPC     big        4          0
  SPARC   big        4          0
  IA64   little     16          0
  (data) must be aligned for (Alignment).
  processed size can be calculated as:
    SizeT processed = Conv(data, size, pc) - data;
  if (processed == 0)
    it means that converter needs more data for processing.
  If (size < Alignment + LookAhead)
    then (processed == 0) is allowed.
 Example code for conversion in loop:
  UInt32 pc = 0;
  size = 0;
  for (;;)
  {
    size += Load_more_input_data(data + size);
    SizeT processed = Conv(data, size, pc) - data;
    if (processed == 0 && no_more_input_data_after_size)
      break; // we stop convert loop
    data += processed;
    size -= processed;
    pc += processed;
  }
 */
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Bra86.c
+++ b/3rdparty/7z/src/Bra86.c
@ -0,0 +1,187 @@
 /* Bra86.c -- Branch converter for X86 code (BCJ)
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "Bra.h"
 #include "CpuArch.h"
 #if defined(MY_CPU_SIZEOF_POINTER) \
    && ( MY_CPU_SIZEOF_POINTER == 4 \
      || MY_CPU_SIZEOF_POINTER == 8)
  #define BR_CONV_USE_OPT_PC_PTR
 #endif
 #ifdef BR_CONV_USE_OPT_PC_PTR
 #define BR_PC_INIT  pc -= (UInt32)(SizeT)p; // (MY_uintptr_t)
 #define BR_PC_GET   (pc + (UInt32)(SizeT)p)
 #else
 #define BR_PC_INIT  pc += (UInt32)size;
 #define BR_PC_GET   (pc - (UInt32)(SizeT)(lim - p))
 // #define BR_PC_INIT
 // #define BR_PC_GET   (pc + (UInt32)(SizeT)(p - data))
 #endif
 #define BR_CONVERT_VAL(v, c) if (encoding) v += c; else v -= c;
 // #define BR_CONVERT_VAL(v, c) if (!encoding) c = (UInt32)0 - c; v += c;
 #define Z7_BRANCH_CONV_ST(name) z7_BranchConvSt_ ## name
 #define BR86_NEED_CONV_FOR_MS_BYTE(b) ((((b) + 1) & 0xfe) == 0)
 #ifdef MY_CPU_LE_UNALIGN
  #define BR86_PREPARE_BCJ_SCAN  const UInt32 v = GetUi32(p) ^ 0xe8e8e8e8;
  #define BR86_IS_BCJ_BYTE(n)    ((v & ((UInt32)0xfe << (n) * 8)) == 0)
 #else
  #define BR86_PREPARE_BCJ_SCAN
  // bad for MSVC X86 (partial write to byte reg):
  #define BR86_IS_BCJ_BYTE(n)    ((p[n - 4] & 0xfe) == 0xe8)
  // bad for old MSVC (partial write to byte reg):
  // #define BR86_IS_BCJ_BYTE(n)    (((*p ^ 0xe8) & 0xfe) == 0)
 #endif
 static
 Z7_FORCE_INLINE
 Z7_ATTRIB_NO_VECTOR
 Byte *Z7_BRANCH_CONV_ST(X86)(Byte *p, SizeT size, UInt32 pc, UInt32 *state, int encoding)
 {
  if (size < 5)
    return p;
 {
  // Byte *p = data;
  const Byte *lim = p + size - 4;
  unsigned mask = (unsigned)*state;  // & 7;
 #ifdef BR_CONV_USE_OPT_PC_PTR
  /* if BR_CONV_USE_OPT_PC_PTR is defined: we need to adjust (pc) for (+4),
        because call/jump offset is relative to the next instruction.
     if BR_CONV_USE_OPT_PC_PTR is not defined : we don't need to adjust (pc) for (+4),
         because  BR_PC_GET uses (pc - (lim - p)), and lim was adjusted for (-4) before.
  */
  pc += 4;
 #endif
  BR_PC_INIT
  goto start;
  for (;; mask |= 4)
  {
    // cont: mask |= 4;
  start:
    if (p >= lim)
      goto fin;
    {
      BR86_PREPARE_BCJ_SCAN
      p += 4;
      if (BR86_IS_BCJ_BYTE(0))  { goto m0; }  mask >>= 1;
      if (BR86_IS_BCJ_BYTE(1))  { goto m1; }  mask >>= 1;
      if (BR86_IS_BCJ_BYTE(2))  { goto m2; }  mask = 0;
      if (BR86_IS_BCJ_BYTE(3))  { goto a3; }
    }
    goto main_loop;
  m0: p--;
  m1: p--;
  m2: p--;
    if (mask == 0)
      goto a3;
    if (p > lim)
      goto fin_p;
    // if (((0x17u >> mask) & 1) == 0)
    if (mask > 4 || mask == 3)
    {
      mask >>= 1;
      continue; // goto cont;
    }
    mask >>= 1;
    if (BR86_NEED_CONV_FOR_MS_BYTE(p[mask]))
      continue; // goto cont;
    // if (!BR86_NEED_CONV_FOR_MS_BYTE(p[3])) continue; // goto cont;
    {
      UInt32 v = GetUi32(p);
      UInt32 c;
      v += (1 << 24);  if (v & 0xfe000000) continue; // goto cont;
      c = BR_PC_GET;
      BR_CONVERT_VAL(v, c)
      {
        mask <<= 3;
        if (BR86_NEED_CONV_FOR_MS_BYTE(v >> mask))
        {
          v ^= (((UInt32)0x100 << mask) - 1);
          #ifdef MY_CPU_X86
          // for X86 : we can recalculate (c) to reduce register pressure
            c = BR_PC_GET;
          #endif
          BR_CONVERT_VAL(v, c)
        }
        mask = 0;
      }
      // v = (v & ((1 << 24) - 1)) - (v & (1 << 24));
      v &= (1 << 25) - 1;  v -= (1 << 24);
      SetUi32(p, v)
      p += 4;
      goto main_loop;
    }
  main_loop:
    if (p >= lim)
      goto fin;
    for (;;)
    {
      BR86_PREPARE_BCJ_SCAN
      p += 4;
      if (BR86_IS_BCJ_BYTE(0))  { goto a0; }
      if (BR86_IS_BCJ_BYTE(1))  { goto a1; }
      if (BR86_IS_BCJ_BYTE(2))  { goto a2; }
      if (BR86_IS_BCJ_BYTE(3))  { goto a3; }
      if (p >= lim)
        goto fin;
    }
  a0: p--;
  a1: p--;
  a2: p--;
  a3:
    if (p > lim)
      goto fin_p;
    // if (!BR86_NEED_CONV_FOR_MS_BYTE(p[3])) continue; // goto cont;
    {
      UInt32 v = GetUi32(p);
      UInt32 c;
      v += (1 << 24);  if (v & 0xfe000000) continue; // goto cont;
      c = BR_PC_GET;
      BR_CONVERT_VAL(v, c)
      // v = (v & ((1 << 24) - 1)) - (v & (1 << 24));
      v &= (1 << 25) - 1;  v -= (1 << 24);
      SetUi32(p, v)
      p += 4;
      goto main_loop;
    }
  }
 fin_p:
  p--;
 fin:
  // the following processing for tail is optional and can be commented
  /*
  lim += 4;
  for (; p < lim; p++, mask >>= 1)
    if ((*p & 0xfe) == 0xe8)
      break;
  */
  *state = (UInt32)mask;
  return p;
 }
 }
 #define Z7_BRANCH_CONV_ST_FUNC_IMP(name, m, encoding) \
 Z7_NO_INLINE \
 Z7_ATTRIB_NO_VECTOR \
 Byte *m(name)(Byte *data, SizeT size, UInt32 pc, UInt32 *state) \
  { return Z7_BRANCH_CONV_ST(name)(data, size, pc, state, encoding); }
 Z7_BRANCH_CONV_ST_FUNC_IMP(X86, Z7_BRANCH_CONV_ST_DEC, 0)
 #ifndef Z7_EXTRACT_ONLY
 Z7_BRANCH_CONV_ST_FUNC_IMP(X86, Z7_BRANCH_CONV_ST_ENC, 1)
 #endif
--- a/3rdparty/7z/src/BraIA64.c
+++ b/3rdparty/7z/src/BraIA64.c
@ -0,0 +1,14 @@
 /* BraIA64.c -- Converter for IA-64 code
 2023-02-20 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 // the code was moved to Bra.c
 #ifdef _MSC_VER
 #pragma warning(disable : 4206) // nonstandard extension used : translation unit is empty
 #endif
 #if defined(__clang__)
 #pragma GCC diagnostic ignored "-Wempty-translation-unit"
 #endif
--- a/3rdparty/7z/src/BwtSort.c
+++ b/3rdparty/7z/src/BwtSort.c
@ -0,0 +1,516 @@
 /* BwtSort.c -- BWT block sorting
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "BwtSort.h"
 #include "Sort.h"
 /* #define BLOCK_SORT_USE_HEAP_SORT */
 /* Don't change it !!! */
 #define kNumHashBytes 2
 #define kNumHashValues (1 << (kNumHashBytes * 8))
 /* kNumRefBitsMax must be < (kNumHashBytes * 8) = 16 */
 #define kNumRefBitsMax 12
 #define BS_TEMP_SIZE kNumHashValues
 #ifdef BLOCK_SORT_EXTERNAL_FLAGS
 /* 32 Flags in UInt32 word */
 #define kNumFlagsBits 5
 #define kNumFlagsInWord (1 << kNumFlagsBits)
 #define kFlagsMask (kNumFlagsInWord - 1)
 #define kAllFlags 0xFFFFFFFF
 #else
 #define kNumBitsMax 20
 #define kIndexMask ((1 << kNumBitsMax) - 1)
 #define kNumExtraBits (32 - kNumBitsMax)
 #define kNumExtra0Bits (kNumExtraBits - 2)
 #define kNumExtra0Mask ((1 << kNumExtra0Bits) - 1)
 #define SetFinishedGroupSize(p, size) \
  {  *(p) |= ((((size) - 1) & kNumExtra0Mask) << kNumBitsMax); \
    if ((size) > (1 << kNumExtra0Bits)) { \
    *(p) |= 0x40000000;  *((p) + 1) |= ((((size) - 1)>> kNumExtra0Bits) << kNumBitsMax); } } \
 static void SetGroupSize(UInt32 *p, UInt32 size)
 {
  if (--size == 0)
    return;
  *p |= 0x80000000 | ((size & kNumExtra0Mask) << kNumBitsMax);
  if (size >= (1 << kNumExtra0Bits))
  {
    *p |= 0x40000000;
    p[1] |= ((size >> kNumExtra0Bits) << kNumBitsMax);
  }
 }
 #endif
 /*
 SortGroup - is recursive Range-Sort function with HeapSort optimization for small blocks
  "range" is not real range. It's only for optimization.
 returns: 1 - if there are groups, 0 - no more groups
 */
 static
 UInt32
 Z7_FASTCALL
 SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 groupSize, int NumRefBits, UInt32 *Indices
  #ifndef BLOCK_SORT_USE_HEAP_SORT
  , UInt32 left, UInt32 range
  #endif
  )
 {
  UInt32 *ind2 = Indices + groupOffset;
  UInt32 *Groups;
  if (groupSize <= 1)
  {
    /*
    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
    SetFinishedGroupSize(ind2, 1)
    #endif
    */
    return 0;
  }
  Groups = Indices + BlockSize + BS_TEMP_SIZE;
  if (groupSize <= ((UInt32)1 << NumRefBits)
      #ifndef BLOCK_SORT_USE_HEAP_SORT
      && groupSize <= range
      #endif
      )
  {
    UInt32 *temp = Indices + BlockSize;
    UInt32 j;
    UInt32 mask, thereAreGroups, group, cg;
    {
      UInt32 gPrev;
      UInt32 gRes = 0;
      {
        UInt32 sp = ind2[0] + NumSortedBytes;
        if (sp >= BlockSize) sp -= BlockSize;
        gPrev = Groups[sp];
        temp[0] = (gPrev << NumRefBits);
      }
      for (j = 1; j < groupSize; j++)
      {
        UInt32 sp = ind2[j] + NumSortedBytes;
        UInt32 g;
        if (sp >= BlockSize) sp -= BlockSize;
        g = Groups[sp];
        temp[j] = (g << NumRefBits) | j;
        gRes |= (gPrev ^ g);
      }
      if (gRes == 0)
      {
        #ifndef BLOCK_SORT_EXTERNAL_FLAGS
        SetGroupSize(ind2, groupSize);
        #endif
        return 1;
      }
    }
    HeapSort(temp, groupSize);
    mask = (((UInt32)1 << NumRefBits) - 1);
    thereAreGroups = 0;
    group = groupOffset;
    cg = (temp[0] >> NumRefBits);
    temp[0] = ind2[temp[0] & mask];
    {
    #ifdef BLOCK_SORT_EXTERNAL_FLAGS
    UInt32 *Flags = Groups + BlockSize;
    #else
    UInt32 prevGroupStart = 0;
    #endif
    for (j = 1; j < groupSize; j++)
    {
      UInt32 val = temp[j];
      UInt32 cgCur = (val >> NumRefBits);
      if (cgCur != cg)
      {
        cg = cgCur;
        group = groupOffset + j;
        #ifdef BLOCK_SORT_EXTERNAL_FLAGS
        {
        UInt32 t = group - 1;
        Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
        }
        #else
        SetGroupSize(temp + prevGroupStart, j - prevGroupStart);
        prevGroupStart = j;
        #endif
      }
      else
        thereAreGroups = 1;
      {
      UInt32 ind = ind2[val & mask];
      temp[j] = ind;
      Groups[ind] = group;
      }
    }
    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
    SetGroupSize(temp + prevGroupStart, j - prevGroupStart);
    #endif
    }
    for (j = 0; j < groupSize; j++)
      ind2[j] = temp[j];
    return thereAreGroups;
  }
  /* Check that all strings are in one group (cannot sort) */
  {
    UInt32 group, j;
    UInt32 sp = ind2[0] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
    group = Groups[sp];
    for (j = 1; j < groupSize; j++)
    {
      sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
      if (Groups[sp] != group)
        break;
    }
    if (j == groupSize)
    {
      #ifndef BLOCK_SORT_EXTERNAL_FLAGS
      SetGroupSize(ind2, groupSize);
      #endif
      return 1;
    }
  }
  #ifndef BLOCK_SORT_USE_HEAP_SORT
  {
  /* ---------- Range Sort ---------- */
  UInt32 i;
  UInt32 mid;
  for (;;)
  {
    UInt32 j;
    if (range <= 1)
    {
      #ifndef BLOCK_SORT_EXTERNAL_FLAGS
      SetGroupSize(ind2, groupSize);
      #endif
      return 1;
    }
    mid = left + ((range + 1) >> 1);
    j = groupSize;
    i = 0;
    do
    {
      UInt32 sp = ind2[i] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
      if (Groups[sp] >= mid)
      {
        for (j--; j > i; j--)
        {
          sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
          if (Groups[sp] < mid)
          {
            UInt32 temp = ind2[i]; ind2[i] = ind2[j]; ind2[j] = temp;
            break;
          }
        }
        if (i >= j)
          break;
      }
    }
    while (++i < j);
    if (i == 0)
    {
      range = range - (mid - left);
      left = mid;
    }
    else if (i == groupSize)
      range = (mid - left);
    else
      break;
  }
  #ifdef BLOCK_SORT_EXTERNAL_FLAGS
  {
    UInt32 t = (groupOffset + i - 1);
    UInt32 *Flags = Groups + BlockSize;
    Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
  }
  #endif
  {
    UInt32 j;
    for (j = i; j < groupSize; j++)
      Groups[ind2[j]] = groupOffset + i;
  }
  {
  UInt32 res = SortGroup(BlockSize, NumSortedBytes, groupOffset, i, NumRefBits, Indices, left, mid - left);
  return res | SortGroup(BlockSize, NumSortedBytes, groupOffset + i, groupSize - i, NumRefBits, Indices, mid, range - (mid - left));
  }
  }
  #else
  /* ---------- Heap Sort ---------- */
  {
    UInt32 j;
    for (j = 0; j < groupSize; j++)
    {
      UInt32 sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
      ind2[j] = sp;
    }
    HeapSortRef(ind2, Groups, groupSize);
    /* Write Flags */
    {
    UInt32 sp = ind2[0];
    UInt32 group = Groups[sp];
    #ifdef BLOCK_SORT_EXTERNAL_FLAGS
    UInt32 *Flags = Groups + BlockSize;
    #else
    UInt32 prevGroupStart = 0;
    #endif
    for (j = 1; j < groupSize; j++)
    {
      sp = ind2[j];
      if (Groups[sp] != group)
      {
        group = Groups[sp];
        #ifdef BLOCK_SORT_EXTERNAL_FLAGS
        {
        UInt32 t = groupOffset + j - 1;
        Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
        }
        #else
        SetGroupSize(ind2 + prevGroupStart, j - prevGroupStart);
        prevGroupStart = j;
        #endif
      }
    }
    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
    SetGroupSize(ind2 + prevGroupStart, j - prevGroupStart);
    #endif
    }
    {
    /* Write new Groups values and Check that there are groups */
    UInt32 thereAreGroups = 0;
    for (j = 0; j < groupSize; j++)
    {
      UInt32 group = groupOffset + j;
      #ifndef BLOCK_SORT_EXTERNAL_FLAGS
      UInt32 subGroupSize = ((ind2[j] & ~0xC0000000) >> kNumBitsMax);
      if ((ind2[j] & 0x40000000) != 0)
        subGroupSize += ((ind2[(size_t)j + 1] >> kNumBitsMax) << kNumExtra0Bits);
      subGroupSize++;
      for (;;)
      {
        UInt32 original = ind2[j];
        UInt32 sp = original & kIndexMask;
        if (sp < NumSortedBytes) sp += BlockSize; sp -= NumSortedBytes;
        ind2[j] = sp | (original & ~kIndexMask);
        Groups[sp] = group;
        if (--subGroupSize == 0)
          break;
        j++;
        thereAreGroups = 1;
      }
      #else
      UInt32 *Flags = Groups + BlockSize;
      for (;;)
      {
        UInt32 sp = ind2[j]; if (sp < NumSortedBytes) sp += BlockSize; sp -= NumSortedBytes;
        ind2[j] = sp;
        Groups[sp] = group;
        if ((Flags[(groupOffset + j) >> kNumFlagsBits] & (1 << ((groupOffset + j) & kFlagsMask))) == 0)
          break;
        j++;
        thereAreGroups = 1;
      }
      #endif
    }
    return thereAreGroups;
    }
  }
  #endif
 }
 /* conditions: blockSize > 0 */
 UInt32 BlockSort(UInt32 *Indices, const Byte *data, UInt32 blockSize)
 {
  UInt32 *counters = Indices + blockSize;
  UInt32 i;
  UInt32 *Groups;
  #ifdef BLOCK_SORT_EXTERNAL_FLAGS
  UInt32 *Flags;
  #endif
  /* Radix-Sort for 2 bytes */
  for (i = 0; i < kNumHashValues; i++)
    counters[i] = 0;
  for (i = 0; i < blockSize - 1; i++)
    counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]]++;
  counters[((UInt32)data[i] << 8) | data[0]]++;
  Groups = counters + BS_TEMP_SIZE;
  #ifdef BLOCK_SORT_EXTERNAL_FLAGS
  Flags = Groups + blockSize;
    {
      UInt32 numWords = (blockSize + kFlagsMask) >> kNumFlagsBits;
      for (i = 0; i < numWords; i++)
        Flags[i] = kAllFlags;
    }
  #endif
  {
    UInt32 sum = 0;
    for (i = 0; i < kNumHashValues; i++)
    {
      UInt32 groupSize = counters[i];
      if (groupSize > 0)
      {
        #ifdef BLOCK_SORT_EXTERNAL_FLAGS
        UInt32 t = sum + groupSize - 1;
        Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
        #endif
        sum += groupSize;
      }
      counters[i] = sum - groupSize;
    }
    for (i = 0; i < blockSize - 1; i++)
      Groups[i] = counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]];
    Groups[i] = counters[((UInt32)data[i] << 8) | data[0]];
    for (i = 0; i < blockSize - 1; i++)
      Indices[counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]]++] = i;
    Indices[counters[((UInt32)data[i] << 8) | data[0]]++] = i;
    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
    {
    UInt32 prev = 0;
    for (i = 0; i < kNumHashValues; i++)
    {
      UInt32 prevGroupSize = counters[i] - prev;
      if (prevGroupSize == 0)
        continue;
      SetGroupSize(Indices + prev, prevGroupSize);
      prev = counters[i];
    }
    }
    #endif
  }
  {
  int NumRefBits;
  UInt32 NumSortedBytes;
  for (NumRefBits = 0; ((blockSize - 1) >> NumRefBits) != 0; NumRefBits++);
  NumRefBits = 32 - NumRefBits;
  if (NumRefBits > kNumRefBitsMax)
    NumRefBits = kNumRefBitsMax;
  for (NumSortedBytes = kNumHashBytes; ; NumSortedBytes <<= 1)
  {
    #ifndef BLOCK_SORT_EXTERNAL_FLAGS
    UInt32 finishedGroupSize = 0;
    #endif
    UInt32 newLimit = 0;
    for (i = 0; i < blockSize;)
    {
      UInt32 groupSize;
      #ifdef BLOCK_SORT_EXTERNAL_FLAGS
      if ((Flags[i >> kNumFlagsBits] & (1 << (i & kFlagsMask))) == 0)
      {
        i++;
        continue;
      }
      for (groupSize = 1;
        (Flags[(i + groupSize) >> kNumFlagsBits] & (1 << ((i + groupSize) & kFlagsMask))) != 0;
        groupSize++);
      groupSize++;
      #else
      groupSize = ((Indices[i] & ~0xC0000000) >> kNumBitsMax);
      {
      BoolInt finishedGroup = ((Indices[i] & 0x80000000) == 0);
      if ((Indices[i] & 0x40000000) != 0)
      {
        groupSize += ((Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits);
        Indices[(size_t)i + 1] &= kIndexMask;
      }
      Indices[i] &= kIndexMask;
      groupSize++;
      if (finishedGroup || groupSize == 1)
      {
        Indices[i - finishedGroupSize] &= kIndexMask;
        if (finishedGroupSize > 1)
          Indices[(size_t)(i - finishedGroupSize) + 1] &= kIndexMask;
        {
        UInt32 newGroupSize = groupSize + finishedGroupSize;
        SetFinishedGroupSize(Indices + i - finishedGroupSize, newGroupSize)
        finishedGroupSize = newGroupSize;
        }
        i += groupSize;
        continue;
      }
      finishedGroupSize = 0;
      }
      #endif
      if (NumSortedBytes >= blockSize)
      {
        UInt32 j;
        for (j = 0; j < groupSize; j++)
        {
          UInt32 t = (i + j);
          /* Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask)); */
          Groups[Indices[t]] = t;
        }
      }
      else
        if (SortGroup(blockSize, NumSortedBytes, i, groupSize, NumRefBits, Indices
          #ifndef BLOCK_SORT_USE_HEAP_SORT
          , 0, blockSize
          #endif
          ) != 0)
          newLimit = i + groupSize;
      i += groupSize;
    }
    if (newLimit == 0)
      break;
  }
  }
  #ifndef BLOCK_SORT_EXTERNAL_FLAGS
  for (i = 0; i < blockSize;)
  {
    UInt32 groupSize = ((Indices[i] & ~0xC0000000) >> kNumBitsMax);
    if ((Indices[i] & 0x40000000) != 0)
    {
      groupSize += ((Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits);
      Indices[(size_t)i + 1] &= kIndexMask;
    }
    Indices[i] &= kIndexMask;
    groupSize++;
    i += groupSize;
  }
  #endif
  return Groups[0];
 }
--- a/3rdparty/7z/src/BwtSort.h
+++ b/3rdparty/7z/src/BwtSort.h
@ -0,0 +1,26 @@
 /* BwtSort.h -- BWT block sorting
 2023-03-03 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_BWT_SORT_H
 #define ZIP7_INC_BWT_SORT_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 /* use BLOCK_SORT_EXTERNAL_FLAGS if blockSize can be > 1M */
 /* #define BLOCK_SORT_EXTERNAL_FLAGS */
 #ifdef BLOCK_SORT_EXTERNAL_FLAGS
 #define BLOCK_SORT_EXTERNAL_SIZE(blockSize) ((((blockSize) + 31) >> 5))
 #else
 #define BLOCK_SORT_EXTERNAL_SIZE(blockSize) 0
 #endif
 #define BLOCK_SORT_BUF_SIZE(blockSize) ((blockSize) * 2 + BLOCK_SORT_EXTERNAL_SIZE(blockSize) + (1 << 16))
 UInt32 BlockSort(UInt32 *indices, const Byte *data, UInt32 blockSize);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Compiler.h
+++ b/3rdparty/7z/src/Compiler.h
@ -0,0 +1,159 @@
 /* Compiler.h : Compiler specific defines and pragmas
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_COMPILER_H
 #define ZIP7_INC_COMPILER_H
 #if defined(__clang__)
 # define Z7_CLANG_VERSION  (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
 #endif
 #if defined(__clang__) && defined(__apple_build_version__)
 # define Z7_APPLE_CLANG_VERSION   Z7_CLANG_VERSION
 #elif defined(__clang__)
 # define Z7_LLVM_CLANG_VERSION    Z7_CLANG_VERSION
 #elif defined(__GNUC__)
 # define Z7_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #endif
 #ifdef _MSC_VER
 #if !defined(__clang__) && !defined(__GNUC__)
 #define Z7_MSC_VER_ORIGINAL _MSC_VER
 #endif
 #endif
 #if defined(__MINGW32__) || defined(__MINGW64__)
 #define Z7_MINGW
 #endif
 // #pragma GCC diagnostic ignored "-Wunknown-pragmas"
 #ifdef __clang__
 // padding size of '' with 4 bytes to alignment boundary
 #pragma GCC diagnostic ignored "-Wpadded"
 #endif
 #ifdef _MSC_VER
  #ifdef UNDER_CE
    #define RPC_NO_WINDOWS_H
    /* #pragma warning(disable : 4115) // '_RPC_ASYNC_STATE' : named type definition in parentheses */
    #pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union
    #pragma warning(disable : 4214) // nonstandard extension used : bit field types other than int
  #endif
 #if defined(_MSC_VER) && _MSC_VER >= 1800
 #pragma warning(disable : 4464) // relative include path contains '..'
 #endif
 // == 1200 : -O1 : for __forceinline
 // >= 1900 : -O1 : for printf
 #pragma warning(disable : 4710) // function not inlined
 #if _MSC_VER < 1900
 // winnt.h: 'Int64ShllMod32'
 #pragma warning(disable : 4514) // unreferenced inline function has been removed
 #endif
 #if _MSC_VER < 1300
 // #pragma warning(disable : 4702) // unreachable code
 // Bra.c : -O1:
 #pragma warning(disable : 4714) // function marked as __forceinline not inlined
 #endif
 /*
 #if _MSC_VER > 1400 && _MSC_VER <= 1900
 // strcat: This function or variable may be unsafe
 // sysinfoapi.h: kit10: GetVersion was declared deprecated
 #pragma warning(disable : 4996)
 #endif
 */
 #if _MSC_VER > 1200
 // -Wall warnings
 #pragma warning(disable : 4711) // function selected for automatic inline expansion
 #pragma warning(disable : 4820) // '2' bytes padding added after data member
 #if _MSC_VER >= 1400 && _MSC_VER < 1920
 // 1400: string.h: _DBG_MEMCPY_INLINE_
 // 1600 - 191x : smmintrin.h __cplusplus'
 // is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
 #pragma warning(disable : 4668)
 // 1400 - 1600 : WinDef.h : 'FARPROC' :
 // 1900 - 191x : immintrin.h: _readfsbase_u32
 // no function prototype given : converting '()' to '(void)'
 #pragma warning(disable : 4255)
 #endif
 #if _MSC_VER >= 1914
 // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
 #pragma warning(disable : 5045)
 #endif
 #endif // _MSC_VER > 1200
 #endif // _MSC_VER
 #if defined(__clang__) && (__clang_major__ >= 4)
  #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE \
    _Pragma("clang loop unroll(disable)") \
    _Pragma("clang loop vectorize(disable)")
  #define Z7_ATTRIB_NO_VECTORIZE
 #elif defined(__GNUC__) && (__GNUC__ >= 5)
  #define Z7_ATTRIB_NO_VECTORIZE __attribute__((optimize("no-tree-vectorize")))
  // __attribute__((optimize("no-unroll-loops")));
  #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
 #elif defined(_MSC_VER) && (_MSC_VER >= 1920)
  #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE \
    _Pragma("loop( no_vector )")
  #define Z7_ATTRIB_NO_VECTORIZE
 #else
  #define Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
  #define Z7_ATTRIB_NO_VECTORIZE
 #endif
 #if defined(MY_CPU_X86_OR_AMD64) && ( \
       defined(__clang__) && (__clang_major__ >= 4) \
    || defined(__GNUC__) && (__GNUC__ >= 5))
  #define Z7_ATTRIB_NO_SSE  __attribute__((__target__("no-sse")))
 #else
  #define Z7_ATTRIB_NO_SSE
 #endif
 #define Z7_ATTRIB_NO_VECTOR \
  Z7_ATTRIB_NO_VECTORIZE \
  Z7_ATTRIB_NO_SSE
 #if defined(__clang__) && (__clang_major__ >= 8) \
  || defined(__GNUC__) && (__GNUC__ >= 1000) \
  /* || defined(_MSC_VER) && (_MSC_VER >= 1920) */
  // GCC is not good for __builtin_expect()
  #define Z7_LIKELY(x)   (__builtin_expect((x), 1))
  #define Z7_UNLIKELY(x) (__builtin_expect((x), 0))
  // #define Z7_unlikely [[unlikely]]
  // #define Z7_likely [[likely]]
 #else
  #define Z7_LIKELY(x)   (x)
  #define Z7_UNLIKELY(x) (x)
  // #define Z7_likely
 #endif
 #if (defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 36000))
 #define Z7_DIAGNOSCTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER \
  _Pragma("GCC diagnostic push") \
  _Pragma("GCC diagnostic ignored \"-Wreserved-macro-identifier\"")
 #define Z7_DIAGNOSCTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER \
  _Pragma("GCC diagnostic pop")
 #else
 #define Z7_DIAGNOSCTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER
 #define Z7_DIAGNOSCTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER
 #endif
 #define UNUSED_VAR(x) (void)x;
 /* #define UNUSED_VAR(x) x=x; */
 #endif
--- a/3rdparty/7z/src/CpuArch.c
+++ b/3rdparty/7z/src/CpuArch.c
@ -0,0 +1,823 @@
 /* CpuArch.c -- CPU specific code
 2023-05-18 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 // #include <stdio.h>
 #include "CpuArch.h"
 #ifdef MY_CPU_X86_OR_AMD64
 #undef NEED_CHECK_FOR_CPUID
 #if !defined(MY_CPU_AMD64)
 #define NEED_CHECK_FOR_CPUID
 #endif
 /*
  cpuid instruction supports (subFunction) parameter in ECX,
  that is used only with some specific (function) parameter values.
  But we always use only (subFunction==0).
 */
 /*
  __cpuid(): MSVC and GCC/CLANG use same function/macro name
             but parameters are different.
   We use MSVC __cpuid() parameters style for our z7_x86_cpuid() function.
 */
 #if defined(__GNUC__) /* && (__GNUC__ >= 10) */ \
    || defined(__clang__) /* && (__clang_major__ >= 10) */
 /* there was some CLANG/GCC compilers that have issues with
   rbx(ebx) handling in asm blocks in -fPIC mode (__PIC__ is defined).
   compiler's <cpuid.h> contains the macro __cpuid() that is similar to our code.
   The history of __cpuid() changes in CLANG/GCC:
   GCC:
     2007: it preserved ebx for (__PIC__ && __i386__)
     2013: it preserved rbx and ebx for __PIC__
     2014: it doesn't preserves rbx and ebx anymore
     we suppose that (__GNUC__ >= 5) fixed that __PIC__ ebx/rbx problem.
   CLANG:
     2014+: it preserves rbx, but only for 64-bit code. No __PIC__ check.
   Why CLANG cares about 64-bit mode only, and doesn't care about ebx (in 32-bit)?
   Do we need __PIC__ test for CLANG or we must care about rbx even if
   __PIC__ is not defined?
 */
 #define ASM_LN "\n"
 #if defined(MY_CPU_AMD64) && defined(__PIC__) \
    && ((defined (__GNUC__) && (__GNUC__ < 5)) || defined(__clang__))
 #define x86_cpuid_MACRO(p, func) { \
  __asm__ __volatile__ ( \
    ASM_LN   "mov     %%rbx, %q1"  \
    ASM_LN   "cpuid"               \
    ASM_LN   "xchg    %%rbx, %q1"  \
    : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }
  /* "=&r" selects free register. It can select even rbx, if that register is free.
     "=&D" for (RDI) also works, but the code can be larger with "=&D"
     "2"(0) means (subFunction = 0),
     2 is (zero-based) index in the output constraint list "=c" (ECX). */
 #elif defined(MY_CPU_X86) && defined(__PIC__) \
    && ((defined (__GNUC__) && (__GNUC__ < 5)) || defined(__clang__))
 #define x86_cpuid_MACRO(p, func) { \
  __asm__ __volatile__ ( \
    ASM_LN   "mov     %%ebx, %k1"  \
    ASM_LN   "cpuid"               \
    ASM_LN   "xchg    %%ebx, %k1"  \
    : "=a" ((p)[0]), "=&r" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }
 #else
 #define x86_cpuid_MACRO(p, func) { \
  __asm__ __volatile__ ( \
    ASM_LN   "cpuid"               \
    : "=a" ((p)[0]), "=b" ((p)[1]), "=c" ((p)[2]), "=d" ((p)[3]) : "0" (func), "2"(0)); }
 #endif
 void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
 {
  x86_cpuid_MACRO(p, func)
 }
 Z7_NO_INLINE
 UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)
 {
 #if defined(NEED_CHECK_FOR_CPUID)
  #define EFALGS_CPUID_BIT 21
  UInt32 a;
  __asm__ __volatile__ (
    ASM_LN   "pushf"
    ASM_LN   "pushf"
    ASM_LN   "pop     %0"
    // ASM_LN   "movl    %0, %1"
    // ASM_LN   "xorl    $0x200000, %0"
    ASM_LN   "btc     %1, %0"
    ASM_LN   "push    %0"
    ASM_LN   "popf"
    ASM_LN   "pushf"
    ASM_LN   "pop     %0"
    ASM_LN   "xorl    (%%esp), %0"
    ASM_LN   "popf"
    ASM_LN
    : "=&r" (a) // "=a"
    : "i" (EFALGS_CPUID_BIT)
    );
  if ((a & (1 << EFALGS_CPUID_BIT)) == 0)
    return 0;
 #endif
  {
    UInt32 p[4];
    x86_cpuid_MACRO(p, 0)
    return p[0];
  }
 }
 #undef ASM_LN
 #elif !defined(_MSC_VER)
 /*
 // for gcc/clang and other: we can try to use __cpuid macro:
 #include <cpuid.h>
 void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
 {
  __cpuid(func, p[0], p[1], p[2], p[3]);
 }
 UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)
 {
  return (UInt32)__get_cpuid_max(0, NULL);
 }
 */
 // for unsupported cpuid:
 void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
 {
  UNUSED_VAR(func)
  p[0] = p[1] = p[2] = p[3] = 0;
 }
 UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)
 {
  return 0;
 }
 #else // _MSC_VER
 #if !defined(MY_CPU_AMD64)
 UInt32 __declspec(naked) Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)
 {
  #if defined(NEED_CHECK_FOR_CPUID)
  #define EFALGS_CPUID_BIT 21
  __asm   pushfd
  __asm   pushfd
  /*
  __asm   pop     eax
  // __asm   mov     edx, eax
  __asm   btc     eax, EFALGS_CPUID_BIT
  __asm   push    eax
  */
  __asm   btc     dword ptr [esp], EFALGS_CPUID_BIT
  __asm   popfd
  __asm   pushfd
  __asm   pop     eax
  // __asm   xor     eax, edx
  __asm   xor     eax, [esp]
  // __asm   push    edx
  __asm   popfd
  __asm   and     eax, (1 shl EFALGS_CPUID_BIT)
  __asm   jz end_func
  #endif
  __asm   push    ebx
  __asm   xor     eax, eax    // func
  __asm   xor     ecx, ecx    // subFunction (optional) for (func == 0)
  __asm   cpuid
  __asm   pop     ebx
  #if defined(NEED_CHECK_FOR_CPUID)
  end_func:
  #endif
  __asm   ret 0
 }
 void __declspec(naked) Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
 {
  UNUSED_VAR(p)
  UNUSED_VAR(func)
  __asm   push    ebx
  __asm   push    edi
  __asm   mov     edi, ecx    // p
  __asm   mov     eax, edx    // func
  __asm   xor     ecx, ecx    // subfunction (optional) for (func == 0)
  __asm   cpuid
  __asm   mov     [edi     ], eax
  __asm   mov     [edi +  4], ebx
  __asm   mov     [edi +  8], ecx
  __asm   mov     [edi + 12], edx
  __asm   pop     edi
  __asm   pop     ebx
  __asm   ret     0
 }
 #else // MY_CPU_AMD64
    #if _MSC_VER >= 1600
      #include <intrin.h>
      #define MY_cpuidex  __cpuidex
    #else
 /*
 __cpuid (func == (0 or 7)) requires subfunction number in ECX.
  MSDN: The __cpuid intrinsic clears the ECX register before calling the cpuid instruction.
   __cpuid() in new MSVC clears ECX.
   __cpuid() in old MSVC (14.00) x64 doesn't clear ECX
 We still can use __cpuid for low (func) values that don't require ECX,
 but __cpuid() in old MSVC will be incorrect for some func values: (func == 7).
 So here we use the hack for old MSVC to send (subFunction) in ECX register to cpuid instruction,
 where ECX value is first parameter for FASTCALL / NO_INLINE func,
 So the caller of MY_cpuidex_HACK() sets ECX as subFunction, and
 old MSVC for __cpuid() doesn't change ECX and cpuid instruction gets (subFunction) value.
 DON'T remove Z7_NO_INLINE and Z7_FASTCALL for MY_cpuidex_HACK(): !!!
 */
 static
 Z7_NO_INLINE void Z7_FASTCALL MY_cpuidex_HACK(UInt32 subFunction, UInt32 func, int *CPUInfo)
 {
  UNUSED_VAR(subFunction)
  __cpuid(CPUInfo, func);
 }
      #define MY_cpuidex(info, func, func2)  MY_cpuidex_HACK(func2, func, info)
      #pragma message("======== MY_cpuidex_HACK WAS USED ========")
    #endif // _MSC_VER >= 1600
 #if !defined(MY_CPU_AMD64)
 /* inlining for __cpuid() in MSVC x86 (32-bit) produces big ineffective code,
   so we disable inlining here */
 Z7_NO_INLINE
 #endif
 void Z7_FASTCALL z7_x86_cpuid(UInt32 p[4], UInt32 func)
 {
  MY_cpuidex((int *)p, (int)func, 0);
 }
 Z7_NO_INLINE
 UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void)
 {
  int a[4];
  MY_cpuidex(a, 0, 0);
  return a[0];
 }
 #endif // MY_CPU_AMD64
 #endif // _MSC_VER
 #if defined(NEED_CHECK_FOR_CPUID)
 #define CHECK_CPUID_IS_SUPPORTED { if (z7_x86_cpuid_GetMaxFunc() == 0) return 0; }
 #else
 #define CHECK_CPUID_IS_SUPPORTED
 #endif
 #undef NEED_CHECK_FOR_CPUID
 static
 BoolInt x86cpuid_Func_1(UInt32 *p)
 {
  CHECK_CPUID_IS_SUPPORTED
  z7_x86_cpuid(p, 1);
  return True;
 }
 /*
 static const UInt32 kVendors[][1] =
 {
  { 0x756E6547 }, // , 0x49656E69, 0x6C65746E },
  { 0x68747541 }, // , 0x69746E65, 0x444D4163 },
  { 0x746E6543 }  // , 0x48727561, 0x736C7561 }
 };
 */
 /*
 typedef struct
 {
  UInt32 maxFunc;
  UInt32 vendor[3];
  UInt32 ver;
  UInt32 b;
  UInt32 c;
  UInt32 d;
 } Cx86cpuid;
 enum
 {
  CPU_FIRM_INTEL,
  CPU_FIRM_AMD,
  CPU_FIRM_VIA
 };
 int x86cpuid_GetFirm(const Cx86cpuid *p);
 #define x86cpuid_ver_GetFamily(ver) (((ver >> 16) & 0xff0) | ((ver >> 8) & 0xf))
 #define x86cpuid_ver_GetModel(ver)  (((ver >> 12) &  0xf0) | ((ver >> 4) & 0xf))
 #define x86cpuid_ver_GetStepping(ver) (ver & 0xf)
 int x86cpuid_GetFirm(const Cx86cpuid *p)
 {
  unsigned i;
  for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[0]); i++)
  {
    const UInt32 *v = kVendors[i];
    if (v[0] == p->vendor[0]
        // && v[1] == p->vendor[1]
        // && v[2] == p->vendor[2]
        )
      return (int)i;
  }
  return -1;
 }
 BoolInt CPU_Is_InOrder()
 {
  Cx86cpuid p;
  UInt32 family, model;
  if (!x86cpuid_CheckAndRead(&p))
    return True;
  family = x86cpuid_ver_GetFamily(p.ver);
  model = x86cpuid_ver_GetModel(p.ver);
  switch (x86cpuid_GetFirm(&p))
  {
    case CPU_FIRM_INTEL: return (family < 6 || (family == 6 && (
        // In-Order Atom CPU
           model == 0x1C  // 45 nm, N4xx, D4xx, N5xx, D5xx, 230, 330
        || model == 0x26  // 45 nm, Z6xx
        || model == 0x27  // 32 nm, Z2460
        || model == 0x35  // 32 nm, Z2760
        || model == 0x36  // 32 nm, N2xxx, D2xxx
        )));
    case CPU_FIRM_AMD: return (family < 5 || (family == 5 && (model < 6 || model == 0xA)));
    case CPU_FIRM_VIA: return (family < 6 || (family == 6 && model < 0xF));
  }
  return False; // v23 : unknown processors are not In-Order
 }
 */
 #ifdef _WIN32
 #include "7zWindows.h"
 #endif
 #if !defined(MY_CPU_AMD64) && defined(_WIN32)
 /* for legacy SSE ia32: there is no user-space cpu instruction to check
   that OS supports SSE register storing/restoring on context switches.
   So we need some OS-specific function to check that it's safe to use SSE registers.
 */
 Z7_FORCE_INLINE
 static BoolInt CPU_Sys_Is_SSE_Supported(void)
 {
 #ifdef _MSC_VER
  #pragma warning(push)
  #pragma warning(disable : 4996) // `GetVersion': was declared deprecated
 #endif
  /* low byte is major version of Windows
     We suppose that any Windows version since
     Windows2000 (major == 5) supports SSE registers */
  return (Byte)GetVersion() >= 5;
 #if defined(_MSC_VER)
  #pragma warning(pop)
 #endif
 }
 #define CHECK_SYS_SSE_SUPPORT if (!CPU_Sys_Is_SSE_Supported()) return False;
 #else
 #define CHECK_SYS_SSE_SUPPORT
 #endif
 #if !defined(MY_CPU_AMD64)
 BoolInt CPU_IsSupported_CMOV(void)
 {
  UInt32 a[4];
  if (!x86cpuid_Func_1(&a[0]))
    return 0;
  return (a[3] >> 15) & 1;
 }
 BoolInt CPU_IsSupported_SSE(void)
 {
  UInt32 a[4];
  CHECK_SYS_SSE_SUPPORT
  if (!x86cpuid_Func_1(&a[0]))
    return 0;
  return (a[3] >> 25) & 1;
 }
 BoolInt CPU_IsSupported_SSE2(void)
 {
  UInt32 a[4];
  CHECK_SYS_SSE_SUPPORT
  if (!x86cpuid_Func_1(&a[0]))
    return 0;
  return (a[3] >> 26) & 1;
 }
 #endif
 static UInt32 x86cpuid_Func_1_ECX(void)
 {
  UInt32 a[4];
  CHECK_SYS_SSE_SUPPORT
  if (!x86cpuid_Func_1(&a[0]))
    return 0;
  return a[2];
 }
 BoolInt CPU_IsSupported_AES(void)
 {
  return (x86cpuid_Func_1_ECX() >> 25) & 1;
 }
 BoolInt CPU_IsSupported_SSSE3(void)
 {
  return (x86cpuid_Func_1_ECX() >> 9) & 1;
 }
 BoolInt CPU_IsSupported_SSE41(void)
 {
  return (x86cpuid_Func_1_ECX() >> 19) & 1;
 }
 BoolInt CPU_IsSupported_SHA(void)
 {
  CHECK_SYS_SSE_SUPPORT
  if (z7_x86_cpuid_GetMaxFunc() < 7)
    return False;
  {
    UInt32 d[4];
    z7_x86_cpuid(d, 7);
    return (d[1] >> 29) & 1;
  }
 }
 /*
 MSVC: _xgetbv() intrinsic is available since VS2010SP1.
   MSVC also defines (_XCR_XFEATURE_ENABLED_MASK) macro in
   <immintrin.h> that we can use or check.
   For any 32-bit x86 we can use asm code in MSVC,
   but MSVC asm code is huge after compilation.
   So _xgetbv() is better
 ICC: _xgetbv() intrinsic is available (in what version of ICC?)
   ICC defines (__GNUC___) and it supports gnu assembler
   also ICC supports MASM style code with -use-msasm switch.
   but ICC doesn't support __attribute__((__target__))
 GCC/CLANG 9:
  _xgetbv() is macro that works via __builtin_ia32_xgetbv()
  and we need __attribute__((__target__("xsave")).
  But with __target__("xsave") the function will be not
  inlined to function that has no __target__("xsave") attribute.
  If we want _xgetbv() call inlining, then we should use asm version
  instead of calling _xgetbv().
  Note:intrinsic is broke before GCC 8.2:
    https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85684
 */
 #if    defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100) \
    || defined(_MSC_VER) && (_MSC_VER >= 1600) && (_MSC_FULL_VER >= 160040219)  \
    || defined(__GNUC__) && (__GNUC__ >= 9) \
    || defined(__clang__) && (__clang_major__ >= 9)
 // we define ATTRIB_XGETBV, if we want to use predefined _xgetbv() from compiler
 #if defined(__INTEL_COMPILER)
 #define ATTRIB_XGETBV
 #elif defined(__GNUC__) || defined(__clang__)
 // we don't define ATTRIB_XGETBV here, because asm version is better for inlining.
 // #define ATTRIB_XGETBV __attribute__((__target__("xsave")))
 #else
 #define ATTRIB_XGETBV
 #endif
 #endif
 #if defined(ATTRIB_XGETBV)
 #include <immintrin.h>
 #endif
 // XFEATURE_ENABLED_MASK/XCR0
 #define MY_XCR_XFEATURE_ENABLED_MASK 0
 #if defined(ATTRIB_XGETBV)
 ATTRIB_XGETBV
 #endif
 static UInt64 x86_xgetbv_0(UInt32 num)
 {
 #if defined(ATTRIB_XGETBV)
  {
    return
      #if (defined(_MSC_VER))
        _xgetbv(num);
      #else
        __builtin_ia32_xgetbv(
          #if !defined(__clang__)
            (int)
          #endif
            num);
      #endif
  }
 #elif defined(__GNUC__) || defined(__clang__) || defined(__SUNPRO_CC)
  UInt32 a, d;
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
  __asm__
  (
    "xgetbv"
    : "=a"(a), "=d"(d) : "c"(num) : "cc"
  );
 #else // is old gcc
  __asm__
  (
    ".byte 0x0f, 0x01, 0xd0" "\n\t"
    : "=a"(a), "=d"(d) : "c"(num) : "cc"
  );
 #endif
  return ((UInt64)d << 32) | a;
  // return a;
 #elif defined(_MSC_VER) && !defined(MY_CPU_AMD64)
  UInt32 a, d;
  __asm {
    push eax
    push edx
    push ecx
    mov ecx, num;
    // xor ecx, ecx // = MY_XCR_XFEATURE_ENABLED_MASK
    _emit 0x0f
    _emit 0x01
    _emit 0xd0
    mov a, eax
    mov d, edx
    pop ecx
    pop edx
    pop eax
  }
  return ((UInt64)d << 32) | a;
  // return a;
 #else // it's unknown compiler
  // #error "Need xgetbv function"
  UNUSED_VAR(num)
  // for MSVC-X64 we could call external function from external file.
  /* Actually we had checked OSXSAVE/AVX in cpuid before.
     So it's expected that OS supports at least AVX and below. */
  // if (num != MY_XCR_XFEATURE_ENABLED_MASK) return 0; // if not XCR0
  return
      // (1 << 0) |  // x87
        (1 << 1)   // SSE
      | (1 << 2);  // AVX
 #endif
 }
 #ifdef _WIN32
 /*
  Windows versions do not know about new ISA extensions that
  can be introduced. But we still can use new extensions,
  even if Windows doesn't report about supporting them,
  But we can use new extensions, only if Windows knows about new ISA extension
  that changes the number or size of registers: SSE, AVX/XSAVE, AVX512
  So it's enough to check
    MY_PF_AVX_INSTRUCTIONS_AVAILABLE
      instead of
    MY_PF_AVX2_INSTRUCTIONS_AVAILABLE
 */
 #define MY_PF_XSAVE_ENABLED                            17
 // #define MY_PF_SSSE3_INSTRUCTIONS_AVAILABLE             36
 // #define MY_PF_SSE4_1_INSTRUCTIONS_AVAILABLE            37
 // #define MY_PF_SSE4_2_INSTRUCTIONS_AVAILABLE            38
 // #define MY_PF_AVX_INSTRUCTIONS_AVAILABLE               39
 // #define MY_PF_AVX2_INSTRUCTIONS_AVAILABLE              40
 // #define MY_PF_AVX512F_INSTRUCTIONS_AVAILABLE           41
 #endif
 BoolInt CPU_IsSupported_AVX(void)
 {
  #ifdef _WIN32
  if (!IsProcessorFeaturePresent(MY_PF_XSAVE_ENABLED))
    return False;
  /* PF_AVX_INSTRUCTIONS_AVAILABLE probably is supported starting from
     some latest Win10 revisions. But we need AVX in older Windows also.
     So we don't use the following check: */
  /*
  if (!IsProcessorFeaturePresent(MY_PF_AVX_INSTRUCTIONS_AVAILABLE))
    return False;
  */
  #endif
  /*
    OS must use new special XSAVE/XRSTOR instructions to save
    AVX registers when it required for context switching.
    At OS statring:
      OS sets CR4.OSXSAVE flag to signal the processor that OS supports the XSAVE extensions.
      Also OS sets bitmask in XCR0 register that defines what
      registers will be processed by XSAVE instruction:
        XCR0.SSE[bit 0] - x87 registers and state
        XCR0.SSE[bit 1] - SSE registers and state
        XCR0.AVX[bit 2] - AVX registers and state
    CR4.OSXSAVE is reflected to CPUID.1:ECX.OSXSAVE[bit 27].
       So we can read that bit in user-space.
    XCR0 is available for reading in user-space by new XGETBV instruction.
  */
  {
    const UInt32 c = x86cpuid_Func_1_ECX();
    if (0 == (1
        & (c >> 28)   // AVX instructions are supported by hardware
        & (c >> 27))) // OSXSAVE bit: XSAVE and related instructions are enabled by OS.
      return False;
  }
  /* also we can check
     CPUID.1:ECX.XSAVE [bit 26] : that shows that
        XSAVE, XRESTOR, XSETBV, XGETBV instructions are supported by hardware.
     But that check is redundant, because if OSXSAVE bit is set, then XSAVE is also set */
  /* If OS have enabled XSAVE extension instructions (OSXSAVE == 1),
     in most cases we expect that OS also will support storing/restoring
     for AVX and SSE states at least.
     But to be ensure for that we call user-space instruction
     XGETBV(0) to get XCR0 value that contains bitmask that defines
     what exact states(registers) OS have enabled for storing/restoring.
  */
  {
    const UInt32 bm = (UInt32)x86_xgetbv_0(MY_XCR_XFEATURE_ENABLED_MASK);
    // printf("\n=== XGetBV=%d\n", bm);
    return 1
        & (bm >> 1)  // SSE state is supported (set by OS) for storing/restoring
        & (bm >> 2); // AVX state is supported (set by OS) for storing/restoring
  }
  // since Win7SP1: we can use GetEnabledXStateFeatures();
 }
 BoolInt CPU_IsSupported_AVX2(void)
 {
  if (!CPU_IsSupported_AVX())
    return False;
  if (z7_x86_cpuid_GetMaxFunc() < 7)
    return False;
  {
    UInt32 d[4];
    z7_x86_cpuid(d, 7);
    // printf("\ncpuid(7): ebx=%8x ecx=%8x\n", d[1], d[2]);
    return 1
      & (d[1] >> 5); // avx2
  }
 }
 BoolInt CPU_IsSupported_VAES_AVX2(void)
 {
  if (!CPU_IsSupported_AVX())
    return False;
  if (z7_x86_cpuid_GetMaxFunc() < 7)
    return False;
  {
    UInt32 d[4];
    z7_x86_cpuid(d, 7);
    // printf("\ncpuid(7): ebx=%8x ecx=%8x\n", d[1], d[2]);
    return 1
      & (d[1] >> 5) // avx2
      // & (d[1] >> 31) // avx512vl
      & (d[2] >> 9); // vaes // VEX-256/EVEX
  }
 }
 BoolInt CPU_IsSupported_PageGB(void)
 {
  CHECK_CPUID_IS_SUPPORTED
  {
    UInt32 d[4];
    z7_x86_cpuid(d, 0x80000000);
    if (d[0] < 0x80000001)
      return False;
    z7_x86_cpuid(d, 0x80000001);
    return (d[3] >> 26) & 1;
  }
 }
 #elif defined(MY_CPU_ARM_OR_ARM64)
 #ifdef _WIN32
 #include "7zWindows.h"
 BoolInt CPU_IsSupported_CRC32(void)  { return IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }
 BoolInt CPU_IsSupported_CRYPTO(void) { return IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }
 BoolInt CPU_IsSupported_NEON(void)   { return IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }
 #else
 #if defined(__APPLE__)
 /*
 #include <stdio.h>
 #include <string.h>
 static void Print_sysctlbyname(const char *name)
 {
  size_t bufSize = 256;
  char buf[256];
  int res = sysctlbyname(name, &buf, &bufSize, NULL, 0);
  {
    int i;
    printf("\nres = %d : %s : '%s' : bufSize = %d, numeric", res, name, buf, (unsigned)bufSize);
    for (i = 0; i < 20; i++)
      printf(" %2x", (unsigned)(Byte)buf[i]);
  }
 }
 */
 /*
  Print_sysctlbyname("hw.pagesize");
  Print_sysctlbyname("machdep.cpu.brand_string");
 */
 static BoolInt z7_sysctlbyname_Get_BoolInt(const char *name)
 {
  UInt32 val = 0;
  if (z7_sysctlbyname_Get_UInt32(name, &val) == 0 && val == 1)
    return 1;
  return 0;
 }
 BoolInt CPU_IsSupported_CRC32(void)
 {
  return z7_sysctlbyname_Get_BoolInt("hw.optional.armv8_crc32");
 }
 BoolInt CPU_IsSupported_NEON(void)
 {
  return z7_sysctlbyname_Get_BoolInt("hw.optional.neon");
 }
 #ifdef MY_CPU_ARM64
 #define APPLE_CRYPTO_SUPPORT_VAL 1
 #else
 #define APPLE_CRYPTO_SUPPORT_VAL 0
 #endif
 BoolInt CPU_IsSupported_SHA1(void) { return APPLE_CRYPTO_SUPPORT_VAL; }
 BoolInt CPU_IsSupported_SHA2(void) { return APPLE_CRYPTO_SUPPORT_VAL; }
 BoolInt CPU_IsSupported_AES (void) { return APPLE_CRYPTO_SUPPORT_VAL; }
 #else // __APPLE__
 #include <sys/auxv.h>
 #define USE_HWCAP
 #ifdef USE_HWCAP
 #include <asm/hwcap.h>
  #define MY_HWCAP_CHECK_FUNC_2(name1, name2) \
  BoolInt CPU_IsSupported_ ## name1() { return (getauxval(AT_HWCAP)  & (HWCAP_  ## name2)) ? 1 : 0; }
 #ifdef MY_CPU_ARM64
  #define MY_HWCAP_CHECK_FUNC(name) \
  MY_HWCAP_CHECK_FUNC_2(name, name)
  MY_HWCAP_CHECK_FUNC_2(NEON, ASIMD)
 // MY_HWCAP_CHECK_FUNC (ASIMD)
 #elif defined(MY_CPU_ARM)
  #define MY_HWCAP_CHECK_FUNC(name) \
  BoolInt CPU_IsSupported_ ## name() { return (getauxval(AT_HWCAP2) & (HWCAP2_ ## name)) ? 1 : 0; }
  MY_HWCAP_CHECK_FUNC_2(NEON, NEON)
 #endif
 #else // USE_HWCAP
  #define MY_HWCAP_CHECK_FUNC(name) \
  BoolInt CPU_IsSupported_ ## name() { return 0; }
  MY_HWCAP_CHECK_FUNC(NEON)
 #endif // USE_HWCAP
 MY_HWCAP_CHECK_FUNC (CRC32)
 MY_HWCAP_CHECK_FUNC (SHA1)
 MY_HWCAP_CHECK_FUNC (SHA2)
 MY_HWCAP_CHECK_FUNC (AES)
 #endif // __APPLE__
 #endif // _WIN32
 #endif // MY_CPU_ARM_OR_ARM64
 #ifdef __APPLE__
 #include <sys/sysctl.h>
 int z7_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize)
 {
  return sysctlbyname(name, buf, bufSize, NULL, 0);
 }
 int z7_sysctlbyname_Get_UInt32(const char *name, UInt32 *val)
 {
  size_t bufSize = sizeof(*val);
  const int res = z7_sysctlbyname_Get(name, val, &bufSize);
  if (res == 0 && bufSize != sizeof(*val))
    return EFAULT;
  return res;
 }
 #endif
--- a/3rdparty/7z/src/CpuArch.h
+++ b/3rdparty/7z/src/CpuArch.h
@ -0,0 +1,523 @@
 /* CpuArch.h -- CPU specific code
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_CPU_ARCH_H
 #define ZIP7_INC_CPU_ARCH_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 /*
 MY_CPU_LE means that CPU is LITTLE ENDIAN.
 MY_CPU_BE means that CPU is BIG ENDIAN.
 If MY_CPU_LE and MY_CPU_BE are not defined, we don't know about ENDIANNESS of platform.
 MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned memory accesses.
 MY_CPU_64BIT means that processor can work with 64-bit registers.
  MY_CPU_64BIT can be used to select fast code branch
  MY_CPU_64BIT doesn't mean that (sizeof(void *) == 8)
 */
 #if  defined(_M_X64) \
  || defined(_M_AMD64) \
  || defined(__x86_64__) \
  || defined(__AMD64__) \
  || defined(__amd64__)
  #define MY_CPU_AMD64
  #ifdef __ILP32__
    #define MY_CPU_NAME "x32"
    #define MY_CPU_SIZEOF_POINTER 4
  #else
    #define MY_CPU_NAME "x64"
    #define MY_CPU_SIZEOF_POINTER 8
  #endif
  #define MY_CPU_64BIT
 #endif
 #if  defined(_M_IX86) \
  || defined(__i386__)
  #define MY_CPU_X86
  #define MY_CPU_NAME "x86"
  /* #define MY_CPU_32BIT */
  #define MY_CPU_SIZEOF_POINTER 4
 #endif
 #if  defined(_M_ARM64) \
  || defined(__AARCH64EL__) \
  || defined(__AARCH64EB__) \
  || defined(__aarch64__)
  #define MY_CPU_ARM64
  #ifdef __ILP32__
    #define MY_CPU_NAME "arm64-32"
    #define MY_CPU_SIZEOF_POINTER 4
  #else
    #define MY_CPU_NAME "arm64"
    #define MY_CPU_SIZEOF_POINTER 8
  #endif
  #define MY_CPU_64BIT
 #endif
 #if  defined(_M_ARM) \
  || defined(_M_ARM_NT) \
  || defined(_M_ARMT) \
  || defined(__arm__) \
  || defined(__thumb__) \
  || defined(__ARMEL__) \
  || defined(__ARMEB__) \
  || defined(__THUMBEL__) \
  || defined(__THUMBEB__)
  #define MY_CPU_ARM
  #if defined(__thumb__) || defined(__THUMBEL__) || defined(_M_ARMT)
    #define MY_CPU_ARMT
    #define MY_CPU_NAME "armt"
  #else
    #define MY_CPU_ARM32
    #define MY_CPU_NAME "arm"
  #endif
  /* #define MY_CPU_32BIT */
  #define MY_CPU_SIZEOF_POINTER 4
 #endif
 #if  defined(_M_IA64) \
  || defined(__ia64__)
  #define MY_CPU_IA64
  #define MY_CPU_NAME "ia64"
  #define MY_CPU_64BIT
 #endif
 #if  defined(__mips64) \
  || defined(__mips64__) \
  || (defined(__mips) && (__mips == 64 || __mips == 4 || __mips == 3))
  #define MY_CPU_NAME "mips64"
  #define MY_CPU_64BIT
 #elif defined(__mips__)
  #define MY_CPU_NAME "mips"
  /* #define MY_CPU_32BIT */
 #endif
 #if  defined(__ppc64__) \
  || defined(__powerpc64__) \
  || defined(__ppc__) \
  || defined(__powerpc__) \
  || defined(__PPC__) \
  || defined(_POWER)
 #define MY_CPU_PPC_OR_PPC64
 #if  defined(__ppc64__) \
  || defined(__powerpc64__) \
  || defined(_LP64) \
  || defined(__64BIT__)
  #ifdef __ILP32__
    #define MY_CPU_NAME "ppc64-32"
    #define MY_CPU_SIZEOF_POINTER 4
  #else
    #define MY_CPU_NAME "ppc64"
    #define MY_CPU_SIZEOF_POINTER 8
  #endif
  #define MY_CPU_64BIT
 #else
  #define MY_CPU_NAME "ppc"
  #define MY_CPU_SIZEOF_POINTER 4
  /* #define MY_CPU_32BIT */
 #endif
 #endif
 #if  defined(__riscv) \
  || defined(__riscv__)
  #if __riscv_xlen == 32
    #define MY_CPU_NAME "riscv32"
  #elif __riscv_xlen == 64
    #define MY_CPU_NAME "riscv64"
  #else
    #define MY_CPU_NAME "riscv"
  #endif
 #endif
 #if defined(MY_CPU_X86) || defined(MY_CPU_AMD64)
 #define MY_CPU_X86_OR_AMD64
 #endif
 #if defined(MY_CPU_ARM) || defined(MY_CPU_ARM64)
 #define MY_CPU_ARM_OR_ARM64
 #endif
 #ifdef _WIN32
  #ifdef MY_CPU_ARM
  #define MY_CPU_ARM_LE
  #endif
  #ifdef MY_CPU_ARM64
  #define MY_CPU_ARM64_LE
  #endif
  #ifdef _M_IA64
  #define MY_CPU_IA64_LE
  #endif
 #endif
 #if defined(MY_CPU_X86_OR_AMD64) \
    || defined(MY_CPU_ARM_LE) \
    || defined(MY_CPU_ARM64_LE) \
    || defined(MY_CPU_IA64_LE) \
    || defined(__LITTLE_ENDIAN__) \
    || defined(__ARMEL__) \
    || defined(__THUMBEL__) \
    || defined(__AARCH64EL__) \
    || defined(__MIPSEL__) \
    || defined(__MIPSEL) \
    || defined(_MIPSEL) \
    || defined(__BFIN__) \
    || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
  #define MY_CPU_LE
 #endif
 #if defined(__BIG_ENDIAN__) \
    || defined(__ARMEB__) \
    || defined(__THUMBEB__) \
    || defined(__AARCH64EB__) \
    || defined(__MIPSEB__) \
    || defined(__MIPSEB) \
    || defined(_MIPSEB) \
    || defined(__m68k__) \
    || defined(__s390__) \
    || defined(__s390x__) \
    || defined(__zarch__) \
    || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
  #define MY_CPU_BE
 #endif
 #if defined(MY_CPU_LE) && defined(MY_CPU_BE)
  #error Stop_Compiling_Bad_Endian
 #endif
 #if !defined(MY_CPU_LE) && !defined(MY_CPU_BE)
  #error Stop_Compiling_CPU_ENDIAN_must_be_detected_at_compile_time
 #endif
 #if defined(MY_CPU_32BIT) && defined(MY_CPU_64BIT)
  #error Stop_Compiling_Bad_32_64_BIT
 #endif
 #ifdef __SIZEOF_POINTER__
  #ifdef MY_CPU_SIZEOF_POINTER
    #if MY_CPU_SIZEOF_POINTER != __SIZEOF_POINTER__
      #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE
    #endif
  #else
    #define MY_CPU_SIZEOF_POINTER  __SIZEOF_POINTER__
  #endif
 #endif
 #if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4)
 #if defined (_LP64)
      #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE
 #endif
 #endif
 #ifdef _MSC_VER
  #if _MSC_VER >= 1300
    #define MY_CPU_pragma_pack_push_1   __pragma(pack(push, 1))
    #define MY_CPU_pragma_pop           __pragma(pack(pop))
  #else
    #define MY_CPU_pragma_pack_push_1
    #define MY_CPU_pragma_pop
  #endif
 #else
  #ifdef __xlC__
    #define MY_CPU_pragma_pack_push_1   _Pragma("pack(1)")
    #define MY_CPU_pragma_pop           _Pragma("pack()")
  #else
    #define MY_CPU_pragma_pack_push_1   _Pragma("pack(push, 1)")
    #define MY_CPU_pragma_pop           _Pragma("pack(pop)")
  #endif
 #endif
 #ifndef MY_CPU_NAME
  #ifdef MY_CPU_LE
    #define MY_CPU_NAME "LE"
  #elif defined(MY_CPU_BE)
    #define MY_CPU_NAME "BE"
  #else
    /*
    #define MY_CPU_NAME ""
    */
  #endif
 #endif
 #ifdef __has_builtin
  #define Z7_has_builtin(x)  __has_builtin(x)
 #else
  #define Z7_has_builtin(x)  0
 #endif
 #define Z7_BSWAP32_CONST(v) \
       ( (((UInt32)(v) << 24)                   ) \
       | (((UInt32)(v) <<  8) & (UInt32)0xff0000) \
       | (((UInt32)(v) >>  8) & (UInt32)0xff00  ) \
       | (((UInt32)(v) >> 24)                   ))
 #if defined(_MSC_VER) && (_MSC_VER >= 1300)
 #include <stdlib.h>
 /* Note: these macros will use bswap instruction (486), that is unsupported in 386 cpu */
 #pragma intrinsic(_byteswap_ushort)
 #pragma intrinsic(_byteswap_ulong)
 #pragma intrinsic(_byteswap_uint64)
 #define Z7_BSWAP16(v)  _byteswap_ushort(v)
 #define Z7_BSWAP32(v)  _byteswap_ulong (v)
 #define Z7_BSWAP64(v)  _byteswap_uint64(v)
 #define Z7_CPU_FAST_BSWAP_SUPPORTED
 #elif  (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) \
    || (defined(__clang__) && Z7_has_builtin(__builtin_bswap16))
 #define Z7_BSWAP16(v)  __builtin_bswap16(v)
 #define Z7_BSWAP32(v)  __builtin_bswap32(v)
 #define Z7_BSWAP64(v)  __builtin_bswap64(v)
 #define Z7_CPU_FAST_BSWAP_SUPPORTED
 #else
 #define Z7_BSWAP16(v) ((UInt16) \
       ( ((UInt32)(v) << 8) \
       | ((UInt32)(v) >> 8) \
       ))
 #define Z7_BSWAP32(v) Z7_BSWAP32_CONST(v)
 #define Z7_BSWAP64(v) \
       ( ( ( (UInt64)(v)                           ) << 8 * 7 ) \
       | ( ( (UInt64)(v) & ((UInt32)0xff << 8 * 1) ) << 8 * 5 ) \
       | ( ( (UInt64)(v) & ((UInt32)0xff << 8 * 2) ) << 8 * 3 ) \
       | ( ( (UInt64)(v) & ((UInt32)0xff << 8 * 3) ) << 8 * 1 ) \
       | ( ( (UInt64)(v) >> 8 * 1 ) & ((UInt32)0xff << 8 * 3) ) \
       | ( ( (UInt64)(v) >> 8 * 3 ) & ((UInt32)0xff << 8 * 2) ) \
       | ( ( (UInt64)(v) >> 8 * 5 ) & ((UInt32)0xff << 8 * 1) ) \
       | ( ( (UInt64)(v) >> 8 * 7 )                           ) \
       )
 #endif
 #ifdef MY_CPU_LE
  #if defined(MY_CPU_X86_OR_AMD64) \
      || defined(MY_CPU_ARM64)
    #define MY_CPU_LE_UNALIGN
    #define MY_CPU_LE_UNALIGN_64
  #elif defined(__ARM_FEATURE_UNALIGNED)
    /* gcc9 for 32-bit arm can use LDRD instruction that requires 32-bit alignment.
       So we can't use unaligned 64-bit operations. */
    #define MY_CPU_LE_UNALIGN
  #endif
 #endif
 #ifdef MY_CPU_LE_UNALIGN
 #define GetUi16(p) (*(const UInt16 *)(const void *)(p))
 #define GetUi32(p) (*(const UInt32 *)(const void *)(p))
 #ifdef MY_CPU_LE_UNALIGN_64
 #define GetUi64(p) (*(const UInt64 *)(const void *)(p))
 #define SetUi64(p, v) { *(UInt64 *)(void *)(p) = (v); }
 #endif
 #define SetUi16(p, v) { *(UInt16 *)(void *)(p) = (v); }
 #define SetUi32(p, v) { *(UInt32 *)(void *)(p) = (v); }
 #else
 #define GetUi16(p) ( (UInt16) ( \
             ((const Byte *)(p))[0] | \
    ((UInt16)((const Byte *)(p))[1] << 8) ))
 #define GetUi32(p) ( \
             ((const Byte *)(p))[0]        | \
    ((UInt32)((const Byte *)(p))[1] <<  8) | \
    ((UInt32)((const Byte *)(p))[2] << 16) | \
    ((UInt32)((const Byte *)(p))[3] << 24))
 #define SetUi16(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
    _ppp_[0] = (Byte)_vvv_; \
    _ppp_[1] = (Byte)(_vvv_ >> 8); }
 #define SetUi32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
    _ppp_[0] = (Byte)_vvv_; \
    _ppp_[1] = (Byte)(_vvv_ >> 8); \
    _ppp_[2] = (Byte)(_vvv_ >> 16); \
    _ppp_[3] = (Byte)(_vvv_ >> 24); }
 #endif
 #ifndef GetUi64
 #define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32))
 #endif
 #ifndef SetUi64
 #define SetUi64(p, v) { Byte *_ppp2_ = (Byte *)(p); UInt64 _vvv2_ = (v); \
    SetUi32(_ppp2_    , (UInt32)_vvv2_) \
    SetUi32(_ppp2_ + 4, (UInt32)(_vvv2_ >> 32)) }
 #endif
 #if defined(MY_CPU_LE_UNALIGN) && defined(Z7_CPU_FAST_BSWAP_SUPPORTED)
 #define GetBe32(p)  Z7_BSWAP32 (*(const UInt32 *)(const void *)(p))
 #define SetBe32(p, v) { (*(UInt32 *)(void *)(p)) = Z7_BSWAP32(v); }
 #if defined(MY_CPU_LE_UNALIGN_64)
 #define GetBe64(p)  Z7_BSWAP64 (*(const UInt64 *)(const void *)(p))
 #endif
 #else
 #define GetBe32(p) ( \
    ((UInt32)((const Byte *)(p))[0] << 24) | \
    ((UInt32)((const Byte *)(p))[1] << 16) | \
    ((UInt32)((const Byte *)(p))[2] <<  8) | \
             ((const Byte *)(p))[3] )
 #define SetBe32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
    _ppp_[0] = (Byte)(_vvv_ >> 24); \
    _ppp_[1] = (Byte)(_vvv_ >> 16); \
    _ppp_[2] = (Byte)(_vvv_ >> 8); \
    _ppp_[3] = (Byte)_vvv_; }
 #endif
 #ifndef GetBe64
 #define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))
 #endif
 #ifndef GetBe16
 #define GetBe16(p) ( (UInt16) ( \
    ((UInt16)((const Byte *)(p))[0] << 8) | \
             ((const Byte *)(p))[1] ))
 #endif
 #if defined(MY_CPU_BE)
 #define Z7_CONV_BE_TO_NATIVE_CONST32(v)  (v)
 #define Z7_CONV_LE_TO_NATIVE_CONST32(v)  Z7_BSWAP32_CONST(v)
 #define Z7_CONV_NATIVE_TO_BE_32(v)       (v)
 #elif defined(MY_CPU_LE)
 #define Z7_CONV_BE_TO_NATIVE_CONST32(v)  Z7_BSWAP32_CONST(v)
 #define Z7_CONV_LE_TO_NATIVE_CONST32(v)  (v)
 #define Z7_CONV_NATIVE_TO_BE_32(v)       Z7_BSWAP32(v)
 #else
 #error Stop_Compiling_Unknown_Endian_CONV
 #endif
 #if defined(MY_CPU_BE)
 #define GetBe32a(p)      (*(const UInt32 *)(const void *)(p))
 #define GetBe16a(p)      (*(const UInt16 *)(const void *)(p))
 #define SetBe32a(p, v)   { *(UInt32 *)(void *)(p) = (v); }
 #define SetBe16a(p, v)   { *(UInt16 *)(void *)(p) = (v); }
 #define GetUi32a(p)      GetUi32(p)
 #define GetUi16a(p)      GetUi16(p)
 #define SetUi32a(p, v)   SetUi32(p, v)
 #define SetUi16a(p, v)   SetUi16(p, v)
 #elif defined(MY_CPU_LE)
 #define GetUi32a(p)      (*(const UInt32 *)(const void *)(p))
 #define GetUi16a(p)      (*(const UInt16 *)(const void *)(p))
 #define SetUi32a(p, v)   { *(UInt32 *)(void *)(p) = (v); }
 #define SetUi16a(p, v)   { *(UInt16 *)(void *)(p) = (v); }
 #define GetBe32a(p)      GetBe32(p)
 #define GetBe16a(p)      GetBe16(p)
 #define SetBe32a(p, v)   SetBe32(p, v)
 #define SetBe16a(p, v)   SetBe16(p, v)
 #else
 #error Stop_Compiling_Unknown_Endian_CPU_a
 #endif
 #if defined(MY_CPU_X86_OR_AMD64) \
  || defined(MY_CPU_ARM_OR_ARM64) \
  || defined(MY_CPU_PPC_OR_PPC64)
  #define Z7_CPU_FAST_ROTATE_SUPPORTED
 #endif
 #ifdef MY_CPU_X86_OR_AMD64
 void Z7_FASTCALL z7_x86_cpuid(UInt32 a[4], UInt32 function);
 UInt32 Z7_FASTCALL z7_x86_cpuid_GetMaxFunc(void);
 #if defined(MY_CPU_AMD64)
 #define Z7_IF_X86_CPUID_SUPPORTED
 #else
 #define Z7_IF_X86_CPUID_SUPPORTED if (z7_x86_cpuid_GetMaxFunc())
 #endif
 BoolInt CPU_IsSupported_AES(void);
 BoolInt CPU_IsSupported_AVX(void);
 BoolInt CPU_IsSupported_AVX2(void);
 BoolInt CPU_IsSupported_VAES_AVX2(void);
 BoolInt CPU_IsSupported_CMOV(void);
 BoolInt CPU_IsSupported_SSE(void);
 BoolInt CPU_IsSupported_SSE2(void);
 BoolInt CPU_IsSupported_SSSE3(void);
 BoolInt CPU_IsSupported_SSE41(void);
 BoolInt CPU_IsSupported_SHA(void);
 BoolInt CPU_IsSupported_PageGB(void);
 #elif defined(MY_CPU_ARM_OR_ARM64)
 BoolInt CPU_IsSupported_CRC32(void);
 BoolInt CPU_IsSupported_NEON(void);
 #if defined(_WIN32)
 BoolInt CPU_IsSupported_CRYPTO(void);
 #define CPU_IsSupported_SHA1  CPU_IsSupported_CRYPTO
 #define CPU_IsSupported_SHA2  CPU_IsSupported_CRYPTO
 #define CPU_IsSupported_AES   CPU_IsSupported_CRYPTO
 #else
 BoolInt CPU_IsSupported_SHA1(void);
 BoolInt CPU_IsSupported_SHA2(void);
 BoolInt CPU_IsSupported_AES(void);
 #endif
 #endif
 #if defined(__APPLE__)
 int z7_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize);
 int z7_sysctlbyname_Get_UInt32(const char *name, UInt32 *val);
 #endif
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Delta.c
+++ b/3rdparty/7z/src/Delta.c
@ -0,0 +1,169 @@
 /* Delta.c -- Delta converter
 2021-02-09 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "Delta.h"
 void Delta_Init(Byte *state)
 {
  unsigned i;
  for (i = 0; i < DELTA_STATE_SIZE; i++)
    state[i] = 0;
 }
 void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size)
 {
  Byte temp[DELTA_STATE_SIZE];
  if (size == 0)
    return;
  {
    unsigned i = 0;
    do
      temp[i] = state[i];
    while (++i != delta);
  }
  if (size <= delta)
  {
    unsigned i = 0, k;
    do
    {
      Byte b = *data;
      *data++ = (Byte)(b - temp[i]);
      temp[i] = b;
    }
    while (++i != size);
    k = 0;
    do
    {
      if (i == delta)
        i = 0;
      state[k] = temp[i++];
    }
    while (++k != delta);
    return;
  }
  {
    Byte *p = data + size - delta;
    {
      unsigned i = 0;
      do
        state[i] = *p++;
      while (++i != delta);
    }
    {
      const Byte *lim = data + delta;
      ptrdiff_t dif = -(ptrdiff_t)delta;
      if (((ptrdiff_t)size + dif) & 1)
      {
        --p;  *p = (Byte)(*p - p[dif]);
      }
      while (p != lim)
      {
        --p;  *p = (Byte)(*p - p[dif]);
        --p;  *p = (Byte)(*p - p[dif]);
      }
      dif = -dif;
      do
      {
        --p;  *p = (Byte)(*p - temp[--dif]);
      }
      while (dif != 0);
    }
  }
 }
 void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size)
 {
  unsigned i;
  const Byte *lim;
  if (size == 0)
    return;
  i = 0;
  lim = data + size;
  if (size <= delta)
  {
    do
      *data = (Byte)(*data + state[i++]);
    while (++data != lim);
    for (; delta != i; state++, delta--)
      *state = state[i];
    data -= i;
  }
  else
  {
    /*
    #define B(n) b ## n
    #define I(n) Byte B(n) = state[n];
    #define U(n) { B(n) = (Byte)((B(n)) + *data++); data[-1] = (B(n)); }
    #define F(n) if (data != lim) { U(n) }
    if (delta == 1)
    {
      I(0)
      if ((lim - data) & 1) { U(0) }
      while (data != lim) { U(0) U(0) }
      data -= 1;
    }
    else if (delta == 2)
    {
      I(0) I(1)
      lim -= 1; while (data < lim) { U(0) U(1) }
      lim += 1; F(0)
      data -= 2;
    }
    else if (delta == 3)
    {
      I(0) I(1) I(2)
      lim -= 2; while (data < lim) { U(0) U(1) U(2) }
      lim += 2; F(0) F(1)
      data -= 3;
    }
    else if (delta == 4)
    {
      I(0) I(1) I(2) I(3)
      lim -= 3; while (data < lim) { U(0) U(1) U(2) U(3) }
      lim += 3; F(0) F(1) F(2)
      data -= 4;
    }
    else
    */
    {
      do
      {
        *data = (Byte)(*data + state[i++]);
        data++;
      }
      while (i != delta);
      {
        ptrdiff_t dif = -(ptrdiff_t)delta;
        do
          *data = (Byte)(*data + data[dif]);
        while (++data != lim);
        data += dif;
      }
    }
  }
  do
    *state++ = *data;
  while (++data != lim);
 }
--- a/3rdparty/7z/src/Delta.h
+++ b/3rdparty/7z/src/Delta.h
@ -0,0 +1,19 @@
 /* Delta.h -- Delta converter
 2023-03-03 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_DELTA_H
 #define ZIP7_INC_DELTA_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #define DELTA_STATE_SIZE 256
 void Delta_Init(Byte *state);
 void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size);
 void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/DllSecur.c
+++ b/3rdparty/7z/src/DllSecur.c
@ -0,0 +1,111 @@
 /* DllSecur.c -- DLL loading security
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #ifdef _WIN32
 #include "7zWindows.h"
 #include "DllSecur.h"
 #ifndef UNDER_CE
 #if (defined(__GNUC__) && (__GNUC__ >= 8)) || defined(__clang__)
  // #pragma GCC diagnostic ignored "-Wcast-function-type"
 #endif
 #if defined(__clang__) || defined(__GNUC__)
 typedef void (*Z7_voidFunction)(void);
 #define MY_CAST_FUNC (Z7_voidFunction)
 #elif defined(_MSC_VER) && _MSC_VER > 1920
 #define MY_CAST_FUNC  (void *)
 // #pragma warning(disable : 4191) // 'type cast': unsafe conversion from 'FARPROC' to 'void (__cdecl *)()'
 #else
 #define MY_CAST_FUNC
 #endif
 typedef BOOL (WINAPI *Func_SetDefaultDllDirectories)(DWORD DirectoryFlags);
 #define MY_LOAD_LIBRARY_SEARCH_USER_DIRS 0x400
 #define MY_LOAD_LIBRARY_SEARCH_SYSTEM32  0x800
 #define DELIM "\0"
 static const char * const g_Dlls =
         "userenv"
  DELIM  "setupapi"
  DELIM  "apphelp"
  DELIM  "propsys"
  DELIM  "dwmapi"
  DELIM  "cryptbase"
  DELIM  "oleacc"
  DELIM  "clbcatq"
  DELIM  "version"
  #ifndef _CONSOLE
  DELIM  "uxtheme"
  #endif
  DELIM;
 #endif
 #ifdef __clang__
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 #if defined (_MSC_VER) && _MSC_VER >= 1900
 // sysinfoapi.h: kit10: GetVersion was declared deprecated
 #pragma warning(disable : 4996)
 #endif
 #define IF_NON_VISTA_SET_DLL_DIRS_AND_RETURN \
    if ((UInt16)GetVersion() != 6) { \
      const \
       Func_SetDefaultDllDirectories setDllDirs = \
      (Func_SetDefaultDllDirectories) MY_CAST_FUNC GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), \
           "SetDefaultDllDirectories"); \
      if (setDllDirs) if (setDllDirs(MY_LOAD_LIBRARY_SEARCH_SYSTEM32 | MY_LOAD_LIBRARY_SEARCH_USER_DIRS)) return; }
 void My_SetDefaultDllDirectories(void)
 {
  #ifndef UNDER_CE
  IF_NON_VISTA_SET_DLL_DIRS_AND_RETURN
  #endif
 }
 void LoadSecurityDlls(void)
 {
  #ifndef UNDER_CE
  // at Vista (ver 6.0) : CoCreateInstance(CLSID_ShellLink, ...) doesn't work after SetDefaultDllDirectories() : Check it ???
  IF_NON_VISTA_SET_DLL_DIRS_AND_RETURN
  {
    wchar_t buf[MAX_PATH + 100];
    const char *dll;
    unsigned pos = GetSystemDirectoryW(buf, MAX_PATH + 2);
    if (pos == 0 || pos > MAX_PATH)
      return;
    if (buf[pos - 1] != '\\')
      buf[pos++] = '\\';
    for (dll = g_Dlls; *dll != 0;)
    {
      wchar_t *dest = &buf[pos];
      for (;;)
      {
        const char c = *dll++;
        if (c == 0)
          break;
        *dest++ = (Byte)c;
      }
      dest[0] = '.';
      dest[1] = 'd';
      dest[2] = 'l';
      dest[3] = 'l';
      dest[4] = 0;
      // lstrcatW(buf, L".dll");
      LoadLibraryExW(buf, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
    }
  }
  #endif
 }
 #endif // _WIN32
--- a/3rdparty/7z/src/DllSecur.h
+++ b/3rdparty/7z/src/DllSecur.h
@ -0,0 +1,20 @@
 /* DllSecur.h -- DLL loading for security
 2023-03-03 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_DLL_SECUR_H
 #define ZIP7_INC_DLL_SECUR_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #ifdef _WIN32
 void My_SetDefaultDllDirectories(void);
 void LoadSecurityDlls(void);
 #endif
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/HuffEnc.c
+++ b/3rdparty/7z/src/HuffEnc.c
@ -0,0 +1,154 @@
 /* HuffEnc.c -- functions for Huffman encoding
 2023-03-04 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "HuffEnc.h"
 #include "Sort.h"
 #define kMaxLen 16
 #define NUM_BITS 10
 #define MASK (((unsigned)1 << NUM_BITS) - 1)
 #define NUM_COUNTERS 64
 #define HUFFMAN_SPEED_OPT
 void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 numSymbols, UInt32 maxLen)
 {
  UInt32 num = 0;
  /* if (maxLen > 10) maxLen = 10; */
  {
    UInt32 i;
    #ifdef HUFFMAN_SPEED_OPT
    UInt32 counters[NUM_COUNTERS];
    for (i = 0; i < NUM_COUNTERS; i++)
      counters[i] = 0;
    for (i = 0; i < numSymbols; i++)
    {
      UInt32 freq = freqs[i];
      counters[(freq < NUM_COUNTERS - 1) ? freq : NUM_COUNTERS - 1]++;
    }
    for (i = 1; i < NUM_COUNTERS; i++)
    {
      UInt32 temp = counters[i];
      counters[i] = num;
      num += temp;
    }
    for (i = 0; i < numSymbols; i++)
    {
      UInt32 freq = freqs[i];
      if (freq == 0)
        lens[i] = 0;
      else
        p[counters[((freq < NUM_COUNTERS - 1) ? freq : NUM_COUNTERS - 1)]++] = i | (freq << NUM_BITS);
    }
    counters[0] = 0;
    HeapSort(p + counters[NUM_COUNTERS - 2], counters[NUM_COUNTERS - 1] - counters[NUM_COUNTERS - 2]);
    #else
    for (i = 0; i < numSymbols; i++)
    {
      UInt32 freq = freqs[i];
      if (freq == 0)
        lens[i] = 0;
      else
        p[num++] = i | (freq << NUM_BITS);
    }
    HeapSort(p, num);
    #endif
  }
  if (num < 2)
  {
    unsigned minCode = 0;
    unsigned maxCode = 1;
    if (num == 1)
    {
      maxCode = (unsigned)p[0] & MASK;
      if (maxCode == 0)
        maxCode++;
    }
    p[minCode] = 0;
    p[maxCode] = 1;
    lens[minCode] = lens[maxCode] = 1;
    return;
  }
  {
    UInt32 b, e, i;
    i = b = e = 0;
    do
    {
      UInt32 n, m, freq;
      n = (i != num && (b == e || (p[i] >> NUM_BITS) <= (p[b] >> NUM_BITS))) ? i++ : b++;
      freq = (p[n] & ~MASK);
      p[n] = (p[n] & MASK) | (e << NUM_BITS);
      m = (i != num && (b == e || (p[i] >> NUM_BITS) <= (p[b] >> NUM_BITS))) ? i++ : b++;
      freq += (p[m] & ~MASK);
      p[m] = (p[m] & MASK) | (e << NUM_BITS);
      p[e] = (p[e] & MASK) | freq;
      e++;
    }
    while (num - e > 1);
    {
      UInt32 lenCounters[kMaxLen + 1];
      for (i = 0; i <= kMaxLen; i++)
        lenCounters[i] = 0;
      p[--e] &= MASK;
      lenCounters[1] = 2;
      while (e != 0)
      {
        UInt32 len = (p[p[--e] >> NUM_BITS] >> NUM_BITS) + 1;
        p[e] = (p[e] & MASK) | (len << NUM_BITS);
        if (len >= maxLen)
          for (len = maxLen - 1; lenCounters[len] == 0; len--);
        lenCounters[len]--;
        lenCounters[(size_t)len + 1] += 2;
      }
      {
        UInt32 len;
        i = 0;
        for (len = maxLen; len != 0; len--)
        {
          UInt32 k;
          for (k = lenCounters[len]; k != 0; k--)
            lens[p[i++] & MASK] = (Byte)len;
        }
      }
      {
        UInt32 nextCodes[kMaxLen + 1];
        {
          UInt32 code = 0;
          UInt32 len;
          for (len = 1; len <= kMaxLen; len++)
            nextCodes[len] = code = (code + lenCounters[(size_t)len - 1]) << 1;
        }
        /* if (code + lenCounters[kMaxLen] - 1 != (1 << kMaxLen) - 1) throw 1; */
        {
          UInt32 k;
          for (k = 0; k < numSymbols; k++)
            p[k] = nextCodes[lens[k]]++;
        }
      }
    }
  }
 }
 #undef kMaxLen
 #undef NUM_BITS
 #undef MASK
 #undef NUM_COUNTERS
 #undef HUFFMAN_SPEED_OPT
--- a/3rdparty/7z/src/HuffEnc.h
+++ b/3rdparty/7z/src/HuffEnc.h
@ -0,0 +1,23 @@
 /* HuffEnc.h -- Huffman encoding
 2023-03-05 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_HUFF_ENC_H
 #define ZIP7_INC_HUFF_ENC_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 /*
 Conditions:
  num <= 1024 = 2 ^ NUM_BITS
  Sum(freqs) < 4M = 2 ^ (32 - NUM_BITS)
  maxLen <= 16 = kMaxLen
  Num_Items(p) >= HUFFMAN_TEMP_SIZE(num)
 */
 void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 num, UInt32 maxLen);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/LzFind.c
+++ b/3rdparty/7z/src/LzFind.c
--- a/3rdparty/7z/src/LzFind.h
+++ b/3rdparty/7z/src/LzFind.h
@ -0,0 +1,159 @@
 /* LzFind.h -- Match finder for LZ algorithms
 2023-03-04 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZ_FIND_H
 #define ZIP7_INC_LZ_FIND_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 typedef UInt32 CLzRef;
 typedef struct
 {
  const Byte *buffer;
  UInt32 pos;
  UInt32 posLimit;
  UInt32 streamPos;  /* wrap over Zero is allowed (streamPos < pos). Use (UInt32)(streamPos - pos) */
  UInt32 lenLimit;
  UInt32 cyclicBufferPos;
  UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
  Byte streamEndWasReached;
  Byte btMode;
  Byte bigHash;
  Byte directInput;
  UInt32 matchMaxLen;
  CLzRef *hash;
  CLzRef *son;
  UInt32 hashMask;
  UInt32 cutValue;
  Byte *bufBase;
  ISeqInStreamPtr stream;
  UInt32 blockSize;
  UInt32 keepSizeBefore;
  UInt32 keepSizeAfter;
  UInt32 numHashBytes;
  size_t directInputRem;
  UInt32 historySize;
  UInt32 fixedHashSize;
  Byte numHashBytes_Min;
  Byte numHashOutBits;
  Byte _pad2_[2];
  SRes result;
  UInt32 crc[256];
  size_t numRefs;
  UInt64 expectedDataSize;
 } CMatchFinder;
 #define Inline_MatchFinder_GetPointerToCurrentPos(p) ((const Byte *)(p)->buffer)
 #define Inline_MatchFinder_GetNumAvailableBytes(p) ((UInt32)((p)->streamPos - (p)->pos))
 /*
 #define Inline_MatchFinder_IsFinishedOK(p) \
    ((p)->streamEndWasReached \
        && (p)->streamPos == (p)->pos \
        && (!(p)->directInput || (p)->directInputRem == 0))
 */
 int MatchFinder_NeedMove(CMatchFinder *p);
 /* Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p); */
 void MatchFinder_MoveBlock(CMatchFinder *p);
 void MatchFinder_ReadIfRequired(CMatchFinder *p);
 void MatchFinder_Construct(CMatchFinder *p);
 /* (directInput = 0) is default value.
   It's required to provide correct (directInput) value
   before calling MatchFinder_Create().
   You can set (directInput) by any of the following calls:
     - MatchFinder_SET_DIRECT_INPUT_BUF()
     - MatchFinder_SET_STREAM()
     - MatchFinder_SET_STREAM_MODE()
 */
 #define MatchFinder_SET_DIRECT_INPUT_BUF(p, _src_, _srcLen_) { \
  (p)->stream = NULL; \
  (p)->directInput = 1; \
  (p)->buffer = (_src_); \
  (p)->directInputRem = (_srcLen_); }
 /*
 #define MatchFinder_SET_STREAM_MODE(p) { \
  (p)->directInput = 0; }
 */
 #define MatchFinder_SET_STREAM(p, _stream_) { \
  (p)->stream = _stream_; \
  (p)->directInput = 0; }
 int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
    UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
    ISzAllocPtr alloc);
 void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc);
 void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems);
 /*
 #define MatchFinder_INIT_POS(p, val) \
    (p)->pos = (val); \
    (p)->streamPos = (val);
 */
 // void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
 #define MatchFinder_REDUCE_OFFSETS(p, subValue) \
    (p)->pos -= (subValue); \
    (p)->streamPos -= (subValue);
 UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
    UInt32 *distances, UInt32 maxLen);
 /*
 Conditions:
  Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func.
  Mf_GetPointerToCurrentPos_Func's result must be used only before any other function
 */
 typedef void (*Mf_Init_Func)(void *object);
 typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
 typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
 typedef UInt32 * (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
 typedef void (*Mf_Skip_Func)(void *object, UInt32);
 typedef struct
 {
  Mf_Init_Func Init;
  Mf_GetNumAvailableBytes_Func GetNumAvailableBytes;
  Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos;
  Mf_GetMatches_Func GetMatches;
  Mf_Skip_Func Skip;
 } IMatchFinder2;
 void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder2 *vTable);
 void MatchFinder_Init_LowHash(CMatchFinder *p);
 void MatchFinder_Init_HighHash(CMatchFinder *p);
 void MatchFinder_Init_4(CMatchFinder *p);
 void MatchFinder_Init(CMatchFinder *p);
 UInt32* Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 UInt32* Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 void LzFindPrepare(void);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/LzFindMt.c
+++ b/3rdparty/7z/src/LzFindMt.c
--- a/3rdparty/7z/src/LzFindMt.h
+++ b/3rdparty/7z/src/LzFindMt.h
@ -0,0 +1,109 @@
 /* LzFindMt.h -- multithreaded Match finder for LZ algorithms
 2023-03-05 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZ_FIND_MT_H
 #define ZIP7_INC_LZ_FIND_MT_H
 #include "LzFind.h"
 #include "Threads.h"
 EXTERN_C_BEGIN
 typedef struct
 {
  UInt32 numProcessedBlocks;
  CThread thread;
  UInt64 affinity;
  BoolInt wasCreated;
  BoolInt needStart;
  BoolInt csWasInitialized;
  BoolInt csWasEntered;
  BoolInt exit;
  BoolInt stopWriting;
  CAutoResetEvent canStart;
  CAutoResetEvent wasStopped;
  CSemaphore freeSemaphore;
  CSemaphore filledSemaphore;
  CCriticalSection cs;
  // UInt32 numBlocks_Sent;
 } CMtSync;
 typedef UInt32 * (*Mf_Mix_Matches)(void *p, UInt32 matchMinPos, UInt32 *distances);
 /* kMtCacheLineDummy must be >= size_of_CPU_cache_line */
 #define kMtCacheLineDummy 128
 typedef void (*Mf_GetHeads)(const Byte *buffer, UInt32 pos,
  UInt32 *hash, UInt32 hashMask, UInt32 *heads, UInt32 numHeads, const UInt32 *crc);
 typedef struct
 {
  /* LZ */
  const Byte *pointerToCurPos;
  UInt32 *btBuf;
  const UInt32 *btBufPos;
  const UInt32 *btBufPosLimit;
  UInt32 lzPos;
  UInt32 btNumAvailBytes;
  UInt32 *hash;
  UInt32 fixedHashSize;
  // UInt32 hash4Mask;
  UInt32 historySize;
  const UInt32 *crc;
  Mf_Mix_Matches MixMatchesFunc;
  UInt32 failure_LZ_BT; // failure in BT transfered to LZ
  // UInt32 failure_LZ_LZ; // failure in LZ tables
  UInt32 failureBuf[1];
  // UInt32 crc[256];
  /* LZ + BT */
  CMtSync btSync;
  Byte btDummy[kMtCacheLineDummy];
  /* BT */
  UInt32 *hashBuf;
  UInt32 hashBufPos;
  UInt32 hashBufPosLimit;
  UInt32 hashNumAvail;
  UInt32 failure_BT;
  CLzRef *son;
  UInt32 matchMaxLen;
  UInt32 numHashBytes;
  UInt32 pos;
  const Byte *buffer;
  UInt32 cyclicBufferPos;
  UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
  UInt32 cutValue;
  /* BT + Hash */
  CMtSync hashSync;
  /* Byte hashDummy[kMtCacheLineDummy]; */
  /* Hash */
  Mf_GetHeads GetHeadsFunc;
  CMatchFinder *MatchFinder;
  // CMatchFinder MatchFinder;
 } CMatchFinderMt;
 // only for Mt part
 void MatchFinderMt_Construct(CMatchFinderMt *p);
 void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAllocPtr alloc);
 SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore,
    UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc);
 void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder2 *vTable);
 /* call MatchFinderMt_InitMt() before IMatchFinder::Init() */
 SRes MatchFinderMt_InitMt(CMatchFinderMt *p);
 void MatchFinderMt_ReleaseStream(CMatchFinderMt *p);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/LzFindOpt.c
+++ b/3rdparty/7z/src/LzFindOpt.c
@ -0,0 +1,578 @@
 /* LzFindOpt.c -- multithreaded Match finder for LZ algorithms
 2023-04-02 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "CpuArch.h"
 #include "LzFind.h"
 // #include "LzFindMt.h"
 // #define LOG_ITERS
 // #define LOG_THREAD
 #ifdef LOG_THREAD
 #include <stdio.h>
 #define PRF(x) x
 #else
 // #define PRF(x)
 #endif
 #ifdef LOG_ITERS
 #include <stdio.h>
 UInt64 g_NumIters_Tree;
 UInt64 g_NumIters_Loop;
 UInt64 g_NumIters_Bytes;
 #define LOG_ITER(x) x
 #else
 #define LOG_ITER(x)
 #endif
 // ---------- BT THREAD ----------
 #define USE_SON_PREFETCH
 #define USE_LONG_MATCH_OPT
 #define kEmptyHashValue 0
 // #define CYC_TO_POS_OFFSET 0
 // #define CYC_TO_POS_OFFSET 1 // for debug
 /*
 Z7_NO_INLINE
 UInt32 * Z7_FASTCALL GetMatchesSpecN_1(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
    UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size, UInt32 *posRes)
 {
  do
  {
    UInt32 delta;
    if (hash == size)
      break;
    delta = *hash++;
    if (delta == 0 || delta > (UInt32)pos)
      return NULL;
    lenLimit++;
    if (delta == (UInt32)pos)
    {
      CLzRef *ptr1 = son + ((size_t)pos << 1) - CYC_TO_POS_OFFSET * 2;
      *d++ = 0;
      ptr1[0] = kEmptyHashValue;
      ptr1[1] = kEmptyHashValue;
    }
 else
 {
  UInt32 *_distances = ++d;
  CLzRef *ptr0 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2 + 1;
  CLzRef *ptr1 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
  const Byte *len0 = cur, *len1 = cur;
  UInt32 cutValue = _cutValue;
  const Byte *maxLen = cur + _maxLen;
  for (LOG_ITER(g_NumIters_Tree++);;)
  {
    LOG_ITER(g_NumIters_Loop++);
    {
      const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
      CLzRef *pair = son + ((size_t)(((ptrdiff_t)pos - CYC_TO_POS_OFFSET) + diff) << 1);
      const Byte *len = (len0 < len1 ? len0 : len1);
    #ifdef USE_SON_PREFETCH
      const UInt32 pair0 = *pair;
    #endif
      if (len[diff] == len[0])
      {
        if (++len != lenLimit && len[diff] == len[0])
          while (++len != lenLimit)
          {
            LOG_ITER(g_NumIters_Bytes++);
            if (len[diff] != len[0])
              break;
          }
        if (maxLen < len)
        {
          maxLen = len;
          *d++ = (UInt32)(len - cur);
          *d++ = delta - 1;
          if (len == lenLimit)
          {
            const UInt32 pair1 = pair[1];
            *ptr1 =
              #ifdef USE_SON_PREFETCH
                pair0;
              #else
                pair[0];
              #endif
            *ptr0 = pair1;
            _distances[-1] = (UInt32)(d - _distances);
            #ifdef USE_LONG_MATCH_OPT
                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
                  break;
            {
              for (;;)
              {
                hash++;
                pos++;
                cur++;
                lenLimit++;
                {
                  CLzRef *ptr = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
                  #if 0
                  *(UInt64 *)(void *)ptr = ((const UInt64 *)(const void *)ptr)[diff];
                  #else
                  const UInt32 p0 = ptr[0 + (diff * 2)];
                  const UInt32 p1 = ptr[1 + (diff * 2)];
                  ptr[0] = p0;
                  ptr[1] = p1;
                  // ptr[0] = ptr[0 + (diff * 2)];
                  // ptr[1] = ptr[1 + (diff * 2)];
                  #endif
                }
                // PrintSon(son + 2, pos - 1);
                // printf("\npos = %x delta = %x\n", pos, delta);
                len++;
                *d++ = 2;
                *d++ = (UInt32)(len - cur);
                *d++ = delta - 1;
                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
                  break;
              }
            }
            #endif
            break;
          }
        }
      }
      {
        const UInt32 curMatch = (UInt32)pos - delta; // (UInt32)(pos + diff);
        if (len[diff] < len[0])
        {
          delta = pair[1];
          if (delta >= curMatch)
            return NULL;
          *ptr1 = curMatch;
          ptr1 = pair + 1;
          len1 = len;
        }
        else
        {
          delta = *pair;
          if (delta >= curMatch)
            return NULL;
          *ptr0 = curMatch;
          ptr0 = pair;
          len0 = len;
        }
        delta = (UInt32)pos - delta;
        if (--cutValue == 0 || delta >= pos)
        {
          *ptr0 = *ptr1 = kEmptyHashValue;
          _distances[-1] = (UInt32)(d - _distances);
          break;
        }
      }
    }
  } // for (tree iterations)
 }
    pos++;
    cur++;
  }
  while (d < limit);
  *posRes = (UInt32)pos;
  return d;
 }
 */
 /* define cbs if you use 2 functions.
       GetMatchesSpecN_1() :  (pos <  _cyclicBufferSize)
       GetMatchesSpecN_2() :  (pos >= _cyclicBufferSize)
  do not define cbs if you use 1 function:
       GetMatchesSpecN_2()
 */
 // #define cbs _cyclicBufferSize
 /*
  we use size_t for (pos) and (_cyclicBufferPos_ instead of UInt32
  to eliminate "movsx" BUG in old MSVC x64 compiler.
 */
 UInt32 * Z7_FASTCALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
    UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
    UInt32 *posRes);
 Z7_NO_INLINE
 UInt32 * Z7_FASTCALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
    UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
    UInt32 *posRes)
 {
  do // while (hash != size)
  {
    UInt32 delta;
  #ifndef cbs
    UInt32 cbs;
  #endif
    if (hash == size)
      break;
    delta = *hash++;
    if (delta == 0)
      return NULL;
    lenLimit++;
  #ifndef cbs
    cbs = _cyclicBufferSize;
    if ((UInt32)pos < cbs)
    {
      if (delta > (UInt32)pos)
        return NULL;
      cbs = (UInt32)pos;
    }
  #endif
    if (delta >= cbs)
    {
      CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
      *d++ = 0;
      ptr1[0] = kEmptyHashValue;
      ptr1[1] = kEmptyHashValue;
    }
 else
 {
  UInt32 *_distances = ++d;
  CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
  CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
  UInt32 cutValue = _cutValue;
  const Byte *len0 = cur, *len1 = cur;
  const Byte *maxLen = cur + _maxLen;
  // if (cutValue == 0) { *ptr0 = *ptr1 = kEmptyHashValue; } else
  for (LOG_ITER(g_NumIters_Tree++);;)
  {
    LOG_ITER(g_NumIters_Loop++);
    {
      // SPEC code
      CLzRef *pair = son + ((size_t)((ptrdiff_t)_cyclicBufferPos - (ptrdiff_t)delta
          + (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)
          ) << 1);
      const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
      const Byte *len = (len0 < len1 ? len0 : len1);
    #ifdef USE_SON_PREFETCH
      const UInt32 pair0 = *pair;
    #endif
      if (len[diff] == len[0])
      {
        if (++len != lenLimit && len[diff] == len[0])
          while (++len != lenLimit)
          {
            LOG_ITER(g_NumIters_Bytes++);
            if (len[diff] != len[0])
              break;
          }
        if (maxLen < len)
        {
          maxLen = len;
          *d++ = (UInt32)(len - cur);
          *d++ = delta - 1;
          if (len == lenLimit)
          {
            const UInt32 pair1 = pair[1];
            *ptr1 =
              #ifdef USE_SON_PREFETCH
                pair0;
              #else
                pair[0];
              #endif
            *ptr0 = pair1;
            _distances[-1] = (UInt32)(d - _distances);
            #ifdef USE_LONG_MATCH_OPT
                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
                  break;
            {
              for (;;)
              {
                *d++ = 2;
                *d++ = (UInt32)(lenLimit - cur);
                *d++ = delta - 1;
                cur++;
                lenLimit++;
                // SPEC
                _cyclicBufferPos++;
                {
                  // SPEC code
                  CLzRef *dest = son + ((size_t)(_cyclicBufferPos) << 1);
                  const CLzRef *src = dest + ((diff
                      + (ptrdiff_t)(UInt32)((_cyclicBufferPos < delta) ? cbs : 0)) << 1);
                  // CLzRef *ptr = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
                  #if 0
                  *(UInt64 *)(void *)dest = *((const UInt64 *)(const void *)src);
                  #else
                  const UInt32 p0 = src[0];
                  const UInt32 p1 = src[1];
                  dest[0] = p0;
                  dest[1] = p1;
                  #endif
                }
                pos++;
                hash++;
                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
                  break;
              } // for() end for long matches
            }
            #endif
            break; // break from TREE iterations
          }
        }
      }
      {
        const UInt32 curMatch = (UInt32)pos - delta; // (UInt32)(pos + diff);
        if (len[diff] < len[0])
        {
          delta = pair[1];
          *ptr1 = curMatch;
          ptr1 = pair + 1;
          len1 = len;
          if (delta >= curMatch)
            return NULL;
        }
        else
        {
          delta = *pair;
          *ptr0 = curMatch;
          ptr0 = pair;
          len0 = len;
          if (delta >= curMatch)
            return NULL;
        }
        delta = (UInt32)pos - delta;
        if (--cutValue == 0 || delta >= cbs)
        {
          *ptr0 = *ptr1 = kEmptyHashValue;
          _distances[-1] = (UInt32)(d - _distances);
          break;
        }
      }
    }
  } // for (tree iterations)
 }
    pos++;
    _cyclicBufferPos++;
    cur++;
  }
  while (d < limit);
  *posRes = (UInt32)pos;
  return d;
 }
 /*
 typedef UInt32 uint32plus; // size_t
 UInt32 * Z7_FASTCALL GetMatchesSpecN_3(uint32plus lenLimit, size_t pos, const Byte *cur, CLzRef *son,
    UInt32 _cutValue, UInt32 *d, uint32plus _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
    UInt32 *posRes)
 {
  do // while (hash != size)
  {
    UInt32 delta;
  #ifndef cbs
    UInt32 cbs;
  #endif
    if (hash == size)
      break;
    delta = *hash++;
    if (delta == 0)
      return NULL;
  #ifndef cbs
    cbs = _cyclicBufferSize;
    if ((UInt32)pos < cbs)
    {
      if (delta > (UInt32)pos)
        return NULL;
      cbs = (UInt32)pos;
    }
  #endif
    if (delta >= cbs)
    {
      CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
      *d++ = 0;
      ptr1[0] = kEmptyHashValue;
      ptr1[1] = kEmptyHashValue;
    }
 else
 {
  CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
  CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
  UInt32 *_distances = ++d;
  uint32plus len0 = 0, len1 = 0;
  UInt32 cutValue = _cutValue;
  uint32plus maxLen = _maxLen;
  // lenLimit++; // const Byte *lenLimit = cur + _lenLimit;
  for (LOG_ITER(g_NumIters_Tree++);;)
  {
    LOG_ITER(g_NumIters_Loop++);
    {
      // const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
      CLzRef *pair = son + ((size_t)((ptrdiff_t)_cyclicBufferPos - delta
          + (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)
          ) << 1);
      const Byte *pb = cur - delta;
      uint32plus len = (len0 < len1 ? len0 : len1);
    #ifdef USE_SON_PREFETCH
      const UInt32 pair0 = *pair;
    #endif
      if (pb[len] == cur[len])
      {
        if (++len != lenLimit && pb[len] == cur[len])
          while (++len != lenLimit)
            if (pb[len] != cur[len])
              break;
        if (maxLen < len)
        {
          maxLen = len;
          *d++ = (UInt32)len;
          *d++ = delta - 1;
          if (len == lenLimit)
          {
            {
              const UInt32 pair1 = pair[1];
              *ptr0 = pair1;
              *ptr1 =
              #ifdef USE_SON_PREFETCH
                pair0;
              #else
                pair[0];
              #endif
            }
            _distances[-1] = (UInt32)(d - _distances);
            #ifdef USE_LONG_MATCH_OPT
                if (hash == size || *hash != delta || pb[lenLimit] != cur[lenLimit] || d >= limit)
                  break;
            {
              const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
              for (;;)
              {
                *d++ = 2;
                *d++ = (UInt32)lenLimit;
                *d++ = delta - 1;
                _cyclicBufferPos++;
                {
                  CLzRef *dest = son + ((size_t)_cyclicBufferPos << 1);
                  const CLzRef *src = dest + ((diff +
                      (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)) << 1);
                #if 0
                  *(UInt64 *)(void *)dest = *((const UInt64 *)(const void *)src);
                #else
                  const UInt32 p0 = src[0];
                  const UInt32 p1 = src[1];
                  dest[0] = p0;
                  dest[1] = p1;
                #endif
                }
                hash++;
                pos++;
                cur++;
                pb++;
                if (hash == size || *hash != delta || pb[lenLimit] != cur[lenLimit] || d >= limit)
                  break;
              }
            }
            #endif
            break;
          }
        }
      }
      {
        const UInt32 curMatch = (UInt32)pos - delta;
        if (pb[len] < cur[len])
        {
          delta = pair[1];
          *ptr1 = curMatch;
          ptr1 = pair + 1;
          len1 = len;
        }
        else
        {
          delta = *pair;
          *ptr0 = curMatch;
          ptr0 = pair;
          len0 = len;
        }
        {
          if (delta >= curMatch)
            return NULL;
          delta = (UInt32)pos - delta;
          if (delta >= cbs
              // delta >= _cyclicBufferSize || delta >= pos
              || --cutValue == 0)
          {
            *ptr0 = *ptr1 = kEmptyHashValue;
            _distances[-1] = (UInt32)(d - _distances);
            break;
          }
        }
      }
    }
  } // for (tree iterations)
 }
    pos++;
    _cyclicBufferPos++;
    cur++;
  }
  while (d < limit);
  *posRes = (UInt32)pos;
  return d;
 }
 */
--- a/3rdparty/7z/src/LzHash.h
+++ b/3rdparty/7z/src/LzHash.h
@ -0,0 +1,34 @@
 /* LzHash.h -- HASH constants for LZ algorithms
 2023-03-05 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZ_HASH_H
 #define ZIP7_INC_LZ_HASH_H
 /*
  (kHash2Size >= (1 <<  8)) : Required
  (kHash3Size >= (1 << 16)) : Required
 */
 #define kHash2Size (1 << 10)
 #define kHash3Size (1 << 16)
 // #define kHash4Size (1 << 20)
 #define kFix3HashSize (kHash2Size)
 #define kFix4HashSize (kHash2Size + kHash3Size)
 // #define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
 /*
  We use up to 3 crc values for hash:
    crc0
    crc1 << Shift_1
    crc2 << Shift_2
  (Shift_1 = 5) and (Shift_2 = 10) is good tradeoff.
  Small values for Shift are not good for collision rate.
  Big value for Shift_2 increases the minimum size
  of hash table, that will be slow for small files.
 */
 #define kLzHash_CrcShift_1 5
 #define kLzHash_CrcShift_2 10
 #endif
--- a/3rdparty/7z/src/Lzma2Dec.c
+++ b/3rdparty/7z/src/Lzma2Dec.c
@ -0,0 +1,491 @@
 /* Lzma2Dec.c -- LZMA2 Decoder
 2023-03-03 : Igor Pavlov : Public domain */
 /* #define SHOW_DEBUG_INFO */
 #include "Precomp.h"
 #ifdef SHOW_DEBUG_INFO
 #include <stdio.h>
 #endif
 #include <string.h>
 #include "Lzma2Dec.h"
 /*
 00000000  -  End of data
 00000001 U U  -  Uncompressed, reset dic, need reset state and set new prop
 00000010 U U  -  Uncompressed, no reset
 100uuuuu U U P P  -  LZMA, no reset
 101uuuuu U U P P  -  LZMA, reset state
 110uuuuu U U P P S  -  LZMA, reset state + set new prop
 111uuuuu U U P P S  -  LZMA, reset state + set new prop, reset dic
  u, U - Unpack Size
  P - Pack Size
  S - Props
 */
 #define LZMA2_CONTROL_COPY_RESET_DIC 1
 #define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & (1 << 7)) == 0)
 #define LZMA2_LCLP_MAX 4
 #define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
 #ifdef SHOW_DEBUG_INFO
 #define PRF(x) x
 #else
 #define PRF(x)
 #endif
 typedef enum
 {
  LZMA2_STATE_CONTROL,
  LZMA2_STATE_UNPACK0,
  LZMA2_STATE_UNPACK1,
  LZMA2_STATE_PACK0,
  LZMA2_STATE_PACK1,
  LZMA2_STATE_PROP,
  LZMA2_STATE_DATA,
  LZMA2_STATE_DATA_CONT,
  LZMA2_STATE_FINISHED,
  LZMA2_STATE_ERROR
 } ELzma2State;
 static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)
 {
  UInt32 dicSize;
  if (prop > 40)
    return SZ_ERROR_UNSUPPORTED;
  dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);
  props[0] = (Byte)LZMA2_LCLP_MAX;
  props[1] = (Byte)(dicSize);
  props[2] = (Byte)(dicSize >> 8);
  props[3] = (Byte)(dicSize >> 16);
  props[4] = (Byte)(dicSize >> 24);
  return SZ_OK;
 }
 SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc)
 {
  Byte props[LZMA_PROPS_SIZE];
  RINOK(Lzma2Dec_GetOldProps(prop, props))
  return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
 }
 SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc)
 {
  Byte props[LZMA_PROPS_SIZE];
  RINOK(Lzma2Dec_GetOldProps(prop, props))
  return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
 }
 void Lzma2Dec_Init(CLzma2Dec *p)
 {
  p->state = LZMA2_STATE_CONTROL;
  p->needInitLevel = 0xE0;
  p->isExtraMode = False;
  p->unpackSize = 0;
  // p->decoder.dicPos = 0; // we can use it instead of full init
  LzmaDec_Init(&p->decoder);
 }
 // ELzma2State
 static unsigned Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
 {
  switch (p->state)
  {
    case LZMA2_STATE_CONTROL:
      p->isExtraMode = False;
      p->control = b;
      PRF(printf("\n %8X", (unsigned)p->decoder.dicPos));
      PRF(printf(" %02X", (unsigned)b));
      if (b == 0)
        return LZMA2_STATE_FINISHED;
      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
      {
        if (b == LZMA2_CONTROL_COPY_RESET_DIC)
          p->needInitLevel = 0xC0;
        else if (b > 2 || p->needInitLevel == 0xE0)
          return LZMA2_STATE_ERROR;
      }
      else
      {
        if (b < p->needInitLevel)
          return LZMA2_STATE_ERROR;
        p->needInitLevel = 0;
        p->unpackSize = (UInt32)(b & 0x1F) << 16;
      }
      return LZMA2_STATE_UNPACK0;
    case LZMA2_STATE_UNPACK0:
      p->unpackSize |= (UInt32)b << 8;
      return LZMA2_STATE_UNPACK1;
    case LZMA2_STATE_UNPACK1:
      p->unpackSize |= (UInt32)b;
      p->unpackSize++;
      PRF(printf(" %7u", (unsigned)p->unpackSize));
      return LZMA2_IS_UNCOMPRESSED_STATE(p) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0;
    case LZMA2_STATE_PACK0:
      p->packSize = (UInt32)b << 8;
      return LZMA2_STATE_PACK1;
    case LZMA2_STATE_PACK1:
      p->packSize |= (UInt32)b;
      p->packSize++;
      // if (p->packSize < 5) return LZMA2_STATE_ERROR;
      PRF(printf(" %5u", (unsigned)p->packSize));
      return (p->control & 0x40) ? LZMA2_STATE_PROP : LZMA2_STATE_DATA;
    case LZMA2_STATE_PROP:
    {
      unsigned lc, lp;
      if (b >= (9 * 5 * 5))
        return LZMA2_STATE_ERROR;
      lc = b % 9;
      b /= 9;
      p->decoder.prop.pb = (Byte)(b / 5);
      lp = b % 5;
      if (lc + lp > LZMA2_LCLP_MAX)
        return LZMA2_STATE_ERROR;
      p->decoder.prop.lc = (Byte)lc;
      p->decoder.prop.lp = (Byte)lp;
      return LZMA2_STATE_DATA;
    }
  }
  return LZMA2_STATE_ERROR;
 }
 static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size)
 {
  memcpy(p->dic + p->dicPos, src, size);
  p->dicPos += size;
  if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)
    p->checkDicSize = p->prop.dicSize;
  p->processedPos += (UInt32)size;
 }
 void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState);
 SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
 {
  SizeT inSize = *srcLen;
  *srcLen = 0;
  *status = LZMA_STATUS_NOT_SPECIFIED;
  while (p->state != LZMA2_STATE_ERROR)
  {
    SizeT dicPos;
    if (p->state == LZMA2_STATE_FINISHED)
    {
      *status = LZMA_STATUS_FINISHED_WITH_MARK;
      return SZ_OK;
    }
    dicPos = p->decoder.dicPos;
    if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY)
    {
      *status = LZMA_STATUS_NOT_FINISHED;
      return SZ_OK;
    }
    if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)
    {
      if (*srcLen == inSize)
      {
        *status = LZMA_STATUS_NEEDS_MORE_INPUT;
        return SZ_OK;
      }
      (*srcLen)++;
      p->state = Lzma2Dec_UpdateState(p, *src++);
      if (dicPos == dicLimit && p->state != LZMA2_STATE_FINISHED)
        break;
      continue;
    }
    {
      SizeT inCur = inSize - *srcLen;
      SizeT outCur = dicLimit - dicPos;
      ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY;
      if (outCur >= p->unpackSize)
      {
        outCur = (SizeT)p->unpackSize;
        curFinishMode = LZMA_FINISH_END;
      }
      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
      {
        if (inCur == 0)
        {
          *status = LZMA_STATUS_NEEDS_MORE_INPUT;
          return SZ_OK;
        }
        if (p->state == LZMA2_STATE_DATA)
        {
          BoolInt initDic = (p->control == LZMA2_CONTROL_COPY_RESET_DIC);
          LzmaDec_InitDicAndState(&p->decoder, initDic, False);
        }
        if (inCur > outCur)
          inCur = outCur;
        if (inCur == 0)
          break;
        LzmaDec_UpdateWithUncompressed(&p->decoder, src, inCur);
        src += inCur;
        *srcLen += inCur;
        p->unpackSize -= (UInt32)inCur;
        p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
      }
      else
      {
        SRes res;
        if (p->state == LZMA2_STATE_DATA)
        {
          BoolInt initDic = (p->control >= 0xE0);
          BoolInt initState = (p->control >= 0xA0);
          LzmaDec_InitDicAndState(&p->decoder, initDic, initState);
          p->state = LZMA2_STATE_DATA_CONT;
        }
        if (inCur > p->packSize)
          inCur = (SizeT)p->packSize;
        res = LzmaDec_DecodeToDic(&p->decoder, dicPos + outCur, src, &inCur, curFinishMode, status);
        src += inCur;
        *srcLen += inCur;
        p->packSize -= (UInt32)inCur;
        outCur = p->decoder.dicPos - dicPos;
        p->unpackSize -= (UInt32)outCur;
        if (res != 0)
          break;
        if (*status == LZMA_STATUS_NEEDS_MORE_INPUT)
        {
          if (p->packSize == 0)
            break;
          return SZ_OK;
        }
        if (inCur == 0 && outCur == 0)
        {
          if (*status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
              || p->unpackSize != 0
              || p->packSize != 0)
            break;
          p->state = LZMA2_STATE_CONTROL;
        }
        *status = LZMA_STATUS_NOT_SPECIFIED;
      }
    }
  }
  *status = LZMA_STATUS_NOT_SPECIFIED;
  p->state = LZMA2_STATE_ERROR;
  return SZ_ERROR_DATA;
 }
 ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,
    SizeT outSize,
    const Byte *src, SizeT *srcLen,
    int checkFinishBlock)
 {
  SizeT inSize = *srcLen;
  *srcLen = 0;
  while (p->state != LZMA2_STATE_ERROR)
  {
    if (p->state == LZMA2_STATE_FINISHED)
      return (ELzma2ParseStatus)LZMA_STATUS_FINISHED_WITH_MARK;
    if (outSize == 0 && !checkFinishBlock)
      return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;
    if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)
    {
      if (*srcLen == inSize)
        return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;
      (*srcLen)++;
      p->state = Lzma2Dec_UpdateState(p, *src++);
      if (p->state == LZMA2_STATE_UNPACK0)
      {
        // if (p->decoder.dicPos != 0)
        if (p->control == LZMA2_CONTROL_COPY_RESET_DIC || p->control >= 0xE0)
          return LZMA2_PARSE_STATUS_NEW_BLOCK;
        // if (outSize == 0) return LZMA_STATUS_NOT_FINISHED;
      }
      // The following code can be commented.
      // It's not big problem, if we read additional input bytes.
      // It will be stopped later in LZMA2_STATE_DATA / LZMA2_STATE_DATA_CONT state.
      if (outSize == 0 && p->state != LZMA2_STATE_FINISHED)
      {
        // checkFinishBlock is true. So we expect that block must be finished,
        // We can return LZMA_STATUS_NOT_SPECIFIED or LZMA_STATUS_NOT_FINISHED here
        // break;
        return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;
      }
      if (p->state == LZMA2_STATE_DATA)
        return LZMA2_PARSE_STATUS_NEW_CHUNK;
      continue;
    }
    if (outSize == 0)
      return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;
    {
      SizeT inCur = inSize - *srcLen;
      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
      {
        if (inCur == 0)
          return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;
        if (inCur > p->unpackSize)
          inCur = p->unpackSize;
        if (inCur > outSize)
          inCur = outSize;
        p->decoder.dicPos += inCur;
        src += inCur;
        *srcLen += inCur;
        outSize -= inCur;
        p->unpackSize -= (UInt32)inCur;
        p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
      }
      else
      {
        p->isExtraMode = True;
        if (inCur == 0)
        {
          if (p->packSize != 0)
            return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;
        }
        else if (p->state == LZMA2_STATE_DATA)
        {
          p->state = LZMA2_STATE_DATA_CONT;
          if (*src != 0)
          {
            // first byte of lzma chunk must be Zero
            *srcLen += 1;
            p->packSize--;
            break;
          }
        }
        if (inCur > p->packSize)
          inCur = (SizeT)p->packSize;
        src += inCur;
        *srcLen += inCur;
        p->packSize -= (UInt32)inCur;
        if (p->packSize == 0)
        {
          SizeT rem = outSize;
          if (rem > p->unpackSize)
            rem = p->unpackSize;
          p->decoder.dicPos += rem;
          p->unpackSize -= (UInt32)rem;
          outSize -= rem;
          if (p->unpackSize == 0)
            p->state = LZMA2_STATE_CONTROL;
        }
      }
    }
  }
  p->state = LZMA2_STATE_ERROR;
  return (ELzma2ParseStatus)LZMA_STATUS_NOT_SPECIFIED;
 }
 SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
 {
  SizeT outSize = *destLen, inSize = *srcLen;
  *srcLen = *destLen = 0;
  for (;;)
  {
    SizeT inCur = inSize, outCur, dicPos;
    ELzmaFinishMode curFinishMode;
    SRes res;
    if (p->decoder.dicPos == p->decoder.dicBufSize)
      p->decoder.dicPos = 0;
    dicPos = p->decoder.dicPos;
    curFinishMode = LZMA_FINISH_ANY;
    outCur = p->decoder.dicBufSize - dicPos;
    if (outCur >= outSize)
    {
      outCur = outSize;
      curFinishMode = finishMode;
    }
    res = Lzma2Dec_DecodeToDic(p, dicPos + outCur, src, &inCur, curFinishMode, status);
    src += inCur;
    inSize -= inCur;
    *srcLen += inCur;
    outCur = p->decoder.dicPos - dicPos;
    memcpy(dest, p->decoder.dic + dicPos, outCur);
    dest += outCur;
    outSize -= outCur;
    *destLen += outCur;
    if (res != 0)
      return res;
    if (outCur == 0 || outSize == 0)
      return SZ_OK;
  }
 }
 SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc)
 {
  CLzma2Dec p;
  SRes res;
  SizeT outSize = *destLen, inSize = *srcLen;
  *destLen = *srcLen = 0;
  *status = LZMA_STATUS_NOT_SPECIFIED;
  Lzma2Dec_CONSTRUCT(&p)
  RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc))
  p.decoder.dic = dest;
  p.decoder.dicBufSize = outSize;
  Lzma2Dec_Init(&p);
  *srcLen = inSize;
  res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
  *destLen = p.decoder.dicPos;
  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
    res = SZ_ERROR_INPUT_EOF;
  Lzma2Dec_FreeProbs(&p, alloc);
  return res;
 }
 #undef PRF
--- a/3rdparty/7z/src/Lzma2Dec.h
+++ b/3rdparty/7z/src/Lzma2Dec.h
@ -0,0 +1,121 @@
 /* Lzma2Dec.h -- LZMA2 Decoder
 2023-03-03 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZMA2_DEC_H
 #define ZIP7_INC_LZMA2_DEC_H
 #include "LzmaDec.h"
 EXTERN_C_BEGIN
 /* ---------- State Interface ---------- */
 typedef struct
 {
  unsigned state;
  Byte control;
  Byte needInitLevel;
  Byte isExtraMode;
  Byte _pad_;
  UInt32 packSize;
  UInt32 unpackSize;
  CLzmaDec decoder;
 } CLzma2Dec;
 #define Lzma2Dec_CONSTRUCT(p)  LzmaDec_CONSTRUCT(&(p)->decoder)
 #define Lzma2Dec_Construct(p)  Lzma2Dec_CONSTRUCT(p)
 #define Lzma2Dec_FreeProbs(p, alloc)  LzmaDec_FreeProbs(&(p)->decoder, alloc)
 #define Lzma2Dec_Free(p, alloc)  LzmaDec_Free(&(p)->decoder, alloc)
 SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc);
 SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc);
 void Lzma2Dec_Init(CLzma2Dec *p);
 /*
 finishMode:
  It has meaning only if the decoding reaches output limit (*destLen or dicLimit).
  LZMA_FINISH_ANY - use smallest number of input bytes
  LZMA_FINISH_END - read EndOfStream marker after decoding
 Returns:
  SZ_OK
    status:
      LZMA_STATUS_FINISHED_WITH_MARK
      LZMA_STATUS_NOT_FINISHED
      LZMA_STATUS_NEEDS_MORE_INPUT
  SZ_ERROR_DATA - Data error
 */
 SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen,
    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 /* ---------- LZMA2 block and chunk parsing ---------- */
 /*
 Lzma2Dec_Parse() parses compressed data stream up to next independent block or next chunk data.
 It can return LZMA_STATUS_* code or LZMA2_PARSE_STATUS_* code:
  - LZMA2_PARSE_STATUS_NEW_BLOCK - there is new block, and 1 additional byte (control byte of next block header) was read from input.
  - LZMA2_PARSE_STATUS_NEW_CHUNK - there is new chunk, and only lzma2 header of new chunk was read.
                                   CLzma2Dec::unpackSize contains unpack size of that chunk
 */
 typedef enum
 {
 /*
  LZMA_STATUS_NOT_SPECIFIED                 // data error
  LZMA_STATUS_FINISHED_WITH_MARK
  LZMA_STATUS_NOT_FINISHED                  //
  LZMA_STATUS_NEEDS_MORE_INPUT
  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK   // unused
 */
  LZMA2_PARSE_STATUS_NEW_BLOCK = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK + 1,
  LZMA2_PARSE_STATUS_NEW_CHUNK
 } ELzma2ParseStatus;
 ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,
    SizeT outSize,   // output size
    const Byte *src, SizeT *srcLen,
    int checkFinishBlock   // set (checkFinishBlock = 1), if it must read full input data, if decoder.dicPos reaches blockMax position.
    );
 /*
 LZMA2 parser doesn't decode LZMA chunks, so we must read
  full input LZMA chunk to decode some part of LZMA chunk.
 Lzma2Dec_GetUnpackExtra() returns the value that shows
    max possible number of output bytes that can be output by decoder
    at current input positon.
 */
 #define Lzma2Dec_GetUnpackExtra(p)  ((p)->isExtraMode ? (p)->unpackSize : 0)
 /* ---------- One Call Interface ---------- */
 /*
 finishMode:
  It has meaning only if the decoding reaches output limit (*destLen).
  LZMA_FINISH_ANY - use smallest number of input bytes
  LZMA_FINISH_END - read EndOfStream marker after decoding
 Returns:
  SZ_OK
    status:
      LZMA_STATUS_FINISHED_WITH_MARK
      LZMA_STATUS_NOT_FINISHED
  SZ_ERROR_DATA - Data error
  SZ_ERROR_MEM  - Memory allocation error
  SZ_ERROR_UNSUPPORTED - Unsupported properties
  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
 */
 SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Lzma2DecMt.c
+++ b/3rdparty/7z/src/Lzma2DecMt.c
--- a/3rdparty/7z/src/Lzma2DecMt.h
+++ b/3rdparty/7z/src/Lzma2DecMt.h
@ -0,0 +1,81 @@
 /* Lzma2DecMt.h -- LZMA2 Decoder Multi-thread
 2023-04-13 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZMA2_DEC_MT_H
 #define ZIP7_INC_LZMA2_DEC_MT_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 typedef struct
 {
  size_t inBufSize_ST;
  size_t outStep_ST;
  #ifndef Z7_ST
  unsigned numThreads;
  size_t inBufSize_MT;
  size_t outBlockMax;
  size_t inBlockMax;
  #endif
 } CLzma2DecMtProps;
 /* init to single-thread mode */
 void Lzma2DecMtProps_Init(CLzma2DecMtProps *p);
 /* ---------- CLzma2DecMtHandle Interface ---------- */
 /* Lzma2DecMt_ * functions can return the following exit codes:
 SRes:
  SZ_OK           - OK
  SZ_ERROR_MEM    - Memory allocation error
  SZ_ERROR_PARAM  - Incorrect paramater in props
  SZ_ERROR_WRITE  - ISeqOutStream write callback error
  // SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
  SZ_ERROR_PROGRESS - some break from progress callback
  SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
 */
 typedef struct CLzma2DecMt CLzma2DecMt;
 typedef CLzma2DecMt * CLzma2DecMtHandle;
 // Z7_DECLARE_HANDLE(CLzma2DecMtHandle)
 CLzma2DecMtHandle Lzma2DecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid);
 void Lzma2DecMt_Destroy(CLzma2DecMtHandle p);
 SRes Lzma2DecMt_Decode(CLzma2DecMtHandle p,
    Byte prop,
    const CLzma2DecMtProps *props,
    ISeqOutStreamPtr outStream,
    const UInt64 *outDataSize, // NULL means undefined
    int finishMode,            // 0 - partial unpacking is allowed, 1 - if lzma2 stream must be finished
    // Byte *outBuf, size_t *outBufSize,
    ISeqInStreamPtr inStream,
    // const Byte *inData, size_t inDataSize,
    // out variables:
    UInt64 *inProcessed,
    int *isMT,  /* out: (*isMT == 0), if single thread decoding was used */
    // UInt64 *outProcessed,
    ICompressProgressPtr progress);
 /* ---------- Read from CLzma2DecMtHandle Interface ---------- */
 SRes Lzma2DecMt_Init(CLzma2DecMtHandle pp,
    Byte prop,
    const CLzma2DecMtProps *props,
    const UInt64 *outDataSize, int finishMode,
    ISeqInStreamPtr inStream);
 SRes Lzma2DecMt_Read(CLzma2DecMtHandle pp,
    Byte *data, size_t *outSize,
    UInt64 *inStreamProcessed);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Lzma2Enc.c
+++ b/3rdparty/7z/src/Lzma2Enc.c
@ -0,0 +1,805 @@
 /* Lzma2Enc.c -- LZMA2 Encoder
 2023-04-13 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include <string.h>
 /* #define Z7_ST */
 #include "Lzma2Enc.h"
 #ifndef Z7_ST
 #include "MtCoder.h"
 #else
 #define MTCODER_THREADS_MAX 1
 #endif
 #define LZMA2_CONTROL_LZMA (1 << 7)
 #define LZMA2_CONTROL_COPY_NO_RESET 2
 #define LZMA2_CONTROL_COPY_RESET_DIC 1
 #define LZMA2_CONTROL_EOF 0
 #define LZMA2_LCLP_MAX 4
 #define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
 #define LZMA2_PACK_SIZE_MAX (1 << 16)
 #define LZMA2_COPY_CHUNK_SIZE LZMA2_PACK_SIZE_MAX
 #define LZMA2_UNPACK_SIZE_MAX (1 << 21)
 #define LZMA2_KEEP_WINDOW_SIZE LZMA2_UNPACK_SIZE_MAX
 #define LZMA2_CHUNK_SIZE_COMPRESSED_MAX ((1 << 16) + 16)
 #define PRF(x) /* x */
 /* ---------- CLimitedSeqInStream ---------- */
 typedef struct
 {
  ISeqInStream vt;
  ISeqInStreamPtr realStream;
  UInt64 limit;
  UInt64 processed;
  int finished;
 } CLimitedSeqInStream;
 static void LimitedSeqInStream_Init(CLimitedSeqInStream *p)
 {
  p->limit = (UInt64)(Int64)-1;
  p->processed = 0;
  p->finished = 0;
 }
 static SRes LimitedSeqInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
 {
  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLimitedSeqInStream)
  size_t size2 = *size;
  SRes res = SZ_OK;
  if (p->limit != (UInt64)(Int64)-1)
  {
    const UInt64 rem = p->limit - p->processed;
    if (size2 > rem)
      size2 = (size_t)rem;
  }
  if (size2 != 0)
  {
    res = ISeqInStream_Read(p->realStream, data, &size2);
    p->finished = (size2 == 0 ? 1 : 0);
    p->processed += size2;
  }
  *size = size2;
  return res;
 }
 /* ---------- CLzma2EncInt ---------- */
 typedef struct
 {
  CLzmaEncHandle enc;
  Byte propsAreSet;
  Byte propsByte;
  Byte needInitState;
  Byte needInitProp;
  UInt64 srcPos;
 } CLzma2EncInt;
 static SRes Lzma2EncInt_InitStream(CLzma2EncInt *p, const CLzma2EncProps *props)
 {
  if (!p->propsAreSet)
  {
    SizeT propsSize = LZMA_PROPS_SIZE;
    Byte propsEncoded[LZMA_PROPS_SIZE];
    RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps))
    RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize))
    p->propsByte = propsEncoded[0];
    p->propsAreSet = True;
  }
  return SZ_OK;
 }
 static void Lzma2EncInt_InitBlock(CLzma2EncInt *p)
 {
  p->srcPos = 0;
  p->needInitState = True;
  p->needInitProp = True;
 }
 SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle p, ISeqInStreamPtr inStream, UInt32 keepWindowSize,
    ISzAllocPtr alloc, ISzAllocPtr allocBig);
 SRes LzmaEnc_MemPrepare(CLzmaEncHandle p, const Byte *src, SizeT srcLen,
    UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
    Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
 const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle p);
 void LzmaEnc_Finish(CLzmaEncHandle p);
 void LzmaEnc_SaveState(CLzmaEncHandle p);
 void LzmaEnc_RestoreState(CLzmaEncHandle p);
 /*
 UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle p);
 */
 static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
    size_t *packSizeRes, ISeqOutStreamPtr outStream)
 {
  size_t packSizeLimit = *packSizeRes;
  size_t packSize = packSizeLimit;
  UInt32 unpackSize = LZMA2_UNPACK_SIZE_MAX;
  unsigned lzHeaderSize = 5 + (p->needInitProp ? 1 : 0);
  BoolInt useCopyBlock;
  SRes res;
  *packSizeRes = 0;
  if (packSize < lzHeaderSize)
    return SZ_ERROR_OUTPUT_EOF;
  packSize -= lzHeaderSize;
  LzmaEnc_SaveState(p->enc);
  res = LzmaEnc_CodeOneMemBlock(p->enc, p->needInitState,
      outBuf + lzHeaderSize, &packSize, LZMA2_PACK_SIZE_MAX, &unpackSize);
  PRF(printf("\npackSize = %7d unpackSize = %7d  ", packSize, unpackSize));
  if (unpackSize == 0)
    return res;
  if (res == SZ_OK)
    useCopyBlock = (packSize + 2 >= unpackSize || packSize > (1 << 16));
  else
  {
    if (res != SZ_ERROR_OUTPUT_EOF)
      return res;
    res = SZ_OK;
    useCopyBlock = True;
  }
  if (useCopyBlock)
  {
    size_t destPos = 0;
    PRF(printf("################# COPY           "));
    while (unpackSize > 0)
    {
      const UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE;
      if (packSizeLimit - destPos < u + 3)
        return SZ_ERROR_OUTPUT_EOF;
      outBuf[destPos++] = (Byte)(p->srcPos == 0 ? LZMA2_CONTROL_COPY_RESET_DIC : LZMA2_CONTROL_COPY_NO_RESET);
      outBuf[destPos++] = (Byte)((u - 1) >> 8);
      outBuf[destPos++] = (Byte)(u - 1);
      memcpy(outBuf + destPos, LzmaEnc_GetCurBuf(p->enc) - unpackSize, u);
      unpackSize -= u;
      destPos += u;
      p->srcPos += u;
      if (outStream)
      {
        *packSizeRes += destPos;
        if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
          return SZ_ERROR_WRITE;
        destPos = 0;
      }
      else
        *packSizeRes = destPos;
      /* needInitState = True; */
    }
    LzmaEnc_RestoreState(p->enc);
    return SZ_OK;
  }
  {
    size_t destPos = 0;
    const UInt32 u = unpackSize - 1;
    const UInt32 pm = (UInt32)(packSize - 1);
    const unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 0);
    PRF(printf("               "));
    outBuf[destPos++] = (Byte)(LZMA2_CONTROL_LZMA | (mode << 5) | ((u >> 16) & 0x1F));
    outBuf[destPos++] = (Byte)(u >> 8);
    outBuf[destPos++] = (Byte)u;
    outBuf[destPos++] = (Byte)(pm >> 8);
    outBuf[destPos++] = (Byte)pm;
    if (p->needInitProp)
      outBuf[destPos++] = p->propsByte;
    p->needInitProp = False;
    p->needInitState = False;
    destPos += packSize;
    p->srcPos += unpackSize;
    if (outStream)
      if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
        return SZ_ERROR_WRITE;
    *packSizeRes = destPos;
    return SZ_OK;
  }
 }
 /* ---------- Lzma2 Props ---------- */
 void Lzma2EncProps_Init(CLzma2EncProps *p)
 {
  LzmaEncProps_Init(&p->lzmaProps);
  p->blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO;
  p->numBlockThreads_Reduced = -1;
  p->numBlockThreads_Max = -1;
  p->numTotalThreads = -1;
 }
 void Lzma2EncProps_Normalize(CLzma2EncProps *p)
 {
  UInt64 fileSize;
  int t1, t1n, t2, t2r, t3;
  {
    CLzmaEncProps lzmaProps = p->lzmaProps;
    LzmaEncProps_Normalize(&lzmaProps);
    t1n = lzmaProps.numThreads;
  }
  t1 = p->lzmaProps.numThreads;
  t2 = p->numBlockThreads_Max;
  t3 = p->numTotalThreads;
  if (t2 > MTCODER_THREADS_MAX)
    t2 = MTCODER_THREADS_MAX;
  if (t3 <= 0)
  {
    if (t2 <= 0)
      t2 = 1;
    t3 = t1n * t2;
  }
  else if (t2 <= 0)
  {
    t2 = t3 / t1n;
    if (t2 == 0)
    {
      t1 = 1;
      t2 = t3;
    }
    if (t2 > MTCODER_THREADS_MAX)
      t2 = MTCODER_THREADS_MAX;
  }
  else if (t1 <= 0)
  {
    t1 = t3 / t2;
    if (t1 == 0)
      t1 = 1;
  }
  else
    t3 = t1n * t2;
  p->lzmaProps.numThreads = t1;
  t2r = t2;
  fileSize = p->lzmaProps.reduceSize;
  if (   p->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
      && p->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO
      && (p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1))
    p->lzmaProps.reduceSize = p->blockSize;
  LzmaEncProps_Normalize(&p->lzmaProps);
  p->lzmaProps.reduceSize = fileSize;
  t1 = p->lzmaProps.numThreads;
  if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
  {
    t2r = t2 = 1;
    t3 = t1;
  }
  else if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO && t2 <= 1)
  {
    /* if there is no block multi-threading, we use SOLID block */
    p->blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID;
  }
  else
  {
    if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
    {
      const UInt32 kMinSize = (UInt32)1 << 20;
      const UInt32 kMaxSize = (UInt32)1 << 28;
      const UInt32 dictSize = p->lzmaProps.dictSize;
      UInt64 blockSize = (UInt64)dictSize << 2;
      if (blockSize < kMinSize) blockSize = kMinSize;
      if (blockSize > kMaxSize) blockSize = kMaxSize;
      if (blockSize < dictSize) blockSize = dictSize;
      blockSize += (kMinSize - 1);
      blockSize &= ~(UInt64)(kMinSize - 1);
      p->blockSize = blockSize;
    }
    if (t2 > 1 && fileSize != (UInt64)(Int64)-1)
    {
      UInt64 numBlocks = fileSize / p->blockSize;
      if (numBlocks * p->blockSize != fileSize)
        numBlocks++;
      if (numBlocks < (unsigned)t2)
      {
        t2r = (int)numBlocks;
        if (t2r == 0)
          t2r = 1;
        t3 = t1 * t2r;
      }
    }
  }
  p->numBlockThreads_Max = t2;
  p->numBlockThreads_Reduced = t2r;
  p->numTotalThreads = t3;
 }
 static SRes Progress(ICompressProgressPtr p, UInt64 inSize, UInt64 outSize)
 {
  return (p && ICompressProgress_Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;
 }
 /* ---------- Lzma2 ---------- */
 struct CLzma2Enc
 {
  Byte propEncoded;
  CLzma2EncProps props;
  UInt64 expectedDataSize;
  Byte *tempBufLzma;
  ISzAllocPtr alloc;
  ISzAllocPtr allocBig;
  CLzma2EncInt coders[MTCODER_THREADS_MAX];
  #ifndef Z7_ST
  ISeqOutStreamPtr outStream;
  Byte *outBuf;
  size_t outBuf_Rem;   /* remainder in outBuf */
  size_t outBufSize;   /* size of allocated outBufs[i] */
  size_t outBufsDataSizes[MTCODER_BLOCKS_MAX];
  BoolInt mtCoder_WasConstructed;
  CMtCoder mtCoder;
  Byte *outBufs[MTCODER_BLOCKS_MAX];
  #endif
 };
 CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
  CLzma2Enc *p = (CLzma2Enc *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Enc));
  if (!p)
    return NULL;
  Lzma2EncProps_Init(&p->props);
  Lzma2EncProps_Normalize(&p->props);
  p->expectedDataSize = (UInt64)(Int64)-1;
  p->tempBufLzma = NULL;
  p->alloc = alloc;
  p->allocBig = allocBig;
  {
    unsigned i;
    for (i = 0; i < MTCODER_THREADS_MAX; i++)
      p->coders[i].enc = NULL;
  }
  #ifndef Z7_ST
  p->mtCoder_WasConstructed = False;
  {
    unsigned i;
    for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
      p->outBufs[i] = NULL;
    p->outBufSize = 0;
  }
  #endif
  return (CLzma2EncHandle)p;
 }
 #ifndef Z7_ST
 static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p)
 {
  unsigned i;
  for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
    if (p->outBufs[i])
    {
      ISzAlloc_Free(p->alloc, p->outBufs[i]);
      p->outBufs[i] = NULL;
    }
  p->outBufSize = 0;
 }
 #endif
 // #define GET_CLzma2Enc_p  CLzma2Enc *p = (CLzma2Enc *)(void *)p;
 void Lzma2Enc_Destroy(CLzma2EncHandle p)
 {
  // GET_CLzma2Enc_p
  unsigned i;
  for (i = 0; i < MTCODER_THREADS_MAX; i++)
  {
    CLzma2EncInt *t = &p->coders[i];
    if (t->enc)
    {
      LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig);
      t->enc = NULL;
    }
  }
  #ifndef Z7_ST
  if (p->mtCoder_WasConstructed)
  {
    MtCoder_Destruct(&p->mtCoder);
    p->mtCoder_WasConstructed = False;
  }
  Lzma2Enc_FreeOutBufs(p);
  #endif
  ISzAlloc_Free(p->alloc, p->tempBufLzma);
  p->tempBufLzma = NULL;
  ISzAlloc_Free(p->alloc, p);
 }
 SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props)
 {
  // GET_CLzma2Enc_p
  CLzmaEncProps lzmaProps = props->lzmaProps;
  LzmaEncProps_Normalize(&lzmaProps);
  if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)
    return SZ_ERROR_PARAM;
  p->props = *props;
  Lzma2EncProps_Normalize(&p->props);
  return SZ_OK;
 }
 void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize)
 {
  // GET_CLzma2Enc_p
  p->expectedDataSize = expectedDataSiize;
 }
 Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p)
 {
  // GET_CLzma2Enc_p
  unsigned i;
  UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);
  for (i = 0; i < 40; i++)
    if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i))
      break;
  return (Byte)i;
 }
 static SRes Lzma2Enc_EncodeMt1(
    CLzma2Enc *me,
    CLzma2EncInt *p,
    ISeqOutStreamPtr outStream,
    Byte *outBuf, size_t *outBufSize,
    ISeqInStreamPtr inStream,
    const Byte *inData, size_t inDataSize,
    int finished,
    ICompressProgressPtr progress)
 {
  UInt64 unpackTotal = 0;
  UInt64 packTotal = 0;
  size_t outLim = 0;
  CLimitedSeqInStream limitedInStream;
  if (outBuf)
  {
    outLim = *outBufSize;
    *outBufSize = 0;
  }
  if (!p->enc)
  {
    p->propsAreSet = False;
    p->enc = LzmaEnc_Create(me->alloc);
    if (!p->enc)
      return SZ_ERROR_MEM;
  }
  limitedInStream.realStream = inStream;
  if (inStream)
  {
    limitedInStream.vt.Read = LimitedSeqInStream_Read;
  }
  if (!outBuf)
  {
    // outStream version works only in one thread. So we use CLzma2Enc::tempBufLzma
    if (!me->tempBufLzma)
    {
      me->tempBufLzma = (Byte *)ISzAlloc_Alloc(me->alloc, LZMA2_CHUNK_SIZE_COMPRESSED_MAX);
      if (!me->tempBufLzma)
        return SZ_ERROR_MEM;
    }
  }
  RINOK(Lzma2EncInt_InitStream(p, &me->props))
  for (;;)
  {
    SRes res = SZ_OK;
    SizeT inSizeCur = 0;
    Lzma2EncInt_InitBlock(p);
    LimitedSeqInStream_Init(&limitedInStream);
    limitedInStream.limit = me->props.blockSize;
    if (inStream)
    {
      UInt64 expected = (UInt64)(Int64)-1;
      // inStream version works only in one thread. So we use CLzma2Enc::expectedDataSize
      if (me->expectedDataSize != (UInt64)(Int64)-1
          && me->expectedDataSize >= unpackTotal)
        expected = me->expectedDataSize - unpackTotal;
      if (me->props.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
          && expected > me->props.blockSize)
        expected = (size_t)me->props.blockSize;
      LzmaEnc_SetDataSize(p->enc, expected);
      RINOK(LzmaEnc_PrepareForLzma2(p->enc,
          &limitedInStream.vt,
          LZMA2_KEEP_WINDOW_SIZE,
          me->alloc,
          me->allocBig))
    }
    else
    {
      inSizeCur = (SizeT)(inDataSize - (size_t)unpackTotal);
      if (me->props.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
          && inSizeCur > me->props.blockSize)
        inSizeCur = (SizeT)(size_t)me->props.blockSize;
      // LzmaEnc_SetDataSize(p->enc, inSizeCur);
      RINOK(LzmaEnc_MemPrepare(p->enc,
          inData + (size_t)unpackTotal, inSizeCur,
          LZMA2_KEEP_WINDOW_SIZE,
          me->alloc,
          me->allocBig))
    }
    for (;;)
    {
      size_t packSize = LZMA2_CHUNK_SIZE_COMPRESSED_MAX;
      if (outBuf)
        packSize = outLim - (size_t)packTotal;
      res = Lzma2EncInt_EncodeSubblock(p,
          outBuf ? outBuf + (size_t)packTotal : me->tempBufLzma, &packSize,
          outBuf ? NULL : outStream);
      if (res != SZ_OK)
        break;
      packTotal += packSize;
      if (outBuf)
        *outBufSize = (size_t)packTotal;
      res = Progress(progress, unpackTotal + p->srcPos, packTotal);
      if (res != SZ_OK)
        break;
      /*
      if (LzmaEnc_GetNumAvailableBytes(p->enc) == 0)
        break;
      */
      if (packSize == 0)
        break;
    }
    LzmaEnc_Finish(p->enc);
    unpackTotal += p->srcPos;
    RINOK(res)
    if (p->srcPos != (inStream ? limitedInStream.processed : inSizeCur))
      return SZ_ERROR_FAIL;
    if (inStream ? limitedInStream.finished : (unpackTotal == inDataSize))
    {
      if (finished)
      {
        if (outBuf)
        {
          const size_t destPos = *outBufSize;
          if (destPos >= outLim)
            return SZ_ERROR_OUTPUT_EOF;
          outBuf[destPos] = LZMA2_CONTROL_EOF; // 0
          *outBufSize = destPos + 1;
        }
        else
        {
          const Byte b = LZMA2_CONTROL_EOF; // 0;
          if (ISeqOutStream_Write(outStream, &b, 1) != 1)
            return SZ_ERROR_WRITE;
        }
      }
      return SZ_OK;
    }
  }
 }
 #ifndef Z7_ST
 static SRes Lzma2Enc_MtCallback_Code(void *p, unsigned coderIndex, unsigned outBufIndex,
    const Byte *src, size_t srcSize, int finished)
 {
  CLzma2Enc *me = (CLzma2Enc *)p;
  size_t destSize = me->outBufSize;
  SRes res;
  CMtProgressThunk progressThunk;
  Byte *dest = me->outBufs[outBufIndex];
  me->outBufsDataSizes[outBufIndex] = 0;
  if (!dest)
  {
    dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
    if (!dest)
      return SZ_ERROR_MEM;
    me->outBufs[outBufIndex] = dest;
  }
  MtProgressThunk_CreateVTable(&progressThunk);
  progressThunk.mtProgress = &me->mtCoder.mtProgress;
  progressThunk.inSize = 0;
  progressThunk.outSize = 0;
  res = Lzma2Enc_EncodeMt1(me,
      &me->coders[coderIndex],
      NULL, dest, &destSize,
      NULL, src, srcSize,
      finished,
      &progressThunk.vt);
  me->outBufsDataSizes[outBufIndex] = destSize;
  return res;
 }
 static SRes Lzma2Enc_MtCallback_Write(void *p, unsigned outBufIndex)
 {
  CLzma2Enc *me = (CLzma2Enc *)p;
  size_t size = me->outBufsDataSizes[outBufIndex];
  const Byte *data = me->outBufs[outBufIndex];
  if (me->outStream)
    return ISeqOutStream_Write(me->outStream, data, size) == size ? SZ_OK : SZ_ERROR_WRITE;
  if (size > me->outBuf_Rem)
    return SZ_ERROR_OUTPUT_EOF;
  memcpy(me->outBuf, data, size);
  me->outBuf_Rem -= size;
  me->outBuf += size;
  return SZ_OK;
 }
 #endif
 SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
    ISeqOutStreamPtr outStream,
    Byte *outBuf, size_t *outBufSize,
    ISeqInStreamPtr inStream,
    const Byte *inData, size_t inDataSize,
    ICompressProgressPtr progress)
 {
  // GET_CLzma2Enc_p
  if (inStream && inData)
    return SZ_ERROR_PARAM;
  if (outStream && outBuf)
    return SZ_ERROR_PARAM;
  {
    unsigned i;
    for (i = 0; i < MTCODER_THREADS_MAX; i++)
      p->coders[i].propsAreSet = False;
  }
  #ifndef Z7_ST
  if (p->props.numBlockThreads_Reduced > 1)
  {
    IMtCoderCallback2 vt;
    if (!p->mtCoder_WasConstructed)
    {
      p->mtCoder_WasConstructed = True;
      MtCoder_Construct(&p->mtCoder);
    }
    vt.Code = Lzma2Enc_MtCallback_Code;
    vt.Write = Lzma2Enc_MtCallback_Write;
    p->outStream = outStream;
    p->outBuf = NULL;
    p->outBuf_Rem = 0;
    if (!outStream)
    {
      p->outBuf = outBuf;
      p->outBuf_Rem = *outBufSize;
      *outBufSize = 0;
    }
    p->mtCoder.allocBig = p->allocBig;
    p->mtCoder.progress = progress;
    p->mtCoder.inStream = inStream;
    p->mtCoder.inData = inData;
    p->mtCoder.inDataSize = inDataSize;
    p->mtCoder.mtCallback = &vt;
    p->mtCoder.mtCallbackObject = p;
    p->mtCoder.blockSize = (size_t)p->props.blockSize;
    if (p->mtCoder.blockSize != p->props.blockSize)
      return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */
    {
      const size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16;
      if (destBlockSize < p->mtCoder.blockSize)
        return SZ_ERROR_PARAM;
      if (p->outBufSize != destBlockSize)
        Lzma2Enc_FreeOutBufs(p);
      p->outBufSize = destBlockSize;
    }
    p->mtCoder.numThreadsMax = (unsigned)p->props.numBlockThreads_Max;
    p->mtCoder.expectedDataSize = p->expectedDataSize;
    {
      const SRes res = MtCoder_Code(&p->mtCoder);
      if (!outStream)
        *outBufSize = (size_t)(p->outBuf - outBuf);
      return res;
    }
  }
  #endif
  return Lzma2Enc_EncodeMt1(p,
      &p->coders[0],
      outStream, outBuf, outBufSize,
      inStream, inData, inDataSize,
      True, /* finished */
      progress);
 }
 #undef PRF
--- a/3rdparty/7z/src/Lzma2Enc.h
+++ b/3rdparty/7z/src/Lzma2Enc.h
@ -0,0 +1,57 @@
 /* Lzma2Enc.h -- LZMA2 Encoder
 2023-04-13 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZMA2_ENC_H
 #define ZIP7_INC_LZMA2_ENC_H
 #include "LzmaEnc.h"
 EXTERN_C_BEGIN
 #define LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO   0
 #define LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID  ((UInt64)(Int64)-1)
 typedef struct
 {
  CLzmaEncProps lzmaProps;
  UInt64 blockSize;
  int numBlockThreads_Reduced;
  int numBlockThreads_Max;
  int numTotalThreads;
 } CLzma2EncProps;
 void Lzma2EncProps_Init(CLzma2EncProps *p);
 void Lzma2EncProps_Normalize(CLzma2EncProps *p);
 /* ---------- CLzmaEnc2Handle Interface ---------- */
 /* Lzma2Enc_* functions can return the following exit codes:
 SRes:
  SZ_OK           - OK
  SZ_ERROR_MEM    - Memory allocation error
  SZ_ERROR_PARAM  - Incorrect paramater in props
  SZ_ERROR_WRITE  - ISeqOutStream write callback error
  SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
  SZ_ERROR_PROGRESS - some break from progress callback
  SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
 */
 typedef struct CLzma2Enc CLzma2Enc;
 typedef CLzma2Enc * CLzma2EncHandle;
 // Z7_DECLARE_HANDLE(CLzma2EncHandle)
 CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
 void Lzma2Enc_Destroy(CLzma2EncHandle p);
 SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props);
 void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize);
 Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p);
 SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
    ISeqOutStreamPtr outStream,
    Byte *outBuf, size_t *outBufSize,
    ISeqInStreamPtr inStream,
    const Byte *inData, size_t inDataSize,
    ICompressProgressPtr progress);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Lzma86.h
+++ b/3rdparty/7z/src/Lzma86.h
@ -0,0 +1,111 @@
 /* Lzma86.h -- LZMA + x86 (BCJ) Filter
 2023-03-03 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZMA86_H
 #define ZIP7_INC_LZMA86_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 #define LZMA86_SIZE_OFFSET (1 + 5)
 #define LZMA86_HEADER_SIZE (LZMA86_SIZE_OFFSET + 8)
 /*
 It's an example for LZMA + x86 Filter use.
 You can use .lzma86 extension, if you write that stream to file.
 .lzma86 header adds one additional byte to standard .lzma header.
 .lzma86 header (14 bytes):
  Offset Size  Description
    0     1    = 0 - no filter, pure LZMA
               = 1 - x86 filter + LZMA
    1     1    lc, lp and pb in encoded form
    2     4    dictSize (little endian)
    6     8    uncompressed size (little endian)
 Lzma86_Encode
 -------------
 level - compression level: 0 <= level <= 9, the default value for "level" is 5.
 dictSize - The dictionary size in bytes. The maximum value is
        128 MB = (1 << 27) bytes for 32-bit version
          1 GB = (1 << 30) bytes for 64-bit version
     The default value is 16 MB = (1 << 24) bytes, for level = 5.
     It's recommended to use the dictionary that is larger than 4 KB and
     that can be calculated as (1 << N) or (3 << N) sizes.
     For better compression ratio dictSize must be >= inSize.
 filterMode:
    SZ_FILTER_NO   - no Filter
    SZ_FILTER_YES  - x86 Filter
    SZ_FILTER_AUTO - it tries both alternatives to select best.
              Encoder will use 2 or 3 passes:
              2 passes when FILTER_NO provides better compression.
              3 passes when FILTER_YES provides better compression.
 Lzma86Encode allocates Data with MyAlloc functions.
 RAM Requirements for compressing:
  RamSize = dictionarySize * 11.5 + 6MB + FilterBlockSize
      filterMode     FilterBlockSize
     SZ_FILTER_NO         0
     SZ_FILTER_YES      inSize
     SZ_FILTER_AUTO     inSize
 Return code:
  SZ_OK               - OK
  SZ_ERROR_MEM        - Memory allocation error
  SZ_ERROR_PARAM      - Incorrect paramater
  SZ_ERROR_OUTPUT_EOF - output buffer overflow
  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
 */
 enum ESzFilterMode
 {
  SZ_FILTER_NO,
  SZ_FILTER_YES,
  SZ_FILTER_AUTO
 };
 SRes Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
    int level, UInt32 dictSize, int filterMode);
 /*
 Lzma86_GetUnpackSize:
  In:
    src      - input data
    srcLen   - input data size
  Out:
    unpackSize - size of uncompressed stream
  Return code:
    SZ_OK               - OK
    SZ_ERROR_INPUT_EOF  - Error in headers
 */
 SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize);
 /*
 Lzma86_Decode:
  In:
    dest     - output data
    destLen  - output data size
    src      - input data
    srcLen   - input data size
  Out:
    destLen  - processed output size
    srcLen   - processed input size
  Return code:
    SZ_OK           - OK
    SZ_ERROR_DATA  - Data error
    SZ_ERROR_MEM   - Memory allocation error
    SZ_ERROR_UNSUPPORTED - unsupported file
    SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer
 */
 SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen);
 EXTERN_C_END
 #endif
--- a/3rdparty/7z/src/Lzma86Dec.c
+++ b/3rdparty/7z/src/Lzma86Dec.c
@ -0,0 +1,53 @@
 /* Lzma86Dec.c -- LZMA + x86 (BCJ) Filter Decoder
 2023-03-03 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include "Lzma86.h"
 #include "Alloc.h"
 #include "Bra.h"
 #include "LzmaDec.h"
 SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize)
 {
  unsigned i;
  if (srcLen < LZMA86_HEADER_SIZE)
    return SZ_ERROR_INPUT_EOF;
  *unpackSize = 0;
  for (i = 0; i < sizeof(UInt64); i++)
    *unpackSize += ((UInt64)src[LZMA86_SIZE_OFFSET + i]) << (8 * i);
  return SZ_OK;
 }
 SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen)
 {
  SRes res;
  int useFilter;
  SizeT inSizePure;
  ELzmaStatus status;
  if (*srcLen < LZMA86_HEADER_SIZE)
    return SZ_ERROR_INPUT_EOF;
  useFilter = src[0];
  if (useFilter > 1)
  {
    *destLen = 0;
    return SZ_ERROR_UNSUPPORTED;
  }
  inSizePure = *srcLen - LZMA86_HEADER_SIZE;
  res = LzmaDecode(dest, destLen, src + LZMA86_HEADER_SIZE, &inSizePure,
      src + 1, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status, &g_Alloc);
  *srcLen = inSizePure + LZMA86_HEADER_SIZE;
  if (res != SZ_OK)
    return res;
  if (useFilter == 1)
  {
    UInt32 x86State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
    z7_BranchConvSt_X86_Dec(dest, *destLen, 0, &x86State);
  }
  return SZ_OK;
 }
--- a/3rdparty/7z/src/Lzma86Enc.c
+++ b/3rdparty/7z/src/Lzma86Enc.c
@ -0,0 +1,103 @@
 /* Lzma86Enc.c -- LZMA + x86 (BCJ) Filter Encoder
 2023-03-03 : Igor Pavlov : Public domain */
 #include "Precomp.h"
 #include <string.h>
 #include "Lzma86.h"
 #include "Alloc.h"
 #include "Bra.h"
 #include "LzmaEnc.h"
 int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
    int level, UInt32 dictSize, int filterMode)
 {
  size_t outSize2 = *destLen;
  Byte *filteredStream;
  BoolInt useFilter;
  int mainResult = SZ_ERROR_OUTPUT_EOF;
  CLzmaEncProps props;
  LzmaEncProps_Init(&props);
  props.level = level;
  props.dictSize = dictSize;
  *destLen = 0;
  if (outSize2 < LZMA86_HEADER_SIZE)
    return SZ_ERROR_OUTPUT_EOF;
  {
    int i;
    UInt64 t = srcLen;
    for (i = 0; i < 8; i++, t >>= 8)
      dest[LZMA86_SIZE_OFFSET + i] = (Byte)t;
  }
  filteredStream = 0;
  useFilter = (filterMode != SZ_FILTER_NO);
  if (useFilter)
  {
    if (srcLen != 0)
    {
      filteredStream = (Byte *)MyAlloc(srcLen);
      if (filteredStream == 0)
        return SZ_ERROR_MEM;
      memcpy(filteredStream, src, srcLen);
    }
    {
      UInt32 x86State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
      z7_BranchConvSt_X86_Enc(filteredStream, srcLen, 0, &x86State);
    }
  }
  {
    size_t minSize = 0;
    BoolInt bestIsFiltered = False;
    /* passes for SZ_FILTER_AUTO:
        0 - BCJ + LZMA
        1 - LZMA
        2 - BCJ + LZMA agaian, if pass 0 (BCJ + LZMA) is better.
    */
    int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
    int i;
    for (i = 0; i < numPasses; i++)
    {
      size_t outSizeProcessed = outSize2 - LZMA86_HEADER_SIZE;
      size_t outPropsSize = 5;
      SRes curRes;
      BoolInt curModeIsFiltered = (numPasses > 1 && i == numPasses - 1);
      if (curModeIsFiltered && !bestIsFiltered)
        break;
      if (useFilter && i == 0)
        curModeIsFiltered = True;
      curRes = LzmaEncode(dest + LZMA86_HEADER_SIZE, &outSizeProcessed,
          curModeIsFiltered ? filteredStream : src, srcLen,
          &props, dest + 1, &outPropsSize, 0,
          NULL, &g_Alloc, &g_Alloc);
      if (curRes != SZ_ERROR_OUTPUT_EOF)
      {
        if (curRes != SZ_OK)
        {
          mainResult = curRes;
          break;
        }
        if (outSizeProcessed <= minSize || mainResult != SZ_OK)
        {
          minSize = outSizeProcessed;
          bestIsFiltered = curModeIsFiltered;
          mainResult = SZ_OK;
        }
      }
    }
    dest[0] = (Byte)(bestIsFiltered ? 1 : 0);
    *destLen = LZMA86_HEADER_SIZE + minSize;
  }
  if (useFilter)
    MyFree(filteredStream);
  return mainResult;
 }
--- a/3rdparty/7z/src/LzmaDec.c
+++ b/3rdparty/7z/src/LzmaDec.c
--- a/3rdparty/7z/src/LzmaDec.h
+++ b/3rdparty/7z/src/LzmaDec.h
@ -0,0 +1,237 @@
 /* LzmaDec.h -- LZMA Decoder
 2023-04-02 : Igor Pavlov : Public domain */
 #ifndef ZIP7_INC_LZMA_DEC_H
 #define ZIP7_INC_LZMA_DEC_H
 #include "7zTypes.h"
 EXTERN_C_BEGIN
 /* #define Z7_LZMA_PROB32 */
 /* Z7_LZMA_PROB32 can increase the speed on some CPUs,
   but memory usage for CLzmaDec::probs will be doubled in that case */
 typedef
 #ifdef Z7_LZMA_PROB32
  UInt32
 #else
  UInt16
 #endif
  CLzmaProb;
 /* ---------- LZMA Properties ---------- */
 #define LZMA_PROPS_SIZE 5
 typedef struct
 {
  Byte lc;
  Byte lp;
  Byte pb;
  Byte _pad_;
  UInt32 dicSize;
 } CLzmaProps;
 /* LzmaProps_Decode - decodes properties
 Returns:
  SZ_OK
  SZ_ERROR_UNSUPPORTED - Unsupported properties
 */
 SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
 /* ---------- LZMA Decoder state ---------- */
 /* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
   Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */
 #define LZMA_REQUIRED_INPUT_MAX 20
 typedef struct
 {
  /* Don't change this structure. ASM code can use it. */
  CLzmaProps prop;
  CLzmaProb *probs;
  CLzmaProb *probs_1664;
  Byte *dic;
  SizeT dicBufSize;
  SizeT dicPos;
  const Byte *buf;
  UInt32 range;
  UInt32 code;
  UInt32 processedPos;
  UInt32 checkDicSize;
  UInt32 reps[4];
  UInt32 state;
  UInt32 remainLen;
  UInt32 numProbs;
  unsigned tempBufSize;
  Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];
 } CLzmaDec;
 #define LzmaDec_CONSTRUCT(p) { (p)->dic = NULL; (p)->probs = NULL; }
 #define LzmaDec_Construct(p) LzmaDec_CONSTRUCT(p)
 void LzmaDec_Init(CLzmaDec *p);
 /* There are two types of LZMA streams:
     - Stream with end mark. That end mark adds about 6 bytes to compressed size.
     - Stream without end mark. You must know exact uncompressed size to decompress such stream. */
 typedef enum
 {
  LZMA_FINISH_ANY,   /* finish at any point */
  LZMA_FINISH_END    /* block must be finished at the end */
 } ELzmaFinishMode;
 /* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!
   You must use LZMA_FINISH_END, when you know that current output buffer
   covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.
   If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,
   and output value of destLen will be less than output buffer size limit.
   You can check status result also.
   You can use multiple checks to test data integrity after full decompression:
     1) Check Result and "status" variable.
     2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
     3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
        You must use correct finish mode in that case. */
 typedef enum
 {
  LZMA_STATUS_NOT_SPECIFIED,               /* use main error code instead */
  LZMA_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
  LZMA_STATUS_NOT_FINISHED,                /* stream was not finished */
  LZMA_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK  /* there is probability that stream was finished without end mark */
 } ELzmaStatus;
 /* ELzmaStatus is used only as output value for function call */
 /* ---------- Interfaces ---------- */
 /* There are 3 levels of interfaces:
     1) Dictionary Interface
     2) Buffer Interface
     3) One Call Interface
   You can select any of these interfaces, but don't mix functions from different
   groups for same object. */
 /* There are two variants to allocate state for Dictionary Interface:
     1) LzmaDec_Allocate / LzmaDec_Free
     2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
   You can use variant 2, if you set dictionary buffer manually.
   For Buffer Interface you must always use variant 1.
 LzmaDec_Allocate* can return:
  SZ_OK
  SZ_ERROR_MEM         - Memory allocation error
  SZ_ERROR_UNSUPPORTED - Unsupported properties
 */
 SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
 void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);
 SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
 void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);
 /* ---------- Dictionary Interface ---------- */
 /* You can use it, if you want to eliminate the overhead for data copying from
   dictionary to some other external buffer.
   You must work with CLzmaDec variables directly in this interface.
   STEPS:
     LzmaDec_Construct()
     LzmaDec_Allocate()
     for (each new stream)
     {
       LzmaDec_Init()
       while (it needs more decompression)
       {
         LzmaDec_DecodeToDic()
         use data from CLzmaDec::dic and update CLzmaDec::dicPos
       }
     }
     LzmaDec_Free()
 */
 /* LzmaDec_DecodeToDic
   The decoding to internal dictionary buffer (CLzmaDec::dic).
   You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
 finishMode:
  It has meaning only if the decoding reaches output limit (dicLimit).
  LZMA_FINISH_ANY - Decode just dicLimit bytes.
  LZMA_FINISH_END - Stream must be finished after dicLimit.
 Returns:
  SZ_OK
    status:
      LZMA_STATUS_FINISHED_WITH_MARK
      LZMA_STATUS_NOT_FINISHED
      LZMA_STATUS_NEEDS_MORE_INPUT
      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
  SZ_ERROR_DATA - Data error
  SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
 */
 SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 /* ---------- Buffer Interface ---------- */
 /* It's zlib-like interface.
   See LzmaDec_DecodeToDic description for information about STEPS and return results,
   but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
   to work with CLzmaDec variables manually.
 finishMode:
  It has meaning only if the decoding reaches output limit (*destLen).
  LZMA_FINISH_ANY - Decode just destLen bytes.
  LZMA_FINISH_END - Stream must be finished after (*destLen).
 */
 SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 /* ---------- One Call Interface ---------- */
 /* LzmaDecode
 finishMode:
  It has meaning only if the decoding reaches output limit (*destLen).
  LZMA_FINISH_ANY - Decode just destLen bytes.
  LZMA_FINISH_END - Stream must be finished after (*destLen).
 Returns:
  SZ_OK
    status:
      LZMA_STATUS_FINISHED_WITH_MARK
      LZMA_STATUS_NOT_FINISHED
      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
  SZ_ERROR_DATA - Data error
  SZ_ERROR_MEM  - Memory allocation error
  SZ_ERROR_UNSUPPORTED - Unsupported properties
  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
  SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
 */
 SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
    ELzmaStatus *status, ISzAllocPtr alloc);
 EXTERN_C_END
 #endif
--- a/Show more
+++ b/Show more
`@ -16,4 +16,4 @@ Submitting your test results for Commercial Games must be done on our forums. Pl`

	`# Contributing`	`# Contributing`

	`Check the [Coding Style Guidelines](https://github.com/RPCS3/rpcs3/wiki/Coding-Style) and [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information). If you have any questions, hit us up on our [Discord Server](https://discord.gg/rpcs3) in the #development channel.`	`Check the [Coding Style Guidelines](https://github.com/RPCS3/rpcs3/wiki/Coding-Style) and [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information). If you have any questions, hit us up on our [Discord Server](https://discord.me/RPCS3) in the #development channel.`
`@ -1 +1,2 @@`
	`patreon: Nekotekina`	`patreon: Nekotekina`
		`custom: https://rpcs3.net/alipay`
		`@ -0,0 +1,3 @@`
							`<!-- Please include a summary of the change and which issue is fixed. -->`

							`[How to test this PR](.github/PR-BUILD.md)`