CDVD | CHD: Account for pre/post gap offsets when filling TOC

This will fix discs with tracks with both an INDEX 00 and INDEX 01
CDVD: Byte swap hack. CHD CD audio with OSDSYS is working
2026-01-31 01:15:24 +01:00 · 2024-11-27 15:55:11 -05:00 · 2024-11-27 15:54:56 -05:00 · 2024-11-27 15:25:59 -05:00
326 changed files with 115137 additions and 168801 deletions
--- a/.github/workflows/cron_update_controller_db.yml
+++ b/.github/workflows/cron_update_controller_db.yml
@@ -22,7 +22,7 @@ jobs:
        uses: peter-evans/create-pull-request@v7
        with:
          title: "PAD: Update to latest controller database"
-          commit-message: "[ci skip] PAD: Update to latest controller database."
+          commit-message: "PAD: Update to latest controller database."
          committer: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
          author: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
          body: "Weekly automatic update of SDL Controller DB."
--- a/.github/workflows/scripts/linux/appimage-qt.sh
+++ b/.github/workflows/scripts/linux/appimage-qt.sh
@@ -206,7 +206,7 @@ GIT_VERSION=$(git tag --points-at HEAD)

 if [[ "${GIT_VERSION}" == "" ]]; then
 	# In the odd event that we run this script before the release gets tagged.
-	GIT_VERSION=$(git describe --tags || true)
+	GIT_VERSION=$(git describe --tags)
 	if [[ "${GIT_VERSION}" == "" ]]; then
 		GIT_VERSION=$(git rev-parse HEAD)
 	fi
--- a/.github/workflows/scripts/linux/build-dependencies-qt.sh
+++ b/.github/workflows/scripts/linux/build-dependencies-qt.sh
@@ -16,11 +16,11 @@ fi

 LIBBACKTRACE=ad106d5fdd5d960bd33fae1c48a351af567fd075
 LIBJPEG=9f
-LIBPNG=1.6.45
-LIBWEBP=1.5.0
+LIBPNG=1.6.44
+LIBWEBP=1.4.0
 LZ4=b8fd2d15309dd4e605070bd4486e26b6ef814e29
-SDL=SDL2-2.30.11
-QT=6.8.1
+SDL=SDL2-2.30.9
+QT=6.8.0
 ZSTD=1.5.6

 SHADERC=2024.1
@@ -34,17 +34,17 @@ cd deps-build
 cat > SHASUMS <<EOF
 fd6f417fe9e3a071cf1424a5152d926a34c4a3c5070745470be6cf12a404ed79  $LIBBACKTRACE.zip
 04705c110cb2469caa79fb71fba3d7bf834914706e9641a4589485c1f832565b  jpegsrc.v$LIBJPEG.tar.gz
-926485350139ffb51ef69760db35f78846c805fef3d59bfdcb2fba704663f370  libpng-$LIBPNG.tar.xz
-7d6fab70cf844bf6769077bd5d7a74893f8ffd4dfb42861745750c63c2a5c92c  libwebp-$LIBWEBP.tar.gz
+60c4da1d5b7f0aa8d158da48e8f8afa9773c1c8baa5d21974df61f1886b8ce8e  libpng-$LIBPNG.tar.xz
+61f873ec69e3be1b99535634340d5bde750b2e4447caa1db9f61be3fd49ab1e5  libwebp-$LIBWEBP.tar.gz
 0728800155f3ed0a0c87e03addbd30ecbe374f7b080678bbca1506051d50dec3  $LZ4.tar.gz
-8b8d4aef2038533da814965220f88f77d60dfa0f32685f80ead65e501337da7f  $SDL.tar.gz
+24b574f71c87a763f50704bbb630cbe38298d544a1f890f099a4696b1d6beba4  $SDL.tar.gz
 8c29e06cf42aacc1eafc4077ae2ec6c6fcb96a626157e0593d5e82a34fd403c1  zstd-$ZSTD.tar.gz
-40b14562ef3bd779bc0e0418ea2ae08fa28235f8ea6e8c0cb3bce1d6ad58dcaf  qtbase-everywhere-src-$QT.tar.xz
-138cc2909aa98f5ff7283e36eb3936eb5e625d3ca3b4febae2ca21d8903dd237  qtimageformats-everywhere-src-$QT.tar.xz
-3d0de73596e36b2daa7c48d77c4426bb091752856912fba720215f756c560dd0  qtsvg-everywhere-src-$QT.tar.xz
-9d43d409be08b8681a0155a9c65114b69c9a3fc11aef6487bb7fdc5b283c432d  qttools-everywhere-src-$QT.tar.xz
-635a6093e99152243b807de51077485ceadd4786d4acb135b9340b2303035a4a  qttranslations-everywhere-src-$QT.tar.xz
-2226fbde4e2ddd12f8bf4b239c8f38fd706a54e789e63467dfddc77129eca203  qtwayland-everywhere-src-$QT.tar.xz
+1bad481710aa27f872de6c9f72651f89a6107f0077003d0ebfcc9fd15cba3c75  qtbase-everywhere-src-$QT.tar.xz
+595bf8557b91e1f8ebc726f1e09868a3c7e610ff5045068f2d4ea2428c49a5d4  qtimageformats-everywhere-src-$QT.tar.xz
+cf7a593d5e520f8177240610d9e55d5b75b0887fe5f385554ff64377f1646199  qtsvg-everywhere-src-$QT.tar.xz
+403115d8268503c6cc6e43310c8ae28eb9e605072a5d04e4a2de8b6af39981f7  qttools-everywhere-src-$QT.tar.xz
+84bf2b67c243cd0c50a08acd7bfa9df2b1965028511815c1b6b65a0687437cb6  qttranslations-everywhere-src-$QT.tar.xz
+175758591638ebf1c6fbb66ac11c7fa0eb8d4ed52e9243cc59075d06a6a2060a  qtwayland-everywhere-src-$QT.tar.xz
 eb3b5f0c16313d34f208d90c2fa1e588a23283eed63b101edd5422be6165d528  shaderc-$SHADERC.tar.gz
 aa27e4454ce631c5a17924ce0624eac736da19fc6f5a2ab15a6c58da7b36950f  shaderc-glslang-$SHADERC_GLSLANG.tar.gz
 5d866ce34a4b6908e262e5ebfffc0a5e11dd411640b5f24c85a80ad44c0d4697  shaderc-spirv-headers-$SHADERC_SPIRVHEADERS.tar.gz
--- a/.github/workflows/scripts/linux/flatpak/modules/20-sdl2.json
+++ b/.github/workflows/scripts/linux/flatpak/modules/20-sdl2.json
@@ -14,8 +14,8 @@
  "sources": [
    {
      "type": "archive",
-      "url": "https://libsdl.org/release/SDL2-2.30.11.tar.gz",
-      "sha256": "8b8d4aef2038533da814965220f88f77d60dfa0f32685f80ead65e501337da7f"
+      "url": "https://libsdl.org/release/SDL2-2.30.9.tar.gz",
+      "sha256": "24b574f71c87a763f50704bbb630cbe38298d544a1f890f099a4696b1d6beba4"
    }
  ],
  "cleanup": [
--- a/.github/workflows/scripts/macos/build-dependencies-universal.sh
+++ b/.github/workflows/scripts/macos/build-dependencies-universal.sh
@@ -40,12 +40,12 @@ fi

 FREETYPE=2.13.3
 HARFBUZZ=10.0.1
-SDL=SDL2-2.30.11
+SDL=SDL2-2.30.9
 ZSTD=1.5.6
 LZ4=b8fd2d15309dd4e605070bd4486e26b6ef814e29
-LIBPNG=1.6.45
+LIBPNG=1.6.44
 LIBJPEG=9f
-LIBWEBP=1.5.0
+LIBWEBP=1.4.0
 FFMPEG=6.0
 MOLTENVK=1.2.9
 QT=6.7.2
@@ -76,11 +76,11 @@ CMAKE_ARCH_UNIVERSAL=-DCMAKE_OSX_ARCHITECTURES="x86_64;arm64"
 cat > SHASUMS <<EOF
 0550350666d427c74daeb85d5ac7bb353acba5f76956395995311a9c6f063289  freetype-$FREETYPE.tar.xz
 e7358ea86fe10fb9261931af6f010d4358dac64f7074420ca9bc94aae2bdd542  harfbuzz-$HARFBUZZ.tar.gz
-8b8d4aef2038533da814965220f88f77d60dfa0f32685f80ead65e501337da7f  $SDL.tar.gz
+24b574f71c87a763f50704bbb630cbe38298d544a1f890f099a4696b1d6beba4  $SDL.tar.gz
 8c29e06cf42aacc1eafc4077ae2ec6c6fcb96a626157e0593d5e82a34fd403c1  zstd-$ZSTD.tar.gz
 0728800155f3ed0a0c87e03addbd30ecbe374f7b080678bbca1506051d50dec3  $LZ4.tar.gz
-926485350139ffb51ef69760db35f78846c805fef3d59bfdcb2fba704663f370  libpng-$LIBPNG.tar.xz
-7d6fab70cf844bf6769077bd5d7a74893f8ffd4dfb42861745750c63c2a5c92c  libwebp-$LIBWEBP.tar.gz
+60c4da1d5b7f0aa8d158da48e8f8afa9773c1c8baa5d21974df61f1886b8ce8e  libpng-$LIBPNG.tar.xz
+61f873ec69e3be1b99535634340d5bde750b2e4447caa1db9f61be3fd49ab1e5  libwebp-$LIBWEBP.tar.gz
 04705c110cb2469caa79fb71fba3d7bf834914706e9641a4589485c1f832565b  jpegsrc.v$LIBJPEG.tar.gz
 57be87c22d9b49c112b6d24bc67d42508660e6b718b3db89c44e47e289137082  ffmpeg-$FFMPEG.tar.xz
 f415a09385030c6510a936155ce211f617c31506db5fbc563e804345f1ecf56e  v$MOLTENVK.tar.gz
--- a/.github/workflows/scripts/macos/build-dependencies.sh
+++ b/.github/workflows/scripts/macos/build-dependencies.sh
@@ -22,12 +22,12 @@ fi

 FREETYPE=2.13.3
 HARFBUZZ=10.0.1
-SDL=SDL2-2.30.11
+SDL=SDL2-2.30.9
 ZSTD=1.5.6
 LZ4=b8fd2d15309dd4e605070bd4486e26b6ef814e29
-LIBPNG=1.6.45
+LIBPNG=1.6.44
 LIBJPEG=9f
-LIBWEBP=1.5.0
+LIBWEBP=1.4.0
 FFMPEG=6.0
 MOLTENVK=1.2.9
 QT=6.7.2
@@ -56,11 +56,11 @@ CMAKE_COMMON=(
 cat > SHASUMS <<EOF
 0550350666d427c74daeb85d5ac7bb353acba5f76956395995311a9c6f063289  freetype-$FREETYPE.tar.xz
 e7358ea86fe10fb9261931af6f010d4358dac64f7074420ca9bc94aae2bdd542  harfbuzz-$HARFBUZZ.tar.gz
-8b8d4aef2038533da814965220f88f77d60dfa0f32685f80ead65e501337da7f  $SDL.tar.gz
+24b574f71c87a763f50704bbb630cbe38298d544a1f890f099a4696b1d6beba4  $SDL.tar.gz
 8c29e06cf42aacc1eafc4077ae2ec6c6fcb96a626157e0593d5e82a34fd403c1  zstd-$ZSTD.tar.gz
 0728800155f3ed0a0c87e03addbd30ecbe374f7b080678bbca1506051d50dec3  $LZ4.tar.gz
-926485350139ffb51ef69760db35f78846c805fef3d59bfdcb2fba704663f370  libpng-$LIBPNG.tar.xz
-7d6fab70cf844bf6769077bd5d7a74893f8ffd4dfb42861745750c63c2a5c92c  libwebp-$LIBWEBP.tar.gz
+60c4da1d5b7f0aa8d158da48e8f8afa9773c1c8baa5d21974df61f1886b8ce8e  libpng-$LIBPNG.tar.xz
+61f873ec69e3be1b99535634340d5bde750b2e4447caa1db9f61be3fd49ab1e5  libwebp-$LIBWEBP.tar.gz
 04705c110cb2469caa79fb71fba3d7bf834914706e9641a4589485c1f832565b  jpegsrc.v$LIBJPEG.tar.gz
 57be87c22d9b49c112b6d24bc67d42508660e6b718b3db89c44e47e289137082  ffmpeg-$FFMPEG.tar.xz
 f415a09385030c6510a936155ce211f617c31506db5fbc563e804345f1ecf56e  v$MOLTENVK.tar.gz
--- a/.github/workflows/scripts/windows/build-dependencies-arm64.bat
+++ b/.github/workflows/scripts/windows/build-dependencies-arm64.bat
@@ -45,12 +45,12 @@ cd "%BUILDDIR%"
 set FREETYPE=2.13.3
 set HARFBUZZ=10.0.1
 set LIBJPEG=9f
-set LIBPNG=1645
+set LIBPNG=1643
 set LZ4=b8fd2d15309dd4e605070bd4486e26b6ef814e29
-set QT=6.8.1
+set QT=6.8.0
 set QTMINOR=6.8
-set SDL=SDL2-2.30.11
-set WEBP=1.5.0
+set SDL=SDL2-2.30.9
+set WEBP=1.4.0
 set ZLIB=1.3.1
 set ZLIBSHORT=131
 set ZSTD=1.5.6
@@ -62,16 +62,16 @@ set SHADERC_SPIRVTOOLS=dd4b663e13c07fea4fbb3f70c1c91c86731099f7

 call :downloadfile "freetype-%FREETYPE%.tar.gz" https://sourceforge.net/projects/freetype/files/freetype2/%FREETYPE%/freetype-%FREETYPE%.tar.gz/download 5c3a8e78f7b24c20b25b54ee575d6daa40007a5f4eea2845861c3409b3021747 || goto error
 call :downloadfile "harfbuzz-%HARFBUZZ%.zip" https://github.com/harfbuzz/harfbuzz/archive/refs/tags/%HARFBUZZ%.zip 8adf9f5a4b6022aa2744f45c89ce347df46fea8403e99f01d650b11c417d0aa8 || goto error
-call :downloadfile "lpng%LIBPNG%.zip" https://download.sourceforge.net/libpng/lpng1645.zip 7d6fab70cf844bf6769077bd5d7a74893f8ffd4dfb42861745750c63c2a5c92c || goto error
+call :downloadfile "lpng%LIBPNG%.zip" https://download.sourceforge.net/libpng/lpng1643.zip fc466a1e638e635d6c66363bdf3f38555b81b0141d0b06ba45b49ccca327436d || goto error
 call :downloadfile "jpegsr%LIBJPEG%.zip" https://ijg.org/files/jpegsr%LIBJPEG%.zip 6255da8c89e09d694e6800688c76145eb6870a76ac0d36c74fccd61b3940aafa || goto error
 call :downloadfile "libwebp-%WEBP%.tar.gz" "https://storage.googleapis.com/downloads.webmproject.org/releases/webp/libwebp-%WEBP%.tar.gz" 61f873ec69e3be1b99535634340d5bde750b2e4447caa1db9f61be3fd49ab1e5 || goto error
 call :downloadfile "lz4-%LZ4%.zip" "https://github.com/lz4/lz4/archive/%LZ4%.zip" 0c33119688d6b180c7e760b0acd70059222389cfd581632623784bee27e51a31 || goto error
-call :downloadfile "%SDL%.zip" "https://libsdl.org/release/%SDL%.zip" a0b3e7ac5f708042683ff0f22e069bdf75563540c615f9854ecc9bc8913e2488 || goto error
-call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" e22d997bd15b795a176c8da62c8c1da0a674eb534e02f7c01ca507bf11bce0c3 || goto error
-call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" 247a0a58039275a5a4fb499a600a90f66dc6e00321bb6f86a9b8d8020344d853 || goto error
-call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" 57bd332e5550ff70a852560c591b786b6ba587c5e41cb5ef91038d82db137ab9 || goto error
-call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" c65a89140f5d68137ffec67d631ec97002fb37077d9b4eb4ee45cbec39b1c38a || goto error
-call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" 30a8e7773e1f274557e049a97f158b808f344247da03ae5240e4956c81d51cd5 || goto error
+call :downloadfile "%SDL%.zip" "https://libsdl.org/release/%SDL%.zip" ec855bcd815b4b63d0c958c42c2923311c656227d6e0c1ae1e721406d346444b || goto error
+call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" c3b41915341d853b6374cf93f1fcced2c8e4be9360f29c656960e1d0d15046a3 || goto error
+call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" 809081a7bdf7e48262fbe9437e4e756df6ad2649433e803c4040026e650d7c91 || goto error
+call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" 89f1ef4595f68c3d34c63a7c1c4ce475e701e103f0473f3fd0718a2e5234de6e || goto error
+call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" 3f813f49d6d28c532dc4b104084f60ff382337f184698fcd6e70ab9efad977c1 || goto error
+call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" 91c33d9946279c9c613b02e52a33df610cc01d13ea6e321b4c4d8ee708b9a03e || goto error
 call :downloadfile "zlib%ZLIBSHORT%.zip" "https://zlib.net/zlib%ZLIBSHORT%.zip" 72af66d44fcc14c22013b46b814d5d2514673dda3d115e64b690c1ad636e7b17 || goto error
 call :downloadfile "zstd-%ZSTD%.zip" "https://github.com/facebook/zstd/archive/refs/tags/v%ZSTD%.zip" 3b1c3b46e416d36931efd34663122d7f51b550c87f74de2d38249516fe7d8be5 || goto error
 call :downloadfile "zstd-fd5f8106a58601a963ee816e6a57aa7c61fafc53.patch" https://github.com/facebook/zstd/commit/fd5f8106a58601a963ee816e6a57aa7c61fafc53.patch 8df152f4969b308546306c074628de761f0b80265de7de534e3822fab22d7535 || goto error
--- a/.github/workflows/scripts/windows/build-dependencies.bat
+++ b/.github/workflows/scripts/windows/build-dependencies.bat
@@ -43,12 +43,12 @@ cd "%BUILDDIR%"
 set FREETYPE=2.13.3
 set HARFBUZZ=10.0.1
 set LIBJPEG=9f
-set LIBPNG=1645
+set LIBPNG=1643
 set LZ4=b8fd2d15309dd4e605070bd4486e26b6ef814e29
-set QT=6.8.1
+set QT=6.8.0
 set QTMINOR=6.8
-set SDL=SDL2-2.30.11
-set WEBP=1.5.0
+set SDL=SDL2-2.30.9
+set WEBP=1.4.0
 set ZLIB=1.3.1
 set ZLIBSHORT=131
 set ZSTD=1.5.6
@@ -60,16 +60,16 @@ set SHADERC_SPIRVTOOLS=dd4b663e13c07fea4fbb3f70c1c91c86731099f7

 call :downloadfile "freetype-%FREETYPE%.tar.gz" https://sourceforge.net/projects/freetype/files/freetype2/%FREETYPE%/freetype-%FREETYPE%.tar.gz/download 5c3a8e78f7b24c20b25b54ee575d6daa40007a5f4eea2845861c3409b3021747 || goto error
 call :downloadfile "harfbuzz-%HARFBUZZ%.zip" https://github.com/harfbuzz/harfbuzz/archive/refs/tags/%HARFBUZZ%.zip 8adf9f5a4b6022aa2744f45c89ce347df46fea8403e99f01d650b11c417d0aa8 || goto error
-call :downloadfile "lpng%LIBPNG%.zip" https://download.sourceforge.net/libpng/lpng1645.zip a66c4b1350b67776e90263e2550933067cd9ccbd318db489f84dcc0d2b033249 || goto error
+call :downloadfile "lpng%LIBPNG%.zip" https://download.sourceforge.net/libpng/lpng1643.zip fc466a1e638e635d6c66363bdf3f38555b81b0141d0b06ba45b49ccca327436d || goto error
 call :downloadfile "jpegsr%LIBJPEG%.zip" https://ijg.org/files/jpegsr%LIBJPEG%.zip 6255da8c89e09d694e6800688c76145eb6870a76ac0d36c74fccd61b3940aafa || goto error
-call :downloadfile "libwebp-%WEBP%.tar.gz" "https://storage.googleapis.com/downloads.webmproject.org/releases/webp/libwebp-%WEBP%.tar.gz" 7d6fab70cf844bf6769077bd5d7a74893f8ffd4dfb42861745750c63c2a5c92c || goto error
+call :downloadfile "libwebp-%WEBP%.tar.gz" "https://storage.googleapis.com/downloads.webmproject.org/releases/webp/libwebp-%WEBP%.tar.gz" 61f873ec69e3be1b99535634340d5bde750b2e4447caa1db9f61be3fd49ab1e5 || goto error
 call :downloadfile "lz4-%LZ4%.zip" "https://github.com/lz4/lz4/archive/%LZ4%.zip" 0c33119688d6b180c7e760b0acd70059222389cfd581632623784bee27e51a31 || goto error
-call :downloadfile "%SDL%.zip" "https://libsdl.org/release/%SDL%.zip" a0b3e7ac5f708042683ff0f22e069bdf75563540c615f9854ecc9bc8913e2488 || goto error
-call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" e22d997bd15b795a176c8da62c8c1da0a674eb534e02f7c01ca507bf11bce0c3 || goto error
-call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" 247a0a58039275a5a4fb499a600a90f66dc6e00321bb6f86a9b8d8020344d853 || goto error
-call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" 57bd332e5550ff70a852560c591b786b6ba587c5e41cb5ef91038d82db137ab9 || goto error
-call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" c65a89140f5d68137ffec67d631ec97002fb37077d9b4eb4ee45cbec39b1c38a || goto error
-call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" 30a8e7773e1f274557e049a97f158b808f344247da03ae5240e4956c81d51cd5 || goto error
+call :downloadfile "%SDL%.zip" "https://libsdl.org/release/%SDL%.zip" ec855bcd815b4b63d0c958c42c2923311c656227d6e0c1ae1e721406d346444b || goto error
+call :downloadfile "qtbase-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtbase-everywhere-src-%QT%.zip" c3b41915341d853b6374cf93f1fcced2c8e4be9360f29c656960e1d0d15046a3 || goto error
+call :downloadfile "qtimageformats-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtimageformats-everywhere-src-%QT%.zip" 809081a7bdf7e48262fbe9437e4e756df6ad2649433e803c4040026e650d7c91 || goto error
+call :downloadfile "qtsvg-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qtsvg-everywhere-src-%QT%.zip" 89f1ef4595f68c3d34c63a7c1c4ce475e701e103f0473f3fd0718a2e5234de6e || goto error
+call :downloadfile "qttools-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttools-everywhere-src-%QT%.zip" 3f813f49d6d28c532dc4b104084f60ff382337f184698fcd6e70ab9efad977c1 || goto error
+call :downloadfile "qttranslations-everywhere-src-%QT%.zip" "https://download.qt.io/official_releases/qt/%QTMINOR%/%QT%/submodules/qttranslations-everywhere-src-%QT%.zip" 91c33d9946279c9c613b02e52a33df610cc01d13ea6e321b4c4d8ee708b9a03e || goto error
 call :downloadfile "zlib%ZLIBSHORT%.zip" "https://zlib.net/zlib%ZLIBSHORT%.zip" 72af66d44fcc14c22013b46b814d5d2514673dda3d115e64b690c1ad636e7b17 || goto error
 call :downloadfile "zstd-%ZSTD%.zip" "https://github.com/facebook/zstd/archive/refs/tags/v%ZSTD%.zip" 3b1c3b46e416d36931efd34663122d7f51b550c87f74de2d38249516fe7d8be5 || goto error
 call :downloadfile "zstd-fd5f8106a58601a963ee816e6a57aa7c61fafc53.patch" https://github.com/facebook/zstd/commit/fd5f8106a58601a963ee816e6a57aa7c61fafc53.patch 8df152f4969b308546306c074628de761f0b80265de7de534e3822fab22d7535 || goto error
--- a/.github/workflows/windows_build_matrix.yml
+++ b/.github/workflows/windows_build_matrix.yml
@@ -13,7 +13,7 @@ jobs:
  lint_vs_proj_files:
    name: Lint VS Project Files
    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
-    runs-on: windows-2025
+    runs-on: windows-2019
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
--- a/.github/workflows/windows_build_qt.yml
+++ b/.github/workflows/windows_build_qt.yml
@@ -12,7 +12,7 @@ on:
      os:
        required: false
        type: string
-        default: windows-2025
+        default: windows-2022
      platform:
        required: false
        type: string
@@ -55,31 +55,13 @@ jobs:
      POWERSHELL_TELEMETRY_OPTOUT: 1

    steps:
+      - name: Tempfix Clang
+        if: inputs.configuration == 'CMake'
+        run: choco uninstall llvm
+        
      - name: Checkout Repository
        uses: actions/checkout@v4

-      - name: Configure MSBuild Clang Version
-        if: inputs.configuration != 'CMake'
-        shell: pwsh
-        run: |
-          [string[]] $clang_cl = &clang-cl.exe --version
-          
-          $version = [Regex]::Match($clang_cl[0], "(\d+\.\d+\.\d+)")
-          $path = $clang_cl[3].TrimStart("InstalledDir: ").TrimEnd("\bin")
-          
-          $output = @"
-          <Project>
-            <PropertyGroup>
-              <LLVMInstallDir>$path</LLVMInstallDir>
-              <LLVMToolsVersion>$version</LLVMToolsVersion>
-            </PropertyGroup>
-          </Project>
-          "@
-          
-          Write-Host $output
-          
-          $output | Out-File Directory.build.props
-
      # actions/checkout elides tags, fetch them primarily for releases
      - name: Fetch Tags
        if: ${{ inputs.fetchTags }}
--- a/3rdparty/cpuinfo/include/cpuinfo.h
+++ b/3rdparty/cpuinfo/include/cpuinfo.h
@@ -419,8 +419,6 @@ enum cpuinfo_uarch {
 	cpuinfo_uarch_zen3 = 0x0020010B,
 	/** AMD Zen 4 microarchitecture. */
 	cpuinfo_uarch_zen4 = 0x0020010C,
-	/** AMD Zen 5 microarchitecture. */
-	cpuinfo_uarch_zen5 = 0x0020010D,

 	/** NSC Geode and AMD Geode GX and LX. */
 	cpuinfo_uarch_geode = 0x00200200,
@@ -820,7 +818,6 @@ struct cpuinfo_x86_isa {
 	bool avx512vp2intersect;
 	bool avx512_4vnniw;
 	bool avx512_4fmaps;
-	bool avx10_1;
 	bool amx_bf16;
 	bool amx_tile;
 	bool amx_int8;
@@ -1436,14 +1433,6 @@ static inline bool cpuinfo_has_x86_avx_ne_convert(void) {
 #endif
 }

-static inline bool cpuinfo_has_x86_avx10_1(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-	return cpuinfo_isa.avx10_1;
-#else
-	return false;
-#endif
-}
-
 static inline bool cpuinfo_has_x86_hle(void) {
 #if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
 	return cpuinfo_isa.hle;
--- a/3rdparty/cpuinfo/src/arm/cache.c
+++ b/3rdparty/cpuinfo/src/arm/cache.c
@@ -1341,8 +1341,7 @@ void cpuinfo_arm_decode_cache(
 			 * information, please refer to the technical manuals
 			 * linked above
 			 */
-			const uint32_t min_l2_size_KB =
-				(uarch == cpuinfo_uarch_neoverse_v2 || midr_is_ampere_altra(midr)) ? 1024 : 256;
+			const uint32_t min_l2_size_KB = uarch == cpuinfo_uarch_neoverse_v2 ? 1024 : 256;
 			const uint32_t min_l3_size_KB = 0;

 			*l1i = (struct cpuinfo_cache){
--- a/3rdparty/cpuinfo/src/arm/midr.h
+++ b/3rdparty/cpuinfo/src/arm/midr.h
@@ -34,7 +34,6 @@
 #define CPUINFO_ARM_MIDR_KRYO_SILVER_820 UINT32_C(0x510F2110)
 #define CPUINFO_ARM_MIDR_EXYNOS_M1_M2 UINT32_C(0x530F0010)
 #define CPUINFO_ARM_MIDR_DENVER2 UINT32_C(0x4E0F0030)
-#define CPUINFO_ARM_MIDR_AMPERE_ALTRA UINT32_C(0x413fd0c1)

 inline static uint32_t midr_set_implementer(uint32_t midr, uint32_t implementer) {
 	return (midr & ~CPUINFO_ARM_MIDR_IMPLEMENTER_MASK) |
@@ -168,11 +167,6 @@ inline static bool midr_is_kryo_gold(uint32_t midr) {
 	return (midr & uarch_mask) == (CPUINFO_ARM_MIDR_KRYO_GOLD & uarch_mask);
 }

-inline static bool midr_is_ampere_altra(uint32_t midr) {
-	const uint32_t uarch_mask = CPUINFO_ARM_MIDR_IMPLEMENTER_MASK | CPUINFO_ARM_MIDR_PART_MASK;
-	return (midr & uarch_mask) == (CPUINFO_ARM_MIDR_AMPERE_ALTRA & uarch_mask);
-}
-
 inline static uint32_t midr_score_core(uint32_t midr) {
 	const uint32_t core_mask = CPUINFO_ARM_MIDR_IMPLEMENTER_MASK | CPUINFO_ARM_MIDR_PART_MASK;
 	switch (midr & core_mask) {
--- a/3rdparty/cpuinfo/src/x86/isa.c
+++ b/3rdparty/cpuinfo/src/x86/isa.c
@@ -429,11 +429,6 @@ struct cpuinfo_x86_isa cpuinfo_x86_detect_isa(
 	 */
 	isa.avx512f = avx512_regs && !!(structured_feature_info0.ebx & UINT32_C(0x00010000));

-	/*
-	 * AVX 10.1 instructions:
-	 */
-	isa.avx10_1 = avx512_regs && !!(structured_feature_info1.edx & UINT32_C(0x00080000));
-
 	/*
 	 * AVX512PF instructions:
 	 * - Intel: ebx[bit 26] in structured feature info (ecx = 0).
--- a/3rdparty/cpuinfo/src/x86/uarch.c
+++ b/3rdparty/cpuinfo/src/x86/uarch.c
@@ -387,8 +387,6 @@ enum cpuinfo_uarch cpuinfo_x86_decode_uarch(
 							return cpuinfo_uarch_zen4;
 					}
 					break;
-				case 0x1a:
-					return cpuinfo_uarch_zen5;
 			}
 			break;
 		case cpuinfo_vendor_hygon:
--- a/3rdparty/d3d12memalloc/LICENSE.txt
+++ b/3rdparty/d3d12memalloc/LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (c) 2019-2024 Advanced Micro Devices, Inc. All rights reserved.
+Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved.

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/3rdparty/d3d12memalloc/README.md
+++ b/3rdparty/d3d12memalloc/README.md
@@ -2,7 +2,7 @@

 Easy to integrate memory allocation library for Direct3D 12.

-**Documentation:** Browse online: [D3D12 Memory Allocator](https://gpuopen-librariesandsdks.github.io/D3D12MemoryAllocator/html/) (generated from Doxygen-style comments in [include/D3D12MemAlloc.h](include/D3D12MemAlloc.h))
+**Documentation:** Browse online: [D3D12 Memory Allocator](https://gpuopen-librariesandsdks.github.io/D3D12MemoryAllocator/html/) (generated from Doxygen-style comments in [src/D3D12MemAlloc.h](src/D3D12MemAlloc.h))

 **License:** MIT. See [LICENSE.txt](LICENSE.txt)

@@ -36,7 +36,6 @@ Additional features:
 - Customization and integration with custom engines: Predefine appropriate macros to provide your own implementation of external facilities used by the library, like assert, mutex, and atomic.
 - Support for resource aliasing (overlap).
 - Custom memory pools: Create a pool with desired parameters (e.g. fixed or limited maximum size, custom `D3D12_HEAP_PROPERTIES` and `D3D12_HEAP_FLAGS`) and allocate memory out of it.
- Support for GPU Upload Heaps from preview Agility SDK (needs compilation with `D3D12MA_OPTIONS16_SUPPORTED` macro).
 - Linear allocator: Create a pool with linear algorithm and use it for much faster allocations and deallocations in free-at-once, stack, double stack, or ring buffer fashion.
 - Defragmentation: Let the library move data around to free some memory blocks and make your allocations better compacted.
 - Statistics: Obtain brief or detailed statistics about the amount of memory used, unused, number of allocated heaps, number of allocations etc. - globally and per memory heap type. Current memory usage and budget as reported by the system can also be queried.
@@ -102,18 +101,15 @@ This software package uses third party software:

 For more information see [NOTICES.txt](NOTICES.txt).

+# Software using this library
+
+- **[The Forge](https://github.com/ConfettiFX/The-Forge)** - cross-platform rendering framework. Apache License 2.0.
+- **[Wicked Engine<img src="https://github.com/turanszkij/WickedEngine/blob/master/Content/logo_small.png" width="28px" align="center"/>](https://github.com/turanszkij/WickedEngine)** - 3D engine with modern graphics 
+
+[Some other projects on GitHub](https://github.com/search?q=D3D12MemAlloc.h&type=Code) and some game development studios that use DX12 in their games.
+
 # See also

 - **[Vcpkg](https://github.com/Microsoft/vcpkg)** dependency manager from Microsoft offers a port of this library that is easy to install.
- **[d3d12ma.c](https://github.com/milliewalky/d3d12ma.c)** - C bindings for this library. Author: Mateusz Maciejewski (Matt Walky). License: MIT.
- **[TerraFX.Interop.D3D12MemoryAllocator](https://github.com/terrafx/terrafx.interop.d3d12memoryallocator)** - interop bindings for this library for C#, as used by [TerraFX](https://github.com/terrafx/terrafx). License: MIT.
 - **[Vulkan Memory Allocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/)** - equivalent library for Vulkan. License: MIT.
-
-# Software using this library
-
- **[Qt Project](https://github.com/qt)**
- **[Ghost of Tsushima: Director's Cut PC](https://www.youtube.com/watch?v=cPKBDbCYctc&t=698s)** - Information avaliable in 11:38 of credits
- **[The Forge](https://github.com/ConfettiFX/The-Forge)** - cross-platform rendering framework. Apache License 2.0.
- **[Wicked Engine<img src="https://github.com/turanszkij/WickedEngine/blob/master/Content/logo_small.png" width="28px" align="center"/>](https://github.com/turanszkij/WickedEngine)** - 3D engine with modern graphics
-
-[Some other projects on GitHub](https://github.com/search?q=D3D12MemAlloc.h&type=Code) and some game development studios that use DX12 in their games.
+- **[TerraFX.Interop.D3D12MemoryAllocator](https://github.com/terrafx/terrafx.interop.d3d12memoryallocator)** - interop bindings for this library for C#, as used by [TerraFX](https://github.com/terrafx/terrafx). License: MIT.
--- a/3rdparty/d3d12memalloc/include/D3D12MemAlloc.h
+++ b/3rdparty/d3d12memalloc/include/D3D12MemAlloc.h
@@ -24,9 +24,9 @@

 /** \mainpage D3D12 Memory Allocator

-<b>Version 2.1.0-development</b> (2024-07-05)
+<b>Version 2.1.0-development</b> (2023-07-05)

-Copyright (c) 2019-2024 Advanced Micro Devices, Inc. All rights reserved. \n
+Copyright (c) 2019-2023 Advanced Micro Devices, Inc. All rights reserved. \n
 License: MIT

 Documentation of all members: D3D12MemAlloc.h
@@ -160,9 +160,9 @@ class D3D12MA_API IUnknownImpl : public IUnknown
 {
 public:
    virtual ~IUnknownImpl() = default;
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override;
-    ULONG STDMETHODCALLTYPE AddRef() override;
-    ULONG STDMETHODCALLTYPE Release() override;
+    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject);
+    virtual ULONG STDMETHODCALLTYPE AddRef();
+    virtual ULONG STDMETHODCALLTYPE Release();
 protected:
    virtual void ReleaseThis() { delete this; }
 private:
@@ -265,18 +265,18 @@ enum ALLOCATION_FLAGS
    */
    ALLOCATION_FLAG_CAN_ALIAS = 0x10,

-    /** %Allocation strategy that chooses smallest possible free range for the allocation
+    /** Allocation strategy that chooses smallest possible free range for the allocation
    to minimize memory usage and fragmentation, possibly at the expense of allocation time.
    */
    ALLOCATION_FLAG_STRATEGY_MIN_MEMORY = 0x00010000,

-    /** %Allocation strategy that chooses first suitable free range for the allocation -
+    /** Allocation strategy that chooses first suitable free range for the allocation -
    not necessarily in terms of the smallest offset but the one that is easiest and fastest to find
    to minimize allocation time, possibly at the expense of allocation quality.
    */
    ALLOCATION_FLAG_STRATEGY_MIN_TIME = 0x00020000,

-    /** %Allocation strategy that chooses always the lowest offset in available space.
+    /** Allocation strategy that chooses always the lowest offset in available space.
    This is not the most efficient strategy but achieves highly packed data.
    Used internally by defragmentation, not recomended in typical usage.
    */
@@ -402,9 +402,8 @@ struct TotalStatistics
    - 1 = `D3D12_HEAP_TYPE_UPLOAD`
    - 2 = `D3D12_HEAP_TYPE_READBACK`
    - 3 = `D3D12_HEAP_TYPE_CUSTOM`
-    - 4 = `D3D12_HEAP_TYPE_GPU_UPLOAD`
    */
-    DetailedStatistics HeapType[5];
+    DetailedStatistics HeapType[4];
    /** \brief One element for each memory segment group located at the following indices:

    - 0 = `DXGI_MEMORY_SEGMENT_GROUP_LOCAL`
@@ -414,9 +413,9 @@ struct TotalStatistics

    - When `IsUMA() == FALSE` (discrete graphics card):
      - `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` (index 0) represents GPU memory
-        (resources allocated in `D3D12_HEAP_TYPE_DEFAULT`, `D3D12_HEAP_TYPE_GPU_UPLOAD` or `D3D12_MEMORY_POOL_L1`).
+      (resources allocated in `D3D12_HEAP_TYPE_DEFAULT` or `D3D12_MEMORY_POOL_L1`).
      - `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL` (index 1) represents system memory
-        (resources allocated in `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`, or `D3D12_MEMORY_POOL_L0`).
+      (resources allocated in `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`, or `D3D12_MEMORY_POOL_L0`).
    - When `IsUMA() == TRUE` (integrated graphics chip):
      - `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` = (index 0) represents memory shared for all the resources.
      - `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL` = (index 1) is unused and always 0.
@@ -543,6 +542,26 @@ public:
    */
    LPCWSTR GetName() const { return m_Name; }

+    /** \brief Returns `TRUE` if the memory of the allocation was filled with zeros when the allocation was created.
+
+    Returns `TRUE` only if the allocator is sure that the entire memory where the
+    allocation was created was filled with zeros at the moment the allocation was made.
+    
+    Returns `FALSE` if the memory could potentially contain garbage data.
+    If it's a render-target or depth-stencil texture, it then needs proper
+    initialization with `ClearRenderTargetView`, `ClearDepthStencilView`, `DiscardResource`,
+    or a copy operation, as described on page
+    "ID3D12Device::CreatePlacedResource method - Notes on the required resource initialization" in Microsoft documentation.
+    Please note that rendering a fullscreen triangle or quad to the texture as
+    a render target is not a proper way of initialization!
+
+    See also articles:
+
+    - "Coming to DirectX 12: More control over memory allocation" on DirectX Developer Blog
+    - ["Initializing DX12 Textures After Allocation and Aliasing"](https://asawicki.info/news_1724_initializing_dx12_textures_after_allocation_and_aliasing).
+    */
+    BOOL WasZeroInitialized() const { return m_PackedData.WasZeroInitialized(); }
+
 protected:
    void ReleaseThis() override;

@@ -601,26 +620,29 @@ private:
    {
    public:
        PackedData() :
-            m_Type(0), m_ResourceDimension(0), m_ResourceFlags(0), m_TextureLayout(0) { }
+            m_Type(0), m_ResourceDimension(0), m_ResourceFlags(0), m_TextureLayout(0), m_WasZeroInitialized(0) { }

        Type GetType() const { return (Type)m_Type; }
        D3D12_RESOURCE_DIMENSION GetResourceDimension() const { return (D3D12_RESOURCE_DIMENSION)m_ResourceDimension; }
        D3D12_RESOURCE_FLAGS GetResourceFlags() const { return (D3D12_RESOURCE_FLAGS)m_ResourceFlags; }
        D3D12_TEXTURE_LAYOUT GetTextureLayout() const { return (D3D12_TEXTURE_LAYOUT)m_TextureLayout; }
+        BOOL WasZeroInitialized() const { return (BOOL)m_WasZeroInitialized; }

        void SetType(Type type);
        void SetResourceDimension(D3D12_RESOURCE_DIMENSION resourceDimension);
        void SetResourceFlags(D3D12_RESOURCE_FLAGS resourceFlags);
        void SetTextureLayout(D3D12_TEXTURE_LAYOUT textureLayout);
+        void SetWasZeroInitialized(BOOL wasZeroInitialized) { m_WasZeroInitialized = wasZeroInitialized ? 1 : 0; }

    private:
        UINT m_Type : 2;               // enum Type
        UINT m_ResourceDimension : 3;  // enum D3D12_RESOURCE_DIMENSION
        UINT m_ResourceFlags : 24;     // flags D3D12_RESOURCE_FLAGS
        UINT m_TextureLayout : 9;      // enum D3D12_TEXTURE_LAYOUT
+        UINT m_WasZeroInitialized : 1; // BOOL
    } m_PackedData;

-    Allocation(AllocatorPimpl* allocator, UINT64 size, UINT64 alignment);
+    Allocation(AllocatorPimpl* allocator, UINT64 size, UINT64 alignment, BOOL wasZeroInitialized);
    //  Nothing here, everything already done in Release.
    virtual ~Allocation() = default;

@@ -1043,16 +1065,6 @@ enum ALLOCATOR_FLAGS
    to create its heaps on smaller alignment not suitable for MSAA textures.
    */
    ALLOCATOR_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED = 0x8,
-    /** \brief Disable optimization that prefers creating small buffers as committed to avoid 64 KB alignment.
-    
-    By default, the library prefers creating small buffers <= 32 KB as committed,
-    because drivers tend to pack them better, while placed buffers require 64 KB alignment.
-    This, however, may decrease performance, as creating committed resources involves allocation of implicit heaps,
-    which may take longer than creating placed resources in existing heaps.
-    Passing this flag will disable this committed preference globally for the allocator.
-    It can also be disabled for a single allocation by using #ALLOCATION_FLAG_STRATEGY_MIN_TIME.
-    */
-    ALLOCATOR_FLAG_DONT_PREFER_SMALL_BUFFERS_COMMITTED = 0x10,
 };

 /// \brief Parameters of created Allocator object. To be used with CreateAllocator().
@@ -1118,15 +1130,6 @@ public:
    - "ID3D12Device::GetCustomHeapProperties method (d3d12.h)"
    */
    BOOL IsCacheCoherentUMA() const;
-    /** \brief Returns true if GPU Upload Heaps are supported on the current system.
-
-    When true, you can use `D3D12_HEAP_TYPE_GPU_UPLOAD`.
-
-    This flag is fetched from `D3D12_FEATURE_D3D12_OPTIONS16::GPUUploadHeapSupported`.
-
-    `#define D3D12MA_OPTIONS16_SUPPORTED 1` is needed for the compilation of this library. Otherwise the flag is always false.
-    */
-    BOOL IsGPUUploadHeapSupported() const;
    /** \brief Returns total amount of memory of specific segment group, in bytes.
    
    \param memorySegmentGroup use `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` or DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL`.
@@ -1444,11 +1447,11 @@ enum VIRTUAL_ALLOCATION_FLAGS
    */
    VIRTUAL_ALLOCATION_FLAG_UPPER_ADDRESS = ALLOCATION_FLAG_UPPER_ADDRESS,

-    /// %Allocation strategy that tries to minimize memory usage.
+    /// Allocation strategy that tries to minimize memory usage.
    VIRTUAL_ALLOCATION_FLAG_STRATEGY_MIN_MEMORY = ALLOCATION_FLAG_STRATEGY_MIN_MEMORY,
-    /// %Allocation strategy that tries to minimize allocation time.
+    /// Allocation strategy that tries to minimize allocation time.
    VIRTUAL_ALLOCATION_FLAG_STRATEGY_MIN_TIME = ALLOCATION_FLAG_STRATEGY_MIN_TIME,
-    /** %Allocation strategy that chooses always the lowest offset in available space.
+    /** \brief Allocation strategy that chooses always the lowest offset in available space.
    This is not the most efficient strategy but achieves highly packed data.
    */
    VIRTUAL_ALLOCATION_FLAG_STRATEGY_MIN_OFFSET = ALLOCATION_FLAG_STRATEGY_MIN_OFFSET,
@@ -1637,9 +1640,6 @@ ID3D12Device* device = (...)
 D3D12MA::ALLOCATOR_DESC allocatorDesc = {};
 allocatorDesc.pDevice = device;
 allocatorDesc.pAdapter = adapter;
-// These flags are optional but recommended.
-allocatorDesc.Flags = D3D12MA::ALLOCATOR_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED |
-    D3D12MA::ALLOCATOR_FLAG_DEFAULT_POOLS_NOT_ZEROED;

 D3D12MA::Allocator* allocator;
 HRESULT hr = D3D12MA::CreateAllocator(&allocatorDesc, &allocator);
@@ -1864,9 +1864,6 @@ to obtain object D3D12MA::Pool. Example:
 \code
 POOL_DESC poolDesc = {};
 poolDesc.HeapProperties.Type = D3D12_HEAP_TYPE_DEFAULT;
-// These flags are optional but recommended.
-poolDesc.Flags = D3D12MA::POOL_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED;
-poolDesc.HeapFlags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;

 Pool* pool;
 HRESULT hr = allocator->CreatePool(&poolDesc, &pool);
--- a/3rdparty/d3d12memalloc/src/D3D12MemAlloc.cpp
+++ b/3rdparty/d3d12memalloc/src/D3D12MemAlloc.cpp
--- a/3rdparty/fmt/CMakeLists.txt
+++ b/3rdparty/fmt/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.8...3.28)
+cmake_minimum_required(VERSION 3.8...3.26)

 # Fallback for using newer policies on CMake <3.12.
 if (${CMAKE_VERSION} VERSION_LESS 3.12)
@@ -36,12 +36,6 @@ function(enable_module target)
  endif ()
 endfunction()

-set(FMT_USE_CMAKE_MODULES FALSE)
-if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.28 AND
-    CMAKE_GENERATOR STREQUAL "Ninja")
-  set(FMT_USE_CMAKE_MODULES TRUE)
-endif ()
-
 # Adds a library compiled with C++20 module support.
 # `enabled` is a CMake variables that specifies if modules are enabled.
 # If modules are disabled `add_module_library` falls back to creating a
@@ -59,7 +53,6 @@ function(add_module_library name)
  if (NOT ${${AML_IF}})
    # Create a non-modular library.
    target_sources(${name} PRIVATE ${AML_FALLBACK})
-    set_target_properties(${name} PROPERTIES CXX_SCAN_FOR_MODULES OFF)
    return()
  endif ()

@@ -69,55 +62,48 @@ function(add_module_library name)
    target_compile_options(${name} PUBLIC -fmodules-ts)
  endif ()

-  target_compile_definitions(${name} PRIVATE FMT_MODULE)
+  # `std` is affected by CMake options and may be higher than C++20.
+  get_target_property(std ${name} CXX_STANDARD)

-  if (FMT_USE_CMAKE_MODULES)
-    target_sources(${name} PUBLIC FILE_SET fmt TYPE CXX_MODULES
-                   FILES ${sources})
-  else()
-    # `std` is affected by CMake options and may be higher than C++20.
-    get_target_property(std ${name} CXX_STANDARD)
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(pcms)
+    foreach (src ${sources})
+      get_filename_component(pcm ${src} NAME_WE)
+      set(pcm ${pcm}.pcm)

-    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-      set(pcms)
-      foreach (src ${sources})
-        get_filename_component(pcm ${src} NAME_WE)
-        set(pcm ${pcm}.pcm)
+      # Propagate -fmodule-file=*.pcm to targets that link with this library.
+      target_compile_options(
+        ${name} PUBLIC -fmodule-file=${CMAKE_CURRENT_BINARY_DIR}/${pcm})

-        # Propagate -fmodule-file=*.pcm to targets that link with this library.
-        target_compile_options(
-          ${name} PUBLIC -fmodule-file=${CMAKE_CURRENT_BINARY_DIR}/${pcm})
+      # Use an absolute path to prevent target_link_libraries prepending -l
+      # to it.
+      set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
+      add_custom_command(
+        OUTPUT ${pcm}
+        COMMAND ${CMAKE_CXX_COMPILER}
+                -std=c++${std} -x c++-module --precompile -c
+                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
+                "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
+        # Required by the -I generator expression above.
+        COMMAND_EXPAND_LISTS
+        DEPENDS ${src})
+    endforeach ()

-        # Use an absolute path to prevent target_link_libraries prepending -l
-        # to it.
-        set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
-        add_custom_command(
-          OUTPUT ${pcm}
-          COMMAND ${CMAKE_CXX_COMPILER}
-                  -std=c++${std} -x c++-module --precompile -c
-                  -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
-                  "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
-          # Required by the -I generator expression above.
-          COMMAND_EXPAND_LISTS
-          DEPENDS ${src})
-      endforeach ()
-
-      # Add .pcm files as sources to make sure they are built before the library.
-      set(sources)
-      foreach (pcm ${pcms})
-        get_filename_component(pcm_we ${pcm} NAME_WE)
-        set(obj ${pcm_we}.o)
-        # Use an absolute path to prevent target_link_libraries prepending -l.
-        set(sources ${sources} ${pcm} ${CMAKE_CURRENT_BINARY_DIR}/${obj})
-        add_custom_command(
-          OUTPUT ${obj}
-          COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
-                  -c -o ${obj} ${pcm}
-          DEPENDS ${pcm})
-      endforeach ()
-    endif ()
-    target_sources(${name} PRIVATE ${sources})
-  endif()
+    # Add .pcm files as sources to make sure they are built before the library.
+    set(sources)
+    foreach (pcm ${pcms})
+      get_filename_component(pcm_we ${pcm} NAME_WE)
+      set(obj ${pcm_we}.o)
+      # Use an absolute path to prevent target_link_libraries prepending -l.
+      set(sources ${sources} ${pcm} ${CMAKE_CURRENT_BINARY_DIR}/${obj})
+      add_custom_command(
+        OUTPUT ${obj}
+        COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
+                -c -o ${obj} ${pcm}
+        DEPENDS ${pcm})
+    endforeach ()
+  endif ()
+  target_sources(${name} PRIVATE ${sources})
 endfunction()

 include(CMakeParseArguments)
@@ -159,33 +145,21 @@ option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
       OFF)

 # Options that control generation of various targets.
-option(FMT_DOC "Generate the doc target." ${FMT_MASTER_PROJECT})
 option(FMT_INSTALL "Generate the install target." ON)
-option(FMT_TEST "Generate the test target." ${FMT_MASTER_PROJECT})
 option(FMT_FUZZ "Generate the fuzz target." OFF)
-option(FMT_CUDA_TEST "Generate the cuda-test target." OFF)
-option(FMT_OS "Include OS-specific APIs." ON)
+option(FMT_OS "Include core requiring OS (Windows/Posix) " ON)
 option(FMT_MODULE "Build a module instead of a traditional library." OFF)
 option(FMT_SYSTEM_HEADERS "Expose headers with marking them as system." OFF)
-option(FMT_UNICODE "Enable Unicode support." ON)

-if (FMT_TEST AND FMT_MODULE)
-  # The tests require {fmt} to be compiled as traditional library
-  message(STATUS "Testing is incompatible with build mode 'module'.")
-endif ()
 set(FMT_SYSTEM_HEADERS_ATTRIBUTE "")
 if (FMT_SYSTEM_HEADERS)
  set(FMT_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
 endif ()
-if (CMAKE_SYSTEM_NAME STREQUAL "MSDOS")
-  set(FMT_TEST OFF)
-  message(STATUS "MSDOS is incompatible with gtest")
-endif ()

-# Get version from base.h
-file(READ include/fmt/base.h base_h)
-if (NOT base_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
-  message(FATAL_ERROR "Cannot get FMT_VERSION from base.h.")
+# Get version from core.h
+file(READ include/fmt/core.h core_h)
+if (NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
+  message(FATAL_ERROR "Cannot get FMT_VERSION from core.h.")
 endif ()
 # Use math to skip leading zeros if any.
 math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
@@ -193,7 +167,7 @@ math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
 math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
 join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
                 ${CPACK_PACKAGE_VERSION_PATCH})
-message(STATUS "{fmt} version: ${FMT_VERSION}")
+message(STATUS "Version: ${FMT_VERSION}")

 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")

@@ -240,13 +214,7 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  endif ()
  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
-          -Wduplicated-cond)
-      # Workaround for GCC regression
-      # [12/13/14/15 regression] New (since gcc 12) false positive null-dereference in vector.resize
-      # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108860
-      if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
-        set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wnull-dereference)
-      endif ()
+          -Wnull-dereference -Wduplicated-cond)
  endif ()
  set(WERROR_FLAG -Werror)
 endif ()
@@ -295,10 +263,13 @@ function(add_headers VAR)
 endfunction()

 # Define the fmt library, its includes and the needed defines.
-add_headers(FMT_HEADERS args.h base.h chrono.h color.h compile.h core.h format.h
+add_headers(FMT_HEADERS args.h chrono.h color.h compile.h core.h format.h
                        format-inl.h os.h ostream.h printf.h ranges.h std.h
                        xchar.h)
 set(FMT_SOURCES src/format.cc)
+if (FMT_OS)
+  set(FMT_SOURCES ${FMT_SOURCES} src/os.cc)
+endif ()

 add_module_library(fmt src/fmt.cc FALLBACK
                   ${FMT_SOURCES} ${FMT_HEADERS} README.md ChangeLog.md
@@ -306,10 +277,6 @@ add_module_library(fmt src/fmt.cc FALLBACK
 add_library(fmt::fmt ALIAS fmt)
 if (FMT_MODULE)
  enable_module(fmt)
-elseif (FMT_OS)
-  target_sources(fmt PRIVATE src/os.cc)
-else()
-  target_compile_definitions(fmt PRIVATE FMT_OS=0)
 endif ()

 if (FMT_WERROR)
@@ -325,7 +292,7 @@ else ()
  message(WARNING "Feature cxx_std_11 is unknown for the CXX compiler")
 endif ()

-target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} BEFORE PUBLIC
+target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)

@@ -361,21 +328,11 @@ endif ()
 add_library(fmt-header-only INTERFACE)
 add_library(fmt::fmt-header-only ALIAS fmt-header-only)

-if (NOT MSVC)
-  # Unicode is always supported on compilers other than MSVC.
-elseif (FMT_UNICODE)
-  # Unicode support requires compiling with /utf-8.
-  target_compile_options(fmt PUBLIC $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-  target_compile_options(fmt-header-only INTERFACE $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-else ()
-  target_compile_definitions(fmt PUBLIC FMT_UNICODE=0)
-endif ()
-
 target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
 target_compile_features(fmt-header-only INTERFACE cxx_std_11)

 target_include_directories(fmt-header-only
-  ${FMT_SYSTEM_HEADERS_ATTRIBUTE} BEFORE INTERFACE
+  ${FMT_SYSTEM_HEADERS_ATTRIBUTE} INTERFACE
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)

@@ -420,20 +377,12 @@ if (FMT_INSTALL)

  set(INSTALL_TARGETS fmt fmt-header-only)

-  set(INSTALL_FILE_SET)
-  if (FMT_USE_CMAKE_MODULES)
-    set(INSTALL_FILE_SET FILE_SET fmt DESTINATION "${FMT_INC_DIR}/fmt")
-  endif()
-
  # Install the library and headers.
-  install(TARGETS ${INSTALL_TARGETS}
-          COMPONENT fmt-core
-          EXPORT ${targets_export_name}
+  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
          LIBRARY DESTINATION ${FMT_LIB_DIR}
          ARCHIVE DESTINATION ${FMT_LIB_DIR}
          PUBLIC_HEADER DESTINATION "${FMT_INC_DIR}/fmt"
-          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-          ${INSTALL_FILE_SET})
+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

  # Use a namespace because CMake provides better diagnostics for namespaced
  # imported targets.
@@ -441,61 +390,13 @@ if (FMT_INSTALL)
         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)

  # Install version, config and target files.
-  install(FILES ${project_config} ${version_config}
-          DESTINATION ${FMT_CMAKE_DIR}
-          COMPONENT fmt-core)
+  install(
+    FILES ${project_config} ${version_config}
+    DESTINATION ${FMT_CMAKE_DIR})
  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
-          NAMESPACE fmt::
-          COMPONENT fmt-core)
+          NAMESPACE fmt::)

-  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}"
-          COMPONENT fmt-core)
-endif ()
-
-function(add_doc_target)
-  find_program(DOXYGEN doxygen
-    PATHS "$ENV{ProgramFiles}/doxygen/bin"
-          "$ENV{ProgramFiles\(x86\)}/doxygen/bin")
-  if (NOT DOXYGEN)
-    message(STATUS "Target 'doc' disabled because doxygen not found")
-    return ()
-  endif ()
-
-  find_program(MKDOCS mkdocs)
-  if (NOT MKDOCS)
-    message(STATUS "Target 'doc' disabled because mkdocs not found")
-    return ()
-  endif ()
-
-  set(sources )
-  foreach (source api.md index.md syntax.md get-started.md fmt.css fmt.js)
-    set(sources ${sources} doc/${source})
-  endforeach()
-
-  add_custom_target(
-    doc
-    COMMAND
-      ${CMAKE_COMMAND}
-        -E env PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}/support/python
-        ${MKDOCS} build -f ${CMAKE_CURRENT_SOURCE_DIR}/support/mkdocs.yml
-        # MkDocs requires the site dir to be outside of the doc dir.
-                        --site-dir ${CMAKE_CURRENT_BINARY_DIR}/doc-html
-                        --no-directory-urls
-    SOURCES ${sources})
-
-  include(GNUInstallDirs)
-  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc-html/
-          DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/fmt
-          COMPONENT fmt-doc OPTIONAL)
-endfunction()
-
-if (FMT_DOC)
-  add_doc_target()
-endif ()
-
-if (FMT_TEST)
-  enable_testing()
-  add_subdirectory(test)
+  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
 endif ()

 # Control fuzzing independent of the unit tests.
@@ -520,7 +421,8 @@ if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
    string(REPLACE "*" ".*" line "${line}")
    set(ignored_files ${ignored_files} "${line}$" "${line}/")
  endforeach ()
-  set(ignored_files ${ignored_files} /.git /build/doxyxml .vagrant)
+  set(ignored_files ${ignored_files}
+    /.git /breathe /format-benchmark sphinx/ .buildinfo .doctrees)

  set(CPACK_SOURCE_GENERATOR ZIP)
  set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
--- a/3rdparty/fmt/ChangeLog.md
+++ b/3rdparty/fmt/ChangeLog.md
--- a/3rdparty/fmt/README.md
+++ b/3rdparty/fmt/README.md
@@ -20,16 +20,16 @@ that help victims of the war in Ukraine: <https://www.stopputin.net/>.
 Q&A: ask questions on [StackOverflow with the tag
 fmt](https://stackoverflow.com/questions/tagged/fmt).

-Try {fmt} in [Compiler Explorer](https://godbolt.org/z/8Mx1EW73v).
+Try {fmt} in [Compiler Explorer](https://godbolt.org/z/Eq5763).

 # Features

- Simple [format API](https://fmt.dev/latest/api/) with positional
+- Simple [format API](https://fmt.dev/latest/api.html) with positional
  arguments for localization
 - Implementation of [C++20
  std::format](https://en.cppreference.com/w/cpp/utility/format) and
  [C++23 std::print](https://en.cppreference.com/w/cpp/io/print)
- [Format string syntax](https://fmt.dev/latest/syntax/) similar
+- [Format string syntax](https://fmt.dev/latest/syntax.html) similar
  to Python\'s
  [format](https://docs.python.org/3/library/stdtypes.html#str.format)
 - Fast IEEE 754 floating-point formatter with correct rounding,
@@ -37,10 +37,10 @@ Try {fmt} in [Compiler Explorer](https://godbolt.org/z/8Mx1EW73v).
  [Dragonbox](https://github.com/jk-jeon/dragonbox) algorithm
 - Portable Unicode support
 - Safe [printf
-  implementation](https://fmt.dev/latest/api/#printf-formatting)
+  implementation](https://fmt.dev/latest/api.html#printf-formatting)
  including the POSIX extension for positional arguments
 - Extensibility: [support for user-defined
-  types](https://fmt.dev/latest/api/#formatting-user-defined-types)
+  types](https://fmt.dev/latest/api.html#formatting-user-defined-types)
 - High performance: faster than common standard library
  implementations of `(s)printf`, iostreams, `to_string` and
  `to_chars`, see [Speed tests](#speed-tests) and [Converting a
@@ -58,8 +58,8 @@ Try {fmt} in [Compiler Explorer](https://godbolt.org/z/8Mx1EW73v).
  buffer overflow errors
 - Ease of use: small self-contained code base, no external
  dependencies, permissive MIT
-  [license](https://github.com/fmtlib/fmt/blob/master/LICENSE)
- [Portability](https://fmt.dev/latest/#portability) with
+  [license](https://github.com/fmtlib/fmt/blob/master/LICENSE.rst)
+- [Portability](https://fmt.dev/latest/index.html#portability) with
  consistent output across platforms and support for older compilers
 - Clean warning-free codebase even on high warning levels such as
  `-Wall -Wextra -pedantic`
@@ -203,38 +203,43 @@ and [ryu](https://github.com/ulfjack/ryu):

 ## Compile time and code bloat

-The script [bloat-test.py][test] from [format-benchmark][bench] tests compile
-time and code bloat for nontrivial projects. It generates 100 translation units
-and uses `printf()` or its alternative five times in each to simulate a
-medium-sized project. The resulting executable size and compile time (Apple
-clang version 15.0.0 (clang-1500.1.0.2.5), macOS Sonoma, best of three) is shown
-in the following tables.
-
-[test]: https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py
-[bench]: https://github.com/fmtlib/format-benchmark
+The script
+[bloat-test.py](https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py)
+from [format-benchmark](https://github.com/fmtlib/format-benchmark)
+tests compile time and code bloat for nontrivial projects. It generates
+100 translation units and uses `printf()` or its alternative five times
+in each to simulate a medium-sized project. The resulting executable
+size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42), macOS
+Sierra, best of three) is shown in the following tables.

 **Optimized build (-O3)**

 | Method        | Compile Time, s | Executable size, KiB | Stripped size, KiB |
 |---------------|-----------------|----------------------|--------------------|
-| printf        |             1.6 |                   54 |                 50 |
-| IOStreams     |            25.9 |                   98 |                 84 |
-| fmt 83652df   |             4.8 |                   54 |                 50 |
-| tinyformat    |            29.1 |                  161 |                136 |
-| Boost Format  |            55.0 |                  530 |                317 |
+| printf        |   2.6           |   29                 |   26               |
+| printf+string |   16.4          |   29                 |   26               |
+| iostreams     |   31.1          |   59                 |   55               |
+| {fmt}         |   19.0          |   37                 |   34               |
+| Boost Format  |   91.9          |   226                |   203              |
+| Folly Format  |   115.7         |   101                |   88               |

-{fmt} is fast to compile and is comparable to `printf` in terms of per-call
-binary size (within a rounding error on this system).
+As you can see, {fmt} has 60% less overhead in terms of resulting binary
+code size compared to iostreams and comes pretty close to `printf`.
+Boost Format and Folly Format have the largest overheads.
+
+`printf+string` is the same as `printf` but with an extra `<string>`
+include to measure the overhead of the latter.

 **Non-optimized build**

 | Method        | Compile Time, s | Executable size, KiB | Stripped size, KiB |
 |---------------|-----------------|----------------------|--------------------|
-| printf        |             1.4 |                   54 |                 50 |
-| IOStreams     |            23.4 |                   92 |                 68 |
-| {fmt} 83652df |             4.4 |                   89 |                 85 |
-| tinyformat    |            24.5 |                  204 |                161 |
-| Boost Format  |            36.4 |                  831 |                462 |
+| printf        |   2.2           |   33                 |   30               |
+| printf+string |   16.0          |   33                 |   30               |
+| iostreams     |   28.3          |   56                 |   52               |
+| {fmt}         |   18.2          |   59                 |   50               |
+| Boost Format  |   54.1          |   365                |   303              |
+| Folly Format  |   79.9          |   445                |   430              |

 `libc`, `lib(std)c++`, and `libfmt` are all linked as shared libraries
 to compare formatting function overhead only. Boost Format is a
@@ -243,7 +248,7 @@ header-only library so it doesn\'t provide any linkage options.
 ## Running the tests

 Please refer to [Building the
-library](https://fmt.dev/latest/get-started/#building-from-source) for
+library](https://fmt.dev/latest/usage.html#building-the-library) for
 instructions on how to build the library and run the unit tests.

 Benchmarks reside in a separate repository,
@@ -265,7 +270,8 @@ or the bloat test:

 # Migrating code

-[clang-tidy](https://clang.llvm.org/extra/clang-tidy/) v18 provides the
+[clang-tidy](https://clang.llvm.org/extra/clang-tidy/) v17 (not yet
+released) provides the
 [modernize-use-std-print](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-std-print.html)
 check that is capable of converting occurrences of `printf` and
 `fprintf` to `fmt::print` if configured to do so. (By default it
@@ -291,14 +297,13 @@ converts to `std::print`.)
 - [ccache](https://ccache.dev/): a compiler cache
 - [ClickHouse](https://github.com/ClickHouse/ClickHouse): an
  analytical database management system
- [ContextVision](https://www.contextvision.com/): medical imaging software
 - [Contour](https://github.com/contour-terminal/contour/): a modern
  terminal emulator
 - [CUAUV](https://cuauv.org/): Cornell University\'s autonomous
  underwater vehicle
 - [Drake](https://drake.mit.edu/): a planning, control, and analysis
  toolbox for nonlinear dynamical systems (MIT)
- [Envoy](https://github.com/envoyproxy/envoy): C++ L7 proxy and
+- [Envoy](https://lyft.github.io/envoy/): C++ L7 proxy and
  communication bus (Lyft)
 - [FiveM](https://fivem.net/): a modification framework for GTA V
 - [fmtlog](https://github.com/MengRao/fmtlog): a performant
@@ -338,7 +343,7 @@ converts to `std::print`.)
 - [Quill](https://github.com/odygrd/quill): asynchronous low-latency
  logging library
 - [QKW](https://github.com/ravijanjam/qkw): generalizing aliasing to
-  simplify navigation, and execute complex multi-line terminal
+  simplify navigation, and executing complex multi-line terminal
  command sequences
 - [redis-cerberus](https://github.com/HunanTV/redis-cerberus): a Redis
  cluster proxy
@@ -427,7 +432,7 @@ code bloat issues (see [Benchmarks](#benchmarks)).

 ## FastFormat

-This is an interesting library that is fast, safe and has positional
+This is an interesting library that is fast, safe, and has positional
 arguments. However, it has significant limitations, citing its author:

 > Three features that have no hope of being accommodated within the
@@ -437,8 +442,8 @@ arguments. However, it has significant limitations, citing its author:
 > - Octal/hexadecimal encoding
 > - Runtime width/alignment specification

-It is also quite big and has a heavy dependency, on STLSoft, which might be
-too restrictive for use in some projects.
+It is also quite big and has a heavy dependency, STLSoft, which might be
+too restrictive for using it in some projects.

 ## Boost Spirit.Karma

@@ -457,7 +462,7 @@ second](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html).

 # Documentation License

-The [Format String Syntax](https://fmt.dev/latest/syntax/) section
+The [Format String Syntax](https://fmt.dev/latest/syntax.html) section
 in the documentation is based on the one from Python [string module
 documentation](https://docs.python.org/3/library/string.html#module-string).
 For this reason, the documentation is distributed under the Python
@@ -481,5 +486,5 @@ To report a security issue, please disclose it at [security
 advisory](https://github.com/fmtlib/fmt/security/advisories/new).

 This project is maintained by a team of volunteers on a
-reasonable-effort basis. As such, please give us at least *90* days to
+reasonable-effort basis. As such, please give us at least 90 days to
 work on a fix before public exposure.
--- a/3rdparty/fmt/include/fmt/args.h
+++ b/3rdparty/fmt/include/fmt/args.h
@@ -8,15 +8,14 @@
 #ifndef FMT_ARGS_H_
 #define FMT_ARGS_H_

-#ifndef FMT_MODULE
-#  include <functional>  // std::reference_wrapper
-#  include <memory>      // std::unique_ptr
-#  include <vector>
-#endif
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>

-#include "format.h"  // std_string_view
+#include "core.h"

 FMT_BEGIN_NAMESPACE
+
 namespace detail {

 template <typename T> struct is_reference_wrapper : std::false_type {};
@@ -29,18 +28,15 @@ auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
  return static_cast<const T&>(v);
 }

-// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
-// 2022 (v17.10.0).
-//
-// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-// templates it doesn't complain about inability to deduce single translation
-// unit for placing vtable. So node is made a fake template.
-template <typename = void> struct node {
-  virtual ~node() = default;
-  std::unique_ptr<node<>> next;
-};
-
 class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
  template <typename T> struct typed_node : node<> {
    T value;

@@ -66,18 +62,28 @@ class dynamic_arg_list {
 }  // namespace detail

 /**
- * A dynamic list of formatting arguments with storage.
- *
- * It can be implicitly converted into `fmt::basic_format_args` for passing
- * into type-erased formatting functions such as `fmt::vformat`.
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
 */
-template <typename Context> class dynamic_format_arg_store {
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
 private:
  using char_type = typename Context::char_type;

  template <typename T> struct need_copy {
    static constexpr detail::type mapped_type =
-        detail::mapped_type_constant<T, char_type>::value;
+        detail::mapped_type_constant<T, Context>::value;

    enum {
      value = !(detail::is_reference_wrapper<T>::value ||
@@ -90,7 +96,7 @@ template <typename Context> class dynamic_format_arg_store {
  };

  template <typename T>
-  using stored_t = conditional_t<
+  using stored_type = conditional_t<
      std::is_convertible<T, std::basic_string<char_type>>::value &&
          !detail::is_reference_wrapper<T>::value,
      std::basic_string<char_type>, T>;
@@ -105,72 +111,80 @@ template <typename Context> class dynamic_format_arg_store {

  friend class basic_format_args<Context>;

+  auto get_types() const -> unsigned long long {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
  auto data() const -> const basic_format_arg<Context>* {
    return named_info_.empty() ? data_.data() : data_.data() + 1;
  }

  template <typename T> void emplace_arg(const T& arg) {
-    data_.emplace_back(arg);
+    data_.emplace_back(detail::make_arg<Context>(arg));
  }

  template <typename T>
  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
-    if (named_info_.empty())
-      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
-    data_.emplace_back(detail::unwrap(arg.value));
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
      data->pop_back();
    };
    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
        guard{&data_, pop_one};
    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
-    data_[0] = {named_info_.data(), named_info_.size()};
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
    guard.release();
  }

 public:
  constexpr dynamic_format_arg_store() = default;

-  operator basic_format_args<Context>() const {
-    return basic_format_args<Context>(data(), static_cast<int>(data_.size()),
-                                      !named_info_.empty());
-  }
-
  /**
-   * Adds an argument into the dynamic store for later passing to a formatting
-   * function.
-   *
-   * Note that custom types and string types (but not string views) are copied
-   * into the store dynamically allocating memory if necessary.
-   *
-   * **Example**:
-   *
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     store.push_back(42);
-   *     store.push_back("abc");
-   *     store.push_back(1.5f);
-   *     std::string result = fmt::vformat("{} and {} and {}", store);
-   */
+    \rst
+    Adds an argument into the dynamic store for later passing to a formatting
+    function.
+
+    Note that custom types and string types (but not string views) are copied
+    into the store dynamically allocating memory if necessary.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
+  */
  template <typename T> void push_back(const T& arg) {
    if (detail::const_check(need_copy<T>::value))
-      emplace_arg(dynamic_args_.push<stored_t<T>>(arg));
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
    else
      emplace_arg(detail::unwrap(arg));
  }

  /**
-   * Adds a reference to the argument into the dynamic store for later passing
-   * to a formatting function.
-   *
-   * **Example**:
-   *
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     char band[] = "Rolling Stones";
-   *     store.push_back(std::cref(band));
-   *     band[9] = 'c'; // Changing str affects the output.
-   *     std::string result = fmt::vformat("{}", store);
-   *     // result == "Rolling Scones"
-   */
+    \rst
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formatting function.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      char band[] = "Rolling Stones";
+      store.push_back(std::cref(band));
+      band[9] = 'c'; // Changing str affects the output.
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
+  */
  template <typename T> void push_back(std::reference_wrapper<T> arg) {
    static_assert(
        need_copy<T>::value,
@@ -179,40 +193,41 @@ template <typename Context> class dynamic_format_arg_store {
  }

  /**
-   * Adds named argument into the dynamic store for later passing to a
-   * formatting function. `std::reference_wrapper` is supported to avoid
-   * copying of the argument. The name is always copied into the store.
-   */
+    Adds named argument into the dynamic store for later passing to a formatting
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
+    argument. The name is always copied into the store.
+  */
  template <typename T>
  void push_back(const detail::named_arg<char_type, T>& arg) {
    const char_type* arg_name =
        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
    if (detail::const_check(need_copy<T>::value)) {
      emplace_arg(
-          fmt::arg(arg_name, dynamic_args_.push<stored_t<T>>(arg.value)));
+          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
    } else {
      emplace_arg(fmt::arg(arg_name, arg.value));
    }
  }

-  /// Erase all elements from the store.
+  /** Erase all elements from the store */
  void clear() {
    data_.clear();
    named_info_.clear();
-    dynamic_args_ = {};
+    dynamic_args_ = detail::dynamic_arg_list();
  }

-  /// Reserves space to store at least `new_cap` arguments including
-  /// `new_cap_named` named arguments.
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
  void reserve(size_t new_cap, size_t new_cap_named) {
    FMT_ASSERT(new_cap >= new_cap_named,
-               "set of arguments includes set of named arguments");
+               "Set of arguments includes set of named arguments");
    data_.reserve(new_cap);
    named_info_.reserve(new_cap_named);
  }
-
-  /// Returns the number of elements in the store.
-  size_t size() const noexcept { return data_.size(); }
 };

 FMT_END_NAMESPACE
--- a/3rdparty/fmt/include/fmt/base.h
+++ b/3rdparty/fmt/include/fmt/base.h
--- a/3rdparty/fmt/include/fmt/chrono.h
+++ b/3rdparty/fmt/include/fmt/chrono.h
--- a/3rdparty/fmt/include/fmt/color.h
+++ b/3rdparty/fmt/include/fmt/color.h
@@ -227,7 +227,7 @@ struct color_type {
 };
 }  // namespace detail

-/// A text style consisting of foreground and background colors and emphasis.
+/** A text style consisting of foreground and background colors and emphasis. */
 class text_style {
 public:
  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
@@ -239,7 +239,7 @@ class text_style {
      foreground_color = rhs.foreground_color;
    } else if (rhs.set_foreground_color) {
      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
-        report_error("can't OR a terminal color");
+        FMT_THROW(format_error("can't OR a terminal color"));
      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
    }

@@ -248,7 +248,7 @@ class text_style {
      background_color = rhs.background_color;
    } else if (rhs.set_background_color) {
      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        report_error("can't OR a terminal color");
+        FMT_THROW(format_error("can't OR a terminal color"));
      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
    }

@@ -310,13 +310,13 @@ class text_style {
  emphasis ems;
 };

-/// Creates a text style from the foreground (text) color.
+/** Creates a text style from the foreground (text) color. */
 FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
    -> text_style {
  return text_style(true, foreground);
 }

-/// Creates a text style from the background color.
+/** Creates a text style from the background color. */
 FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
    -> text_style {
  return text_style(false, background);
@@ -330,7 +330,7 @@ FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
 namespace detail {

 template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(color_type text_color,
+  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
                                  const char* esc) noexcept {
    // If we have a terminal color, we need to output another escape code
    // sequence.
@@ -390,8 +390,8 @@ template <typename Char> struct ansi_color_escape {
  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }

  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
-  FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
-    return buffer + basic_string_view<Char>(buffer).size();
+  FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
+    return buffer + std::char_traits<Char>::length(buffer);
  }

 private:
@@ -412,13 +412,13 @@ template <typename Char> struct ansi_color_escape {
 };

 template <typename Char>
-FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept
+FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
    -> ansi_color_escape<Char> {
  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }

 template <typename Char>
-FMT_CONSTEXPR auto make_background_color(color_type background) noexcept
+FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
    -> ansi_color_escape<Char> {
  return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
@@ -434,7 +434,7 @@ template <typename Char> inline void reset_color(buffer<Char>& buffer) {
  buffer.append(reset_color.begin(), reset_color.end());
 }

-template <typename T> struct styled_arg : view {
+template <typename T> struct styled_arg : detail::view {
  const T& value;
  text_style style;
  styled_arg(const T& v, text_style s) : value(v), style(s) {}
@@ -442,115 +442,145 @@ template <typename T> struct styled_arg : view {

 template <typename Char>
 void vformat_to(buffer<Char>& buf, const text_style& ts,
-                basic_string_view<Char> fmt,
-                basic_format_args<buffered_context<Char>> args) {
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  bool has_style = false;
  if (ts.has_emphasis()) {
    has_style = true;
-    auto emphasis = make_emphasis<Char>(ts.get_emphasis());
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
    buf.append(emphasis.begin(), emphasis.end());
  }
  if (ts.has_foreground()) {
    has_style = true;
-    auto foreground = make_foreground_color<Char>(ts.get_foreground());
+    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
    buf.append(foreground.begin(), foreground.end());
  }
  if (ts.has_background()) {
    has_style = true;
-    auto background = make_background_color<Char>(ts.get_background());
+    auto background = detail::make_background_color<Char>(ts.get_background());
    buf.append(background.begin(), background.end());
  }
-  vformat_to(buf, fmt, args);
-  if (has_style) reset_color<Char>(buf);
+  detail::vformat_to(buf, format_str, args, {});
+  if (has_style) detail::reset_color<Char>(buf);
 }
+
 }  // namespace detail

-inline void vprint(FILE* f, const text_style& ts, string_view fmt,
+inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
                   format_args args) {
+  // Legacy wide streams are not supported.
  auto buf = memory_buffer();
  detail::vformat_to(buf, ts, fmt, args);
-  print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
+  if (detail::is_utf8()) {
+    detail::print(f, string_view(buf.begin(), buf.size()));
+    return;
+  }
+  buf.push_back('\0');
+  int result = std::fputs(buf.data(), f);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }

 /**
- * Formats a string and prints it to the specified file stream using ANSI
- * escape sequences to specify text formatting.
- *
- * **Example**:
- *
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
- *                "Elapsed time: {0:.2f} seconds", 1.23);
+  \rst
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
 */
-template <typename... T>
-void print(FILE* f, const text_style& ts, format_string<T...> fmt,
-           T&&... args) {
-  vprint(f, ts, fmt.str, vargs<T...>{{args...}});
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }

 /**
- * Formats a string and prints it to stdout using ANSI escape sequences to
- * specify text formatting.
- *
- * **Example**:
- *
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
- *                "Elapsed time: {0:.2f} seconds", 1.23);
+  \rst
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
 */
-template <typename... T>
-void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
-  return print(stdout, ts, fmt, std::forward<T>(args)...);
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
 }

-inline auto vformat(const text_style& ts, string_view fmt, format_args args)
-    -> std::string {
-  auto buf = memory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
+template <typename S, typename Char = char_t<S>>
+inline auto vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
  return fmt::to_string(buf);
 }

 /**
- * Formats arguments and returns the result as a string using ANSI escape
- * sequences to specify text formatting.
- *
- * **Example**:
- *
- * ```
- * #include <fmt/color.h>
- * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
- *                                   "The answer is {}", 42);
- * ```
- */
-template <typename... T>
-inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
-    -> std::string {
-  return fmt::vformat(ts, fmt.str, vargs<T...>{{args...}});
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline auto format(const text_style& ts, const S& format_str,
+                   const Args&... args) -> std::basic_string<Char> {
+  return fmt::vformat(ts, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }

-/// Formats a string with the given text_style and writes the output to `out`.
-template <typename OutputIt,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
-                format_args args) -> OutputIt {
-  auto&& buf = detail::get_buffer<char>(out);
-  detail::vformat_to(buf, ts, fmt, args);
+/**
+  Formats a string with the given text_style and writes the output to ``out``.
+ */
+template <typename OutputIt, typename Char,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+auto vformat_to(OutputIt out, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, ts, format_str, args);
  return detail::get_iterator(buf, out);
 }

 /**
- * Formats arguments with the given text style, writes the result to the output
- * iterator `out` and returns the iterator past the end of the output range.
- *
- * **Example**:
- *
- *     std::vector<char> out;
- *     fmt::format_to(std::back_inserter(out),
- *                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
- */
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-inline auto format_to(OutputIt out, const text_style& ts,
-                      format_string<T...> fmt, T&&... args) -> OutputIt {
-  return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}});
+  \rst
+  Formats arguments with the given text_style, writes the result to the output
+  iterator ``out`` and returns the iterator past the end of the output range.
+
+  **Example**::
+
+    std::vector<char> out;
+    fmt::format_to(std::back_inserter(out),
+                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+  \endrst
+*/
+template <
+    typename OutputIt, typename S, typename... Args,
+    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
+                  detail::is_string<S>::value>
+inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, ts, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }

 template <typename T, typename Char>
@@ -559,44 +589,47 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    const auto& ts = arg.style;
+    const auto& value = arg.value;
    auto out = ctx.out();

    bool has_style = false;
    if (ts.has_emphasis()) {
      has_style = true;
      auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
-      out = detail::copy<Char>(emphasis.begin(), emphasis.end(), out);
+      out = std::copy(emphasis.begin(), emphasis.end(), out);
    }
    if (ts.has_foreground()) {
      has_style = true;
      auto foreground =
          detail::make_foreground_color<Char>(ts.get_foreground());
-      out = detail::copy<Char>(foreground.begin(), foreground.end(), out);
+      out = std::copy(foreground.begin(), foreground.end(), out);
    }
    if (ts.has_background()) {
      has_style = true;
      auto background =
          detail::make_background_color<Char>(ts.get_background());
-      out = detail::copy<Char>(background.begin(), background.end(), out);
+      out = std::copy(background.begin(), background.end(), out);
    }
-    out = formatter<T, Char>::format(arg.value, ctx);
+    out = formatter<T, Char>::format(value, ctx);
    if (has_style) {
      auto reset_color = string_view("\x1b[0m");
-      out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out);
+      out = std::copy(reset_color.begin(), reset_color.end(), out);
    }
    return out;
  }
 };

 /**
- * Returns an argument that will be formatted using ANSI escape sequences,
- * to be used in a formatting function.
- *
- * **Example**:
- *
- *     fmt::print("Elapsed time: {0:.2f} seconds",
- *                fmt::styled(1.23, fmt::fg(fmt::color::green) |
- *                                  fmt::bg(fmt::color::blue)));
+  \rst
+  Returns an argument that will be formatted using ANSI escape sequences,
+  to be used in a formatting function.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {0:.2f} seconds",
+               fmt::styled(1.23, fmt::fg(fmt::color::green) |
+                                 fmt::bg(fmt::color::blue)));
+  \endrst
 */
 template <typename T>
 FMT_CONSTEXPR auto styled(const T& value, text_style ts)
--- a/3rdparty/fmt/include/fmt/compile.h
+++ b/3rdparty/fmt/include/fmt/compile.h
@@ -8,44 +8,49 @@
 #ifndef FMT_COMPILE_H_
 #define FMT_COMPILE_H_

-#ifndef FMT_MODULE
-#  include <iterator>  // std::back_inserter
-#endif
-
 #include "format.h"

 FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Char, typename InputIt>
+FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
+                                   counting_iterator it) -> counting_iterator {
+  return it + (end - begin);
+}

 // A compile-time string which is compiled into fast formatting code.
-FMT_EXPORT class compiled_string {};
-
-namespace detail {
+class compiled_string {};

 template <typename S>
 struct is_compiled_string : std::is_base_of<compiled_string, S> {};

 /**
- * Converts a string literal `s` into a format string that will be parsed at
- * compile time and converted into efficient formatting code. Requires C++17
- * `constexpr if` compiler support.
- *
- * **Example**:
- *
- *     // Converts 42 into std::string using the most efficient method and no
- *     // runtime format string processing.
- *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \rst
+  Converts a string literal *s* into a format string that will be parsed at
+  compile time and converted into efficient formatting code. Requires C++17
+  ``constexpr if`` compiler support.
+
+  **Example**::
+
+    // Converts 42 into std::string using the most efficient method and no
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \endrst
 */
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
 #else
 #  define FMT_COMPILE(s) FMT_STRING(s)
 #endif

 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
-template <typename Char, size_t N, fmt::detail::fixed_string<Char, N> Str>
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
 struct udl_compiled_string : compiled_string {
  using char_type = Char;
-  constexpr explicit operator basic_string_view<char_type>() const {
+  explicit constexpr operator basic_string_view<char_type>() const {
    return {Str.data, N - 1};
  }
 };
@@ -70,29 +75,6 @@ constexpr const auto& get([[maybe_unused]] const T& first,
    return detail::get<N - 1>(rest...);
 }

-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-template <int N, typename T, typename... Args, typename Char>
-constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-  if constexpr (is_static_named_arg<T>()) {
-    if (name == T::name) return N;
-  }
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<N + 1, Args...>(name);
-  (void)name;  // Workaround an MSVC bug about "unused" parameter.
-  return -1;
-}
-#  endif
-
-template <typename... Args, typename Char>
-FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<0, Args...>(name);
-#  endif
-  (void)name;
-  return -1;
-}
-
 template <typename Char, typename... Args>
 constexpr int get_arg_index_by_name(basic_string_view<Char> name,
                                    type_list<Args...>) {
@@ -162,12 +144,11 @@ template <typename Char, typename T, int N> struct field {
  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&... args) const {
    const T& arg = get_arg_checked<T, N>(args...);
-    if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
+    if constexpr (std::is_convertible_v<T, basic_string_view<Char>>) {
      auto s = basic_string_view<Char>(arg);
-      return copy<Char>(s.begin(), s.end(), out);
-    } else {
-      return write<Char>(out, arg);
+      return copy_str<Char>(s.begin(), s.end(), out);
    }
+    return write<Char>(out, arg);
  }
 };

@@ -255,12 +236,13 @@ constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
 }

 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S fmt);
+constexpr auto compile_format_string(S format_str);

 template <typename Args, size_t POS, int ID, typename T, typename S>
-constexpr auto parse_tail(T head, S fmt) {
-  if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
-    constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS !=
+                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
                               unknown_format>())
      return tail;
@@ -292,7 +274,6 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
 }

 template <typename Char> struct arg_id_handler {
-  arg_id_kind kind;
  arg_ref<Char> arg_id;

  constexpr int on_auto() {
@@ -300,28 +281,25 @@ template <typename Char> struct arg_id_handler {
    return 0;
  }
  constexpr int on_index(int id) {
-    kind = arg_id_kind::index;
    arg_id = arg_ref<Char>(id);
    return 0;
  }
  constexpr int on_name(basic_string_view<Char> id) {
-    kind = arg_id_kind::name;
    arg_id = arg_ref<Char>(id);
    return 0;
  }
 };

 template <typename Char> struct parse_arg_id_result {
-  arg_id_kind kind;
  arg_ref<Char> arg_id;
  const Char* arg_id_end;
 };

 template <int ID, typename Char>
 constexpr auto parse_arg_id(const Char* begin, const Char* end) {
-  auto handler = arg_id_handler<Char>{arg_id_kind::none, arg_ref<Char>{}};
+  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
  auto arg_id_end = parse_arg_id(begin, end, handler);
-  return parse_arg_id_result<Char>{handler.kind, handler.arg_id, arg_id_end};
+  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
 }

 template <typename T, typename Enable = void> struct field_type {
@@ -335,13 +313,14 @@ struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {

 template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
          typename S>
-constexpr auto parse_replacement_field_then_tail(S fmt) {
+constexpr auto parse_replacement_field_then_tail(S format_str) {
  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(fmt);
+  constexpr auto str = basic_string_view<char_type>(format_str);
  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
  if constexpr (c == '}') {
    return parse_tail<Args, END_POS + 1, NEXT_ID>(
-        field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
+        format_str);
  } else if constexpr (c != ':') {
    FMT_THROW(format_error("expected ':'"));
  } else {
@@ -354,7 +333,7 @@ constexpr auto parse_replacement_field_then_tail(S fmt) {
      return parse_tail<Args, result.end + 1, result.next_arg_id>(
          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
              result.fmt},
-          fmt);
+          format_str);
    }
  }
 }
@@ -362,21 +341,22 @@ constexpr auto parse_replacement_field_then_tail(S fmt) {
 // Compiles a non-empty format string and returns the compiled representation
 // or unknown_format() on unrecognized input.
 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S fmt) {
+constexpr auto compile_format_string(S format_str) {
  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(fmt);
+  constexpr auto str = basic_string_view<char_type>(format_str);
  if constexpr (str[POS] == '{') {
    if constexpr (POS + 1 == str.size())
      FMT_THROW(format_error("unmatched '{' in format string"));
    if constexpr (str[POS + 1] == '{') {
-      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
      static_assert(ID != manual_indexing_id,
                    "cannot switch from manual to automatic argument indexing");
      constexpr auto next_id =
          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
-                                               POS + 1, ID, next_id>(fmt);
+                                               POS + 1, ID, next_id>(
+          format_str);
    } else {
      constexpr auto arg_id_result =
          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
@@ -384,27 +364,28 @@ constexpr auto compile_format_string(S fmt) {
      constexpr char_type c =
          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
      static_assert(c == '}' || c == ':', "missing '}' in format string");
-      if constexpr (arg_id_result.kind == arg_id_kind::index) {
+      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
        static_assert(
            ID == manual_indexing_id || ID == 0,
            "cannot switch from automatic to manual argument indexing");
-        constexpr auto arg_index = arg_id_result.arg_id.index;
+        constexpr auto arg_index = arg_id_result.arg_id.val.index;
        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
                                                 Args, arg_id_end_pos,
                                                 arg_index, manual_indexing_id>(
-            fmt);
-      } else if constexpr (arg_id_result.kind == arg_id_kind::name) {
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
        constexpr auto arg_index =
-            get_arg_index_by_name(arg_id_result.arg_id.name, Args{});
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
        if constexpr (arg_index >= 0) {
          constexpr auto next_id =
              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
          return parse_replacement_field_then_tail<
              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
-              arg_index, next_id>(fmt);
+              arg_index, next_id>(format_str);
        } else if constexpr (c == '}') {
          return parse_tail<Args, arg_id_end_pos + 1, ID>(
-              runtime_named_field<char_type>{arg_id_result.arg_id.name}, fmt);
+              runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+              format_str);
        } else if constexpr (c == ':') {
          return unknown_format();  // no type info for specs parsing
        }
@@ -413,26 +394,29 @@ constexpr auto compile_format_string(S fmt) {
  } else if constexpr (str[POS] == '}') {
    if constexpr (POS + 1 == str.size())
      FMT_THROW(format_error("unmatched '}' in format string"));
-    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
  } else {
    constexpr auto end = parse_text(str, POS + 1);
    if constexpr (end - POS > 1) {
-      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
+                                       format_str);
    } else {
-      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
    }
  }
 }

 template <typename... Args, typename S,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-constexpr auto compile(S fmt) {
-  constexpr auto str = basic_string_view<typename S::char_type>(fmt);
+constexpr auto compile(S format_str) {
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
  if constexpr (str.size() == 0) {
    return detail::make_text(str, 0, 0);
  } else {
    constexpr auto result =
-        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
+            format_str);
    return result;
  }
 }
@@ -504,40 +488,40 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {

 template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
+auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args)
    -> format_to_n_result<OutputIt> {
  using traits = detail::fixed_buffer_traits;
  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
+  fmt::format_to(std::back_inserter(buf), format_str,
+                 std::forward<Args>(args)...);
  return {buf.out(), buf.count()};
 }

 template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
+FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
    -> size_t {
-  auto buf = detail::counting_buffer<>();
-  fmt::format_to(appender(buf), fmt, args...);
-  return buf.count();
+  return fmt::format_to(detail::counting_iterator(), format_str, args...)
+      .count();
 }

 template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(std::FILE* f, const S& fmt, const Args&... args) {
-  auto buf = memory_buffer();
-  fmt::format_to(appender(buf), fmt, args...);
-  detail::print(f, {buf.data(), buf.size()});
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
 }

 template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(const S& fmt, const Args&... args) {
-  print(stdout, fmt, args...);
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
 }

 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-template <detail::fixed_string Str> constexpr auto operator""_cf() {
+template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
  using char_t = remove_cvref_t<decltype(Str.data[0])>;
  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
                                     Str>();
--- a/3rdparty/fmt/include/fmt/core.h
+++ b/3rdparty/fmt/include/fmt/core.h
--- a/3rdparty/fmt/include/fmt/format-inl.h
+++ b/3rdparty/fmt/include/fmt/format-inl.h
@@ -8,36 +8,36 @@
 #ifndef FMT_FORMAT_INL_H_
 #define FMT_FORMAT_INL_H_

-#ifndef FMT_MODULE
-#  include <algorithm>
-#  include <cerrno>  // errno
-#  include <climits>
-#  include <cmath>
-#  include <exception>
+#include <algorithm>
+#include <cerrno>  // errno
+#include <climits>
+#include <cmath>
+#include <exception>
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#  include <locale>
 #endif

-#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)
+#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
 #  include <io.h>  // _isatty
 #endif

 #include "format.h"

-#if FMT_USE_LOCALE
-#  include <locale>
-#endif
-
-#ifndef FMT_FUNC
-#  define FMT_FUNC
-#endif
-
 FMT_BEGIN_NAMESPACE
 namespace detail {

 FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
  // Use unchecked std::fprintf to avoid triggering another assertion when
-  // writing to stderr fails.
-  fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
-  abort();
+  // writing to stderr fails
+  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
+  // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
+  // code pass.
+  std::terminate();
+}
+
+FMT_FUNC void throw_format_error(const char* message) {
+  FMT_THROW(format_error(message));
 }

 FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
@@ -56,105 +56,89 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
    ++error_code_size;
  }
  error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
-  auto it = appender(out);
+  auto it = buffer_appender<char>(out);
  if (message.size() <= inline_buffer_size - error_code_size)
    fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
  fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
  FMT_ASSERT(out.size() <= inline_buffer_size, "");
 }

-FMT_FUNC void do_report_error(format_func func, int error_code,
-                              const char* message) noexcept {
+FMT_FUNC void report_error(format_func func, int error_code,
+                           const char* message) noexcept {
  memory_buffer full_message;
  func(full_message, error_code, message);
-  // Don't use fwrite_all because the latter may throw.
+  // Don't use fwrite_fully because the latter may throw.
  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
    std::fputc('\n', stderr);
 }

 // A wrapper around fwrite that throws on error.
-inline void fwrite_all(const void* ptr, size_t count, FILE* stream) {
+inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
  size_t written = std::fwrite(ptr, 1, count, stream);
  if (written < count)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }

-#if FMT_USE_LOCALE
-using std::locale;
-using std::numpunct;
-using std::use_facet;
-
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 template <typename Locale>
 locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, locale>::value, "");
+  static_assert(std::is_same<Locale, std::locale>::value, "");
 }
-#else
-struct locale {};
-template <typename Char> struct numpunct {
-  auto grouping() const -> std::string { return "\03"; }
-  auto thousands_sep() const -> Char { return ','; }
-  auto decimal_point() const -> Char { return '.'; }
-};
-template <typename Facet> Facet use_facet(locale) { return {}; }
-#endif  // FMT_USE_LOCALE

 template <typename Locale> auto locale_ref::get() const -> Locale {
-  static_assert(std::is_same<Locale, locale>::value, "");
-#if FMT_USE_LOCALE
-  if (locale_) return *static_cast<const locale*>(locale_);
-#endif
-  return locale();
+  static_assert(std::is_same<Locale, std::locale>::value, "");
+  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
 }

 template <typename Char>
 FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
-  auto&& facet = use_facet<numpunct<Char>>(loc.get<locale>());
+  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
  auto grouping = facet.grouping();
  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
  return {std::move(grouping), thousands_sep};
 }
 template <typename Char>
 FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
-  return use_facet<numpunct<Char>>(loc.get<locale>()).decimal_point();
+  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
+      .decimal_point();
 }
+#else
+template <typename Char>
+FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char> {
+  return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
+}
+template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
+  return '.';
+}
+#endif

-#if FMT_USE_LOCALE
 FMT_FUNC auto write_loc(appender out, loc_value value,
-                        const format_specs& specs, locale_ref loc) -> bool {
+                        const format_specs<>& specs, locale_ref loc) -> bool {
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
  auto locale = loc.get<std::locale>();
  // We cannot use the num_put<char> facet because it may produce output in
  // a wrong encoding.
  using facet = format_facet<std::locale>;
  if (std::has_facet<facet>(locale))
-    return use_facet<facet>(locale).put(out, value, specs);
+    return std::use_facet<facet>(locale).put(out, value, specs);
  return facet(locale).put(out, value, specs);
-}
 #endif
+  return false;
+}
 }  // namespace detail

-FMT_FUNC void report_error(const char* message) {
-#if FMT_USE_EXCEPTIONS
-  // Use FMT_THROW instead of throw to avoid bogus unreachable code warnings
-  // from MSVC.
-  FMT_THROW(format_error(message));
-#else
-  fputs(message, stderr);
-  abort();
-#endif
-}
-
 template <typename Locale> typename Locale::id format_facet<Locale>::id;

+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
-  auto& np = detail::use_facet<detail::numpunct<char>>(loc);
-  grouping_ = np.grouping();
-  if (!grouping_.empty()) separator_ = std::string(1, np.thousands_sep());
+  auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
+  grouping_ = numpunct.grouping();
+  if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
 }

-#if FMT_USE_LOCALE
 template <>
 FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
-    appender out, loc_value val, const format_specs& specs) const -> bool {
+    appender out, loc_value val, const format_specs<>& specs) const -> bool {
  return val.visit(
      detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
 }
@@ -1427,7 +1411,7 @@ FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
                                  const char* message) noexcept {
  FMT_TRY {
    auto ec = std::error_code(error_code, std::generic_category());
-    detail::write(appender(out), std::system_error(ec, message).what());
+    write(std::back_inserter(out), std::system_error(ec, message).what());
    return;
  }
  FMT_CATCH(...) {}
@@ -1436,7 +1420,7 @@ FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,

 FMT_FUNC void report_system_error(int error_code,
                                  const char* message) noexcept {
-  do_report_error(format_system_error, error_code, message);
+  report_error(format_system_error, error_code, message);
 }

 FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
@@ -1448,252 +1432,9 @@ FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
 }

 namespace detail {
-
-FMT_FUNC void vformat_to(buffer<char>& buf, string_view fmt, format_args args,
-                         locale_ref loc) {
-  auto out = appender(buf);
-  if (fmt.size() == 2 && equal2(fmt.data(), "{}"))
-    return args.get(0).visit(default_arg_formatter<char>{out});
-  parse_format_string(
-      fmt, format_handler<char>{parse_context<char>(fmt), {out, args, loc}});
-}
-
-template <typename T> struct span {
-  T* data;
-  size_t size;
-};
-
-template <typename F> auto flockfile(F* f) -> decltype(_lock_file(f)) {
-  _lock_file(f);
-}
-template <typename F> auto funlockfile(F* f) -> decltype(_unlock_file(f)) {
-  _unlock_file(f);
-}
-
-#ifndef getc_unlocked
-template <typename F> auto getc_unlocked(F* f) -> decltype(_fgetc_nolock(f)) {
-  return _fgetc_nolock(f);
-}
-#endif
-
-template <typename F = FILE, typename Enable = void>
-struct has_flockfile : std::false_type {};
-
-template <typename F>
-struct has_flockfile<F, void_t<decltype(flockfile(&std::declval<F&>()))>>
-    : std::true_type {};
-
-// A FILE wrapper. F is FILE defined as a template parameter to make system API
-// detection work.
-template <typename F> class file_base {
- public:
-  F* file_;
-
- public:
-  file_base(F* file) : file_(file) {}
-  operator F*() const { return file_; }
-
-  // Reads a code unit from the stream.
-  auto get() -> int {
-    int result = getc_unlocked(file_);
-    if (result == EOF && ferror(file_) != 0)
-      FMT_THROW(system_error(errno, FMT_STRING("getc failed")));
-    return result;
-  }
-
-  // Puts the code unit back into the stream buffer.
-  void unget(char c) {
-    if (ungetc(c, file_) == EOF)
-      FMT_THROW(system_error(errno, FMT_STRING("ungetc failed")));
-  }
-
-  void flush() { fflush(this->file_); }
-};
-
-// A FILE wrapper for glibc.
-template <typename F> class glibc_file : public file_base<F> {
- private:
-  enum {
-    line_buffered = 0x200,  // _IO_LINE_BUF
-    unbuffered = 2          // _IO_UNBUFFERED
-  };
-
- public:
-  using file_base<F>::file_base;
-
-  auto is_buffered() const -> bool {
-    return (this->file_->_flags & unbuffered) == 0;
-  }
-
-  void init_buffer() {
-    if (this->file_->_IO_write_ptr) return;
-    // Force buffer initialization by placing and removing a char in a buffer.
-    assume(this->file_->_IO_write_ptr >= this->file_->_IO_write_end);
-    putc_unlocked(0, this->file_);
-    --this->file_->_IO_write_ptr;
-  }
-
-  // Returns the file's read buffer.
-  auto get_read_buffer() const -> span<const char> {
-    auto ptr = this->file_->_IO_read_ptr;
-    return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)};
-  }
-
-  // Returns the file's write buffer.
-  auto get_write_buffer() const -> span<char> {
-    auto ptr = this->file_->_IO_write_ptr;
-    return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)};
-  }
-
-  void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; }
-
-  bool needs_flush() const {
-    if ((this->file_->_flags & line_buffered) == 0) return false;
-    char* end = this->file_->_IO_write_end;
-    return memchr(end, '\n', to_unsigned(this->file_->_IO_write_ptr - end));
-  }
-
-  void flush() { fflush_unlocked(this->file_); }
-};
-
-// A FILE wrapper for Apple's libc.
-template <typename F> class apple_file : public file_base<F> {
- private:
-  enum {
-    line_buffered = 1,  // __SNBF
-    unbuffered = 2      // __SLBF
-  };
-
- public:
-  using file_base<F>::file_base;
-
-  auto is_buffered() const -> bool {
-    return (this->file_->_flags & unbuffered) == 0;
-  }
-
-  void init_buffer() {
-    if (this->file_->_p) return;
-    // Force buffer initialization by placing and removing a char in a buffer.
-    putc_unlocked(0, this->file_);
-    --this->file_->_p;
-    ++this->file_->_w;
-  }
-
-  auto get_read_buffer() const -> span<const char> {
-    return {reinterpret_cast<char*>(this->file_->_p),
-            to_unsigned(this->file_->_r)};
-  }
-
-  auto get_write_buffer() const -> span<char> {
-    return {reinterpret_cast<char*>(this->file_->_p),
-            to_unsigned(this->file_->_bf._base + this->file_->_bf._size -
-                        this->file_->_p)};
-  }
-
-  void advance_write_buffer(size_t size) {
-    this->file_->_p += size;
-    this->file_->_w -= size;
-  }
-
-  bool needs_flush() const {
-    if ((this->file_->_flags & line_buffered) == 0) return false;
-    return memchr(this->file_->_p + this->file_->_w, '\n',
-                  to_unsigned(-this->file_->_w));
-  }
-};
-
-// A fallback FILE wrapper.
-template <typename F> class fallback_file : public file_base<F> {
- private:
-  char next_;  // The next unconsumed character in the buffer.
-  bool has_next_ = false;
-
- public:
-  using file_base<F>::file_base;
-
-  auto is_buffered() const -> bool { return false; }
-  auto needs_flush() const -> bool { return false; }
-  void init_buffer() {}
-
-  auto get_read_buffer() const -> span<const char> {
-    return {&next_, has_next_ ? 1u : 0u};
-  }
-
-  auto get_write_buffer() const -> span<char> { return {nullptr, 0}; }
-
-  void advance_write_buffer(size_t) {}
-
-  auto get() -> int {
-    has_next_ = false;
-    return file_base<F>::get();
-  }
-
-  void unget(char c) {
-    file_base<F>::unget(c);
-    next_ = c;
-    has_next_ = true;
-  }
-};
-
-#ifndef FMT_USE_FALLBACK_FILE
-#  define FMT_USE_FALLBACK_FILE 0
-#endif
-
-template <typename F,
-          FMT_ENABLE_IF(sizeof(F::_p) != 0 && !FMT_USE_FALLBACK_FILE)>
-auto get_file(F* f, int) -> apple_file<F> {
-  return f;
-}
-template <typename F,
-          FMT_ENABLE_IF(sizeof(F::_IO_read_ptr) != 0 && !FMT_USE_FALLBACK_FILE)>
-inline auto get_file(F* f, int) -> glibc_file<F> {
-  return f;
-}
-
-inline auto get_file(FILE* f, ...) -> fallback_file<FILE> { return f; }
-
-using file_ref = decltype(get_file(static_cast<FILE*>(nullptr), 0));
-
-template <typename F = FILE, typename Enable = void>
-class file_print_buffer : public buffer<char> {
- public:
-  explicit file_print_buffer(F*) : buffer(nullptr, size_t()) {}
-};
-
-template <typename F>
-class file_print_buffer<F, enable_if_t<has_flockfile<F>::value>>
-    : public buffer<char> {
- private:
-  file_ref file_;
-
-  static void grow(buffer<char>& base, size_t) {
-    auto& self = static_cast<file_print_buffer&>(base);
-    self.file_.advance_write_buffer(self.size());
-    if (self.file_.get_write_buffer().size == 0) self.file_.flush();
-    auto buf = self.file_.get_write_buffer();
-    FMT_ASSERT(buf.size > 0, "");
-    self.set(buf.data, buf.size);
-    self.clear();
-  }
-
- public:
-  explicit file_print_buffer(F* f) : buffer(grow, size_t()), file_(f) {
-    flockfile(f);
-    file_.init_buffer();
-    auto buf = file_.get_write_buffer();
-    set(buf.data, buf.size);
-  }
-  ~file_print_buffer() {
-    file_.advance_write_buffer(size());
-    bool flush = file_.needs_flush();
-    F* f = file_;    // Make funlockfile depend on the template parameter F
-    funlockfile(f);  // for the system API detection to work.
-    if (flush) fflush(file_);
-  }
-};
-
-#if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE)
+#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
 FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
+FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
 #else
 using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
@@ -1704,48 +1445,36 @@ FMT_FUNC bool write_console(int fd, string_view text) {
  return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
                       static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
 }
+
+FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
+  return write_console(_fileno(f), text);
+}
 #endif

 #ifdef _WIN32
 // Print assuming legacy (non-Unicode) encoding.
-FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args,
-                              bool newline) {
+FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
  auto buffer = memory_buffer();
  detail::vformat_to(buffer, fmt, args);
-  if (newline) buffer.push_back('\n');
-  fwrite_all(buffer.data(), buffer.size(), f);
+  fwrite_fully(buffer.data(), buffer.size(), f);
 }
 #endif

 FMT_FUNC void print(std::FILE* f, string_view text) {
-#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)
+#ifdef _WIN32
  int fd = _fileno(f);
  if (_isatty(fd)) {
    std::fflush(f);
    if (write_console(fd, text)) return;
  }
 #endif
-  fwrite_all(text.data(), text.size(), f);
+  fwrite_fully(text.data(), text.size(), f);
 }
 }  // namespace detail

-FMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) {
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
-  detail::print(f, {buffer.data(), buffer.size()});
-}
-
 FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
-  if (!detail::file_ref(f).is_buffered() || !detail::has_flockfile<>())
-    return vprint_buffered(f, fmt, args);
-  auto&& buffer = detail::file_print_buffer<>(f);
-  return detail::vformat_to(buffer, fmt, args);
-}
-
-FMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) {
  auto buffer = memory_buffer();
  detail::vformat_to(buffer, fmt, args);
-  buffer.push_back('\n');
  detail::print(f, {buffer.data(), buffer.size()});
 }

--- a/3rdparty/fmt/include/fmt/format.h
+++ b/3rdparty/fmt/include/fmt/format.h
--- a/3rdparty/fmt/include/fmt/os.h
+++ b/3rdparty/fmt/include/fmt/os.h
@@ -8,18 +8,18 @@
 #ifndef FMT_OS_H_
 #define FMT_OS_H_

+#include <cerrno>
+#include <cstddef>
+#include <cstdio>
+#include <system_error>  // std::system_error
+
 #include "format.h"

-#ifndef FMT_MODULE
-#  include <cerrno>
-#  include <cstddef>
-#  include <cstdio>
-#  include <system_error>  // std::system_error
-
+#if defined __APPLE__ || defined(__FreeBSD__)
 #  if FMT_HAS_INCLUDE(<xlocale.h>)
-#    include <xlocale.h>  // LC_NUMERIC_MASK on macOS
+#    include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
 #  endif
-#endif  // FMT_MODULE
+#endif

 #ifndef FMT_USE_FCNTL
 // UWP doesn't provide _pipe.
@@ -77,33 +77,46 @@ FMT_BEGIN_NAMESPACE
 FMT_BEGIN_EXPORT

 /**
- * A reference to a null-terminated string. It can be constructed from a C
- * string or `std::string`.
- *
- * You can use one of the following type aliases for common character types:
- *
- * +---------------+-----------------------------+
- * | Type          | Definition                  |
- * +===============+=============================+
- * | cstring_view  | basic_cstring_view<char>    |
- * +---------------+-----------------------------+
- * | wcstring_view | basic_cstring_view<wchar_t> |
- * +---------------+-----------------------------+
- *
- * This class is most useful as a parameter type for functions that wrap C APIs.
+  \rst
+  A reference to a null-terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following type aliases for common character types:
+
+  +---------------+-----------------------------+
+  | Type          | Definition                  |
+  +===============+=============================+
+  | cstring_view  | basic_cstring_view<char>    |
+  +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
 */
 template <typename Char> class basic_cstring_view {
 private:
  const Char* data_;

 public:
-  /// Constructs a string reference object from a C string.
+  /** Constructs a string reference object from a C string. */
  basic_cstring_view(const Char* s) : data_(s) {}

-  /// Constructs a string reference from an `std::string` object.
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}

-  /// Returns the pointer to a C string.
+  /** Returns the pointer to a C string. */
  auto c_str() const -> const Char* { return data_; }
 };

@@ -118,38 +131,41 @@ FMT_API void format_windows_error(buffer<char>& out, int error_code,
                                  const char* message) noexcept;
 }

-FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
                                         format_args args);

 /**
- * Constructs a `std::system_error` object with the description of the form
- *
- *     <message>: <system-message>
- *
- * where `<message>` is the formatted message and `<system-message>` is the
- * system message corresponding to the error code.
- * `error_code` is a Windows error code as given by `GetLastError`.
- * If `error_code` is not a valid error code such as -1, the system message
- * will look like "error -1".
- *
- * **Example**:
- *
- *     // This throws a system_error with the description
- *     //   cannot open file 'madeup': The system cannot find the file
- * specified.
- *     // or similar (system message may vary).
- *     const char *filename = "madeup";
- *     LPOFSTRUCT of = LPOFSTRUCT();
- *     HFILE file = OpenFile(filename, &of, OF_READ);
- *     if (file == HFILE_ERROR) {
- *       throw fmt::windows_error(GetLastError(),
- *                                "cannot open file '{}'", filename);
- *     }
- */
-template <typename... T>
-auto windows_error(int error_code, string_view message, const T&... args)
-    -> std::system_error {
-  return vwindows_error(error_code, message, vargs<T...>{{args...}});
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
+
+ .. parsed-literal::
+   *<message>*: *<system-message>*
+
+ where *<message>* is the formatted message and *<system-message>* is the
+ system message corresponding to the error code.
+ *error_code* is a Windows error code as given by ``GetLastError``.
+ If *error_code* is not a valid error code such as -1, the system message
+ will look like "error -1".
+
+ **Example**::
+
+   // This throws a system_error with the description
+   //   cannot open file 'madeup': The system cannot find the file specified.
+   // or similar (system message may vary).
+   const char *filename = "madeup";
+   LPOFSTRUCT of = LPOFSTRUCT();
+   HFILE file = OpenFile(filename, &of, OF_READ);
+   if (file == HFILE_ERROR) {
+     throw fmt::windows_error(GetLastError(),
+                              "cannot open file '{}'", filename);
+   }
+ \endrst
+*/
+template <typename... Args>
+std::system_error windows_error(int error_code, string_view message,
+                                const Args&... args) {
+  return vwindows_error(error_code, message, fmt::make_format_args(args...));
 }

 // Reports a Windows error without throwing an exception.
@@ -164,8 +180,8 @@ inline auto system_category() noexcept -> const std::error_category& {
 // std::system is not available on some platforms such as iOS (#2248).
 #ifdef __OSX__
 template <typename S, typename... Args, typename Char = char_t<S>>
-void say(const S& fmt, Args&&... args) {
-  std::system(format("say \"{}\"", format(fmt, args...)).c_str());
+void say(const S& format_str, Args&&... args) {
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
 }
 #endif

@@ -176,24 +192,24 @@ class buffered_file {

  friend class file;

-  inline explicit buffered_file(FILE* f) : file_(f) {}
+  explicit buffered_file(FILE* f) : file_(f) {}

 public:
  buffered_file(const buffered_file&) = delete;
  void operator=(const buffered_file&) = delete;

  // Constructs a buffered_file object which doesn't represent any file.
-  inline buffered_file() noexcept : file_(nullptr) {}
+  buffered_file() noexcept : file_(nullptr) {}

  // Destroys the object closing the file it represents if any.
  FMT_API ~buffered_file() noexcept;

 public:
-  inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
+  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
    other.file_ = nullptr;
  }

-  inline auto operator=(buffered_file&& other) -> buffered_file& {
+  auto operator=(buffered_file&& other) -> buffered_file& {
    close();
    file_ = other.file_;
    other.file_ = nullptr;
@@ -207,20 +223,21 @@ class buffered_file {
  FMT_API void close();

  // Returns the pointer to a FILE object representing this file.
-  inline auto get() const noexcept -> FILE* { return file_; }
+  auto get() const noexcept -> FILE* { return file_; }

  FMT_API auto descriptor() const -> int;

-  template <typename... T>
-  inline void print(string_view fmt, const T&... args) {
-    fmt::vargs<T...> vargs = {{args...}};
-    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
-                               : fmt::vprint(file_, fmt, vargs);
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args&... args) {
+    vprint(format_str, fmt::make_format_args(args...));
  }
 };

 #if FMT_USE_FCNTL
-
 // A file. Closed file is represented by a file object with descriptor -1.
 // Methods that are not declared with noexcept may throw
 // fmt::system_error in case of failure. Note that some errors such as
@@ -234,8 +251,6 @@ class FMT_API file {
  // Constructs a file object with a given descriptor.
  explicit file(int fd) : fd_(fd) {}

-  friend struct pipe;
-
 public:
  // Possible values for the oflag argument to the constructor.
  enum {
@@ -248,7 +263,7 @@ class FMT_API file {
  };

  // Constructs a file object which doesn't represent any file.
-  inline file() noexcept : fd_(-1) {}
+  file() noexcept : fd_(-1) {}

  // Opens a file and constructs a file object representing this file.
  file(cstring_view path, int oflag);
@@ -257,10 +272,10 @@ class FMT_API file {
  file(const file&) = delete;
  void operator=(const file&) = delete;

-  inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }

  // Move assignment is not noexcept because close may throw.
-  inline auto operator=(file&& other) -> file& {
+  auto operator=(file&& other) -> file& {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
@@ -271,7 +286,7 @@ class FMT_API file {
  ~file() noexcept;

  // Returns the file descriptor.
-  inline auto descriptor() const noexcept -> int { return fd_; }
+  auto descriptor() const noexcept -> int { return fd_; }

  // Closes the file.
  void close();
@@ -298,6 +313,11 @@ class FMT_API file {
  // necessary.
  void dup2(int fd, std::error_code& ec) noexcept;

+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  // DEPRECATED! Taking files as out parameters is deprecated.
+  static void pipe(file& read_end, file& write_end);
+
  // Creates a buffered_file object associated with this file and detaches
  // this file object from the file.
  auto fdopen(const char* mode) -> buffered_file;
@@ -309,24 +329,15 @@ class FMT_API file {
 #  endif
 };

-struct FMT_API pipe {
-  file read_end;
-  file write_end;
-
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  pipe();
-};
-
 // Returns the memory page size.
 auto getpagesize() -> long;

 namespace detail {

 struct buffer_size {
-  constexpr buffer_size() = default;
+  buffer_size() = default;
  size_t value = 0;
-  FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {
+  auto operator=(size_t val) const -> buffer_size {
    auto bs = buffer_size();
    bs.value = val;
    return bs;
@@ -337,7 +348,7 @@ struct ostream_params {
  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;

-  constexpr ostream_params() {}
+  ostream_params() {}

  template <typename... T>
  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
@@ -358,62 +369,79 @@ struct ostream_params {
 #  endif
 };

-}  // namespace detail
-
-FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();
-
-/// A fast buffered output stream for writing from a single thread. Writing from
-/// multiple threads without external synchronization may result in a data race.
-class FMT_API ostream : private detail::buffer<char> {
- private:
+class file_buffer final : public buffer<char> {
  file file_;

-  ostream(cstring_view path, const detail::ostream_params& params);
-
-  static void grow(buffer<char>& buf, size_t);
+  FMT_API void grow(size_t) override;

 public:
-  ostream(ostream&& other) noexcept;
-  ~ostream();
+  FMT_API file_buffer(cstring_view path, const ostream_params& params);
+  FMT_API file_buffer(file_buffer&& other);
+  FMT_API ~file_buffer();

-  operator writer() {
-    detail::buffer<char>& buf = *this;
-    return buf;
-  }
-
-  inline void flush() {
+  void flush() {
    if (size() == 0) return;
    file_.write(data(), size() * sizeof(data()[0]));
    clear();
  }

-  template <typename... T>
-  friend auto output_file(cstring_view path, T... params) -> ostream;
-
-  inline void close() {
+  void close() {
    flush();
    file_.close();
  }
+};

-  /// Formats `args` according to specifications in `fmt` and writes the
-  /// output to the file.
+}  // namespace detail
+
+// Added {} below to work around default constructor error known to
+// occur in Xcode versions 7.2.1 and 8.2.1.
+constexpr detail::buffer_size buffer_size{};
+
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream {
+ private:
+  FMT_MSC_WARNING(suppress : 4251)
+  detail::file_buffer buffer_;
+
+  ostream(cstring_view path, const detail::ostream_params& params)
+      : buffer_(path, params) {}
+
+ public:
+  ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
+
+  ~ostream();
+
+  void flush() { buffer_.flush(); }
+
+  template <typename... T>
+  friend auto output_file(cstring_view path, T... params) -> ostream;
+
+  void close() { buffer_.close(); }
+
+  /**
+    Formats ``args`` according to specifications in ``fmt`` and writes the
+    output to the file.
+   */
  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(appender(*this), fmt.str, vargs<T...>{{args...}});
+    vformat_to(std::back_inserter(buffer_), fmt,
+               fmt::make_format_args(args...));
  }
 };

 /**
- * Opens a file for writing. Supported parameters passed in `params`:
- *
- * - `<integer>`: Flags passed to [open](
- *   https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
- *   (`file::WRONLY | file::CREATE | file::TRUNC` by default)
- * - `buffer_size=<integer>`: Output buffer size
- *
- * **Example**:
- *
- *     auto out = fmt::output_file("guide.txt");
- *     out.print("Don't {}", "Panic");
+  \rst
+  Opens a file for writing. Supported parameters passed in *params*:
+
+  * ``<integer>``: Flags passed to `open
+    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
+    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
+  * ``buffer_size=<integer>``: Output buffer size
+
+  **Example**::
+
+    auto out = fmt::output_file("guide.txt");
+    out.print("Don't {}", "Panic");
+  \endrst
 */
 template <typename... T>
 inline auto output_file(cstring_view path, T... params) -> ostream {
--- a/3rdparty/fmt/include/fmt/ostream.h
+++ b/3rdparty/fmt/include/fmt/ostream.h
@@ -8,9 +8,7 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_

-#ifndef FMT_MODULE
-#  include <fstream>  // std::filebuf
-#endif
+#include <fstream>  // std::filebuf

 #ifdef _WIN32
 #  ifdef __GLIBCXX__
@@ -20,19 +18,42 @@
 #  include <io.h>
 #endif

-#include "chrono.h"  // formatbuf
-
-#ifdef _MSVC_STL_UPDATE
-#  define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE
-#elif defined(_MSC_VER) && _MSC_VER < 1912  // VS 15.5
-#  define FMT_MSVC_STL_UPDATE _MSVC_LANG
-#else
-#  define FMT_MSVC_STL_UPDATE 0
-#endif
+#include "format.h"

 FMT_BEGIN_NAMESPACE
 namespace detail {

+template <typename Streambuf> class formatbuf : public Streambuf {
+ private:
+  using char_type = typename Streambuf::char_type;
+  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
+  using int_type = typename Streambuf::int_type;
+  using traits_type = typename Streambuf::traits_type;
+
+  buffer<char_type>& buffer_;
+
+ public:
+  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
+
+ protected:
+  // The put area is always empty. This makes the implementation simpler and has
+  // the advantage that the streambuf and the buffer are always in sync and
+  // sputc never writes into uninitialized memory. A disadvantage is that each
+  // call to sputc always results in a (virtual) call to overflow. There is no
+  // disadvantage here for sputn since this always results in a call to xsputn.
+
+  auto overflow(int_type ch) -> int_type override {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<char_type>(ch));
+    return ch;
+  }
+
+  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
 // Generate a unique explicit instantion in every translation unit using a tag
 // type in an anonymous namespace.
 namespace {
@@ -43,18 +64,53 @@ class file_access {
  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
 };

-#if FMT_MSVC_STL_UPDATE
+#if FMT_MSC_VERSION
 template class file_access<file_access_tag, std::filebuf,
                           &std::filebuf::_Myfile>;
 auto get_file(std::filebuf&) -> FILE*;
 #endif

+inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
+    -> bool {
+  FILE* f = nullptr;
+#if FMT_MSC_VERSION && false
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    f = get_file(*buf);
+  else
+    return false;
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+  auto* rdbuf = os.rdbuf();
+  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    f = sfbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    f = fbuf->file();
+  else
+    return false;
+#else
+  ignore_unused(os, data, f);
+#endif
+#ifdef _WIN32
+  if (f) {
+    int fd = _fileno(f);
+    if (_isatty(fd)) {
+      os.flush();
+      return write_console(fd, data);
+    }
+  }
+#endif
+  return false;
+}
+inline auto write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) -> bool {
+  return false;
+}
+
 // Write the content of buf to os.
 // It is a separate function rather than a part of vprint to simplify testing.
 template <typename Char>
 void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  const Char* buf_data = buf.data();
-  using unsigned_streamsize = make_unsigned_t<std::streamsize>;
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
  unsigned_streamsize size = buf.size();
  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
  do {
@@ -65,9 +121,21 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  } while (size != 0);
 }

+template <typename Char, typename T>
+void format_value(buffer<Char>& buf, const T& value) {
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& output = std::basic_ostream<Char>(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  output.imbue(std::locale::classic());  // The default is always unlocalized.
+#endif
+  output << value;
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+}
+
 template <typename T> struct streamed_view {
  const T& value;
 };
+
 }  // namespace detail

 // Formats an object of type T that has an overloaded ostream operator<<.
@@ -75,14 +143,11 @@ template <typename Char>
 struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
  void set_debug_format() = delete;

-  template <typename T, typename Context>
-  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
+  template <typename T, typename OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
+      -> OutputIt {
    auto buffer = basic_memory_buffer<Char>();
-    auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer);
-    auto&& output = std::basic_ostream<Char>(&formatbuf);
-    output.imbue(std::locale::classic());  // The default is always unlocalized.
-    output << value;
-    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+    detail::format_value(buffer, value);
    return formatter<basic_string_view<Char>, Char>::format(
        {buffer.data(), buffer.size()}, ctx);
  }
@@ -93,67 +158,73 @@ using ostream_formatter = basic_ostream_formatter<char>;
 template <typename T, typename Char>
 struct formatter<detail::streamed_view<T>, Char>
    : basic_ostream_formatter<Char> {
-  template <typename Context>
-  auto format(detail::streamed_view<T> view, Context& ctx) const
-      -> decltype(ctx.out()) {
+  template <typename OutputIt>
+  auto format(detail::streamed_view<T> view,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
    return basic_ostream_formatter<Char>::format(view.value, ctx);
  }
 };

 /**
- * Returns a view that formats `value` via an ostream `operator<<`.
- *
- * **Example**:
- *
- *     fmt::print("Current thread id: {}\n",
- *                fmt::streamed(std::this_thread::get_id()));
+  \rst
+  Returns a view that formats `value` via an ostream ``operator<<``.
+
+  **Example**::
+
+    fmt::print("Current thread id: {}\n",
+               fmt::streamed(std::this_thread::get_id()));
+  \endrst
 */
 template <typename T>
 constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
  return {value};
 }

-inline void vprint(std::ostream& os, string_view fmt, format_args args) {
+namespace detail {
+
+inline void vprint_directly(std::ostream& os, string_view format_str,
+                            format_args args) {
  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
-  FILE* f = nullptr;
-#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI
-  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
-    f = detail::get_file(*buf);
-#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
-  auto* rdbuf = os.rdbuf();
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    f = sfbuf->file();
-  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    f = fbuf->file();
-#endif
-#ifdef _WIN32
-  if (f) {
-    int fd = _fileno(f);
-    if (_isatty(fd)) {
-      os.flush();
-      if (detail::write_console(fd, {buffer.data(), buffer.size()})) return;
-    }
-  }
-#endif
-  detail::ignore_unused(f);
+  detail::vformat_to(buffer, format_str, args);
+  detail::write_buffer(os, buffer);
+}
+
+}  // namespace detail
+
+FMT_EXPORT template <typename Char>
+void vprint(std::basic_ostream<Char>& os,
+            basic_string_view<type_identity_t<Char>> format_str,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  auto buffer = basic_memory_buffer<Char>();
+  detail::vformat_to(buffer, format_str, args);
+  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
  detail::write_buffer(os, buffer);
 }

 /**
- * Prints formatted data to the stream `os`.
- *
- * **Example**:
- *
- *     fmt::print(cerr, "Don't {}!", "panic");
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
 */
 FMT_EXPORT template <typename... T>
 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmt::vargs<T...> vargs = {{args...}};
-  if (detail::use_utf8) return vprint(os, fmt.str, vargs);
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt.str, vargs);
-  detail::write_buffer(os, buffer);
+  const auto& vargs = fmt::make_format_args(args...);
+  if (detail::is_utf8())
+    vprint(os, fmt, vargs);
+  else
+    detail::vprint_directly(os, fmt, vargs);
+}
+
+FMT_EXPORT
+template <typename... Args>
+void print(std::wostream& os,
+           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+           Args&&... args) {
+  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
 }

 FMT_EXPORT template <typename... T>
@@ -161,6 +232,14 @@ void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
 }

+FMT_EXPORT
+template <typename... Args>
+void println(std::wostream& os,
+             basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+             Args&&... args) {
+  print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
+}
+
 FMT_END_NAMESPACE

 #endif  // FMT_OSTREAM_H_
--- a/3rdparty/fmt/include/fmt/printf.h
+++ b/3rdparty/fmt/include/fmt/printf.h
@@ -8,10 +8,8 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_

-#ifndef FMT_MODULE
-#  include <algorithm>  // std::max
-#  include <limits>     // std::numeric_limits
-#endif
+#include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits

 #include "format.h"

@@ -24,7 +22,7 @@ template <typename T> struct printf_formatter {

 template <typename Char> class basic_printf_context {
 private:
-  basic_appender<Char> out_;
+  detail::buffer_appender<Char> out_;
  basic_format_args<basic_printf_context> args_;

  static_assert(std::is_same<Char, char>::value ||
@@ -33,53 +31,43 @@ template <typename Char> class basic_printf_context {

 public:
  using char_type = Char;
-  using parse_context_type = parse_context<Char>;
+  using parse_context_type = basic_format_parse_context<Char>;
  template <typename T> using formatter_type = printf_formatter<T>;
-  enum { builtin_types = 1 };

-  /// Constructs a `printf_context` object. References to the arguments are
-  /// stored in the context object so make sure they have appropriate lifetimes.
-  basic_printf_context(basic_appender<Char> out,
+  /**
+    \rst
+    Constructs a ``printf_context`` object. References to the arguments are
+    stored in the context object so make sure they have appropriate lifetimes.
+    \endrst
+   */
+  basic_printf_context(detail::buffer_appender<Char> out,
                       basic_format_args<basic_printf_context> args)
      : out_(out), args_(args) {}

-  auto out() -> basic_appender<Char> { return out_; }
-  void advance_to(basic_appender<Char>) {}
+  auto out() -> detail::buffer_appender<Char> { return out_; }
+  void advance_to(detail::buffer_appender<Char>) {}

  auto locale() -> detail::locale_ref { return {}; }

  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
    return args_.get(id);
  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    detail::error_handler().on_error(message);
+  }
 };

 namespace detail {

-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline auto find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) -> bool {
-  out =
-      static_cast<const char*>(memchr(first, value, to_unsigned(last - first)));
-  return out != nullptr;
-}
-
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
 template <bool IsSigned> struct int_checker {
  template <typename T> static auto fits_in_int(T value) -> bool {
-    unsigned max = to_unsigned(max_value<int>());
+    unsigned max = max_value<int>();
    return value <= max;
  }
-  inline static auto fits_in_int(bool) -> bool { return true; }
+  static auto fits_in_int(bool) -> bool { return true; }
 };

 template <> struct int_checker<true> {
@@ -87,20 +75,20 @@ template <> struct int_checker<true> {
    return value >= (std::numeric_limits<int>::min)() &&
           value <= max_value<int>();
  }
-  inline static auto fits_in_int(int) -> bool { return true; }
+  static auto fits_in_int(int) -> bool { return true; }
 };

 struct printf_precision_handler {
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  auto operator()(T value) -> int {
    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      report_error("number is too big");
+      throw_format_error("number is too big");
    return (std::max)(static_cast<int>(value), 0);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  auto operator()(T) -> int {
-    report_error("precision is not integer");
+    throw_format_error("precision is not integer");
    return 0;
  }
 };
@@ -145,19 +133,25 @@ template <typename T, typename Context> class arg_converter {
    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
    if (const_check(sizeof(target_type) <= sizeof(int))) {
      // Extra casts are used to silence warnings.
-      using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-      if (is_signed)
-        arg_ = static_cast<int>(static_cast<target_type>(value));
-      else
-        arg_ = static_cast<unsigned>(static_cast<unsigned_type>(value));
+      if (is_signed) {
+        auto n = static_cast<int>(static_cast<target_type>(value));
+        arg_ = detail::make_arg<Context>(n);
+      } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
+        arg_ = detail::make_arg<Context>(n);
+      }
    } else {
-      // glibc's printf doesn't sign extend arguments of smaller types:
-      //   std::printf("%lld", -42);  // prints "4294967254"
-      // but we don't have to do the same because it's a UB.
-      if (is_signed)
-        arg_ = static_cast<long long>(value);
-      else
-        arg_ = static_cast<typename make_unsigned_or_bool<U>::type>(value);
+      if (is_signed) {
+        // glibc's printf doesn't sign extend arguments of smaller types:
+        //   std::printf("%lld", -42);  // prints "4294967254"
+        // but we don't have to do the same because it's a UB.
+        auto n = static_cast<long long>(value);
+        arg_ = detail::make_arg<Context>(n);
+      } else {
+        auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
+        arg_ = detail::make_arg<Context>(n);
+      }
    }
  }

@@ -171,7 +165,7 @@ template <typename T, typename Context> class arg_converter {
 // unsigned).
 template <typename T, typename Context, typename Char>
 void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  arg.visit(arg_converter<T, Context>(arg, type));
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
 }

 // Converts an integer argument to char for printf.
@@ -184,7 +178,8 @@ template <typename Context> class char_converter {

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  void operator()(T value) {
-    arg_ = static_cast<typename Context::char_type>(value);
+    auto c = static_cast<typename Context::char_type>(value);
+    arg_ = detail::make_arg<Context>(c);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@@ -200,28 +195,28 @@ template <typename Char> struct get_cstring {

 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-class printf_width_handler {
+template <typename Char> class printf_width_handler {
 private:
-  format_specs& specs_;
+  format_specs<Char>& specs_;

 public:
-  inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+  explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  auto operator()(T value) -> unsigned {
    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
    if (detail::is_negative(value)) {
-      specs_.set_align(align::left);
+      specs_.align = align::left;
      width = 0 - width;
    }
-    unsigned int_max = to_unsigned(max_value<int>());
-    if (width > int_max) report_error("number is too big");
+    unsigned int_max = max_value<int>();
+    if (width > int_max) throw_format_error("number is too big");
    return static_cast<unsigned>(width);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  auto operator()(T) -> unsigned {
-    report_error("width is not integer");
+    throw_format_error("width is not integer");
    return 0;
  }
 };
@@ -229,12 +224,12 @@ class printf_width_handler {
 // Workaround for a bug with the XL compiler when initializing
 // printf_arg_formatter's base class.
 template <typename Char>
-auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
+auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
    -> arg_formatter<Char> {
  return {iter, s, locale_ref()};
 }

-// The `printf` argument formatter.
+// The ``printf`` argument formatter.
 template <typename Char>
 class printf_arg_formatter : public arg_formatter<Char> {
 private:
@@ -245,96 +240,105 @@ class printf_arg_formatter : public arg_formatter<Char> {

  void write_null_pointer(bool is_string = false) {
    auto s = this->specs;
-    s.set_type(presentation_type::none);
-    write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
-  }
-
-  template <typename T> void write(T value) {
-    detail::write<Char>(this->out, value, this->specs, this->locale);
+    s.type = presentation_type::none;
+    write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
  }

 public:
-  printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
+  printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
                       context_type& ctx)
      : base(make_arg_formatter(iter, s)), context_(ctx) {}

-  void operator()(monostate value) { write(value); }
+  void operator()(monostate value) { base::operator()(value); }

  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
  void operator()(T value) {
    // MSVC2013 fails to compile separate overloads for bool and Char so use
    // std::is_same instead.
    if (!std::is_same<T, Char>::value) {
-      write(value);
+      base::operator()(value);
      return;
    }
-    format_specs s = this->specs;
-    if (s.type() != presentation_type::none &&
-        s.type() != presentation_type::chr) {
+    format_specs<Char> fmt_specs = this->specs;
+    if (fmt_specs.type != presentation_type::none &&
+        fmt_specs.type != presentation_type::chr) {
      return (*this)(static_cast<int>(value));
    }
-    s.set_sign(sign::none);
-    s.clear_alt();
-    s.set_fill(' ');  // Ignore '0' flag for char types.
+    fmt_specs.sign = sign::none;
+    fmt_specs.alt = false;
+    fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
    // align::numeric needs to be overwritten here since the '0' flag is
    // ignored for non-numeric types
-    if (s.align() == align::none || s.align() == align::numeric)
-      s.set_align(align::right);
-    detail::write<Char>(this->out, static_cast<Char>(value), s);
+    if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
+      fmt_specs.align = align::right;
+    write<Char>(this->out, static_cast<Char>(value), fmt_specs);
  }

  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
  void operator()(T value) {
-    write(value);
+    base::operator()(value);
  }

+  /** Formats a null-terminated C string. */
  void operator()(const char* value) {
    if (value)
-      write(value);
+      base::operator()(value);
    else
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
+      write_null_pointer(this->specs.type != presentation_type::pointer);
  }

+  /** Formats a null-terminated wide C string. */
  void operator()(const wchar_t* value) {
    if (value)
-      write(value);
+      base::operator()(value);
    else
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
+      write_null_pointer(this->specs.type != presentation_type::pointer);
  }

-  void operator()(basic_string_view<Char> value) { write(value); }
+  void operator()(basic_string_view<Char> value) { base::operator()(value); }

+  /** Formats a pointer. */
  void operator()(const void* value) {
    if (value)
-      write(value);
+      base::operator()(value);
    else
      write_null_pointer();
  }

+  /** Formats an argument of a custom (user-defined) type. */
  void operator()(typename basic_format_arg<context_type>::handle handle) {
-    auto parse_ctx = parse_context<Char>({});
+    auto parse_ctx = basic_format_parse_context<Char>({});
    handle.format(parse_ctx, context_);
  }
 };

 template <typename Char>
-void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
+void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
  for (; it != end; ++it) {
    switch (*it) {
-    case '-': specs.set_align(align::left); break;
-    case '+': specs.set_sign(sign::plus); break;
-    case '0': specs.set_fill('0'); break;
-    case ' ':
-      if (specs.sign() != sign::plus) specs.set_sign(sign::space);
+    case '-':
+      specs.align = align::left;
      break;
-    case '#': specs.set_alt(); break;
-    default:  return;
+    case '+':
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      if (specs.sign != sign::plus) specs.sign = sign::space;
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
    }
  }
 }

 template <typename Char, typename GetArg>
-auto parse_header(const Char*& it, const Char* end, format_specs& specs,
+auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
                  GetArg get_arg) -> int {
  int arg_index = -1;
  Char c = *it;
@@ -346,11 +350,11 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
      ++it;
      arg_index = value != -1 ? value : max_value<int>();
    } else {
-      if (c == '0') specs.set_fill('0');
+      if (c == '0') specs.fill[0] = '0';
      if (value != 0) {
        // Nonzero value means that we parsed width and don't need to
        // parse it or flags again, so return now.
-        if (value == -1) report_error("number is too big");
+        if (value == -1) throw_format_error("number is too big");
        specs.width = value;
        return arg_index;
      }
@@ -361,47 +365,63 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
  if (it != end) {
    if (*it >= '0' && *it <= '9') {
      specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) report_error("number is too big");
+      if (specs.width == -1) throw_format_error("number is too big");
    } else if (*it == '*') {
      ++it;
-      specs.width = static_cast<int>(
-          get_arg(-1).visit(detail::printf_width_handler(specs)));
+      specs.width = static_cast<int>(visit_format_arg(
+          detail::printf_width_handler<Char>(specs), get_arg(-1)));
    }
  }
  return arg_index;
 }

-inline auto parse_printf_presentation_type(char c, type t, bool& upper)
+inline auto parse_printf_presentation_type(char c, type t)
    -> presentation_type {
  using pt = presentation_type;
  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
  switch (c) {
-  case 'd': return in(t, integral_set) ? pt::dec : pt::none;
-  case 'o': return in(t, integral_set) ? pt::oct : pt::none;
-  case 'X': upper = true; FMT_FALLTHROUGH;
-  case 'x': return in(t, integral_set) ? pt::hex : pt::none;
-  case 'E': upper = true; FMT_FALLTHROUGH;
-  case 'e': return in(t, float_set) ? pt::exp : pt::none;
-  case 'F': upper = true; FMT_FALLTHROUGH;
-  case 'f': return in(t, float_set) ? pt::fixed : pt::none;
-  case 'G': upper = true; FMT_FALLTHROUGH;
-  case 'g': return in(t, float_set) ? pt::general : pt::none;
-  case 'A': upper = true; FMT_FALLTHROUGH;
-  case 'a': return in(t, float_set) ? pt::hexfloat : pt::none;
-  case 'c': return in(t, integral_set) ? pt::chr : pt::none;
-  case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none;
-  case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
-  default:  return pt::none;
+  case 'd':
+    return in(t, integral_set) ? pt::dec : pt::none;
+  case 'o':
+    return in(t, integral_set) ? pt::oct : pt::none;
+  case 'x':
+    return in(t, integral_set) ? pt::hex_lower : pt::none;
+  case 'X':
+    return in(t, integral_set) ? pt::hex_upper : pt::none;
+  case 'a':
+    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
+  case 'A':
+    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
+  case 'e':
+    return in(t, float_set) ? pt::exp_lower : pt::none;
+  case 'E':
+    return in(t, float_set) ? pt::exp_upper : pt::none;
+  case 'f':
+    return in(t, float_set) ? pt::fixed_lower : pt::none;
+  case 'F':
+    return in(t, float_set) ? pt::fixed_upper : pt::none;
+  case 'g':
+    return in(t, float_set) ? pt::general_lower : pt::none;
+  case 'G':
+    return in(t, float_set) ? pt::general_upper : pt::none;
+  case 'c':
+    return in(t, integral_set) ? pt::chr : pt::none;
+  case 's':
+    return in(t, string_set | cstring_set) ? pt::string : pt::none;
+  case 'p':
+    return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
+  default:
+    return pt::none;
  }
 }

 template <typename Char, typename Context>
 void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
             basic_format_args<Context> args) {
-  using iterator = basic_appender<Char>;
+  using iterator = buffer_appender<Char>;
  auto out = iterator(buf);
  auto context = basic_printf_context<Char>(out, args);
-  auto parse_ctx = parse_context<Char>(format);
+  auto parse_ctx = basic_format_parse_context<Char>(format);

  // Returns the argument with specified index or, if arg_index is -1, the next
  // argument.
@@ -429,12 +449,12 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
    }
    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));

-    auto specs = format_specs();
-    specs.set_align(align::right);
+    auto specs = format_specs<Char>();
+    specs.align = align::right;

    // Parse argument index, flags and width.
    int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) report_error("argument not found");
+    if (arg_index == 0) throw_format_error("argument not found");

    // Parse precision.
    if (it != end && *it == '.') {
@@ -444,8 +464,8 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
        specs.precision = parse_nonnegative_int(it, end, 0);
      } else if (c == '*') {
        ++it;
-        specs.precision =
-            static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
+        specs.precision = static_cast<int>(
+            visit_format_arg(printf_precision_handler(), get_arg(-1)));
      } else {
        specs.precision = 0;
      }
@@ -454,26 +474,25 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
    auto arg = get_arg(arg_index);
    // For d, i, o, u, x, and X conversion specifiers, if a precision is
    // specified, the '0' flag is ignored
-    if (specs.precision >= 0 && is_integral_type(arg.type())) {
+    if (specs.precision >= 0 && arg.is_integral()) {
      // Ignore '0' for non-numeric types or if '-' present.
-      specs.set_fill(' ');
+      specs.fill[0] = ' ';
    }
    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
-      auto str = arg.visit(get_cstring<Char>());
+      auto str = visit_format_arg(get_cstring<Char>(), arg);
      auto str_end = str + specs.precision;
      auto nul = std::find(str, str_end, Char());
      auto sv = basic_string_view<Char>(
          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
-      arg = sv;
+      arg = make_arg<basic_printf_context<Char>>(sv);
    }
-    if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();
-    if (specs.fill_unit<Char>() == '0') {
-      if (is_arithmetic_type(arg.type()) && specs.align() != align::left) {
-        specs.set_align(align::numeric);
-      } else {
-        // Ignore '0' flag for non-numeric types or if '-' flag is also present.
-        specs.set_fill(' ');
-      }
+    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic() && specs.align != align::left)
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+                              // flag is also present.
    }

    // Parse length and convert the argument to the required type.
@@ -498,39 +517,47 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
        convert_arg<long>(arg, t);
      }
      break;
-    case 'j': convert_arg<intmax_t>(arg, t); break;
-    case 'z': convert_arg<size_t>(arg, t); break;
-    case 't': convert_arg<std::ptrdiff_t>(arg, t); break;
+    case 'j':
+      convert_arg<intmax_t>(arg, t);
+      break;
+    case 'z':
+      convert_arg<size_t>(arg, t);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, t);
+      break;
    case 'L':
      // printf produces garbage when 'L' is omitted for long double, no
      // need to do the same.
      break;
-    default: --it; convert_arg<void>(arg, c);
+    default:
+      --it;
+      convert_arg<void>(arg, c);
    }

    // Parse type.
-    if (it == end) report_error("invalid format string");
+    if (it == end) throw_format_error("invalid format string");
    char type = static_cast<char>(*it++);
-    if (is_integral_type(arg.type())) {
+    if (arg.is_integral()) {
      // Normalize type.
      switch (type) {
      case 'i':
-      case 'u': type = 'd'; break;
+      case 'u':
+        type = 'd';
+        break;
      case 'c':
-        arg.visit(char_converter<basic_printf_context<Char>>(arg));
+        visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
        break;
      }
    }
-    bool upper = false;
-    specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));
-    if (specs.type() == presentation_type::none)
-      report_error("invalid format specifier");
-    if (upper) specs.set_upper();
+    specs.type = parse_printf_presentation_type(type, arg.type());
+    if (specs.type == presentation_type::none)
+      throw_format_error("invalid format specifier");

    start = it;

    // Format argument.
-    arg.visit(printf_arg_formatter<Char>(out, specs, context));
+    visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
  }
  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
@@ -542,44 +569,56 @@ using wprintf_context = basic_printf_context<wchar_t>;
 using printf_args = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;

-/// Constructs an `format_arg_store` object that contains references to
-/// arguments and can be implicitly converted to `printf_args`.
-template <typename Char = char, typename... T>
-inline auto make_printf_args(T&... args)
-    -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
-  return fmt::make_format_args<basic_printf_context<Char>>(args...);
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template <typename... T>
+inline auto make_printf_args(const T&... args)
+    -> format_arg_store<printf_context, T...> {
+  return {args...};
 }

-template <typename Char> struct vprintf_args {
-  using type = basic_format_args<basic_printf_context<Char>>;
-};
+// DEPRECATED!
+template <typename... T>
+inline auto make_wprintf_args(const T&... args)
+    -> format_arg_store<wprintf_context, T...> {
+  return {args...};
+}

 template <typename Char>
-inline auto vsprintf(basic_string_view<Char> fmt,
-                     typename vprintf_args<Char>::type args)
+inline auto vsprintf(
+    basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  auto buf = basic_memory_buffer<Char>();
  detail::vprintf(buf, fmt, args);
-  return {buf.data(), buf.size()};
+  return to_string(buf);
 }

 /**
- * Formats `args` according to specifications in `fmt` and returns the result
- * as as string.
- *
- * **Example**:
- *
- *     std::string message = fmt::sprintf("The answer is %d", 42);
- */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename S, typename... T,
+          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
 inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
  return vsprintf(detail::to_string_view(fmt),
                  fmt::make_format_args<basic_printf_context<Char>>(args...));
 }

 template <typename Char>
-inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
-                     typename vprintf_args<Char>::type args) -> int {
+inline auto vfprintf(
+    std::FILE* f, basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
+    -> int {
  auto buf = basic_memory_buffer<Char>();
  detail::vprintf(buf, fmt, args);
  size_t size = buf.size();
@@ -589,33 +628,36 @@ inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
 }

 /**
- * Formats `args` according to specifications in `fmt` and writes the output
- * to `f`.
- *
- * **Example**:
- *
- *     fmt::fprintf(stderr, "Don't %s!", "panic");
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
 */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
+template <typename S, typename... T, typename Char = char_t<S>>
 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
  return vfprintf(f, detail::to_string_view(fmt),
-                  make_printf_args<Char>(args...));
+                  fmt::make_format_args<basic_printf_context<Char>>(args...));
 }

 template <typename Char>
-FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
-                                   typename vprintf_args<Char>::type args)
+FMT_DEPRECATED inline auto vprintf(
+    basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> int {
  return vfprintf(stdout, fmt, args);
 }

 /**
- * Formats `args` according to specifications in `fmt` and writes the output
- * to `stdout`.
- *
- * **Example**:
- *
- *   fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
 */
 template <typename... T>
 inline auto printf(string_view fmt, const T&... args) -> int {
@@ -624,7 +666,7 @@ inline auto printf(string_view fmt, const T&... args) -> int {
 template <typename... T>
 FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
                                  const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...));
+  return vfprintf(stdout, fmt, make_wprintf_args(args...));
 }

 FMT_END_EXPORT
--- a/3rdparty/fmt/include/fmt/ranges.h
+++ b/3rdparty/fmt/include/fmt/ranges.h
@@ -8,31 +8,67 @@
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_

-#ifndef FMT_MODULE
-#  include <initializer_list>
-#  include <iterator>
-#  include <string>
-#  include <tuple>
-#  include <type_traits>
-#  include <utility>
-#endif
+#include <initializer_list>
+#include <tuple>
+#include <type_traits>

 #include "format.h"

 FMT_BEGIN_NAMESPACE

-FMT_EXPORT
-enum class range_format { disabled, map, set, sequence, string, debug_string };
-
 namespace detail {

+template <typename Range, typename OutputIt>
+auto copy(const Range& range, OutputIt out) -> OutputIt {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
+}
+
+template <typename OutputIt>
+auto copy(const char* str, OutputIt out) -> OutputIt {
+  while (*str) *out++ = *str++;
+  return out;
+}
+
+template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
+  *out++ = ch;
+  return out;
+}
+
+template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
+  *out++ = ch;
+  return out;
+}
+
+// Returns true if T has a std::string-like interface, like std::string_view.
+template <typename T> class is_std_string_like {
+  template <typename U>
+  static auto check(U* p)
+      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+  template <typename> static void check(...);
+
+ public:
+  static constexpr const bool value =
+      is_string<T>::value ||
+      std::is_convertible<T, std_string_view<char>>::value ||
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template <typename Char>
+struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
+
 template <typename T> class is_map {
  template <typename U> static auto check(U*) -> typename U::mapped_type;
  template <typename> static void check(...);

 public:
+#ifdef FMT_FORMAT_MAP_AS_LIST  // DEPRECATED!
+  static constexpr const bool value = false;
+#else
  static constexpr const bool value =
      !std::is_void<decltype(check<T>(nullptr))>::value;
+#endif
 };

 template <typename T> class is_set {
@@ -40,10 +76,26 @@ template <typename T> class is_set {
  template <typename> static void check(...);

 public:
+#ifdef FMT_FORMAT_SET_AS_LIST  // DEPRECATED!
+  static constexpr const bool value = false;
+#else
  static constexpr const bool value =
      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
+#endif
 };

+template <typename... Ts> struct conditional_helper {};
+
+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800
+
+#  define FMT_DECLTYPE_RETURN(val)  \
+    ->decltype(val) { return val; } \
+    static_assert(                  \
+        true, "")  // This makes it so that a semicolon is required after the
+                   // macro, which helps clang-format handle the formatting.
+
 // C array overload
 template <typename T, std::size_t N>
 auto range_begin(const T (&arr)[N]) -> const T* {
@@ -58,21 +110,17 @@ template <typename T, typename Enable = void>
 struct has_member_fn_begin_end_t : std::false_type {};

 template <typename T>
-struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()),
+struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
                                           decltype(std::declval<T>().end())>>
    : std::true_type {};

-// Member function overloads.
+// Member function overload
 template <typename T>
-auto range_begin(T&& rng) -> decltype(static_cast<T&&>(rng).begin()) {
-  return static_cast<T&&>(rng).begin();
-}
+auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
 template <typename T>
-auto range_end(T&& rng) -> decltype(static_cast<T&&>(rng).end()) {
-  return static_cast<T&&>(rng).end();
-}
+auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());

-// ADL overloads. Only participate in overload resolution if member functions
+// ADL overload. Only participates in overload resolution if member functions
 // are not found.
 template <typename T>
 auto range_begin(T&& rng)
@@ -93,30 +141,31 @@ struct has_mutable_begin_end : std::false_type {};

 template <typename T>
 struct has_const_begin_end<
-    T, void_t<decltype(*detail::range_begin(
-                  std::declval<const remove_cvref_t<T>&>())),
-              decltype(detail::range_end(
-                  std::declval<const remove_cvref_t<T>&>()))>>
+    T,
+    void_t<
+        decltype(detail::range_begin(std::declval<const remove_cvref_t<T>&>())),
+        decltype(detail::range_end(std::declval<const remove_cvref_t<T>&>()))>>
    : std::true_type {};

 template <typename T>
 struct has_mutable_begin_end<
-    T, void_t<decltype(*detail::range_begin(std::declval<T&>())),
-              decltype(detail::range_end(std::declval<T&>())),
+    T, void_t<decltype(detail::range_begin(std::declval<T>())),
+              decltype(detail::range_end(std::declval<T>())),
              // the extra int here is because older versions of MSVC don't
              // SFINAE properly unless there are distinct types
              int>> : std::true_type {};

-template <typename T, typename _ = void> struct is_range_ : std::false_type {};
 template <typename T>
 struct is_range_<T, void>
    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
                                    has_mutable_begin_end<T>::value)> {};
+#  undef FMT_DECLTYPE_RETURN
+#endif

 // tuple_size and tuple_element check.
 template <typename T> class is_tuple_like_ {
-  template <typename U, typename V = typename std::remove_cv<U>::type>
-  static auto check(U* p) -> decltype(std::tuple_size<V>::value, 0);
+  template <typename U>
+  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
  template <typename> static void check(...);

 public:
@@ -157,13 +206,12 @@ class is_tuple_formattable_ {
  static constexpr const bool value = false;
 };
 template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
-  template <size_t... Is>
-  static auto all_true(index_sequence<Is...>,
-                       integer_sequence<bool, (Is >= 0)...>) -> std::true_type;
-  static auto all_true(...) -> std::false_type;
-
-  template <size_t... Is>
-  static auto check(index_sequence<Is...>) -> decltype(all_true(
+  template <std::size_t... Is>
+  static auto check2(index_sequence<Is...>,
+                     integer_sequence<bool, (Is == Is)...>) -> std::true_type;
+  static auto check2(...) -> std::false_type;
+  template <std::size_t... Is>
+  static auto check(index_sequence<Is...>) -> decltype(check2(
      index_sequence<Is...>{},
      integer_sequence<bool,
                       (is_formattable<typename std::tuple_element<Is, T>::type,
@@ -244,32 +292,21 @@ FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
 template <typename Formatter>
 FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}

-template <typename T>
-struct range_format_kind_
-    : std::integral_constant<range_format,
-                             std::is_same<uncvref_type<T>, T>::value
-                                 ? range_format::disabled
-                             : is_map<T>::value ? range_format::map
-                             : is_set<T>::value ? range_format::set
-                                                : range_format::sequence> {};
-
-template <range_format K>
-using range_format_constant = std::integral_constant<range_format, K>;
-
 // These are not generic lambdas for compatibility with C++11.
-template <typename Char> struct parse_empty_specs {
+template <typename ParseContext> struct parse_empty_specs {
  template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
    f.parse(ctx);
    detail::maybe_set_debug_format(f, true);
  }
-  parse_context<Char>& ctx;
+  ParseContext& ctx;
 };
 template <typename FormatContext> struct format_tuple_element {
  using char_type = typename FormatContext::char_type;

  template <typename T>
  void operator()(const formatter<T, char_type>& f, const T& v) {
-    if (i > 0) ctx.advance_to(detail::copy<char_type>(separator, ctx.out()));
+    if (i > 0)
+      ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out()));
    ctx.advance_to(f.format(v, ctx));
    ++i;
  }
@@ -318,48 +355,66 @@ struct formatter<Tuple, Char,
    closing_bracket_ = close;
  }

-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it != end && detail::to_ascii(*it) == 'n') {
-      ++it;
-      set_brackets({}, {});
-      set_separator({});
-    }
-    if (it != end && *it != '}') report_error("invalid format specifier");
-    ctx.advance_to(it);
-    detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx});
+    if (it != ctx.end() && *it != '}')
+      FMT_THROW(format_error("invalid format specifier"));
+    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
    return it;
  }

  template <typename FormatContext>
  auto format(const Tuple& value, FormatContext& ctx) const
      -> decltype(ctx.out()) {
-    ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out()));
+    ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
    detail::for_each2(
        formatters_, value,
        detail::format_tuple_element<FormatContext>{0, ctx, separator_});
-    return detail::copy<Char>(closing_bracket_, ctx.out());
+    return detail::copy_str<Char>(closing_bracket_, ctx.out());
  }
 };

 template <typename T, typename Char> struct is_range {
  static constexpr const bool value =
-      detail::is_range_<T>::value && !detail::has_to_string_view<T>::value;
+      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_convertible<T, detail::std_string_view<Char>>::value;
 };

 namespace detail {
+template <typename Context> struct range_mapper {
+  using mapper = arg_mapper<Context>;
+
+  template <typename T,
+            FMT_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value) -> T&& {
+    return static_cast<T&&>(value);
+  }
+  template <typename T,
+            FMT_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value)
+      -> decltype(mapper().map(static_cast<T&&>(value))) {
+    return mapper().map(static_cast<T&&>(value));
+  }
+};

 template <typename Char, typename Element>
-using range_formatter_type = formatter<remove_cvref_t<Element>, Char>;
+using range_formatter_type =
+    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
+                  std::declval<Element>()))>,
+              Char>;

 template <typename R>
 using maybe_const_range =
    conditional_t<has_const_begin_end<R>::value, const R, R>;

+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
 template <typename R, typename Char>
 struct is_formattable_delayed
    : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
+#endif
 }  // namespace detail

 template <typename...> struct conjunction : std::true_type {};
@@ -383,24 +438,6 @@ struct range_formatter<
      detail::string_literal<Char, '['>{};
  basic_string_view<Char> closing_bracket_ =
      detail::string_literal<Char, ']'>{};
-  bool is_debug = false;
-
-  template <typename Output, typename It, typename Sentinel, typename U = T,
-            FMT_ENABLE_IF(std::is_same<U, Char>::value)>
-  auto write_debug_string(Output& out, It it, Sentinel end) const -> Output {
-    auto buf = basic_memory_buffer<Char>();
-    for (; it != end; ++it) buf.push_back(*it);
-    auto specs = format_specs();
-    specs.set_type(presentation_type::debug);
-    return detail::write<Char>(
-        out, basic_string_view<Char>(buf.data(), buf.size()), specs);
-  }
-
-  template <typename Output, typename It, typename Sentinel, typename U = T,
-            FMT_ENABLE_IF(!std::is_same<U, Char>::value)>
-  auto write_debug_string(Output& out, It, Sentinel) const -> Output {
-    return out;
-  }

 public:
  FMT_CONSTEXPR range_formatter() {}
@@ -419,40 +456,21 @@ struct range_formatter<
    closing_bracket_ = close;
  }

-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    auto end = ctx.end();
-    detail::maybe_set_debug_format(underlying_, true);
-    if (it == end) return underlying_.parse(ctx);

-    switch (detail::to_ascii(*it)) {
-    case 'n':
+    if (it != end && *it == 'n') {
      set_brackets({}, {});
      ++it;
-      break;
-    case '?':
-      is_debug = true;
-      set_brackets({}, {});
-      ++it;
-      if (it == end || *it != 's') report_error("invalid format specifier");
-      FMT_FALLTHROUGH;
-    case 's':
-      if (!std::is_same<T, Char>::value)
-        report_error("invalid format specifier");
-      if (!is_debug) {
-        set_brackets(detail::string_literal<Char, '"'>{},
-                     detail::string_literal<Char, '"'>{});
-        set_separator({});
-        detail::maybe_set_debug_format(underlying_, false);
-      }
-      ++it;
-      return it;
    }

    if (it != end && *it != '}') {
-      if (*it != ':') report_error("invalid format specifier");
-      detail::maybe_set_debug_format(underlying_, false);
+      if (*it != ':') FMT_THROW(format_error("invalid format specifier"));
      ++it;
+    } else {
+      detail::maybe_set_debug_format(underlying_, true);
    }

    ctx.advance_to(it);
@@ -461,26 +479,80 @@ struct range_formatter<

  template <typename R, typename FormatContext>
  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
+    detail::range_mapper<buffer_context<Char>> mapper;
    auto out = ctx.out();
+    out = detail::copy_str<Char>(opening_bracket_, out);
+    int i = 0;
    auto it = detail::range_begin(range);
    auto end = detail::range_end(range);
-    if (is_debug) return write_debug_string(out, std::move(it), end);
-
-    out = detail::copy<Char>(opening_bracket_, out);
-    int i = 0;
    for (; it != end; ++it) {
-      if (i > 0) out = detail::copy<Char>(separator_, out);
+      if (i > 0) out = detail::copy_str<Char>(separator_, out);
      ctx.advance_to(out);
-      auto&& item = *it;  // Need an lvalue
-      out = underlying_.format(item, ctx);
+      auto&& item = *it;
+      out = underlying_.format(mapper.map(item), ctx);
      ++i;
    }
-    out = detail::copy<Char>(closing_bracket_, out);
+    out = detail::copy_str<Char>(closing_bracket_, out);
    return out;
  }
 };

-FMT_EXPORT
+enum class range_format { disabled, map, set, sequence, string, debug_string };
+
+namespace detail {
+template <typename T>
+struct range_format_kind_
+    : std::integral_constant<range_format,
+                             std::is_same<uncvref_type<T>, T>::value
+                                 ? range_format::disabled
+                             : is_map<T>::value ? range_format::map
+                             : is_set<T>::value ? range_format::set
+                                                : range_format::sequence> {};
+
+template <range_format K, typename R, typename Char, typename Enable = void>
+struct range_default_formatter;
+
+template <range_format K>
+using range_format_constant = std::integral_constant<range_format, K>;
+
+template <range_format K, typename R, typename Char>
+struct range_default_formatter<
+    K, R, Char,
+    enable_if_t<(K == range_format::sequence || K == range_format::map ||
+                 K == range_format::set)>> {
+  using range_type = detail::maybe_const_range<R>;
+  range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
+
+  FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::set>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
+  }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::map>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
+    underlying_.underlying().set_brackets({}, {});
+    underlying_.underlying().set_separator(
+        detail::string_literal<Char, ':', ' '>{});
+  }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return underlying_.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  auto format(range_type& range, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return underlying_.format(range, ctx);
+  }
+};
+}  // namespace detail
+
 template <typename T, typename Char, typename Enable = void>
 struct range_format_kind
    : conditional_t<
@@ -490,189 +562,23 @@ struct range_format_kind
 template <typename R, typename Char>
 struct formatter<
    R, Char,
-    enable_if_t<conjunction<
-        bool_constant<
-            range_format_kind<R, Char>::value != range_format::disabled &&
-            range_format_kind<R, Char>::value != range_format::map &&
-            range_format_kind<R, Char>::value != range_format::string &&
-            range_format_kind<R, Char>::value != range_format::debug_string>,
-        detail::is_formattable_delayed<R, Char>>::value>> {
- private:
-  using range_type = detail::maybe_const_range<R>;
-  range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_;
-
- public:
-  using nonlocking = void;
-
-  FMT_CONSTEXPR formatter() {
-    if (detail::const_check(range_format_kind<R, Char>::value !=
-                            range_format::set))
-      return;
-    range_formatter_.set_brackets(detail::string_literal<Char, '{'>{},
-                                  detail::string_literal<Char, '}'>{});
-  }
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return range_formatter_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(range_type& range, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return range_formatter_.format(range, ctx);
-  }
-};
-
-// A map formatter.
-template <typename R, typename Char>
-struct formatter<
-    R, Char,
-    enable_if_t<range_format_kind<R, Char>::value == range_format::map>> {
- private:
-  using map_type = detail::maybe_const_range<R>;
-  using element_type = detail::uncvref_type<map_type>;
-
-  decltype(detail::tuple::get_formatters<element_type, Char>(
-      detail::tuple_index_sequence<element_type>())) formatters_;
-  bool no_delimiters_ = false;
-
- public:
-  FMT_CONSTEXPR formatter() {}
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it != end) {
-      if (detail::to_ascii(*it) == 'n') {
-        no_delimiters_ = true;
-        ++it;
-      }
-      if (it != end && *it != '}') {
-        if (*it != ':') report_error("invalid format specifier");
-        ++it;
-      }
-      ctx.advance_to(it);
-    }
-    detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx});
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    basic_string_view<Char> open = detail::string_literal<Char, '{'>{};
-    if (!no_delimiters_) out = detail::copy<Char>(open, out);
-    int i = 0;
-    basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{};
-    for (auto&& value : map) {
-      if (i > 0) out = detail::copy<Char>(sep, out);
-      ctx.advance_to(out);
-      detail::for_each2(formatters_, value,
-                        detail::format_tuple_element<FormatContext>{
-                            0, ctx, detail::string_literal<Char, ':', ' '>{}});
-      ++i;
-    }
-    basic_string_view<Char> close = detail::string_literal<Char, '}'>{};
-    if (!no_delimiters_) out = detail::copy<Char>(close, out);
-    return out;
-  }
-};
-
-// A (debug_)string formatter.
-template <typename R, typename Char>
-struct formatter<
-    R, Char,
-    enable_if_t<range_format_kind<R, Char>::value == range_format::string ||
-                range_format_kind<R, Char>::value ==
-                    range_format::debug_string>> {
- private:
-  using range_type = detail::maybe_const_range<R>;
-  using string_type =
-      conditional_t<std::is_constructible<
-                        detail::std_string_view<Char>,
-                        decltype(detail::range_begin(std::declval<R>())),
-                        decltype(detail::range_end(std::declval<R>()))>::value,
-                    detail::std_string_view<Char>, std::basic_string<Char>>;
-
-  formatter<string_type, Char> underlying_;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(range_type& range, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    if (detail::const_check(range_format_kind<R, Char>::value ==
-                            range_format::debug_string))
-      *out++ = '"';
-    out = underlying_.format(
-        string_type{detail::range_begin(range), detail::range_end(range)}, ctx);
-    if (detail::const_check(range_format_kind<R, Char>::value ==
-                            range_format::debug_string))
-      *out++ = '"';
-    return out;
-  }
-};
-
-template <typename It, typename Sentinel, typename Char = char>
-struct join_view : detail::view {
-  It begin;
-  Sentinel end;
-  basic_string_view<Char> sep;
-
-  join_view(It b, Sentinel e, basic_string_view<Char> s)
-      : begin(std::move(b)), end(e), sep(s) {}
-};
-
-template <typename It, typename Sentinel, typename Char>
-struct formatter<join_view<It, Sentinel, Char>, Char> {
- private:
-  using value_type =
-#ifdef __cpp_lib_ranges
-      std::iter_value_t<It>;
-#else
-      typename std::iterator_traits<It>::value_type;
+    enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value !=
+                                          range_format::disabled>
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+                            ,
+                            detail::is_formattable_delayed<R, Char>
 #endif
-  formatter<remove_cvref_t<value_type>, Char> value_formatter_;
-
-  using view = conditional_t<std::is_copy_constructible<It>::value,
-                             const join_view<It, Sentinel, Char>,
-                             join_view<It, Sentinel, Char>>;
-
- public:
-  using nonlocking = void;
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return value_formatter_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(view& value, FormatContext& ctx) const -> decltype(ctx.out()) {
-    using iter =
-        conditional_t<std::is_copy_constructible<view>::value, It, It&>;
-    iter it = value.begin;
-    auto out = ctx.out();
-    if (it == value.end) return out;
-    out = value_formatter_.format(*it, ctx);
-    ++it;
-    while (it != value.end) {
-      out = detail::copy<Char>(value.sep.begin(), value.sep.end(), out);
-      ctx.advance_to(out);
-      out = value_formatter_.format(*it, ctx);
-      ++it;
-    }
-    return out;
-  }
+                            >::value>>
+    : detail::range_default_formatter<range_format_kind<R, Char>::value, R,
+                                      Char> {
 };

-template <typename Char, typename Tuple> struct tuple_join_view : detail::view {
-  const Tuple& tuple;
+template <typename Char, typename... T> struct tuple_join_view : detail::view {
+  const std::tuple<T...>& tuple;
  basic_string_view<Char> sep;

-  tuple_join_view(const Tuple& t, basic_string_view<Char> s)
+  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
      : tuple(t), sep{s} {}
 };

@@ -683,64 +589,65 @@ template <typename Char, typename Tuple> struct tuple_join_view : detail::view {
 #  define FMT_TUPLE_JOIN_SPECIFIERS 0
 #endif

-template <typename Char, typename Tuple>
-struct formatter<tuple_join_view<Char, Tuple>, Char,
-                 enable_if_t<is_tuple_like<Tuple>::value>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return do_parse(ctx, std::tuple_size<Tuple>());
+template <typename Char, typename... T>
+struct formatter<tuple_join_view<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
  }

  template <typename FormatContext>
-  auto format(const tuple_join_view<Char, Tuple>& value,
+  auto format(const tuple_join_view<Char, T...>& value,
              FormatContext& ctx) const -> typename FormatContext::iterator {
-    return do_format(value, ctx, std::tuple_size<Tuple>());
+    return do_format(value, ctx,
+                     std::integral_constant<size_t, sizeof...(T)>());
  }

 private:
-  decltype(detail::tuple::get_formatters<Tuple, Char>(
-      detail::tuple_index_sequence<Tuple>())) formatters_;
+  std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;

-  FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx,
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
                              std::integral_constant<size_t, 0>)
-      -> const Char* {
+      -> decltype(ctx.begin()) {
    return ctx.begin();
  }

-  template <size_t N>
-  FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx,
+  template <typename ParseContext, size_t N>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
                              std::integral_constant<size_t, N>)
-      -> const Char* {
+      -> decltype(ctx.begin()) {
    auto end = ctx.begin();
 #if FMT_TUPLE_JOIN_SPECIFIERS
-    end = std::get<std::tuple_size<Tuple>::value - N>(formatters_).parse(ctx);
+    end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
    if (N > 1) {
      auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
      if (end != end1)
-        report_error("incompatible format specs for tuple elements");
+        FMT_THROW(format_error("incompatible format specs for tuple elements"));
    }
 #endif
    return end;
  }

  template <typename FormatContext>
-  auto do_format(const tuple_join_view<Char, Tuple>&, FormatContext& ctx,
+  auto do_format(const tuple_join_view<Char, T...>&, FormatContext& ctx,
                 std::integral_constant<size_t, 0>) const ->
      typename FormatContext::iterator {
    return ctx.out();
  }

  template <typename FormatContext, size_t N>
-  auto do_format(const tuple_join_view<Char, Tuple>& value, FormatContext& ctx,
+  auto do_format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
                 std::integral_constant<size_t, N>) const ->
      typename FormatContext::iterator {
-    using std::get;
-    auto out =
-        std::get<std::tuple_size<Tuple>::value - N>(formatters_)
-            .format(get<std::tuple_size<Tuple>::value - N>(value.tuple), ctx);
-    if (N <= 1) return out;
-    out = detail::copy<Char>(value.sep, out);
-    ctx.advance_to(out);
-    return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
+    auto out = std::get<sizeof...(T) - N>(formatters_)
+                   .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
+    if (N > 1) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
+    }
+    return out;
  }
 };

@@ -784,57 +691,40 @@ struct formatter<

 FMT_BEGIN_EXPORT

-/// Returns a view that formats the iterator range `[begin, end)` with elements
-/// separated by `sep`.
-template <typename It, typename Sentinel>
-auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
-  return {std::move(begin), end, sep};
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
+    -> tuple_join_view<char, T...> {
+  return {tuple, sep};
 }

-/**
- * Returns a view that formats `range` with elements separated by `sep`.
- *
- * **Example**:
- *
- *     auto v = std::vector<int>{1, 2, 3};
- *     fmt::print("{}", fmt::join(v, ", "));
- *     // Output: 1, 2, 3
- *
- * `fmt::join` applies passed format specifiers to the range elements:
- *
- *     fmt::print("{:02}", fmt::join(v, ", "));
- *     // Output: 01, 02, 03
- */
-template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
-auto join(Range&& r, string_view sep)
-    -> join_view<decltype(detail::range_begin(r)),
-                 decltype(detail::range_end(r))> {
-  return {detail::range_begin(r), detail::range_end(r), sep};
-}
-
-/**
- * Returns an object that formats `std::tuple` with elements separated by `sep`.
- *
- * **Example**:
- *
- *     auto t = std::tuple<int, char>{1, 'a'};
- *     fmt::print("{}", fmt::join(t, ", "));
- *     // Output: 1, a
- */
-template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
-FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep)
-    -> tuple_join_view<char, Tuple> {
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
+                        basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, T...> {
  return {tuple, sep};
 }

 /**
- * Returns an object that formats `std::initializer_list` with elements
- * separated by `sep`.
- *
- * **Example**:
- *
- *     fmt::print("{}", fmt::join({1, 2, 3}, ", "));
- *     // Output: "1, 2, 3"
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
+
+  **Example**::
+
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
 */
 template <typename T>
 auto join(std::initializer_list<T> list, string_view sep)
--- a/3rdparty/fmt/include/fmt/std.h
+++ b/3rdparty/fmt/include/fmt/std.h
@@ -8,49 +8,39 @@
 #ifndef FMT_STD_H_
 #define FMT_STD_H_

+#include <atomic>
+#include <bitset>
+#include <cstdlib>
+#include <exception>
+#include <memory>
+#include <thread>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
 #include "format.h"
 #include "ostream.h"

-#ifndef FMT_MODULE
-#  include <atomic>
-#  include <bitset>
-#  include <complex>
-#  include <cstdlib>
-#  include <exception>
-#  include <functional>
-#  include <memory>
-#  include <thread>
-#  include <type_traits>
-#  include <typeinfo>
-#  include <utility>
-#  include <vector>
-
-// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
-#  if FMT_CPLUSPLUS >= 201703L
-#    if FMT_HAS_INCLUDE(<filesystem>) && \
-        (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0)
-#      include <filesystem>
-#    endif
-#    if FMT_HAS_INCLUDE(<variant>)
-#      include <variant>
-#    endif
-#    if FMT_HAS_INCLUDE(<optional>)
-#      include <optional>
-#    endif
-#  endif
-// Use > instead of >= in the version check because <source_location> may be
-// available after C++17 but before C++20 is marked as implemented.
-#  if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
-#    include <source_location>
-#  endif
-#  if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>)
-#    include <expected>
-#  endif
-#endif  // FMT_MODULE
-
 #if FMT_HAS_INCLUDE(<version>)
 #  include <version>
 #endif
+// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
+#if FMT_CPLUSPLUS >= 201703L
+#  if FMT_HAS_INCLUDE(<filesystem>)
+#    include <filesystem>
+#  endif
+#  if FMT_HAS_INCLUDE(<variant>)
+#    include <variant>
+#  endif
+#  if FMT_HAS_INCLUDE(<optional>)
+#    include <optional>
+#  endif
+#endif
+
+#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
+#  include <source_location>
+#endif

 // GCC 4 does not support FMT_HAS_INCLUDE.
 #if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
@@ -62,6 +52,17 @@
 #  endif
 #endif

+// Check if typeid is available.
+#ifndef FMT_USE_TYPEID
+// __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
+#  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
+      defined(__INTEL_RTTI__) || defined(__RTTI)
+#    define FMT_USE_TYPEID 1
+#  else
+#    define FMT_USE_TYPEID 0
+#  endif
+#endif
+
 // For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
 #ifndef FMT_CPP_LIB_FILESYSTEM
 #  ifdef __cpp_lib_filesystem
@@ -116,7 +117,7 @@ void write_escaped_path(basic_memory_buffer<Char>& quoted,
 FMT_EXPORT
 template <typename Char> struct formatter<std::filesystem::path, Char> {
 private:
-  format_specs specs_;
+  format_specs<Char> specs_;
  detail::arg_ref<Char> width_ref_;
  bool debug_ = false;
  char path_type_ = 0;
@@ -124,33 +125,33 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
 public:
  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }

-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
    auto it = ctx.begin(), end = ctx.end();
    if (it == end) return it;

    it = detail::parse_align(it, end, specs_);
    if (it == end) return it;

-    Char c = *it;
-    if ((c >= '0' && c <= '9') || c == '{')
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
+    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
    if (it != end && *it == '?') {
      debug_ = true;
      ++it;
    }
-    if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);
+    if (it != end && (*it == 'g')) path_type_ = *it++;
    return it;
  }

  template <typename FormatContext>
  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
    auto specs = specs_;
-    auto path_string =
-        !path_type_ ? p.native()
-                    : p.generic_string<std::filesystem::path::value_type>();
+#  ifdef _WIN32
+    auto path_string = !path_type_ ? p.native() : p.generic_wstring();
+#  else
+    auto path_string = !path_type_ ? p.native() : p.generic_string();
+#  endif

-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
+                                                       ctx);
    if (!debug_) {
      auto s = detail::get_path_string<Char>(p, path_string);
      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
@@ -162,30 +163,13 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
                         specs);
  }
 };
-
-class path : public std::filesystem::path {
- public:
-  auto display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{}"), base);
-  }
-  auto system_string() const -> std::string { return string(); }
-
-  auto generic_display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{:g}"), base);
-  }
-  auto generic_system_string() const -> std::string { return generic_string(); }
-};
-
 FMT_END_NAMESPACE
 #endif  // FMT_CPP_LIB_FILESYSTEM

 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
 template <std::size_t N, typename Char>
-struct formatter<std::bitset<N>, Char>
-    : nested_formatter<basic_string_view<Char>, Char> {
+struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
 private:
  // Functor because C++11 doesn't support generic lambdas.
  struct writer {
@@ -205,7 +189,7 @@ struct formatter<std::bitset<N>, Char>
  template <typename FormatContext>
  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
      -> decltype(ctx.out()) {
-    return this->write_padded(ctx, writer{bs});
+    return write_padded(ctx, writer{bs});
  }
 };

@@ -238,7 +222,7 @@ struct formatter<std::optional<T>, Char,
  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}

 public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
    maybe_set_debug_format(underlying_, true);
    return underlying_.parse(ctx);
  }
@@ -258,62 +242,13 @@ struct formatter<std::optional<T>, Char,
 FMT_END_NAMESPACE
 #endif  // __cpp_lib_optional

-#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename Char, typename OutputIt, typename T>
-auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
-  if constexpr (has_to_string_view<T>::value)
-    return write_escaped_string<Char>(out, detail::to_string_view(v));
-  if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
-  return write<Char>(out, v);
-}
-
-}  // namespace detail
-
-FMT_END_NAMESPACE
-#endif
-
-#ifdef __cpp_lib_expected
-FMT_BEGIN_NAMESPACE
-
-FMT_EXPORT
-template <typename T, typename E, typename Char>
-struct formatter<std::expected<T, E>, Char,
-                 std::enable_if_t<(std::is_void<T>::value ||
-                                   is_formattable<T, Char>::value) &&
-                                  is_formattable<E, Char>::value>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::expected<T, E>& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-
-    if (value.has_value()) {
-      out = detail::write<Char>(out, "expected(");
-      if constexpr (!std::is_void<T>::value)
-        out = detail::write_escaped_alternative<Char>(out, *value);
-    } else {
-      out = detail::write<Char>(out, "unexpected(");
-      out = detail::write_escaped_alternative<Char>(out, value.error());
-    }
-    *out++ = ')';
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_expected
-
 #ifdef __cpp_lib_source_location
 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
 template <> struct formatter<std::source_location> {
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); }
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+    return ctx.begin();
+  }

  template <typename FormatContext>
  auto format(const std::source_location& loc, FormatContext& ctx) const
@@ -356,6 +291,16 @@ template <typename T, typename C> class is_variant_formattable_ {
      decltype(check(variant_index_sequence<T>{}))::value;
 };

+template <typename Char, typename OutputIt, typename T>
+auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
+  if constexpr (is_string<T>::value)
+    return write_escaped_string<Char>(out, detail::to_string_view(v));
+  else if constexpr (std::is_same_v<T, Char>)
+    return write_escaped_char(out, v);
+  else
+    return write<Char>(out, v);
+}
+
 }  // namespace detail

 template <typename T> struct is_variant_like {
@@ -369,7 +314,8 @@ template <typename T, typename C> struct is_variant_formattable {

 FMT_EXPORT
 template <typename Char> struct formatter<std::monostate, Char> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

@@ -386,7 +332,8 @@ struct formatter<
    Variant, Char,
    std::enable_if_t<std::conjunction_v<
        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

@@ -399,7 +346,7 @@ struct formatter<
    FMT_TRY {
      std::visit(
          [&](const auto& v) {
-            out = detail::write_escaped_alternative<Char>(out, v);
+            out = detail::write_variant_alternative<Char>(out, v);
          },
          value);
    }
@@ -415,127 +362,22 @@ FMT_END_NAMESPACE

 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
-template <> struct formatter<std::error_code> {
- private:
-  format_specs specs_;
-  detail::arg_ref<char> width_ref_;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    char c = *it;
-    if ((c >= '0' && c <= '9') || c == '{')
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
-    return it;
-  }
-
-  template <typename FormatContext>
-  FMT_CONSTEXPR20 auto format(const std::error_code& ec,
-                              FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto specs = specs_;
-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
-    memory_buffer buf;
-    buf.append(string_view(ec.category().name()));
-    buf.push_back(':');
-    detail::write<char>(appender(buf), ec.value());
-    return detail::write<char>(ctx.out(), string_view(buf.data(), buf.size()),
-                               specs);
-  }
-};
-
-#if FMT_USE_RTTI
-namespace detail {
-
-template <typename Char, typename OutputIt>
-auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
-#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
-  int status = 0;
-  std::size_t size = 0;
-  std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
-      abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
-
-  string_view demangled_name_view;
-  if (demangled_name_ptr) {
-    demangled_name_view = demangled_name_ptr.get();
-
-    // Normalization of stdlib inline namespace names.
-    // libc++ inline namespaces.
-    //  std::__1::*       -> std::*
-    //  std::__1::__fs::* -> std::*
-    // libstdc++ inline namespaces.
-    //  std::__cxx11::*             -> std::*
-    //  std::filesystem::__cxx11::* -> std::filesystem::*
-    if (demangled_name_view.starts_with("std::")) {
-      char* begin = demangled_name_ptr.get();
-      char* to = begin + 5;  // std::
-      for (char *from = to, *end = begin + demangled_name_view.size();
-           from < end;) {
-        // This is safe, because demangled_name is NUL-terminated.
-        if (from[0] == '_' && from[1] == '_') {
-          char* next = from + 1;
-          while (next < end && *next != ':') next++;
-          if (next[0] == ':' && next[1] == ':') {
-            from = next + 2;
-            continue;
-          }
-        }
-        *to++ = *from++;
-      }
-      demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-    }
-  } else {
-    demangled_name_view = string_view(ti.name());
-  }
-  return detail::write_bytes<Char>(out, demangled_name_view);
-#  elif FMT_MSC_VERSION
-  const string_view demangled_name(ti.name());
-  for (std::size_t i = 0; i < demangled_name.size(); ++i) {
-    auto sub = demangled_name;
-    sub.remove_prefix(i);
-    if (sub.starts_with("enum ")) {
-      i += 4;
-      continue;
-    }
-    if (sub.starts_with("class ") || sub.starts_with("union ")) {
-      i += 5;
-      continue;
-    }
-    if (sub.starts_with("struct ")) {
-      i += 6;
-      continue;
-    }
-    if (*sub.begin() != ' ') *out++ = *sub.begin();
-  }
-  return out;
-#  else
-  return detail::write_bytes<Char>(out, string_view(ti.name()));
-#  endif
-}
-
-}  // namespace detail
-
-FMT_EXPORT
-template <typename Char>
-struct formatter<std::type_info, Char  // DEPRECATED! Mixing code unit types.
-                 > {
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

-  template <typename Context>
-  auto format(const std::type_info& ti, Context& ctx) const
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
      -> decltype(ctx.out()) {
-    return detail::write_demangled_name<Char>(ctx.out(), ti);
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
  }
 };
-#endif

 FMT_EXPORT
 template <typename T, typename Char>
@@ -546,29 +388,81 @@ struct formatter<
  bool with_typename_ = false;

 public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    auto end = ctx.end();
    if (it == end || *it == '}') return it;
    if (*it == 't') {
      ++it;
-      with_typename_ = FMT_USE_RTTI != 0;
+      with_typename_ = FMT_USE_TYPEID != 0;
    }
    return it;
  }

-  template <typename Context>
-  auto format(const std::exception& ex, Context& ctx) const
-      -> decltype(ctx.out()) {
+  template <typename OutputIt>
+  auto format(const std::exception& ex,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
+    format_specs<Char> spec;
    auto out = ctx.out();
-#if FMT_USE_RTTI
-    if (with_typename_) {
-      out = detail::write_demangled_name<Char>(out, typeid(ex));
-      *out++ = ':';
-      *out++ = ' ';
+    if (!with_typename_)
+      return detail::write_bytes(out, string_view(ex.what()), spec);
+
+#if FMT_USE_TYPEID
+    const std::type_info& ti = typeid(ex);
+#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
+    int status = 0;
+    std::size_t size = 0;
+    std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
+        abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
+
+    string_view demangled_name_view;
+    if (demangled_name_ptr) {
+      demangled_name_view = demangled_name_ptr.get();
+
+      // Normalization of stdlib inline namespace names.
+      // libc++ inline namespaces.
+      //  std::__1::*       -> std::*
+      //  std::__1::__fs::* -> std::*
+      // libstdc++ inline namespaces.
+      //  std::__cxx11::*             -> std::*
+      //  std::filesystem::__cxx11::* -> std::filesystem::*
+      if (demangled_name_view.starts_with("std::")) {
+        char* begin = demangled_name_ptr.get();
+        char* to = begin + 5;  // std::
+        for (char *from = to, *end = begin + demangled_name_view.size();
+             from < end;) {
+          // This is safe, because demangled_name is NUL-terminated.
+          if (from[0] == '_' && from[1] == '_') {
+            char* next = from + 1;
+            while (next < end && *next != ':') next++;
+            if (next[0] == ':' && next[1] == ':') {
+              from = next + 2;
+              continue;
+            }
+          }
+          *to++ = *from++;
+        }
+        demangled_name_view = {begin, detail::to_unsigned(to - begin)};
+      }
+    } else {
+      demangled_name_view = string_view(ti.name());
    }
+    out = detail::write_bytes(out, demangled_name_view, spec);
+#  elif FMT_MSC_VERSION
+    string_view demangled_name_view(ti.name());
+    if (demangled_name_view.starts_with("class "))
+      demangled_name_view.remove_prefix(6);
+    else if (demangled_name_view.starts_with("struct "))
+      demangled_name_view.remove_prefix(7);
+    out = detail::write_bytes(out, demangled_name_view, spec);
+#  else
+    out = detail::write_bytes(out, string_view(ti.name()), spec);
+#  endif
+    *out++ = ':';
+    *out++ = ' ';
+    return detail::write_bytes(out, string_view(ex.what()), spec);
 #endif
-    return detail::write_bytes<Char>(out, string_view(ex.what()));
  }
 };

@@ -615,14 +509,6 @@ struct formatter<BitRef, Char,
  }
 };

-template <typename T, typename Deleter>
-auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
-  return p.get();
-}
-template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
-  return p.get();
-}
-
 FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<std::atomic<T>, Char,
@@ -647,80 +533,5 @@ struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
 };
 #endif  // __cpp_lib_atomic_flag_test

-FMT_EXPORT
-template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
- private:
-  detail::dynamic_format_specs<Char> specs_;
-
-  template <typename FormatContext, typename OutputIt>
-  FMT_CONSTEXPR auto do_format(const std::complex<T>& c,
-                               detail::dynamic_format_specs<Char>& specs,
-                               FormatContext& ctx, OutputIt out) const
-      -> OutputIt {
-    if (c.real() != 0) {
-      *out++ = Char('(');
-      out = detail::write<Char>(out, c.real(), specs, ctx.locale());
-      specs.set_sign(sign::plus);
-      out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-      if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-      *out++ = Char('i');
-      *out++ = Char(')');
-      return out;
-    }
-    out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-    if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-    *out++ = Char('i');
-    return out;
-  }
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
-    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
-                              detail::type_constant<T, Char>::value);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::complex<T>& c, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto specs = specs_;
-    if (specs.dynamic()) {
-      detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,
-                                  specs.width_ref, ctx);
-      detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
-                                  specs.precision_ref, ctx);
-    }
-
-    if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
-    auto buf = basic_memory_buffer<Char>();
-
-    auto outer_specs = format_specs();
-    outer_specs.width = specs.width;
-    outer_specs.copy_fill_from(specs);
-    outer_specs.set_align(specs.align());
-
-    specs.width = 0;
-    specs.set_fill({});
-    specs.set_align(align::none);
-
-    do_format(c, specs, ctx, basic_appender<Char>(buf));
-    return detail::write<Char>(ctx.out(),
-                               basic_string_view<Char>(buf.data(), buf.size()),
-                               outer_specs);
-  }
-};
-
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<std::reference_wrapper<T>, Char,
-                 enable_if_t<is_formattable<remove_cvref_t<T>, Char>::value>>
-    : formatter<remove_cvref_t<T>, Char> {
-  template <typename FormatContext>
-  auto format(std::reference_wrapper<T> ref, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<remove_cvref_t<T>, Char>::format(ref.get(), ctx);
-  }
-};
-
 FMT_END_NAMESPACE
 #endif  // FMT_STD_H_
--- a/3rdparty/fmt/include/fmt/xchar.h
+++ b/3rdparty/fmt/include/fmt/xchar.h
@@ -8,16 +8,12 @@
 #ifndef FMT_XCHAR_H_
 #define FMT_XCHAR_H_

-#include "color.h"
-#include "format.h"
-#include "ostream.h"
-#include "ranges.h"
+#include <cwchar>

-#ifndef FMT_MODULE
-#  include <cwchar>
-#  if FMT_USE_LOCALE
-#    include <locale>
-#  endif
+#include "format.h"
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#  include <locale>
 #endif

 FMT_BEGIN_NAMESPACE
@@ -26,26 +22,10 @@ namespace detail {
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;

-template <typename S, typename = void> struct format_string_char {};
-
-template <typename S>
-struct format_string_char<
-    S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> {
-  using type = char_t<S>;
-};
-
-template <typename S>
-struct format_string_char<
-    S, enable_if_t<std::is_base_of<detail::compile_string, S>::value>> {
-  using type = typename S::char_type;
-};
-
-template <typename S>
-using format_string_char_t = typename format_string_char<S>::type;
-
-inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
-                      const format_specs& specs, locale_ref loc) -> bool {
-#if FMT_USE_LOCALE
+inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
+                      loc_value value, const format_specs<wchar_t>& specs,
+                      locale_ref loc) -> bool {
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
  auto& numpunct =
      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
  auto separator = std::wstring();
@@ -60,79 +40,42 @@ inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
 FMT_BEGIN_EXPORT

 using wstring_view = basic_string_view<wchar_t>;
-using wformat_parse_context = parse_context<wchar_t>;
-using wformat_context = buffered_context<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
 using wformat_args = basic_format_args<wformat_context>;
 using wmemory_buffer = basic_memory_buffer<wchar_t>;

-template <typename Char, typename... T> struct basic_fstring {
- private:
-  basic_string_view<Char> str_;
-
-  static constexpr int num_static_named_args =
-      detail::count_static_named_args<T...>();
-
-  using checker = detail::format_string_checker<
-      Char, static_cast<int>(sizeof...(T)), num_static_named_args,
-      num_static_named_args != detail::count_named_args<T...>()>;
-
-  using arg_pack = detail::arg_pack<T...>;
-
- public:
-  using t = basic_fstring;
-
-  template <typename S,
-            FMT_ENABLE_IF(
-                std::is_convertible<const S&, basic_string_view<Char>>::value)>
-  FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) {
-    if (FMT_USE_CONSTEVAL)
-      detail::parse_format_string<Char>(s, checker(s, arg_pack()));
-  }
-  template <typename S,
-            FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&&
-                              std::is_same<typename S::char_type, Char>::value)>
-  FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) {
-    FMT_CONSTEXPR auto sv = basic_string_view<Char>(S());
-    FMT_CONSTEXPR int ignore =
-        (parse_format_string(sv, checker(sv, arg_pack())), 0);
-    detail::ignore_unused(ignore);
-  }
-  basic_fstring(runtime_format_string<Char> fmt) : str_(fmt.str) {}
-
-  operator basic_string_view<Char>() const { return str_; }
-  auto get() const -> basic_string_view<Char> { return str_; }
-};
-
-template <typename Char, typename... T>
-using basic_format_string = basic_fstring<Char, T...>;
-
-template <typename... T>
-using wformat_string = typename basic_format_string<wchar_t, T...>::t;
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename... Args> using wformat_string = wstring_view;
+inline auto runtime(wstring_view s) -> wstring_view { return s; }
+#else
+template <typename... Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
 inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
  return {{s}};
 }
+#endif

 template <> struct is_char<wchar_t> : std::true_type {};
+template <> struct is_char<detail::char8_type> : std::true_type {};
 template <> struct is_char<char16_t> : std::true_type {};
 template <> struct is_char<char32_t> : std::true_type {};

-#ifdef __cpp_char8_t
-template <> struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled> {};
-#endif
-
 template <typename... T>
-constexpr auto make_wformat_args(T&... args)
-    -> decltype(fmt::make_format_args<wformat_context>(args...)) {
-  return fmt::make_format_args<wformat_context>(args...);
+constexpr auto make_wformat_args(const T&... args)
+    -> format_arg_store<wformat_context, T...> {
+  return {args...};
 }

-#if !FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg<wchar_t> {
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
+constexpr auto operator""_a(const wchar_t* s, size_t)
+    -> detail::udl_arg<wchar_t> {
  return {s};
 }
-}  // namespace literals
 #endif
+}  // namespace literals

 template <typename It, typename Sentinel>
 auto join(It begin, Sentinel end, wstring_view sep)
@@ -140,9 +83,9 @@ auto join(It begin, Sentinel end, wstring_view sep)
  return {begin, end, sep};
 }

-template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
+template <typename Range>
 auto join(Range&& range, wstring_view sep)
-    -> join_view<decltype(std::begin(range)), decltype(std::end(range)),
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
                 wchar_t> {
  return join(std::begin(range), std::end(range), sep);
 }
@@ -153,19 +96,13 @@ auto join(std::initializer_list<T> list, wstring_view sep)
  return join(std::begin(list), std::end(list), sep);
 }

-template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
-auto join(const Tuple& tuple, basic_string_view<wchar_t> sep)
-    -> tuple_join_view<wchar_t, Tuple> {
-  return {tuple, sep};
-}
-
 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto vformat(basic_string_view<Char> fmt,
-             typename detail::vformat_args<Char>::type args)
+auto vformat(basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, fmt, args);
-  return {buf.data(), buf.size()};
+  detail::vformat_to(buf, format_str, args);
+  return to_string(buf);
 }

 template <typename... T>
@@ -173,122 +110,110 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
  return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
 }

-template <typename OutputIt, typename... T>
-auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args)
-    -> OutputIt {
-  return vformat_to(out, fmt::wstring_view(fmt),
-                    fmt::make_wformat_args(args...));
-}
-
 // Pass char_t as a default template parameter instead of using
 // std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+template <typename S, typename... T, typename Char = char_t<S>,
          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
                        !std::is_same<Char, wchar_t>::value)>
-auto format(const S& fmt, T&&... args) -> std::basic_string<Char> {
-  return vformat(detail::to_string_view(fmt),
-                 fmt::make_format_args<buffered_context<Char>>(args...));
+auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
+  return vformat(detail::to_string_view(format_str),
+                 fmt::make_format_args<buffer_context<Char>>(args...));
 }

-template <typename Locale, typename S,
-          typename Char = detail::format_string_char_t<S>,
+template <typename Locale, typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto vformat(const Locale& loc, const S& fmt,
-                    typename detail::vformat_args<Char>::type args)
+inline auto vformat(
+    const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, detail::to_string_view(fmt), args,
-                     detail::locale_ref(loc));
-  return {buf.data(), buf.size()};
+  return detail::vformat(loc, detail::to_string_view(format_str), args);
 }

-template <typename Locale, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+template <typename Locale, typename S, typename... T, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto format(const Locale& loc, const S& fmt, T&&... args)
+inline auto format(const Locale& loc, const S& format_str, T&&... args)
    -> std::basic_string<Char> {
-  return vformat(loc, detail::to_string_view(fmt),
-                 fmt::make_format_args<buffered_context<Char>>(args...));
+  return detail::vformat(loc, detail::to_string_view(format_str),
+                         fmt::make_format_args<buffer_context<Char>>(args...));
 }

-template <typename OutputIt, typename S,
-          typename Char = detail::format_string_char_t<S>,
+template <typename OutputIt, typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-auto vformat_to(OutputIt out, const S& fmt,
-                typename detail::vformat_args<Char>::type args) -> OutputIt {
+auto vformat_to(OutputIt out, const S& format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, detail::to_string_view(fmt), args);
+  detail::vformat_to(buf, detail::to_string_view(format_str), args);
  return detail::get_iterator(buf, out);
 }

 template <typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
-                        !std::is_same<Char, char>::value &&
-                        !std::is_same<Char, wchar_t>::value)>
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
 inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
  return vformat_to(out, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = detail::format_string_char_t<S>,
+          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_locale<Locale>::value&&
                                detail::is_exotic_char<Char>::value)>
-inline auto vformat_to(OutputIt out, const Locale& loc, const S& fmt,
-                       typename detail::vformat_args<Char>::type args)
-    -> OutputIt {
+inline auto vformat_to(
+    OutputIt out, const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
-  vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc));
+  vformat_to(buf, detail::to_string_view(format_str), args,
+             detail::locale_ref(loc));
  return detail::get_iterator(buf, out);
 }

-template <typename Locale, typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+template <typename OutputIt, typename Locale, typename S, typename... T,
+          typename Char = char_t<S>,
          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
                        detail::is_locale<Locale>::value &&
                        detail::is_exotic_char<Char>::value>
-inline auto format_to(OutputIt out, const Locale& loc, const S& fmt,
+inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
                      T&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
+  return vformat_to(out, loc, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }

 template <typename OutputIt, typename Char, typename... Args,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view<Char> fmt,
-                         typename detail::vformat_args<Char>::type args)
+inline auto vformat_to_n(
+    OutputIt out, size_t n, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> format_to_n_result<OutputIt> {
  using traits = detail::fixed_buffer_traits;
  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
-  detail::vformat_to(buf, fmt, args);
+  detail::vformat_to(buf, format_str, args);
  return {buf.out(), buf.count()};
 }

 template <typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
 inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
    -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
-                      fmt::make_format_args<buffered_context<Char>>(args...));
+  return vformat_to_n(out, n, detail::to_string_view(fmt),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }

-template <typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
+template <typename S, typename... T, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
 inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
  auto buf = detail::counting_buffer<Char>();
  detail::vformat_to(buf, detail::to_string_view(fmt),
-                     fmt::make_format_args<buffered_context<Char>>(args...));
+                     fmt::make_format_args<buffer_context<Char>>(args...));
  return buf.count();
 }

@@ -322,48 +247,9 @@ template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
  return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
 }

-inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
-    -> std::wstring {
-  auto buf = wmemory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  return {buf.data(), buf.size()};
-}
-
-template <typename... T>
-inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args)
-    -> std::wstring {
-  return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(std::FILE* f, const text_style& ts,
-                          wformat_string<T...> fmt, const T&... args) {
-  vprint(f, ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt,
-                          const T&... args) {
-  return print(stdout, ts, fmt, args...);
-}
-
-inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) {
-  auto buffer = basic_memory_buffer<wchar_t>();
-  detail::vformat_to(buffer, fmt, args);
-  detail::write_buffer(os, buffer);
-}
-
-template <typename... T>
-void print(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
-}
-
-template <typename... T>
-void println(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  print(os, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-/// Converts `value` to `std::wstring` using the default format for type `T`.
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
 template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
  return format(FMT_STRING(L"{}"), value);
 }
--- a/3rdparty/fmt/src/fmt.cc
+++ b/3rdparty/fmt/src/fmt.cc
@@ -1,57 +1,38 @@
 module;

-#ifdef _MSVC_LANG
-#  define FMT_CPLUSPLUS _MSVC_LANG
-#else
-#  define FMT_CPLUSPLUS __cplusplus
-#endif
-
 // Put all implementation-provided headers into the global module fragment
 // to prevent attachment to this module.
-#ifndef FMT_IMPORT_STD
-#  include <algorithm>
-#  include <bitset>
-#  include <chrono>
-#  include <cmath>
-#  include <complex>
-#  include <cstddef>
-#  include <cstdint>
-#  include <cstdio>
-#  include <cstdlib>
-#  include <cstring>
-#  include <ctime>
-#  include <exception>
-#  if FMT_CPLUSPLUS > 202002L
-#    include <expected>
-#  endif
-#  include <filesystem>
-#  include <fstream>
-#  include <functional>
-#  include <iterator>
-#  include <limits>
-#  include <locale>
-#  include <memory>
-#  include <optional>
-#  include <ostream>
-#  include <source_location>
-#  include <stdexcept>
-#  include <string>
-#  include <string_view>
-#  include <system_error>
-#  include <thread>
-#  include <type_traits>
-#  include <typeinfo>
-#  include <utility>
-#  include <variant>
-#  include <vector>
-#else
-#  include <limits.h>
-#  include <stdint.h>
-#  include <stdio.h>
-#  include <time.h>
-#endif
+#include <algorithm>
 #include <cerrno>
+#include <chrono>
 #include <climits>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <exception>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <locale>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <thread>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <variant>
+#include <vector>
 #include <version>

 #if __has_include(<cxxabi.h>)
@@ -89,10 +70,6 @@ module;

 export module fmt;

-#ifdef FMT_IMPORT_STD
-import std;
-#endif
-
 #define FMT_EXPORT export
 #define FMT_BEGIN_EXPORT export {
 #define FMT_END_EXPORT }
@@ -106,10 +83,6 @@ import std;
 extern "C++" {
 #endif

-#ifndef FMT_OS
-#  define FMT_OS 1
-#endif
-
 // All library-provided declarations and definitions must be in the module
 // purview to be exported.
 #include "fmt/args.h"
@@ -117,12 +90,8 @@ extern "C++" {
 #include "fmt/color.h"
 #include "fmt/compile.h"
 #include "fmt/format.h"
-#if FMT_OS
-#  include "fmt/os.h"
-#endif
-#include "fmt/ostream.h"
+#include "fmt/os.h"
 #include "fmt/printf.h"
-#include "fmt/ranges.h"
 #include "fmt/std.h"
 #include "fmt/xchar.h"

@@ -135,17 +104,5 @@ extern "C++" {
 module :private;
 #endif

-#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
-extern "C++" {
-#endif
-
-#if FMT_HAS_INCLUDE("format.cc")
-#  include "format.cc"
-#endif
-#if FMT_OS && FMT_HAS_INCLUDE("os.cc")
-#  include "os.cc"
-#endif
-
-#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
-}
-#endif
+#include "format.cc"
+#include "os.cc"
--- a/3rdparty/fmt/src/format.cc
+++ b/3rdparty/fmt/src/format.cc
@@ -15,8 +15,7 @@ template FMT_API auto dragonbox::to_decimal(float x) noexcept
 template FMT_API auto dragonbox::to_decimal(double x) noexcept
    -> dragonbox::decimal_fp<double>;

-#if FMT_USE_LOCALE
-// DEPRECATED! locale_ref in the detail namespace
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 template FMT_API locale_ref::locale_ref(const std::locale& loc);
 template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
 #endif
@@ -27,10 +26,8 @@ template FMT_API auto thousands_sep_impl(locale_ref)
    -> thousands_sep_result<char>;
 template FMT_API auto decimal_point_impl(locale_ref) -> char;

-// DEPRECATED!
 template FMT_API void buffer<char>::append(const char*, const char*);

-// DEPRECATED!
 template FMT_API void vformat_to(buffer<char>&, string_view,
                                 typename vformat_args<>::type, locale_ref);

--- a/3rdparty/fmt/src/os.cc
+++ b/3rdparty/fmt/src/os.cc
@@ -12,51 +12,47 @@

 #include "fmt/os.h"

-#ifndef FMT_MODULE
-#  include <climits>
+#include <climits>

-#  if FMT_USE_FCNTL
-#    include <sys/stat.h>
-#    include <sys/types.h>
+#if FMT_USE_FCNTL
+#  include <sys/stat.h>
+#  include <sys/types.h>

-#    ifdef _WRS_KERNEL    // VxWorks7 kernel
-#      include <ioLib.h>  // getpagesize
-#    endif
-
-#    ifndef _WIN32
-#      include <unistd.h>
-#    else
-#      ifndef WIN32_LEAN_AND_MEAN
-#        define WIN32_LEAN_AND_MEAN
-#      endif
-#      include <io.h>
-#    endif  // _WIN32
-#  endif    // FMT_USE_FCNTL
-
-#  ifdef _WIN32
-#    include <windows.h>
+#  ifdef _WRS_KERNEL    // VxWorks7 kernel
+#    include <ioLib.h>  // getpagesize
 #  endif
-#endif
+
+#  ifndef _WIN32
+#    include <unistd.h>
+#  else
+#    ifndef WIN32_LEAN_AND_MEAN
+#      define WIN32_LEAN_AND_MEAN
+#    endif
+#    include <io.h>
+
+#    ifndef S_IRUSR
+#      define S_IRUSR _S_IREAD
+#    endif
+#    ifndef S_IWUSR
+#      define S_IWUSR _S_IWRITE
+#    endif
+#    ifndef S_IRGRP
+#      define S_IRGRP 0
+#    endif
+#    ifndef S_IWGRP
+#      define S_IWGRP 0
+#    endif
+#    ifndef S_IROTH
+#      define S_IROTH 0
+#    endif
+#    ifndef S_IWOTH
+#      define S_IWOTH 0
+#    endif
+#  endif  // _WIN32
+#endif    // FMT_USE_FCNTL

 #ifdef _WIN32
-#  ifndef S_IRUSR
-#    define S_IRUSR _S_IREAD
-#  endif
-#  ifndef S_IWUSR
-#    define S_IWUSR _S_IWRITE
-#  endif
-#  ifndef S_IRGRP
-#    define S_IRGRP 0
-#  endif
-#  ifndef S_IWGRP
-#    define S_IWGRP 0
-#  endif
-#  ifndef S_IROTH
-#    define S_IROTH 0
-#  endif
-#  ifndef S_IWOTH
-#    define S_IWOTH 0
-#  endif
+#  include <windows.h>
 #endif

 namespace {
@@ -160,7 +156,7 @@ void detail::format_windows_error(detail::buffer<char>& out, int error_code,
 }

 void report_windows_error(int error_code, const char* message) noexcept {
-  do_report_error(detail::format_windows_error, error_code, message);
+  report_error(detail::format_windows_error, error_code, message);
 }
 #endif  // _WIN32

@@ -186,14 +182,12 @@ void buffered_file::close() {
 }

 int buffered_file::descriptor() const {
-#ifdef FMT_HAS_SYSTEM
-  // fileno is a macro on OpenBSD.
-#  ifdef fileno
-#    undef fileno
-#  endif
+#if !defined(fileno)
  int fd = FMT_POSIX_CALL(fileno(file_));
-#elif defined(_WIN32)
-  int fd = _fileno(file_);
+#elif defined(FMT_HAS_SYSTEM)
+  // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL.
+#  define FMT_DISABLE_MACRO
+  int fd = FMT_SYSTEM(fileno FMT_DISABLE_MACRO(file_));
 #else
  int fd = fileno(file_);
 #endif
@@ -206,7 +200,6 @@ int buffered_file::descriptor() const {
 #  ifdef _WIN32
 using mode_t = int;
 #  endif
-
 constexpr mode_t default_open_mode =
    S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;

@@ -308,6 +301,29 @@ void file::dup2(int fd, std::error_code& ec) noexcept {
  if (result == -1) ec = std::error_code(errno, std::generic_category());
 }

+void file::pipe(file& read_end, file& write_end) {
+  // Close the descriptors first to make sure that assignments don't throw
+  // and there are no leaks.
+  read_end.close();
+  write_end.close();
+  int fds[2] = {};
+#  ifdef _WIN32
+  // Make the default pipe capacity same as on Linux 2.6.11+.
+  enum { DEFAULT_CAPACITY = 65536 };
+  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
+#  else
+  // Don't retry as the pipe function doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
+  int result = FMT_POSIX_CALL(pipe(fds));
+#  endif
+  if (result != 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot create pipe")));
+  // The following assignments don't throw because read_fd and write_fd
+  // are closed.
+  read_end = file(fds[0]);
+  write_end = file(fds[1]);
+}
+
 buffered_file file::fdopen(const char* mode) {
 // Don't retry as fdopen doesn't return EINTR.
 #  if defined(__MINGW32__) && defined(_POSIX_)
@@ -336,24 +352,6 @@ file file::open_windows_file(wcstring_view path, int oflag) {
 }
 #  endif

-pipe::pipe() {
-  int fds[2] = {};
-#  ifdef _WIN32
-  // Make the default pipe capacity same as on Linux 2.6.11+.
-  enum { DEFAULT_CAPACITY = 65536 };
-  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
-#  else
-  // Don't retry as the pipe function doesn't return EINTR.
-  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
-  int result = FMT_POSIX_CALL(pipe(fds));
-#  endif
-  if (result != 0)
-    FMT_THROW(system_error(errno, FMT_STRING("cannot create pipe")));
-  // The following assignments don't throw.
-  read_end = file(fds[0]);
-  write_end = file(fds[1]);
-}
-
 #  if !defined(__MSDOS__)
 long getpagesize() {
 #    ifdef _WIN32
@@ -374,25 +372,31 @@ long getpagesize() {
 }
 #  endif

-void ostream::grow(buffer<char>& buf, size_t) {
-  if (buf.size() == buf.capacity()) static_cast<ostream&>(buf).flush();
+namespace detail {
+
+void file_buffer::grow(size_t) {
+  if (this->size() == this->capacity()) flush();
 }

-ostream::ostream(cstring_view path, const detail::ostream_params& params)
-    : buffer<char>(grow), file_(path, params.oflag) {
+file_buffer::file_buffer(cstring_view path,
+                         const detail::ostream_params& params)
+    : file_(path, params.oflag) {
  set(new char[params.buffer_size], params.buffer_size);
 }

-ostream::ostream(ostream&& other) noexcept
-    : buffer<char>(grow, other.data(), other.size(), other.capacity()),
+file_buffer::file_buffer(file_buffer&& other)
+    : detail::buffer<char>(other.data(), other.size(), other.capacity()),
      file_(std::move(other.file_)) {
  other.clear();
  other.set(nullptr, 0);
 }

-ostream::~ostream() {
+file_buffer::~file_buffer() {
  flush();
  delete[] data();
 }
+}  // namespace detail
+
+ostream::~ostream() = default;
 #endif  // FMT_USE_FCNTL
 FMT_END_NAMESPACE
--- a/3rdparty/googletest/README.md
+++ b/3rdparty/googletest/README.md
@@ -9,7 +9,7 @@ GoogleTest now follows the
 We recommend
 [updating to the latest commit in the `main` branch as often as possible](https://github.com/abseil/abseil-cpp/blob/master/FAQ.md#what-is-live-at-head-and-how-do-i-do-it).
 We do publish occasional semantic versions, tagged with
-`v${major}.${minor}.${patch}` (e.g. `v1.15.0`).
+`v${major}.${minor}.${patch}` (e.g. `v1.13.0`).

 #### Documentation Updates

@@ -17,21 +17,25 @@ Our documentation is now live on GitHub Pages at
 https://google.github.io/googletest/. We recommend browsing the documentation on
 GitHub Pages rather than directly in the repository.

-#### Release 1.15.0
+#### Release 1.13.0

-[Release 1.15.0](https://github.com/google/googletest/releases/tag/v1.15.0) is
+[Release 1.13.0](https://github.com/google/googletest/releases/tag/v1.13.0) is
 now available.

-The 1.15.x branch requires at least C++14.
+The 1.13.x branch requires at least C++14.

 #### Continuous Integration

-We use Google's internal systems for continuous integration.
+We use Google's internal systems for continuous integration. \
+GitHub Actions were added for the convenience of open-source contributors. They
+are exclusively maintained by the open-source community and not used by the
+GoogleTest team.

 #### Coming Soon

 *   We are planning to take a dependency on
    [Abseil](https://github.com/abseil/abseil-cpp).
+*   More documentation improvements are planned.

 ## Welcome to **GoogleTest**, Google's C++ test framework!

@@ -96,12 +100,12 @@ tools.
 In addition to many internal projects at Google, GoogleTest is also used by the
 following notable projects:

-*   The [Chromium projects](https://www.chromium.org/) (behind the Chrome
-    browser and Chrome OS).
-*   The [LLVM](https://llvm.org/) compiler.
+*   The [Chromium projects](http://www.chromium.org/) (behind the Chrome browser
+    and Chrome OS).
+*   The [LLVM](http://llvm.org/) compiler.
 *   [Protocol Buffers](https://github.com/google/protobuf), Google's data
    interchange format.
-*   The [OpenCV](https://opencv.org/) computer vision library.
+*   The [OpenCV](http://opencv.org/) computer vision library.

 ## Related Open Source Projects

--- a/3rdparty/googletest/googlemock/README.md
+++ b/3rdparty/googletest/googlemock/README.md
@@ -8,8 +8,8 @@ derive better designs of your system and write better tests.
 It is inspired by:

 *   [jMock](http://www.jmock.org/)
-*   [EasyMock](https://easymock.org/)
-*   [Hamcrest](https://code.google.com/p/hamcrest/)
+*   [EasyMock](http://www.easymock.org/)
+*   [Hamcrest](http://code.google.com/p/hamcrest/)

 It is designed with C++'s specifics in mind.

@@ -36,5 +36,5 @@ Details and examples can be found here:
 *   [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html)

 GoogleMock is a part of
-[GoogleTest C++ testing framework](https://github.com/google/googletest/) and a
+[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a
 subject to the same requirements.
--- a/3rdparty/googletest/googlemock/include/gmock/gmock-actions.h
+++ b/3rdparty/googletest/googlemock/include/gmock/gmock-actions.h
@@ -135,7 +135,6 @@
 #endif

 #include <algorithm>
-#include <exception>
 #include <functional>
 #include <memory>
 #include <string>
@@ -176,15 +175,9 @@ struct BuiltInDefaultValueGetter<T, false> {
  static T Get() {
    Assert(false, __FILE__, __LINE__,
           "Default action undefined for the function return type.");
-#if defined(__GNUC__) || defined(__clang__)
-    __builtin_unreachable();
-#elif defined(_MSC_VER)
-    __assume(0);
-#else
-    return Invalid<T>();
+    return internal::Invalid<T>();
    // The above statement will never be reached, but is required in
    // order for this function to compile.
-#endif
  }
 };

@@ -1747,13 +1740,6 @@ struct ThrowAction {
    return [copy](Args...) -> R { throw copy; };
  }
 };
-struct RethrowAction {
-  std::exception_ptr exception;
-  template <typename R, typename... Args>
-  operator Action<R(Args...)>() const {  // NOLINT
-    return [ex = exception](Args...) -> R { std::rethrow_exception(ex); };
-  }
-};
 #endif  // GTEST_HAS_EXCEPTIONS

 }  // namespace internal
@@ -2070,23 +2056,13 @@ internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
  return {pointer};
 }

-#if GTEST_HAS_EXCEPTIONS
 // Action Throw(exception) can be used in a mock function of any type
-// to throw the given exception.  Any copyable value can be thrown,
-// except for std::exception_ptr, which is likely a mistake if
-// thrown directly.
+// to throw the given exception.  Any copyable value can be thrown.
+#if GTEST_HAS_EXCEPTIONS
 template <typename T>
-typename std::enable_if<
-    !std::is_base_of<std::exception_ptr, typename std::decay<T>::type>::value,
-    internal::ThrowAction<typename std::decay<T>::type>>::type
-Throw(T&& exception) {
+internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
  return {std::forward<T>(exception)};
 }
-// Action Rethrow(exception_ptr) can be used in a mock function of any type
-// to rethrow any exception_ptr. Note that the same object is thrown each time.
-inline internal::RethrowAction Rethrow(std::exception_ptr exception) {
-  return {std::move(exception)};
-}
 #endif  // GTEST_HAS_EXCEPTIONS

 namespace internal {
@@ -2135,13 +2111,13 @@ struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
  R operator()(Args&&... arg) const {
    static constexpr size_t kMaxArgs =
        sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
-    return Apply(std::make_index_sequence<kMaxArgs>{},
-                 std::make_index_sequence<10 - kMaxArgs>{},
+    return Apply(MakeIndexSequence<kMaxArgs>{},
+                 MakeIndexSequence<10 - kMaxArgs>{},
                 args_type{std::forward<Args>(arg)...});
  }

  template <std::size_t... arg_id, std::size_t... excess_id>
-  R Apply(std::index_sequence<arg_id...>, std::index_sequence<excess_id...>,
+  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
          const args_type& args) const {
    // Impl need not be specific to the signature of action being implemented;
    // only the implementing function body needs to have all of the specific
@@ -2174,9 +2150,9 @@ template <typename F, typename Impl>
 }

 #define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
-  , GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED const arg##i##_type& arg##i
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_                               \
-  GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED const args_type& args GMOCK_PP_REPEAT( \
+  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_                 \
+  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
      GMOCK_INTERNAL_ARG_UNUSED, , 10)

 #define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
--- a/3rdparty/googletest/googlemock/include/gmock/gmock-function-mocker.h
+++ b/3rdparty/googletest/googlemock/include/gmock/gmock-function-mocker.h
@@ -37,7 +37,6 @@
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_

-#include <cstddef>
 #include <type_traits>  // IWYU pragma: keep
 #include <utility>      // IWYU pragma: keep

@@ -70,22 +69,22 @@ constexpr bool PrefixOf(const char* a, const char* b) {
  return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
 }

-template <size_t N, size_t M>
+template <int N, int M>
 constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {
  return N <= M && internal::PrefixOf(prefix, str);
 }

-template <size_t N, size_t M>
+template <int N, int M>
 constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {
  return N <= M && internal::PrefixOf(suffix, str + M - N);
 }

-template <size_t N, size_t M>
+template <int N, int M>
 constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {
  return N == M && internal::PrefixOf(a, b);
 }

-template <size_t N>
+template <int N>
 constexpr bool ValidateSpec(const char (&spec)[N]) {
  return internal::Equals("const", spec) ||
         internal::Equals("override", spec) ||
--- a/3rdparty/googletest/googlemock/include/gmock/gmock-matchers.h
+++ b/3rdparty/googletest/googlemock/include/gmock/gmock-matchers.h
@@ -490,12 +490,12 @@ class MatcherBaseImpl<Derived<Ts...>> {

  template <typename F>
  operator ::testing::Matcher<F>() const {  // NOLINT(runtime/explicit)
-    return Apply<F>(std::make_index_sequence<sizeof...(Ts)>{});
+    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
  }

 private:
  template <typename F, std::size_t... tuple_ids>
-  ::testing::Matcher<F> Apply(std::index_sequence<tuple_ids...>) const {
+  ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {
    return ::testing::Matcher<F>(
        new typename Derived<Ts...>::template gmock_Impl<F>(
            std::get<tuple_ids>(params_)...));
@@ -1048,7 +1048,7 @@ class StartsWithMatcher {
  template <typename MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
-    const StringType s2(s);
+    const StringType& s2(s);
    return s2.length() >= prefix_.length() &&
           s2.substr(0, prefix_.length()) == prefix_;
  }
@@ -1102,7 +1102,7 @@ class EndsWithMatcher {
  template <typename MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
-    const StringType s2(s);
+    const StringType& s2(s);
    return s2.length() >= suffix_.length() &&
           s2.substr(s2.length() - suffix_.length()) == suffix_;
  }
@@ -2920,27 +2920,26 @@ class EachMatcher {
  const M inner_matcher_;
 };

-// Use go/ranked-overloads for dispatching.
-struct Rank0 {};
-struct Rank1 : Rank0 {};
+struct Rank1 {};
+struct Rank0 : Rank1 {};

 namespace pair_getters {
 using std::get;
 template <typename T>
-auto First(T& x, Rank0) -> decltype(get<0>(x)) {  // NOLINT
+auto First(T& x, Rank1) -> decltype(get<0>(x)) {  // NOLINT
  return get<0>(x);
 }
 template <typename T>
-auto First(T& x, Rank1) -> decltype((x.first)) {  // NOLINT
+auto First(T& x, Rank0) -> decltype((x.first)) {  // NOLINT
  return x.first;
 }

 template <typename T>
-auto Second(T& x, Rank0) -> decltype(get<1>(x)) {  // NOLINT
+auto Second(T& x, Rank1) -> decltype(get<1>(x)) {  // NOLINT
  return get<1>(x);
 }
 template <typename T>
-auto Second(T& x, Rank1) -> decltype((x.second)) {  // NOLINT
+auto Second(T& x, Rank0) -> decltype((x.second)) {  // NOLINT
  return x.second;
 }
 }  // namespace pair_getters
@@ -2966,7 +2965,7 @@ class KeyMatcherImpl : public MatcherInterface<PairType> {
                       MatchResultListener* listener) const override {
    StringMatchResultListener inner_listener;
    const bool match = inner_matcher_.MatchAndExplain(
-        pair_getters::First(key_value, Rank1()), &inner_listener);
+        pair_getters::First(key_value, Rank0()), &inner_listener);
    const std::string explanation = inner_listener.str();
    if (!explanation.empty()) {
      *listener << "whose first field is a value " << explanation;
@@ -3088,18 +3087,18 @@ class PairMatcherImpl : public MatcherInterface<PairType> {
    if (!listener->IsInterested()) {
      // If the listener is not interested, we don't need to construct the
      // explanation.
-      return first_matcher_.Matches(pair_getters::First(a_pair, Rank1())) &&
-             second_matcher_.Matches(pair_getters::Second(a_pair, Rank1()));
+      return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) &&
+             second_matcher_.Matches(pair_getters::Second(a_pair, Rank0()));
    }
    StringMatchResultListener first_inner_listener;
-    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank1()),
+    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),
                                        &first_inner_listener)) {
      *listener << "whose first field does not match";
      PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
      return false;
    }
    StringMatchResultListener second_inner_listener;
-    if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank1()),
+    if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()),
                                         &second_inner_listener)) {
      *listener << "whose second field does not match";
      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
@@ -3152,8 +3151,8 @@ class PairMatcher {
 };

 template <typename T, size_t... I>
-auto UnpackStructImpl(const T& t, std::index_sequence<I...>,
-                      int) -> decltype(std::tie(get<I>(t)...)) {
+auto UnpackStructImpl(const T& t, IndexSequence<I...>, int)
+    -> decltype(std::tie(get<I>(t)...)) {
  static_assert(std::tuple_size<T>::value == sizeof...(I),
                "Number of arguments doesn't match the number of fields.");
  return std::tie(get<I>(t)...);
@@ -3161,97 +3160,97 @@ auto UnpackStructImpl(const T& t, std::index_sequence<I...>,

 #if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<1>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {
  const auto& [a] = t;
  return std::tie(a);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<2>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {
  const auto& [a, b] = t;
  return std::tie(a, b);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<3>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) {
  const auto& [a, b, c] = t;
  return std::tie(a, b, c);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<4>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) {
  const auto& [a, b, c, d] = t;
  return std::tie(a, b, c, d);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<5>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) {
  const auto& [a, b, c, d, e] = t;
  return std::tie(a, b, c, d, e);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<6>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) {
  const auto& [a, b, c, d, e, f] = t;
  return std::tie(a, b, c, d, e, f);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<7>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) {
  const auto& [a, b, c, d, e, f, g] = t;
  return std::tie(a, b, c, d, e, f, g);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<8>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) {
  const auto& [a, b, c, d, e, f, g, h] = t;
  return std::tie(a, b, c, d, e, f, g, h);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<9>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) {
  const auto& [a, b, c, d, e, f, g, h, i] = t;
  return std::tie(a, b, c, d, e, f, g, h, i);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<10>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<11>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<12>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<13>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<14>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<15>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<16>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<17>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<17>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<18>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<18>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r);
 }
 template <typename T>
-auto UnpackStructImpl(const T& t, std::make_index_sequence<19>, char) {
+auto UnpackStructImpl(const T& t, MakeIndexSequence<19>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s);
 }
@@ -3259,8 +3258,8 @@ auto UnpackStructImpl(const T& t, std::make_index_sequence<19>, char) {

 template <size_t I, typename T>
 auto UnpackStruct(const T& t)
-    -> decltype((UnpackStructImpl)(t, std::make_index_sequence<I>{}, 0)) {
-  return (UnpackStructImpl)(t, std::make_index_sequence<I>{}, 0);
+    -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) {
+  return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0);
 }

 // Helper function to do comma folding in C++11.
@@ -3273,7 +3272,7 @@ template <typename Struct, typename StructSize>
 class FieldsAreMatcherImpl;

 template <typename Struct, size_t... I>
-class FieldsAreMatcherImpl<Struct, std::index_sequence<I...>>
+class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
    : public MatcherInterface<Struct> {
  using UnpackedType =
      decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));
@@ -3355,8 +3354,8 @@ class FieldsAreMatcher {
  template <typename Struct>
  operator Matcher<Struct>() const {  // NOLINT
    return Matcher<Struct>(
-        new FieldsAreMatcherImpl<const Struct&,
-                                 std::index_sequence_for<Inner...>>(matchers_));
+        new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(
+            matchers_));
  }

 private:
@@ -5445,47 +5444,47 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
      ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)

 // MATCHER* macros itself are listed below.
-#define MATCHER(name, description)                                            \
-  class name##Matcher                                                         \
-      : public ::testing::internal::MatcherBaseImpl<name##Matcher> {          \
-   public:                                                                    \
-    template <typename arg_type>                                              \
-    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {  \
-     public:                                                                  \
-      gmock_Impl() {}                                                         \
-      bool MatchAndExplain(                                                   \
-          const arg_type& arg,                                                \
-          ::testing::MatchResultListener* result_listener) const override;    \
-      void DescribeTo(::std::ostream* gmock_os) const override {              \
-        *gmock_os << FormatDescription(false);                                \
-      }                                                                       \
-      void DescribeNegationTo(::std::ostream* gmock_os) const override {      \
-        *gmock_os << FormatDescription(true);                                 \
-      }                                                                       \
-                                                                              \
-     private:                                                                 \
-      ::std::string FormatDescription(bool negation) const {                  \
-        /* NOLINTNEXTLINE readability-redundant-string-init */                \
-        ::std::string gmock_description = (description);                      \
-        if (!gmock_description.empty()) {                                     \
-          return gmock_description;                                           \
-        }                                                                     \
-        return ::testing::internal::FormatMatcherDescription(negation, #name, \
-                                                             {}, {});         \
-      }                                                                       \
-    };                                                                        \
-  };                                                                          \
-  inline name##Matcher GMOCK_INTERNAL_WARNING_PUSH()                          \
-      GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-function")              \
-          GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function")   \
-              name GMOCK_INTERNAL_WARNING_POP()() {                           \
-    return {};                                                                \
-  }                                                                           \
-  template <typename arg_type>                                                \
-  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                  \
-      const arg_type& arg,                                                    \
-      GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED ::testing::MatchResultListener*   \
-          result_listener) const
+#define MATCHER(name, description)                                             \
+  class name##Matcher                                                          \
+      : public ::testing::internal::MatcherBaseImpl<name##Matcher> {           \
+   public:                                                                     \
+    template <typename arg_type>                                               \
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
+     public:                                                                   \
+      gmock_Impl() {}                                                          \
+      bool MatchAndExplain(                                                    \
+          const arg_type& arg,                                                 \
+          ::testing::MatchResultListener* result_listener) const override;     \
+      void DescribeTo(::std::ostream* gmock_os) const override {               \
+        *gmock_os << FormatDescription(false);                                 \
+      }                                                                        \
+      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
+        *gmock_os << FormatDescription(true);                                  \
+      }                                                                        \
+                                                                               \
+     private:                                                                  \
+      ::std::string FormatDescription(bool negation) const {                   \
+        /* NOLINTNEXTLINE readability-redundant-string-init */                 \
+        ::std::string gmock_description = (description);                       \
+        if (!gmock_description.empty()) {                                      \
+          return gmock_description;                                            \
+        }                                                                      \
+        return ::testing::internal::FormatMatcherDescription(negation, #name,  \
+                                                             {}, {});          \
+      }                                                                        \
+    };                                                                         \
+  };                                                                           \
+  inline name##Matcher GMOCK_INTERNAL_WARNING_PUSH()                           \
+      GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-function")               \
+          GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function")    \
+              name GMOCK_INTERNAL_WARNING_POP()() {                            \
+    return {};                                                                 \
+  }                                                                            \
+  template <typename arg_type>                                                 \
+  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                   \
+      const arg_type& arg,                                                     \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \
+      const

 #define MATCHER_P(name, p0, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (#p0), (p0))
@@ -5567,11 +5566,11 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
  }                                                                            \
  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
  template <typename arg_type>                                                 \
-  bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::                   \
-      gmock_Impl<arg_type>::MatchAndExplain(                                   \
-          const arg_type& arg,                                                 \
-          GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED ::testing::                    \
-              MatchResultListener* result_listener) const
+  bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl<        \
+      arg_type>::MatchAndExplain(const arg_type& arg,                          \
+                                 ::testing::MatchResultListener*               \
+                                     result_listener GTEST_ATTRIBUTE_UNUSED_)  \
+      const

 #define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \
  GMOCK_PP_TAIL(                                     \
@@ -5606,8 +5605,8 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(

 #define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args))
-#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg) \
-  , ::std::forward<arg##_type>(gmock_p##i)
+#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \
+  , gmock_p##i

 // To prevent ADL on certain functions we put them on a separate namespace.
 using namespace no_adl;  // NOLINT
--- a/3rdparty/googletest/googlemock/include/gmock/gmock-more-actions.h
+++ b/3rdparty/googletest/googlemock/include/gmock/gmock-more-actions.h
@@ -592,9 +592,8 @@ namespace internal {
 // Overloads for other custom-callables are provided in the
 // internal/custom/gmock-generated-actions.h header.
 template <typename F, typename... Args>
-auto InvokeArgument(F &&f,
-                    Args... args) -> decltype(std::forward<F>(f)(args...)) {
-  return std::forward<F>(f)(args...);
+auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
+  return f(args...);
 }

 template <std::size_t index, typename... Params>
@@ -607,7 +606,7 @@ struct InvokeArgumentAction {
    internal::FlatTuple<Args &&...> args_tuple(FlatTupleConstructTag{},
                                               std::forward<Args>(args)...);
    return params.Apply([&](const Params &...unpacked_params) {
-      auto &&callable = std::move(args_tuple.template Get<index>());
+      auto &&callable = args_tuple.template Get<index>();
      return internal::InvokeArgument(
          std::forward<decltype(callable)>(callable), unpacked_params...);
    });
--- a/3rdparty/googletest/googlemock/include/gmock/gmock.h
+++ b/3rdparty/googletest/googlemock/include/gmock/gmock.h
@@ -53,14 +53,13 @@
 //
 // where all clauses are optional and WillOnce() can be repeated.

-#include "gmock/gmock-actions.h"  // IWYU pragma: export
-#include "gmock/gmock-cardinalities.h"  // IWYU pragma: export
-#include "gmock/gmock-function-mocker.h"  // IWYU pragma: export
-#include "gmock/gmock-matchers.h"  // IWYU pragma: export
-#include "gmock/gmock-more-actions.h"  // IWYU pragma: export
-#include "gmock/gmock-more-matchers.h"  // IWYU pragma: export
-#include "gmock/gmock-nice-strict.h"  // IWYU pragma: export
-#include "gmock/gmock-spec-builders.h"  // IWYU pragma: export
+#include "gmock/gmock-actions.h"
+#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-function-mocker.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-more-actions.h"
+#include "gmock/gmock-more-matchers.h"
+#include "gmock/gmock-nice-strict.h"
 #include "gmock/internal/gmock-internal-utils.h"
 #include "gmock/internal/gmock-port.h"

--- a/3rdparty/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ b/3rdparty/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
@@ -44,7 +44,6 @@
 #include <ostream>  // NOLINT
 #include <string>
 #include <type_traits>
-#include <utility>
 #include <vector>

 #include "gmock/internal/gmock-port.h"
@@ -421,7 +420,7 @@ struct RemoveConstFromKey<std::pair<const K, V> > {
 GTEST_API_ void IllegalDoDefault(const char* file, int line);

 template <typename F, typename Tuple, size_t... Idx>
-auto ApplyImpl(F&& f, Tuple&& args, std::index_sequence<Idx...>)
+auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>)
    -> decltype(std::forward<F>(f)(
        std::get<Idx>(std::forward<Tuple>(args))...)) {
  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
@@ -429,13 +428,12 @@ auto ApplyImpl(F&& f, Tuple&& args, std::index_sequence<Idx...>)

 // Apply the function to a tuple of arguments.
 template <typename F, typename Tuple>
-auto Apply(F&& f, Tuple&& args)
-    -> decltype(ApplyImpl(
-        std::forward<F>(f), std::forward<Tuple>(args),
-        std::make_index_sequence<std::tuple_size<
-            typename std::remove_reference<Tuple>::type>::value>())) {
+auto Apply(F&& f, Tuple&& args) -> decltype(ApplyImpl(
+    std::forward<F>(f), std::forward<Tuple>(args),
+    MakeIndexSequence<std::tuple_size<
+        typename std::remove_reference<Tuple>::type>::value>())) {
  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
-                   std::make_index_sequence<std::tuple_size<
+                   MakeIndexSequence<std::tuple_size<
                       typename std::remove_reference<Tuple>::type>::value>());
 }

--- a/3rdparty/googletest/googlemock/include/gmock/internal/gmock-port.h
+++ b/3rdparty/googletest/googlemock/include/gmock/internal/gmock-port.h
@@ -56,7 +56,7 @@
 #include "gmock/internal/custom/gmock-port.h"
 #include "gtest/internal/gtest-port.h"

-#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#ifdef GTEST_HAS_ABSL
 #include "absl/flags/declare.h"
 #include "absl/flags/flag.h"
 #endif
@@ -73,7 +73,7 @@
 #define GMOCK_FLAG(name) FLAGS_gmock_##name

 // Pick a command line flags implementation.
-#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#ifdef GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GMOCK_DEFINE_bool_(name, default_val, doc) \
@@ -95,7 +95,7 @@
 #define GMOCK_FLAG_SET(name, value) \
  (void)(::absl::SetFlag(&GMOCK_FLAG(name), value))

-#else  // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#else  // GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GMOCK_DEFINE_bool_(name, default_val, doc)  \
@@ -134,6 +134,6 @@
 #define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name)
 #define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value)

-#endif  // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#endif  // GTEST_HAS_ABSL

 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
--- a/3rdparty/googletest/googlemock/src/gmock-internal-utils.cc
+++ b/3rdparty/googletest/googlemock/src/gmock-internal-utils.cc
@@ -44,7 +44,6 @@
 #include <iostream>
 #include <ostream>  // NOLINT
 #include <string>
-#include <utility>
 #include <vector>

 #include "gmock/gmock.h"
@@ -212,14 +211,14 @@ constexpr char UnBase64Impl(char c, const char* const base64, char carry) {
 }

 template <size_t... I>
-constexpr std::array<char, 256> UnBase64Impl(std::index_sequence<I...>,
+constexpr std::array<char, 256> UnBase64Impl(IndexSequence<I...>,
                                             const char* const base64) {
  return {
      {UnBase64Impl(UndoWebSafeEncoding(static_cast<char>(I)), base64, 0)...}};
 }

 constexpr std::array<char, 256> UnBase64(const char* const base64) {
-  return UnBase64Impl(std::make_index_sequence<256>{}, base64);
+  return UnBase64Impl(MakeIndexSequence<256>{}, base64);
 }

 static constexpr char kBase64[] =
--- a/3rdparty/googletest/googlemock/src/gmock-matchers.cc
+++ b/3rdparty/googletest/googlemock/src/gmock-matchers.cc
@@ -120,7 +120,7 @@ GTEST_API_ std::string FormatMatcherDescription(
 //   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
 //       "Introduction to Algorithms (Second ed.)", pp. 651-664.
 //   [2] "Ford-Fulkerson algorithm", Wikipedia,
-//       'https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
+//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
 class MaxBipartiteMatchState {
 public:
  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
@@ -236,8 +236,9 @@ static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
  os << "{";
  const char* sep = "";
  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
-    os << sep << "\n  (" << "element #" << it->first << ", " << "matcher #"
-       << it->second << ")";
+    os << sep << "\n  ("
+       << "element #" << it->first << ", "
+       << "matcher #" << it->second << ")";
    sep = ",";
  }
  os << "\n}";
@@ -373,20 +374,20 @@ bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
    return true;
  }

-  const bool is_exact_match_with_size_discrepency =
-      match_flags() == UnorderedMatcherRequire::ExactMatch &&
-      matrix.LhsSize() != matrix.RhsSize();
-  if (is_exact_match_with_size_discrepency) {
-    // The element count doesn't match.  If the container is empty,
-    // there's no need to explain anything as Google Mock already
-    // prints the empty container. Otherwise we just need to show
-    // how many elements there actually are.
-    if (matrix.LhsSize() != 0 && listener->IsInterested()) {
-      *listener << "which has " << Elements(matrix.LhsSize()) << "\n";
+  if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+    if (matrix.LhsSize() != matrix.RhsSize()) {
+      // The element count doesn't match.  If the container is empty,
+      // there's no need to explain anything as Google Mock already
+      // prints the empty container. Otherwise we just need to show
+      // how many elements there actually are.
+      if (matrix.LhsSize() != 0 && listener->IsInterested()) {
+        *listener << "which has " << Elements(matrix.LhsSize());
+      }
+      return false;
    }
  }

-  bool result = !is_exact_match_with_size_discrepency;
+  bool result = true;
  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);

--- a/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc
+++ b/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc
@@ -490,7 +490,6 @@ class MockObjectRegistry {
  // failure, unless the user explicitly asked us to ignore it.
  ~MockObjectRegistry() {
    if (!GMOCK_FLAG_GET(catch_leaked_mocks)) return;
-    internal::MutexLock l(&internal::g_gmock_mutex);

    int leaked_count = 0;
    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
@@ -531,7 +530,7 @@ class MockObjectRegistry {
 #ifdef GTEST_OS_QURT
      qurt_exception_raise_fatal();
 #else
-      _Exit(1);  // We cannot call exit() as it is not reentrant and
+      _exit(1);  // We cannot call exit() as it is not reentrant and
                 // may already have been called.
 #endif
    }
--- a/3rdparty/googletest/googletest/README.md
+++ b/3rdparty/googletest/googletest/README.md
@@ -12,7 +12,7 @@ GoogleTest comes with a CMake build script
 ([CMakeLists.txt](https://github.com/google/googletest/blob/main/CMakeLists.txt))
 that can be used on a wide range of platforms ("C" stands for cross-platform.).
 If you don't have CMake installed already, you can download it for free from
-<https://cmake.org/>.
+<http://www.cmake.org/>.

 CMake works by generating native makefiles or build projects that can be used in
 the compiler environment of your choice. You can either build GoogleTest as a
@@ -25,7 +25,7 @@ When building GoogleTest as a standalone project, the typical workflow starts
 with

 ```
-git clone https://github.com/google/googletest.git -b v1.15.0
+git clone https://github.com/google/googletest.git -b v1.13.0
 cd googletest        # Main directory of the cloned repository.
 mkdir build          # Create a directory to hold the build output.
 cd build
--- a/3rdparty/googletest/googletest/include/gtest/gtest-assertion-result.h
+++ b/3rdparty/googletest/googletest/include/gtest/gtest-assertion-result.h
@@ -129,7 +129,7 @@ namespace testing {
 //
 //   Expected: Foo() is even
 //     Actual: it's 5
-
+//
 class GTEST_API_ AssertionResult {
 public:
  // Copy constructor.
--- a/3rdparty/googletest/googletest/include/gtest/gtest-death-test.h
+++ b/3rdparty/googletest/googletest/include/gtest/gtest-death-test.h
@@ -293,8 +293,8 @@ class GTEST_API_ KilledBySignal {
 //                statement is compiled but not executed, to ensure that
 //                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
 //                parameter if and only if EXPECT_DEATH compiles with it.
-//   regex_or_matcher -  A regex that a macro such as EXPECT_DEATH would use
-//                to test the output of statement.  This parameter has to be
+//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
+//                the output of statement.  This parameter has to be
 //                compiled but not evaluated by this macro, to ensure that
 //                this macro only accepts expressions that a macro such as
 //                EXPECT_DEATH would accept.
@@ -311,13 +311,13 @@ class GTEST_API_ KilledBySignal {
 //  statement unconditionally returns or throws. The Message constructor at
 //  the end allows the syntax of streaming additional messages into the
 //  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
-#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex_or_matcher, terminator)  \
+#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator)             \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
  if (::testing::internal::AlwaysTrue()) {                                     \
    GTEST_LOG_(WARNING) << "Death tests are not supported on this platform.\n" \
                        << "Statement '" #statement "' cannot be verified.";   \
  } else if (::testing::internal::AlwaysFalse()) {                             \
-    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher);               \
+    ::testing::internal::RE::PartialMatch(".*", (regex));                      \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);                 \
    terminator;                                                                \
  } else                                                                       \
--- a/3rdparty/googletest/googletest/include/gtest/gtest-message.h
+++ b/3rdparty/googletest/googletest/include/gtest/gtest-message.h
@@ -59,7 +59,7 @@
 #ifdef GTEST_HAS_ABSL
 #include <type_traits>

-#include "absl/strings/has_absl_stringify.h"
+#include "absl/strings/internal/has_absl_stringify.h"
 #include "absl/strings/str_cat.h"
 #endif  // GTEST_HAS_ABSL

@@ -121,14 +121,14 @@ class GTEST_API_ Message {
  // Streams a non-pointer value to this object. If building a version of
  // GoogleTest with ABSL, this overload is only enabled if the value does not
  // have an AbslStringify definition.
-  template <
-      typename T
+  template <typename T
 #ifdef GTEST_HAS_ABSL
-      ,
-      typename std::enable_if<!absl::HasAbslStringify<T>::value,  // NOLINT
-                              int>::type = 0
+            ,
+            typename std::enable_if<
+                !absl::strings_internal::HasAbslStringify<T>::value,  // NOLINT
+                int>::type = 0
 #endif  // GTEST_HAS_ABSL
-      >
+            >
  inline Message& operator<<(const T& val) {
        // Some libraries overload << for STL containers.  These
    // overloads are defined in the global namespace instead of ::std.
@@ -153,8 +153,9 @@ class GTEST_API_ Message {
  // Streams a non-pointer value with an AbslStringify definition to this
  // object.
  template <typename T,
-            typename std::enable_if<absl::HasAbslStringify<T>::value,  // NOLINT
-                                    int>::type = 0>
+            typename std::enable_if<
+                absl::strings_internal::HasAbslStringify<T>::value,  // NOLINT
+                int>::type = 0>
  inline Message& operator<<(const T& val) {
    // ::operator<< is needed here for a similar reason as with the non-Abseil
    // version above
--- a/3rdparty/googletest/googletest/include/gtest/gtest-param-test.h
+++ b/3rdparty/googletest/googletest/include/gtest/gtest-param-test.h
@@ -178,7 +178,7 @@ TEST_P(DerivedTest, DoesBlah) {
 #include <utility>

 #include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-param-util.h"  // IWYU pragma: export
+#include "gtest/internal/gtest-param-util.h"
 #include "gtest/internal/gtest-port.h"

 namespace testing {
@@ -469,7 +469,7 @@ internal::ParamConverterGenerator<T> ConvertGenerator(
              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
      return 0;                                                                \
    }                                                                          \
-    GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static int gtest_registering_dummy_; \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
  };                                                                           \
  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
                             test_name)::gtest_registering_dummy_ =            \
@@ -514,8 +514,8 @@ internal::ParamConverterGenerator<T> ConvertGenerator(
        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,   \
        DUMMY_PARAM_))))(info);                                              \
  }                                                                          \
-  GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static int                           \
-      gtest_##prefix##test_suite_name##_dummy_ =                             \
+  static int gtest_##prefix##test_suite_name##_dummy_                        \
+      GTEST_ATTRIBUTE_UNUSED_ =                                              \
          ::testing::UnitTest::GetInstance()                                 \
              ->parameterized_test_registry()                                \
              .GetTestSuitePatternHolder<test_suite_name>(                   \
--- a/3rdparty/googletest/googletest/include/gtest/gtest-printers.h
+++ b/3rdparty/googletest/googletest/include/gtest/gtest-printers.h
@@ -116,16 +116,12 @@
 #include <vector>

 #ifdef GTEST_HAS_ABSL
-#include "absl/strings/has_absl_stringify.h"
+#include "absl/strings/internal/has_absl_stringify.h"
 #include "absl/strings/str_cat.h"
 #endif  // GTEST_HAS_ABSL
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-port.h"

-#if GTEST_INTERNAL_HAS_STD_SPAN
-#include <span>  // NOLINT
-#endif           // GTEST_INTERNAL_HAS_STD_SPAN
-
 namespace testing {

 // Definitions in the internal* namespaces are subject to change without notice.
@@ -135,32 +131,13 @@ namespace internal {
 template <typename T>
 void UniversalPrint(const T& value, ::std::ostream* os);

-template <typename T>
-struct IsStdSpan {
-  static constexpr bool value = false;
-};
-
-#if GTEST_INTERNAL_HAS_STD_SPAN
-template <typename E>
-struct IsStdSpan<std::span<E>> {
-  static constexpr bool value = true;
-};
-#endif  // GTEST_INTERNAL_HAS_STD_SPAN
-
 // Used to print an STL-style container when the user doesn't define
 // a PrintTo() for it.
-//
-// NOTE: Since std::span does not have const_iterator until C++23, it would
-// fail IsContainerTest before C++23. However, IsContainerTest only uses
-// the presence of const_iterator to avoid treating iterators as containers
-// because of iterator::iterator. Which means std::span satisfies the *intended*
-// condition of IsContainerTest.
 struct ContainerPrinter {
  template <typename T,
            typename = typename std::enable_if<
-                ((sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
-                 !IsRecursiveContainer<T>::value) ||
-                IsStdSpan<T>::value>::type>
+                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
+                !IsRecursiveContainer<T>::value>::type>
  static void PrintValue(const T& container, std::ostream* os) {
    const size_t kMaxCount = 32;  // The maximum number of elements to print.
    *os << '{';
@@ -241,8 +218,8 @@ struct StreamPrinter {
  // ADL (possibly involving implicit conversions).
  // (Use SFINAE via return type, because it seems GCC < 12 doesn't handle name
  // lookup properly when we do it in the template parameter list.)
-  static auto PrintValue(const T& value,
-                         ::std::ostream* os) -> decltype((void)(*os << value)) {
+  static auto PrintValue(const T& value, ::std::ostream* os)
+      -> decltype((void)(*os << value)) {
    // Call streaming operator found by ADL, possibly with implicit conversions
    // of the arguments.
    *os << value;
@@ -292,9 +269,10 @@ struct ConvertibleToStringViewPrinter {

 #ifdef GTEST_HAS_ABSL
 struct ConvertibleToAbslStringifyPrinter {
-  template <typename T,
-            typename = typename std::enable_if<
-                absl::HasAbslStringify<T>::value>::type>  // NOLINT
+  template <
+      typename T,
+      typename = typename std::enable_if<
+          absl::strings_internal::HasAbslStringify<T>::value>::type>  // NOLINT
  static void PrintValue(const T& value, ::std::ostream* os) {
    *os << absl::StrCat(value);
  }
@@ -552,63 +530,49 @@ int AppropriateResolution(FloatType val) {
  int full = std::numeric_limits<FloatType>::max_digits10;
  if (val < 0) val = -val;

-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
  if (val < 1000000) {
    FloatType mulfor6 = 1e10;
-    // Without these static casts, the template instantiation for float would
-    // fail to compile when -Wdouble-promotion is enabled, as the arithmetic and
-    // comparison logic would promote floats to doubles.
-    if (val >= static_cast<FloatType>(100000.0)) {  // 100,000 to 999,999
+    if (val >= 100000.0) {  // 100,000 to 999,999
      mulfor6 = 1.0;
-    } else if (val >= static_cast<FloatType>(10000.0)) {
+    } else if (val >= 10000.0) {
      mulfor6 = 1e1;
-    } else if (val >= static_cast<FloatType>(1000.0)) {
+    } else if (val >= 1000.0) {
      mulfor6 = 1e2;
-    } else if (val >= static_cast<FloatType>(100.0)) {
+    } else if (val >= 100.0) {
      mulfor6 = 1e3;
-    } else if (val >= static_cast<FloatType>(10.0)) {
+    } else if (val >= 10.0) {
      mulfor6 = 1e4;
-    } else if (val >= static_cast<FloatType>(1.0)) {
+    } else if (val >= 1.0) {
      mulfor6 = 1e5;
-    } else if (val >= static_cast<FloatType>(0.1)) {
+    } else if (val >= 0.1) {
      mulfor6 = 1e6;
-    } else if (val >= static_cast<FloatType>(0.01)) {
+    } else if (val >= 0.01) {
      mulfor6 = 1e7;
-    } else if (val >= static_cast<FloatType>(0.001)) {
+    } else if (val >= 0.001) {
      mulfor6 = 1e8;
-    } else if (val >= static_cast<FloatType>(0.0001)) {
+    } else if (val >= 0.0001) {
      mulfor6 = 1e9;
    }
-    if (static_cast<FloatType>(static_cast<int32_t>(
-            val * mulfor6 + (static_cast<FloatType>(0.5)))) /
+    if (static_cast<FloatType>(static_cast<int32_t>(val * mulfor6 + 0.5)) /
            mulfor6 ==
        val)
      return 6;
-  } else if (val < static_cast<FloatType>(1e10)) {
-    FloatType divfor6 = static_cast<FloatType>(1.0);
-    if (val >= static_cast<FloatType>(1e9)) {  // 1,000,000,000 to 9,999,999,999
+  } else if (val < 1e10) {
+    FloatType divfor6 = 1.0;
+    if (val >= 1e9) {  // 1,000,000,000 to 9,999,999,999
      divfor6 = 10000;
-    } else if (val >=
-               static_cast<FloatType>(1e8)) {  // 100,000,000 to 999,999,999
+    } else if (val >= 1e8) {  // 100,000,000 to 999,999,999
      divfor6 = 1000;
-    } else if (val >=
-               static_cast<FloatType>(1e7)) {  // 10,000,000 to 99,999,999
+    } else if (val >= 1e7) {  // 10,000,000 to 99,999,999
      divfor6 = 100;
-    } else if (val >= static_cast<FloatType>(1e6)) {  // 1,000,000 to 9,999,999
+    } else if (val >= 1e6) {  // 1,000,000 to 9,999,999
      divfor6 = 10;
    }
-    if (static_cast<FloatType>(static_cast<int32_t>(
-            val / divfor6 + (static_cast<FloatType>(0.5)))) *
+    if (static_cast<FloatType>(static_cast<int32_t>(val / divfor6 + 0.5)) *
            divfor6 ==
        val)
      return 6;
  }
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
  return full;
 }

--- a/3rdparty/googletest/googletest/include/gtest/gtest-typed-test.h
+++ b/3rdparty/googletest/googletest/include/gtest/gtest-typed-test.h
@@ -194,34 +194,33 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
  GTEST_NAME_GENERATOR_(CaseName)

-#define TYPED_TEST(CaseName, TestName)                                       \
-  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                      \
-                "test-name must not be empty");                              \
-  template <typename gtest_TypeParam_>                                       \
-  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                           \
-      : public CaseName<gtest_TypeParam_> {                                  \
-   private:                                                                  \
-    typedef CaseName<gtest_TypeParam_> TestFixture;                          \
-    typedef gtest_TypeParam_ TypeParam;                                      \
-    void TestBody() override;                                                \
-  };                                                                         \
-  GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static bool                          \
-      gtest_##CaseName##_##TestName##_registered_ =                          \
-          ::testing::internal::TypeParameterizedTest<                        \
-              CaseName,                                                      \
-              ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(       \
-                  CaseName, TestName)>,                                      \
-              GTEST_TYPE_PARAMS_(                                            \
-                  CaseName)>::Register("",                                   \
-                                       ::testing::internal::CodeLocation(    \
-                                           __FILE__, __LINE__),              \
-                                       GTEST_STRINGIFY_(CaseName),           \
-                                       GTEST_STRINGIFY_(TestName), 0,        \
-                                       ::testing::internal::GenerateNames<   \
-                                           GTEST_NAME_GENERATOR_(CaseName),  \
-                                           GTEST_TYPE_PARAMS_(CaseName)>()); \
-  template <typename gtest_TypeParam_>                                       \
-  void GTEST_TEST_CLASS_NAME_(CaseName,                                      \
+#define TYPED_TEST(CaseName, TestName)                                        \
+  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \
+                "test-name must not be empty");                               \
+  template <typename gtest_TypeParam_>                                        \
+  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \
+      : public CaseName<gtest_TypeParam_> {                                   \
+   private:                                                                   \
+    typedef CaseName<gtest_TypeParam_> TestFixture;                           \
+    typedef gtest_TypeParam_ TypeParam;                                       \
+    void TestBody() override;                                                 \
+  };                                                                          \
+  static bool gtest_##CaseName##_##TestName##_registered_                     \
+      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
+          CaseName,                                                           \
+          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
+                                                                  TestName)>, \
+          GTEST_TYPE_PARAMS_(                                                 \
+              CaseName)>::Register("",                                        \
+                                   ::testing::internal::CodeLocation(         \
+                                       __FILE__, __LINE__),                   \
+                                   GTEST_STRINGIFY_(CaseName),                \
+                                   GTEST_STRINGIFY_(TestName), 0,             \
+                                   ::testing::internal::GenerateNames<        \
+                                       GTEST_NAME_GENERATOR_(CaseName),       \
+                                       GTEST_TYPE_PARAMS_(CaseName)>());      \
+  template <typename gtest_TypeParam_>                                        \
+  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \
                              TestName)<gtest_TypeParam_>::TestBody()

 // Legacy API is deprecated but still available
@@ -268,23 +267,22 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
  TYPED_TEST_SUITE_P
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

-#define TYPED_TEST_P(SuiteName, TestName)                         \
-  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                   \
-  template <typename gtest_TypeParam_>                            \
-  class TestName : public SuiteName<gtest_TypeParam_> {           \
-   private:                                                       \
-    typedef SuiteName<gtest_TypeParam_> TestFixture;              \
-    typedef gtest_TypeParam_ TypeParam;                           \
-    void TestBody() override;                                     \
-  };                                                              \
-  GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static bool               \
-      gtest_##TestName##_defined_ =                               \
-          GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName( \
-              __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),    \
-              GTEST_STRINGIFY_(TestName));                        \
-  }                                                               \
-  template <typename gtest_TypeParam_>                            \
-  void GTEST_SUITE_NAMESPACE_(                                    \
+#define TYPED_TEST_P(SuiteName, TestName)                           \
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                     \
+  template <typename gtest_TypeParam_>                              \
+  class TestName : public SuiteName<gtest_TypeParam_> {             \
+   private:                                                         \
+    typedef SuiteName<gtest_TypeParam_> TestFixture;                \
+    typedef gtest_TypeParam_ TypeParam;                             \
+    void TestBody() override;                                       \
+  };                                                                \
+  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \
+          __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),          \
+          GTEST_STRINGIFY_(TestName));                              \
+  }                                                                 \
+  template <typename gtest_TypeParam_>                              \
+  void GTEST_SUITE_NAMESPACE_(                                      \
      SuiteName)::TestName<gtest_TypeParam_>::TestBody()

 // Note: this won't work correctly if the trailing arguments are macros.
@@ -292,8 +290,8 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                             \
  typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_;      \
  }                                                                         \
-  GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static const char* const            \
-  GTEST_REGISTERED_TEST_NAMES_(SuiteName) =                                 \
+  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \
+      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \
      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)

@@ -305,24 +303,22 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
  REGISTER_TYPED_TEST_SUITE_P
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

-#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)        \
-  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                        \
-                "test-suit-prefix must not be empty");                       \
-  GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static bool                          \
-      gtest_##Prefix##_##SuiteName =                                         \
-          ::testing::internal::TypeParameterizedTestSuite<                   \
-              SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_, \
-              ::testing::internal::GenerateTypeList<Types>::type>::          \
-              Register(                                                      \
-                  GTEST_STRINGIFY_(Prefix),                                  \
-                  ::testing::internal::CodeLocation(__FILE__, __LINE__),     \
-                  &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),               \
-                  GTEST_STRINGIFY_(SuiteName),                               \
-                  GTEST_REGISTERED_TEST_NAMES_(SuiteName),                   \
-                  ::testing::internal::GenerateNames<                        \
-                      ::testing::internal::NameGeneratorSelector<            \
-                          __VA_ARGS__>::type,                                \
-                      ::testing::internal::GenerateTypeList<Types>::type>())
+#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)     \
+  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                     \
+                "test-suit-prefix must not be empty");                    \
+  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =      \
+      ::testing::internal::TypeParameterizedTestSuite<                    \
+          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,  \
+          ::testing::internal::GenerateTypeList<Types>::type>::           \
+          Register(GTEST_STRINGIFY_(Prefix),                              \
+                   ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),           \
+                   GTEST_STRINGIFY_(SuiteName),                           \
+                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),               \
+                   ::testing::internal::GenerateNames<                    \
+                       ::testing::internal::NameGeneratorSelector<        \
+                           __VA_ARGS__>::type,                            \
+                       ::testing::internal::GenerateTypeList<Types>::type>())

 // Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
--- a/3rdparty/googletest/googletest/include/gtest/gtest.h
+++ b/3rdparty/googletest/googletest/include/gtest/gtest.h
@@ -51,6 +51,7 @@

 #include <cstddef>
 #include <cstdint>
+#include <iomanip>
 #include <limits>
 #include <memory>
 #include <ostream>
@@ -60,16 +61,16 @@
 #include <type_traits>
 #include <vector>

-#include "gtest/gtest-assertion-result.h"  // IWYU pragma: export
-#include "gtest/gtest-death-test.h"  // IWYU pragma: export
-#include "gtest/gtest-matchers.h"  // IWYU pragma: export
-#include "gtest/gtest-message.h"  // IWYU pragma: export
-#include "gtest/gtest-param-test.h"  // IWYU pragma: export
-#include "gtest/gtest-printers.h"  // IWYU pragma: export
-#include "gtest/gtest-test-part.h"  // IWYU pragma: export
-#include "gtest/gtest-typed-test.h"  // IWYU pragma: export
-#include "gtest/gtest_pred_impl.h"  // IWYU pragma: export
-#include "gtest/gtest_prod.h"  // IWYU pragma: export
+#include "gtest/gtest-assertion-result.h"
+#include "gtest/gtest-death-test.h"
+#include "gtest/gtest-matchers.h"
+#include "gtest/gtest-message.h"
+#include "gtest/gtest-param-test.h"
+#include "gtest/gtest-printers.h"
+#include "gtest/gtest-test-part.h"
+#include "gtest/gtest-typed-test.h"
+#include "gtest/gtest_pred_impl.h"
+#include "gtest/gtest_prod.h"
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-string.h"

@@ -607,7 +608,7 @@ class GTEST_API_ TestInfo {
  friend class internal::UnitTestImpl;
  friend class internal::StreamingListenerTest;
  friend TestInfo* internal::MakeAndRegisterTestInfo(
-      std::string test_suite_name, const char* name, const char* type_param,
+      const char* test_suite_name, const char* name, const char* type_param,
      const char* value_param, internal::CodeLocation code_location,
      internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
      internal::TearDownTestSuiteFunc tear_down_tc,
@@ -615,7 +616,7 @@ class GTEST_API_ TestInfo {

  // Constructs a TestInfo object. The newly constructed instance assumes
  // ownership of the factory object.
-  TestInfo(std::string test_suite_name, std::string name,
+  TestInfo(const std::string& test_suite_name, const std::string& name,
           const char* a_type_param,   // NULL if not a type-parameterized test
           const char* a_value_param,  // NULL if not a value-parameterized test
           internal::CodeLocation a_code_location,
@@ -683,7 +684,7 @@ class GTEST_API_ TestSuite {
  //                 this is not a type-parameterized test.
  //   set_up_tc:    pointer to the function that sets up the test suite
  //   tear_down_tc: pointer to the function that tears down the test suite
-  TestSuite(const std::string& name, const char* a_type_param,
+  TestSuite(const char* name, const char* a_type_param,
            internal::SetUpTestSuiteFunc set_up_tc,
            internal::TearDownTestSuiteFunc tear_down_tc);

@@ -1262,20 +1263,6 @@ class GTEST_API_ UnitTest {
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  TestSuite* GetMutableTestSuite(int i);

-  // Invokes OsStackTrackGetterInterface::UponLeavingGTest. UponLeavingGTest()
-  // should be called immediately before Google Test calls user code. It saves
-  // some information about the current stack that CurrentStackTrace() will use
-  // to find and hide Google Test stack frames.
-  void UponLeavingGTest();
-
-  // Sets the TestSuite object for the test that's currently running.
-  void set_current_test_suite(TestSuite* a_current_test_suite)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Sets the TestInfo object for the test that's currently running.
-  void set_current_test_info(TestInfo* a_current_test_info)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
  // Accessors for the implementation object.
  internal::UnitTestImpl* impl() { return impl_; }
  const internal::UnitTestImpl* impl() const { return impl_; }
@@ -1284,8 +1271,6 @@ class GTEST_API_ UnitTest {
  // members of UnitTest.
  friend class ScopedTrace;
  friend class Test;
-  friend class TestInfo;
-  friend class TestSuite;
  friend class internal::AssertHelper;
  friend class internal::StreamingListenerTest;
  friend class internal::UnitTestRecordPropertyTestHelper;
@@ -1589,12 +1574,12 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
  }

  ::std::stringstream lhs_ss;
-  lhs_ss.precision(std::numeric_limits<RawType>::digits10 + 2);
-  lhs_ss << lhs_value;
+  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << lhs_value;

  ::std::stringstream rhs_ss;
-  rhs_ss.precision(std::numeric_limits<RawType>::digits10 + 2);
-  rhs_ss << rhs_value;
+  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << rhs_value;

  return EqFailure(lhs_expression, rhs_expression,
                   StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss),
@@ -1767,7 +1752,6 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
 // generic name and clashes with some other libraries.
 #if !(defined(GTEST_DONT_DEFINE_FAIL) && GTEST_DONT_DEFINE_FAIL)
 #define FAIL() GTEST_FAIL()
-#define FAIL_AT(file, line) GTEST_FAIL_AT(file, line)
 #endif

 // Generates a success with a generic message.
@@ -2324,8 +2308,7 @@ TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
 // tests are successful, or 1 otherwise.
 //
 // RUN_ALL_TESTS() should be invoked after the command line has been
-// parsed by InitGoogleTest(). RUN_ALL_TESTS will tear down and delete any
-// installed environments and should only be called once per binary.
+// parsed by InitGoogleTest().
 //
 // This function was formerly a macro; thus, it is in the global
 // namespace and has an all-caps name.
--- a/3rdparty/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
+++ b/3rdparty/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
@@ -46,38 +46,17 @@

 #include "gtest/gtest-matchers.h"
 #include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-port.h"

 GTEST_DECLARE_string_(internal_run_death_test);

 namespace testing {
 namespace internal {

-// Name of the flag (needed for parsing Google Test flag).
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kDeathTestUseFork[] = "death_test_use_fork";
 const char kInternalRunDeathTestFlag[] = "internal_run_death_test";

-// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
-// and interpreted as a regex (rather than an Eq matcher) for legacy
-// compatibility.
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    ::testing::internal::RE regex) {
-  return ContainsRegex(regex.pattern());
-}
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
-  return ContainsRegex(regex);
-}
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    const ::std::string& regex) {
-  return ContainsRegex(regex);
-}
-
-// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
-// used directly.
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    Matcher<const ::std::string&> matcher) {
-  return matcher;
-}
-
 #ifdef GTEST_HAS_DEATH_TEST

 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
@@ -94,7 +73,7 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 //
 // exit status:  The integer exit information in the format specified
 //               by wait(2)
-// exit code:    The integer code passed to exit(3), _Exit(2), or
+// exit code:    The integer code passed to exit(3), _exit(2), or
 //               returned from main()
 class GTEST_API_ DeathTest {
 public:
@@ -191,6 +170,28 @@ class DefaultDeathTestFactory : public DeathTestFactory {
 // by a signal, or exited normally with a nonzero exit code.
 GTEST_API_ bool ExitedUnsuccessfully(int exit_status);

+// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
+// and interpreted as a regex (rather than an Eq matcher) for legacy
+// compatibility.
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    ::testing::internal::RE regex) {
+  return ContainsRegex(regex.pattern());
+}
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
+  return ContainsRegex(regex);
+}
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    const ::std::string& regex) {
+  return ContainsRegex(regex);
+}
+
+// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
+// used directly.
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    Matcher<const ::std::string&> matcher) {
+  return matcher;
+}
+
 // Traps C++ exceptions escaping statement and reports them as test
 // failures. Note that trapping SEH exceptions is not implemented here.
 #if GTEST_HAS_EXCEPTIONS
--- a/3rdparty/googletest/googletest/include/gtest/internal/gtest-filepath.h
+++ b/3rdparty/googletest/googletest/include/gtest/internal/gtest-filepath.h
@@ -43,7 +43,6 @@
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_

 #include <string>
-#include <utility>

 #include "gtest/internal/gtest-port.h"
 #include "gtest/internal/gtest-string.h"
@@ -71,9 +70,8 @@ class GTEST_API_ FilePath {
 public:
  FilePath() : pathname_("") {}
  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) {}
-  FilePath(FilePath&& rhs) noexcept : pathname_(std::move(rhs.pathname_)) {}

-  explicit FilePath(std::string pathname) : pathname_(std::move(pathname)) {
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
    Normalize();
  }

@@ -81,10 +79,6 @@ class GTEST_API_ FilePath {
    Set(rhs);
    return *this;
  }
-  FilePath& operator=(FilePath&& rhs) noexcept {
-    pathname_ = std::move(rhs.pathname_);
-    return *this;
-  }

  void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; }

--- a/3rdparty/googletest/googletest/include/gtest/internal/gtest-internal.h
+++ b/3rdparty/googletest/googletest/include/gtest/internal/gtest-internal.h
@@ -58,6 +58,7 @@

 #include <cstdint>
 #include <functional>
+#include <iomanip>
 #include <limits>
 #include <map>
 #include <set>
@@ -78,7 +79,7 @@
 //
 // will result in the token foo__LINE__, instead of foo followed by
 // the current line number.  For more details, see
-// https://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo##bar

@@ -169,7 +170,7 @@ namespace edit_distance {
 // All edits cost the same, with replace having lower priority than
 // add/remove.
 // Simple implementation of the Wagner-Fischer algorithm.
-// See https://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
 enum EditType { kMatch, kAdd, kRemove, kReplace };
 GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
    const std::vector<size_t>& left, const std::vector<size_t>& right);
@@ -236,7 +237,7 @@ GTEST_API_ std::string GetBoolAssertionFailureMessage(
 //   For double, there are 11 exponent bits and 52 fraction bits.
 //
 //   More details can be found at
-//   https://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
 //
 // Template parameter:
 //
@@ -281,7 +282,7 @@ class FloatingPoint {
  // bits.  Therefore, 4 should be enough for ordinary use.
  //
  // See the following article for more details on ULP:
-  // https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
  static const uint32_t kMaxUlps = 4;

  // Constructs a FloatingPoint from a raw floating-point number.
@@ -362,7 +363,7 @@ class FloatingPoint {
  //   N - 1  (the biggest number representable using
  //          sign-and-magnitude) is represented by 2N - 1.
  //
-  // Read https://en.wikipedia.org/wiki/Signed_number_representations
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
  // for more details on signed number representations.
  static Bits SignAndMagnitudeToBiased(const Bits& sam) {
    if (kSignBitMask & sam) {
@@ -474,8 +475,8 @@ using SetUpTestSuiteFunc = void (*)();
 using TearDownTestSuiteFunc = void (*)();

 struct CodeLocation {
-  CodeLocation(std::string a_file, int a_line)
-      : file(std::move(a_file)), line(a_line) {}
+  CodeLocation(const std::string& a_file, int a_line)
+      : file(a_file), line(a_line) {}

  std::string file;
  int line;
@@ -555,7 +556,7 @@ struct SuiteApiResolver : T {
 //   type_param:       the name of the test's type parameter, or NULL if
 //                     this is not a typed or a type-parameterized test.
 //   value_param:      text representation of the test's value parameter,
-//                     or NULL if this is not a value-parameterized test.
+//                     or NULL if this is not a type-parameterized test.
 //   code_location:    code location where the test is defined
 //   fixture_class_id: ID of the test fixture class
 //   set_up_tc:        pointer to the function that sets up the test suite
@@ -564,7 +565,7 @@ struct SuiteApiResolver : T {
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
-    std::string test_suite_name, const char* name, const char* type_param,
+    const char* test_suite_name, const char* name, const char* type_param,
    const char* value_param, CodeLocation code_location,
    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
@@ -595,7 +596,8 @@ class GTEST_API_ TypedTestSuitePState {
      fflush(stderr);
      posix::Abort();
    }
-    registered_tests_.emplace(test_name, CodeLocation(file, line));
+    registered_tests_.insert(
+        ::std::make_pair(test_name, CodeLocation(file, line)));
    return true;
  }

@@ -699,7 +701,7 @@ class TypeParameterizedTest {
  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
  // Types).  Valid values for 'index' are [0, N - 1] where N is the
  // length of Types.
-  static bool Register(const char* prefix, CodeLocation code_location,
+  static bool Register(const char* prefix, const CodeLocation& code_location,
                       const char* case_name, const char* test_names, int index,
                       const std::vector<std::string>& type_names =
                           GenerateNames<DefaultNameGenerator, Types>()) {
@@ -711,7 +713,8 @@ class TypeParameterizedTest {
    // list.
    MakeAndRegisterTestInfo(
        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
-         "/" + type_names[static_cast<size_t>(index)]),
+         "/" + type_names[static_cast<size_t>(index)])
+            .c_str(),
        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
        GetTypeName<Type>().c_str(),
        nullptr,  // No value parameter.
@@ -723,9 +726,13 @@ class TypeParameterizedTest {
        new TestFactoryImpl<TestClass>);

    // Next, recurses (at compile time) with the tail of the type list.
-    return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>::
-        Register(prefix, std::move(code_location), case_name, test_names,
-                 index + 1, type_names);
+    return TypeParameterizedTest<Fixture, TestSel,
+                                 typename Types::Tail>::Register(prefix,
+                                                                 code_location,
+                                                                 case_name,
+                                                                 test_names,
+                                                                 index + 1,
+                                                                 type_names);
  }
 };

@@ -733,7 +740,7 @@ class TypeParameterizedTest {
 template <GTEST_TEMPLATE_ Fixture, class TestSel>
 class TypeParameterizedTest<Fixture, TestSel, internal::None> {
 public:
-  static bool Register(const char* /*prefix*/, CodeLocation,
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
                       const char* /*case_name*/, const char* /*test_names*/,
                       int /*index*/,
                       const std::vector<std::string>& =
@@ -780,8 +787,7 @@ class TypeParameterizedTestSuite {

    // Next, recurses (at compile time) with the tail of the test list.
    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
-                                      Types>::Register(prefix,
-                                                       std::move(code_location),
+                                      Types>::Register(prefix, code_location,
                                                       state, case_name,
                                                       SkipComma(test_names),
                                                       type_names);
@@ -1137,6 +1143,40 @@ class NativeArray {
  void (NativeArray::*clone_)(const Element*, size_t);
 };

+// Backport of std::index_sequence.
+template <size_t... Is>
+struct IndexSequence {
+  using type = IndexSequence;
+};
+
+// Double the IndexSequence, and one if plus_one is true.
+template <bool plus_one, typename T, size_t sizeofT>
+struct DoubleSequence;
+template <size_t... I, size_t sizeofT>
+struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
+  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
+};
+template <size_t... I, size_t sizeofT>
+struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
+  using type = IndexSequence<I..., (sizeofT + I)...>;
+};
+
+// Backport of std::make_index_sequence.
+// It uses O(ln(N)) instantiation depth.
+template <size_t N>
+struct MakeIndexSequenceImpl
+    : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
+                     N / 2>::type {};
+
+template <>
+struct MakeIndexSequenceImpl<0> : IndexSequence<> {};
+
+template <size_t N>
+using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type;
+
+template <typename... T>
+using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type;
+
 template <size_t>
 struct Ignore {
  Ignore(...);  // NOLINT
@@ -1145,7 +1185,7 @@ struct Ignore {
 template <typename>
 struct ElemFromListImpl;
 template <size_t... I>
-struct ElemFromListImpl<std::index_sequence<I...>> {
+struct ElemFromListImpl<IndexSequence<I...>> {
  // We make Ignore a template to solve a problem with MSVC.
  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
  // MSVC doesn't understand how to deal with that pack expansion.
@@ -1156,8 +1196,9 @@ struct ElemFromListImpl<std::index_sequence<I...>> {

 template <size_t N, typename... T>
 struct ElemFromList {
-  using type = decltype(ElemFromListImpl<std::make_index_sequence<N>>::Apply(
-      static_cast<T (*)()>(nullptr)...));
+  using type =
+      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
+          static_cast<T (*)()>(nullptr)...));
 };

 struct FlatTupleConstructTag {};
@@ -1182,9 +1223,9 @@ template <typename Derived, typename Idx>
 struct FlatTupleBase;

 template <size_t... Idx, typename... T>
-struct FlatTupleBase<FlatTuple<T...>, std::index_sequence<Idx...>>
+struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
-  using Indices = std::index_sequence<Idx...>;
+  using Indices = IndexSequence<Idx...>;
  FlatTupleBase() = default;
  template <typename... Args>
  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
@@ -1219,15 +1260,14 @@ struct FlatTupleBase<FlatTuple<T...>, std::index_sequence<Idx...>>
 // implementations.
 // FlatTuple and ElemFromList are not recursive and have a fixed depth
 // regardless of T...
-// std::make_index_sequence, on the other hand, it is recursive but with an
+// MakeIndexSequence, on the other hand, it is recursive but with an
 // instantiation depth of O(ln(N)).
 template <typename... T>
 class FlatTuple
    : private FlatTupleBase<FlatTuple<T...>,
-                            std::make_index_sequence<sizeof...(T)>> {
-  using Indices =
-      typename FlatTupleBase<FlatTuple<T...>,
-                             std::make_index_sequence<sizeof...(T)>>::Indices;
+                            typename MakeIndexSequence<sizeof...(T)>::type> {
+  using Indices = typename FlatTupleBase<
+      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;

 public:
  FlatTuple() = default;
@@ -1501,8 +1541,7 @@ class NeverThrown {
                                                                               \
   private:                                                                    \
    void TestBody() override;                                                  \
-    GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED static ::testing::TestInfo* const    \
-        test_info_;                                                            \
+    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;      \
  };                                                                           \
                                                                               \
  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,           \
--- a/3rdparty/googletest/googletest/include/gtest/internal/gtest-param-util.h
+++ b/3rdparty/googletest/googletest/include/gtest/internal/gtest-param-util.h
@@ -47,7 +47,6 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
-#include <unordered_map>
 #include <utility>
 #include <vector>

@@ -86,7 +85,7 @@ namespace internal {
 // TEST_P macro is used to define two tests with the same name
 // but in different namespaces.
 GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
-                                           const CodeLocation& code_location);
+                                           CodeLocation code_location);

 template <typename>
 class ParamGeneratorInterface;
@@ -380,7 +379,9 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
 // integer test parameter index.
 template <class ParamType>
 std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
-  return std::to_string(info.index);
+  Message name_stream;
+  name_stream << info.index;
+  return name_stream.GetString();
 }

 template <typename T = int>
@@ -512,10 +513,9 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);

-  explicit ParameterizedTestSuiteInfo(std::string name,
+  explicit ParameterizedTestSuiteInfo(const char* name,
                                      CodeLocation code_location)
-      : test_suite_name_(std::move(name)),
-        code_location_(std::move(code_location)) {}
+      : test_suite_name_(name), code_location_(code_location) {}

  // Test suite base name for display purposes.
  const std::string& GetTestSuiteName() const override {
@@ -529,21 +529,20 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  // prefix). test_base_name is the name of an individual test without
  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
  // test suite base name and DoBar is test base name.
-  void AddTestPattern(const char*,
-                      const char* test_base_name,
+  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
                      TestMetaFactoryBase<ParamType>* meta_factory,
                      CodeLocation code_location) {
-    tests_.emplace_back(
-        new TestInfo(test_base_name, meta_factory, std::move(code_location)));
+    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
+        test_suite_name, test_base_name, meta_factory, code_location)));
  }
  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
  // about a generator.
-  int AddTestSuiteInstantiation(std::string instantiation_name,
+  int AddTestSuiteInstantiation(const std::string& instantiation_name,
                                GeneratorCreationFunc* func,
                                ParamNameGeneratorFunc* name_func,
                                const char* file, int line) {
-    instantiations_.emplace_back(std::move(instantiation_name), func, name_func,
-                                 file, line);
+    instantiations_.push_back(
+        InstantiationInfo(instantiation_name, func, name_func, file, line));
    return 0;  // Return value used only to run this method in namespace scope.
  }
  // UnitTest class invokes this method to register tests in this test suite
@@ -554,61 +553,60 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  void RegisterTests() override {
    bool generated_instantiations = false;

-    std::string test_suite_name;
-    std::string test_name;
-    for (const std::shared_ptr<TestInfo>& test_info : tests_) {
-      for (const InstantiationInfo& instantiation : instantiations_) {
-        const std::string& instantiation_name = instantiation.name;
-        ParamGenerator<ParamType> generator((*instantiation.generator)());
-        ParamNameGeneratorFunc* name_func = instantiation.name_func;
-        const char* file = instantiation.file;
-        int line = instantiation.line;
+    for (typename TestInfoContainer::iterator test_it = tests_.begin();
+         test_it != tests_.end(); ++test_it) {
+      std::shared_ptr<TestInfo> test_info = *test_it;
+      for (typename InstantiationContainer::iterator gen_it =
+               instantiations_.begin();
+           gen_it != instantiations_.end(); ++gen_it) {
+        const std::string& instantiation_name = gen_it->name;
+        ParamGenerator<ParamType> generator((*gen_it->generator)());
+        ParamNameGeneratorFunc* name_func = gen_it->name_func;
+        const char* file = gen_it->file;
+        int line = gen_it->line;

+        std::string test_suite_name;
        if (!instantiation_name.empty())
          test_suite_name = instantiation_name + "/";
-        else
-          test_suite_name.clear();
-        test_suite_name += test_suite_name_;
+        test_suite_name += test_info->test_suite_base_name;

        size_t i = 0;
        std::set<std::string> test_param_names;
-        for (const auto& param : generator) {
+        for (typename ParamGenerator<ParamType>::iterator param_it =
+                 generator.begin();
+             param_it != generator.end(); ++param_it, ++i) {
          generated_instantiations = true;

-          test_name.clear();
+          Message test_name_stream;

          std::string param_name =
-              name_func(TestParamInfo<ParamType>(param, i));
+              name_func(TestParamInfo<ParamType>(*param_it, i));

          GTEST_CHECK_(IsValidParamName(param_name))
              << "Parameterized test name '" << param_name
-              << "' is invalid (contains spaces, dashes, or any "
-                 "non-alphanumeric characters other than underscores), in "
-              << file << " line " << line << "" << std::endl;
+              << "' is invalid, in " << file << " line " << line << std::endl;

          GTEST_CHECK_(test_param_names.count(param_name) == 0)
              << "Duplicate parameterized test name '" << param_name << "', in "
              << file << " line " << line << std::endl;

+          test_param_names.insert(param_name);
+
          if (!test_info->test_base_name.empty()) {
-            test_name.append(test_info->test_base_name).append("/");
+            test_name_stream << test_info->test_base_name << "/";
          }
-          test_name += param_name;
-
-          test_param_names.insert(std::move(param_name));
-
+          test_name_stream << param_name;
          MakeAndRegisterTestInfo(
-              test_suite_name, test_name.c_str(),
+              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
              nullptr,  // No type parameter.
-              PrintToString(param).c_str(), test_info->code_location,
+              PrintToString(*param_it).c_str(), test_info->code_location,
              GetTestSuiteTypeId(),
              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
-              test_info->test_meta_factory->CreateTestFactory(param));
-          ++i;
-        }  // for param
-      }  // for instantiation
-    }  // for test_info
+              test_info->test_meta_factory->CreateTestFactory(*param_it));
+        }  // for param_it
+      }    // for gen_it
+    }      // for test_it

    if (!generated_instantiations) {
      // There are no generaotrs, or they all generate nothing ...
@@ -621,13 +619,15 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  // LocalTestInfo structure keeps information about a single test registered
  // with TEST_P macro.
  struct TestInfo {
-    TestInfo(const char* a_test_base_name,
+    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
             TestMetaFactoryBase<ParamType>* a_test_meta_factory,
             CodeLocation a_code_location)
-        : test_base_name(a_test_base_name),
+        : test_suite_base_name(a_test_suite_base_name),
+          test_base_name(a_test_base_name),
          test_meta_factory(a_test_meta_factory),
-          code_location(std::move(a_code_location)) {}
+          code_location(a_code_location) {}

+    const std::string test_suite_base_name;
    const std::string test_base_name;
    const std::unique_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;
    const CodeLocation code_location;
@@ -637,10 +637,11 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  //  <Instantiation name, Sequence generator creation function,
  //     Name generator function, Source file, Source line>
  struct InstantiationInfo {
-    InstantiationInfo(std::string name_in, GeneratorCreationFunc* generator_in,
+    InstantiationInfo(const std::string& name_in,
+                      GeneratorCreationFunc* generator_in,
                      ParamNameGeneratorFunc* name_func_in, const char* file_in,
                      int line_in)
-        : name(std::move(name_in)),
+        : name(name_in),
          generator(generator_in),
          name_func(name_func_in),
          file(file_in),
@@ -701,32 +702,29 @@ class ParameterizedTestSuiteRegistry {
  // tests and instantiations of a particular test suite.
  template <class TestSuite>
  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
-      std::string test_suite_name, CodeLocation code_location) {
+      const char* test_suite_name, CodeLocation code_location) {
    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
-
-    auto item_it = suite_name_to_info_index_.find(test_suite_name);
-    if (item_it != suite_name_to_info_index_.end()) {
-      auto* test_suite_info = test_suite_infos_[item_it->second];
-      if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
-        // Complain about incorrect usage of Google Test facilities
-        // and terminate the program since we cannot guaranty correct
-        // test suite setup and tear-down in this case.
-        ReportInvalidTestSuiteType(test_suite_name.c_str(), code_location);
-        posix::Abort();
-      } else {
-        // At this point we are sure that the object we found is of the same
-        // type we are looking for, so we downcast it to that type
-        // without further checks.
-        typed_test_info =
-            CheckedDowncastToActualType<ParameterizedTestSuiteInfo<TestSuite>>(
-                test_suite_info);
+    for (auto& test_suite_info : test_suite_infos_) {
+      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
+        if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
+          // Complain about incorrect usage of Google Test facilities
+          // and terminate the program since we cannot guaranty correct
+          // test suite setup and tear-down in this case.
+          ReportInvalidTestSuiteType(test_suite_name, code_location);
+          posix::Abort();
+        } else {
+          // At this point we are sure that the object we found is of the same
+          // type we are looking for, so we downcast it to that type
+          // without further checks.
+          typed_test_info = CheckedDowncastToActualType<
+              ParameterizedTestSuiteInfo<TestSuite>>(test_suite_info);
+        }
+        break;
      }
    }
    if (typed_test_info == nullptr) {
      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
-          test_suite_name, std::move(code_location));
-      suite_name_to_info_index_.emplace(std::move(test_suite_name),
-                                        test_suite_infos_.size());
+          test_suite_name, code_location);
      test_suite_infos_.push_back(typed_test_info);
    }
    return typed_test_info;
@@ -740,9 +738,8 @@ class ParameterizedTestSuiteRegistry {
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  template <class TestCase>
  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
-      std::string test_case_name, CodeLocation code_location) {
-    return GetTestSuitePatternHolder<TestCase>(std::move(test_case_name),
-                                               std::move(code_location));
+      const char* test_case_name, CodeLocation code_location) {
+    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
  }

 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
@@ -751,7 +748,6 @@ class ParameterizedTestSuiteRegistry {
  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;

  TestSuiteInfoContainer test_suite_infos_;
-  ::std::unordered_map<std::string, size_t> suite_name_to_info_index_;

  ParameterizedTestSuiteRegistry(const ParameterizedTestSuiteRegistry&) =
      delete;
@@ -778,7 +774,7 @@ class TypeParameterizedTestSuiteRegistry {
 private:
  struct TypeParameterizedTestSuiteInfo {
    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
-        : code_location(std::move(c)), instantiated(false) {}
+        : code_location(c), instantiated(false) {}

    CodeLocation code_location;
    bool instantiated;
@@ -807,12 +803,12 @@ class ValueArray {

  template <typename T>
  operator ParamGenerator<T>() const {  // NOLINT
-    return ValuesIn(MakeVector<T>(std::make_index_sequence<sizeof...(Ts)>()));
+    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
  }

 private:
  template <typename T, size_t... I>
-  std::vector<T> MakeVector(std::index_sequence<I...>) const {
+  std::vector<T> MakeVector(IndexSequence<I...>) const {
    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
  }

@@ -842,7 +838,7 @@ class CartesianProductGenerator
  template <class I>
  class IteratorImpl;
  template <size_t... I>
-  class IteratorImpl<std::index_sequence<I...>>
+  class IteratorImpl<IndexSequence<I...>>
      : public ParamIteratorInterface<ParamType> {
   public:
    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
@@ -933,7 +929,7 @@ class CartesianProductGenerator
    std::shared_ptr<ParamType> current_value_;
  };

-  using Iterator = IteratorImpl<std::make_index_sequence<sizeof...(T)>>;
+  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;

  std::tuple<ParamGenerator<T>...> generators_;
 };
--- a/3rdparty/googletest/googletest/include/gtest/internal/gtest-port-arch.h
+++ b/3rdparty/googletest/googletest/include/gtest/internal/gtest-port-arch.h
@@ -56,8 +56,6 @@
 #elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
 #define GTEST_OS_WINDOWS_PHONE 1
 #define GTEST_OS_WINDOWS_TV_TITLE 1
-#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_GAMES)
-#define GTEST_OS_WINDOWS_GAMES 1
 #else
 // WINAPI_FAMILY defined but no known partition matched.
 // Default to desktop.
--- a/3rdparty/googletest/googletest/include/gtest/internal/gtest-port.h
+++ b/3rdparty/googletest/googletest/include/gtest/internal/gtest-port.h
@@ -194,6 +194,8 @@
 //
 // Macros for basic C++ coding:
 //   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
+//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
+//                              variable don't have to be used.
 //   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
 //   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
 //                                        suppressed (constant conditional).
@@ -206,8 +208,6 @@
 //   or
 //                                 UniversalPrinter<absl::optional>
 //                                 specializations. Always defined to 0 or 1.
-//   GTEST_INTERNAL_HAS_STD_SPAN - for enabling UniversalPrinter<std::span>
-//                                 specializations. Always defined to 0 or 1
 //   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
 //                                    Matcher<absl::string_view>
 //                                    specializations. Always defined to 0 or 1.
@@ -279,22 +279,6 @@
 #error C++ versions less than C++14 are not supported.
 #endif

-// MSVC >= 19.11 (VS 2017 Update 3) supports __has_include.
-#ifdef __has_include
-#define GTEST_INTERNAL_HAS_INCLUDE __has_include
-#else
-#define GTEST_INTERNAL_HAS_INCLUDE(...) 0
-#endif
-
-// Detect C++ feature test macros as gracefully as possible.
-// MSVC >= 19.15, Clang >= 3.4.1, and GCC >= 4.1.2 support feature test macros.
-#if GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L && \
-    (!defined(__has_include) || GTEST_INTERNAL_HAS_INCLUDE(<version>))
-#include <version>  // C++20 and later
-#elif (!defined(__has_include) || GTEST_INTERNAL_HAS_INCLUDE(<ciso646>))
-#include <ciso646>  // Pre-C++20
-#endif
-
 #include <ctype.h>   // for isspace, etc
 #include <stddef.h>  // for ptrdiff_t
 #include <stdio.h>
@@ -336,8 +320,7 @@
 #define GTEST_HAS_NOTIFICATION_ 0
 #endif

-#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
-#define GTEST_INTERNAL_HAS_ABSL_FLAGS  // Used only in this file.
+#ifdef GTEST_HAS_ABSL
 #include "absl/flags/declare.h"
 #include "absl/flags/flag.h"
 #include "absl/flags/reflection.h"
@@ -607,8 +590,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
     defined(GTEST_OS_NETBSD) || defined(GTEST_OS_FUCHSIA) ||         \
     defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_GNU_KFREEBSD) || \
     defined(GTEST_OS_OPENBSD) || defined(GTEST_OS_HAIKU) ||          \
-     defined(GTEST_OS_GNU_HURD) || defined(GTEST_OS_SOLARIS) ||       \
-     defined(GTEST_OS_AIX) || defined(GTEST_OS_ZOS))
+     defined(GTEST_OS_GNU_HURD))
 #define GTEST_HAS_PTHREAD 1
 #else
 #define GTEST_HAS_PTHREAD 0
@@ -627,7 +609,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // Determines whether clone(2) is supported.
 // Usually it will only be available on Linux, excluding
 // Linux on the Itanium architecture.
-// Also see https://linux.die.net/man/2/clone.
+// Also see http://linux.die.net/man/2/clone.
 #ifndef GTEST_HAS_CLONE
 // The user didn't tell us, so we need to figure it out.

@@ -658,9 +640,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // platforms except known mobile / embedded ones. Also, if the port doesn't have
 // a file system, stream redirection is not supported.
 #if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
-    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_WINDOWS_GAMES) ||     \
-    defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) ||               \
-    defined(GTEST_OS_QURT) || !GTEST_HAS_FILE_SYSTEM
+    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) ||           \
+    defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) ||                  \
+    !GTEST_HAS_FILE_SYSTEM
 #define GTEST_HAS_STREAM_REDIRECTION 0
 #else
 #define GTEST_HAS_STREAM_REDIRECTION 1
@@ -670,7 +652,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // Determines whether to support death tests.
 // pops up a dialog window that cannot be suppressed programmatically.
 #if (defined(GTEST_OS_LINUX) || defined(GTEST_OS_CYGWIN) ||           \
-     defined(GTEST_OS_SOLARIS) || defined(GTEST_OS_ZOS) ||            \
+     defined(GTEST_OS_SOLARIS) ||                                     \
     (defined(GTEST_OS_MAC) && !defined(GTEST_OS_IOS)) ||             \
     (defined(GTEST_OS_WINDOWS_DESKTOP) && _MSC_VER) ||               \
     defined(GTEST_OS_WINDOWS_MINGW) || defined(GTEST_OS_AIX) ||      \
@@ -748,20 +730,6 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #define GTEST_HAVE_ATTRIBUTE_(x) 0
 #endif

-// GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE
-//
-// A function-like feature checking macro that accepts C++11 style attributes.
-// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
-// (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
-// find `__has_cpp_attribute`, will evaluate to 0.
-#if defined(__has_cpp_attribute)
-// NOTE: requiring __cplusplus above should not be necessary, but
-// works around https://bugs.llvm.org/show_bug.cgi?id=23435.
-#define GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#define GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE(x) 0
-#endif
-
 // GTEST_HAVE_FEATURE_
 //
 // A function-like feature checking macro that is a wrapper around
@@ -773,22 +741,14 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #endif

 // Use this annotation after a variable or parameter declaration to tell the
-// compiler the variable/parameter may be used.
+// compiler the variable/parameter does not have to be used.
 // Example:
 //
-//   GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED int foo = bar();
-//
-// This can be removed once we only support only C++17 or newer and
-// [[maybe_unused]] is available on all supported platforms.
-#if GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE(maybe_unused)
-#define GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED [[maybe_unused]]
-#elif GTEST_HAVE_ATTRIBUTE_(unused)
-// This is inferior to [[maybe_unused]] as it can produce a
-// -Wused-but-marked-unused warning on optionally used symbols, but it is all we
-// have.
-#define GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED __attribute__((__unused__))
+//   GTEST_ATTRIBUTE_UNUSED_ int foo = bar();
+#if GTEST_HAVE_ATTRIBUTE_(unused)
+#define GTEST_ATTRIBUTE_UNUSED_ __attribute__((unused))
 #else
-#define GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED
+#define GTEST_ATTRIBUTE_UNUSED_
 #endif

 // Use this annotation before a function that takes a printf format string.
@@ -867,9 +827,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #ifndef GTEST_API_

 #ifdef _MSC_VER
-#if defined(GTEST_LINKED_AS_SHARED_LIBRARY) && GTEST_LINKED_AS_SHARED_LIBRARY
+#if GTEST_LINKED_AS_SHARED_LIBRARY
 #define GTEST_API_ __declspec(dllimport)
-#elif defined(GTEST_CREATE_SHARED_LIBRARY) && GTEST_CREATE_SHARED_LIBRARY
+#elif GTEST_CREATE_SHARED_LIBRARY
 #define GTEST_API_ __declspec(dllexport)
 #endif
 #elif GTEST_HAVE_ATTRIBUTE_(visibility)
@@ -2027,9 +1987,7 @@ inline std::string StripTrailingSpaces(std::string str) {
 namespace posix {

 // File system porting.
-// Note: Not every I/O-related function is related to file systems, so don't
-// just disable all of them here. For example, fileno() and isatty(), etc. must
-// always be available in order to detect if a pipe points to a terminal.
+#if GTEST_HAS_FILE_SYSTEM
 #ifdef GTEST_OS_WINDOWS

 typedef struct _stat StatStruct;
@@ -2040,32 +1998,27 @@ inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
 // time and thus not defined there.
 #else
 inline int FileNo(FILE* file) { return _fileno(file); }
-#if GTEST_HAS_FILE_SYSTEM
 inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
 inline int RmDir(const char* dir) { return _rmdir(dir); }
 inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; }
-#endif
 #endif  // GTEST_OS_WINDOWS_MOBILE

 #elif defined(GTEST_OS_ESP8266)
 typedef struct stat StatStruct;

 inline int FileNo(FILE* file) { return fileno(file); }
-#if GTEST_HAS_FILE_SYSTEM
 inline int Stat(const char* path, StatStruct* buf) {
  // stat function not implemented on ESP8266
  return 0;
 }
 inline int RmDir(const char* dir) { return rmdir(dir); }
 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
-#endif

 #else

 typedef struct stat StatStruct;

 inline int FileNo(FILE* file) { return fileno(file); }
-#if GTEST_HAS_FILE_SYSTEM
 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
 #ifdef GTEST_OS_QURT
 // QuRT doesn't support any directory functions, including rmdir
@@ -2074,9 +2027,9 @@ inline int RmDir(const char*) { return 0; }
 inline int RmDir(const char* dir) { return rmdir(dir); }
 #endif
 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
-#endif

 #endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_HAS_FILE_SYSTEM

 // Other functions with a different name on Windows.

@@ -2129,9 +2082,8 @@ GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
 // defined there.
 #if GTEST_HAS_FILE_SYSTEM
 #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
-    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_GAMES) &&     \
-    !defined(GTEST_OS_ESP8266) && !defined(GTEST_OS_XTENSA) &&               \
-    !defined(GTEST_OS_QURT)
+    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_ESP8266) &&           \
+    !defined(GTEST_OS_XTENSA) && !defined(GTEST_OS_QURT)
 inline int ChDir(const char* dir) { return chdir(dir); }
 #endif
 inline FILE* FOpen(const char* path, const char* mode) {
@@ -2275,7 +2227,7 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
 #endif  // !defined(GTEST_FLAG)

 // Pick a command line flags implementation.
-#ifdef GTEST_INTERNAL_HAS_ABSL_FLAGS
+#ifdef GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GTEST_DEFINE_bool_(name, default_val, doc) \
@@ -2300,8 +2252,7 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
  (void)(::absl::SetFlag(&GTEST_FLAG(name), value))
 #define GTEST_USE_OWN_FLAGFILE_FLAG_ 0

-#undef GTEST_INTERNAL_HAS_ABSL_FLAGS
-#else  // ndef GTEST_INTERNAL_HAS_ABSL_FLAGS
+#else  // GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GTEST_DEFINE_bool_(name, default_val, doc)  \
@@ -2343,7 +2294,7 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
 #define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
 #define GTEST_USE_OWN_FLAGFILE_FLAG_ 1

-#endif  // GTEST_INTERNAL_HAS_ABSL_FLAGS
+#endif  // GTEST_HAS_ABSL

 // Thread annotations
 #if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
@@ -2398,9 +2349,9 @@ using Any = ::absl::any;
 }  // namespace internal
 }  // namespace testing
 #else
-#if defined(__cpp_lib_any) || (GTEST_INTERNAL_HAS_INCLUDE(<any>) &&        \
-                               GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
-                               (!defined(_MSC_VER) || GTEST_HAS_RTTI))
+#ifdef __has_include
+#if __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
+    (!defined(_MSC_VER) || GTEST_HAS_RTTI)
 // Otherwise for C++17 and higher use std::any for UniversalPrinter<>
 // specializations.
 #define GTEST_INTERNAL_HAS_ANY 1
@@ -2412,7 +2363,8 @@ using Any = ::std::any;
 }  // namespace testing
 // The case where absl is configured NOT to alias std::any is not
 // supported.
-#endif  // __cpp_lib_any
+#endif  // __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#endif  // __has_include
 #endif  // GTEST_HAS_ABSL

 #ifndef GTEST_INTERNAL_HAS_ANY
@@ -2432,8 +2384,8 @@ inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; }
 }  // namespace internal
 }  // namespace testing
 #else
-#if defined(__cpp_lib_optional) || (GTEST_INTERNAL_HAS_INCLUDE(<optional>) && \
-                                    GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L)
+#ifdef __has_include
+#if __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
 // Otherwise for C++17 and higher use std::optional for UniversalPrinter<>
 // specializations.
 #define GTEST_INTERNAL_HAS_OPTIONAL 1
@@ -2447,22 +2399,14 @@ inline ::std::nullopt_t Nullopt() { return ::std::nullopt; }
 }  // namespace testing
 // The case where absl is configured NOT to alias std::optional is not
 // supported.
-#endif  // __cpp_lib_optional
+#endif  // __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#endif  // __has_include
 #endif  // GTEST_HAS_ABSL

 #ifndef GTEST_INTERNAL_HAS_OPTIONAL
 #define GTEST_INTERNAL_HAS_OPTIONAL 0
 #endif

-#if defined(__cpp_lib_span) || (GTEST_INTERNAL_HAS_INCLUDE(<span>) && \
-                                GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L)
-#define GTEST_INTERNAL_HAS_STD_SPAN 1
-#endif  // __cpp_lib_span
-
-#ifndef GTEST_INTERNAL_HAS_STD_SPAN
-#define GTEST_INTERNAL_HAS_STD_SPAN 0
-#endif
-
 #ifdef GTEST_HAS_ABSL
 // Always use absl::string_view for Matcher<> specializations if googletest
 // is built with absl support.
@@ -2474,9 +2418,8 @@ using StringView = ::absl::string_view;
 }  // namespace internal
 }  // namespace testing
 #else
-#if defined(__cpp_lib_string_view) ||             \
-    (GTEST_INTERNAL_HAS_INCLUDE(<string_view>) && \
-     GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L)
+#ifdef __has_include
+#if __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
 // Otherwise for C++17 and higher use std::string_view for Matcher<>
 // specializations.
 #define GTEST_INTERNAL_HAS_STRING_VIEW 1
@@ -2488,7 +2431,9 @@ using StringView = ::std::string_view;
 }  // namespace testing
 // The case where absl is configured NOT to alias std::string_view is not
 // supported.
-#endif  // __cpp_lib_string_view
+#endif  // __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >=
+        // 201703L
+#endif  // __has_include
 #endif  // GTEST_HAS_ABSL

 #ifndef GTEST_INTERNAL_HAS_STRING_VIEW
@@ -2507,8 +2452,8 @@ using Variant = ::absl::variant<T...>;
 }  // namespace internal
 }  // namespace testing
 #else
-#if defined(__cpp_lib_variant) || (GTEST_INTERNAL_HAS_INCLUDE(<variant>) && \
-                                   GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L)
+#ifdef __has_include
+#if __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
 // Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
 // specializations.
 #define GTEST_INTERNAL_HAS_VARIANT 1
@@ -2520,16 +2465,16 @@ using Variant = ::std::variant<T...>;
 }  // namespace internal
 }  // namespace testing
 // The case where absl is configured NOT to alias std::variant is not supported.
-#endif  // __cpp_lib_variant
+#endif  // __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#endif  // __has_include
 #endif  // GTEST_HAS_ABSL

 #ifndef GTEST_INTERNAL_HAS_VARIANT
 #define GTEST_INTERNAL_HAS_VARIANT 0
 #endif

-#if (defined(__cpp_constexpr) && !defined(__cpp_inline_variables)) || \
-    (defined(GTEST_INTERNAL_CPLUSPLUS_LANG) &&                        \
-     GTEST_INTERNAL_CPLUSPLUS_LANG < 201703L)
+#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
+    GTEST_INTERNAL_CPLUSPLUS_LANG < 201703L
 #define GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL 1
 #endif

--- a/3rdparty/googletest/googletest/include/gtest/internal/gtest-type-util.h
+++ b/3rdparty/googletest/googletest/include/gtest/internal/gtest-type-util.h
@@ -71,7 +71,7 @@ inline std::string CanonicalizeForStdLibVersioning(std::string s) {
  // Strip redundant spaces in typename to match MSVC
  // For example, std::pair<int, bool> -> std::pair<int,bool>
  static const char to_search[] = ", ";
-  const char replace_char = ',';
+  static const char replace_str[] = ",";
  size_t pos = 0;
  while (true) {
    // Get the next occurrence from the current position
@@ -80,8 +80,8 @@ inline std::string CanonicalizeForStdLibVersioning(std::string s) {
      break;
    }
    // Replace this occurrence of substring
-    s.replace(pos, strlen(to_search), 1, replace_char);
-    ++pos;
+    s.replace(pos, strlen(to_search), replace_str);
+    pos += strlen(replace_str);
  }
  return s;
 }
--- a/3rdparty/googletest/googletest/src/gtest-death-test.cc
+++ b/3rdparty/googletest/googletest/src/gtest-death-test.cc
@@ -32,8 +32,6 @@

 #include "gtest/gtest-death-test.h"

-#include <stdlib.h>
-
 #include <functional>
 #include <memory>
 #include <sstream>
@@ -117,7 +115,7 @@ GTEST_DEFINE_string_(
 GTEST_DEFINE_bool_(
    death_test_use_fork,
    testing::internal::BoolFromGTestEnv("death_test_use_fork", false),
-    "Instructs to use fork()/_Exit() instead of clone() in death tests. "
+    "Instructs to use fork()/_exit() instead of clone() in death tests. "
    "Ignored and always uses fork() on POSIX systems where clone() is not "
    "implemented. Useful when running under valgrind or similar tools if "
    "those do not support clone(). Valgrind 3.3.1 will just fail if "
@@ -301,7 +299,7 @@ enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
    fputc(kDeathTestInternalError, parent);
    fprintf(parent, "%s", message.c_str());
    fflush(parent);
-    _Exit(1);
+    _exit(1);
  } else {
    fprintf(stderr, "%s", message.c_str());
    fflush(stderr);
@@ -513,7 +511,7 @@ std::string DeathTestImpl::GetErrorLogs() { return GetCapturedStderr(); }
 // Signals that the death test code which should have exited, didn't.
 // Should be called only in a death test child process.
 // Writes a status byte to the child's status file descriptor, then
-// calls _Exit(1).
+// calls _exit(1).
 void DeathTestImpl::Abort(AbortReason reason) {
  // The parent process considers the death test to be a failure if
  // it finds any data in our pipe.  So, here we write a single flag byte
@@ -525,13 +523,13 @@ void DeathTestImpl::Abort(AbortReason reason) {
  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
  // We are leaking the descriptor here because on some platforms (i.e.,
  // when built as Windows DLL), destructors of global objects will still
-  // run after calling _Exit(). On such systems, write_fd_ will be
+  // run after calling _exit(). On such systems, write_fd_ will be
  // indirectly closed from the destructor of UnitTestImpl, causing double
  // close if it is also closed here. On debug configurations, double close
  // may assert. As there are no in-process buffers to flush here, we are
  // relying on the OS to close the descriptor after the process terminates
  // when the destructors are not run.
-  _Exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
+  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
 }

 // Returns an indented copy of stderr output for a death test.
@@ -630,13 +628,13 @@ bool DeathTestImpl::Passed(bool status_ok) {
 #ifndef GTEST_OS_WINDOWS
 // Note: The return value points into args, so the return value's lifetime is
 // bound to that of args.
-static std::vector<char*> CreateArgvFromArgs(std::vector<std::string>& args) {
-  std::vector<char*> result;
-  result.reserve(args.size() + 1);
-  for (auto& arg : args) {
-    result.push_back(&arg[0]);
+static std::unique_ptr<char*[]> CreateArgvFromArgs(
+    std::vector<std::string>& args) {
+  auto result = std::make_unique<char*[]>(args.size() + 1);
+  for (size_t i = 0; i < args.size(); ++i) {
+    result[i] = &args[i][0];
  }
-  result.push_back(nullptr);  // Extra null terminator.
+  result[args.size()] = nullptr;  // extra null terminator
  return result;
 }
 #endif
@@ -785,7 +783,7 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
      // size_t has the same width as pointers on both 32-bit and 64-bit
      // Windows platforms.
-      // See https://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
+      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) + "|" +
      StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));

@@ -1036,8 +1034,8 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
  // "Fuchsia Test Component" which contains a "Fuchsia Component Manifest")
  // Launching processes is a privileged operation in Fuchsia, and the
  // declaration indicates that the ability is required for the component.
-  std::vector<char*> argv = CreateArgvFromArgs(args);
-  status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.data(),
+  std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
+  status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.get(),
                          nullptr, 2, spawn_actions,
                          child_process_.reset_and_get_address(), nullptr);
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
@@ -1335,7 +1333,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
 #endif  // GTEST_HAS_CLONE

  if (use_fork && (child_pid = fork()) == 0) {
-    _Exit(ExecDeathTestChildMain(&args));
+    _exit(ExecDeathTestChildMain(&args));
  }
 #endif  // GTEST_OS_QNX
 #ifdef GTEST_OS_LINUX
@@ -1388,8 +1386,8 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
  // is necessary.
  FlushInfoLog();

-  std::vector<char*> argv = CreateArgvFromArgs(args);
-  const pid_t child_pid = ExecDeathTestSpawnChild(argv.data(), pipe_fd[0]);
+  std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
+  const pid_t child_pid = ExecDeathTestSpawnChild(argv.get(), pipe_fd[0]);
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
  set_child_pid(child_pid);
  set_read_fd(pipe_fd[0]);
--- a/3rdparty/googletest/googletest/src/gtest-filepath.cc
+++ b/3rdparty/googletest/googletest/src/gtest-filepath.cc
@@ -336,7 +336,7 @@ bool FilePath::CreateDirectoriesRecursively() const {
    return false;
  }

-  if (pathname_.empty() || this->DirectoryExists()) {
+  if (pathname_.length() == 0 || this->DirectoryExists()) {
    return true;
  }

--- a/3rdparty/googletest/googletest/src/gtest-internal-inl.h
+++ b/3rdparty/googletest/googletest/src/gtest-internal-inl.h
@@ -46,7 +46,6 @@
 #include <memory>
 #include <set>
 #include <string>
-#include <unordered_map>
 #include <vector>

 #include "gtest/internal/gtest-port.h"
@@ -313,7 +312,7 @@ void ShuffleRange(internal::Random* random, int begin, int end,
      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from
-  // https://en.wikipedia.org/wiki/Fisher-Yates_shuffle
+  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
  for (int range_width = end - begin; range_width >= 2; range_width--) {
    const int last_in_range = begin + range_width - 1;
    const int selected =
@@ -650,15 +649,13 @@ class GTEST_API_ UnitTestImpl {
  //                    this is not a typed or a type-parameterized test.
  //   set_up_tc:       pointer to the function that sets up the test suite
  //   tear_down_tc:    pointer to the function that tears down the test suite
-  TestSuite* GetTestSuite(const std::string& test_suite_name,
-                          const char* type_param,
+  TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param,
                          internal::SetUpTestSuiteFunc set_up_tc,
                          internal::TearDownTestSuiteFunc tear_down_tc);

 //  Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  TestCase* GetTestCase(const std::string& test_case_name,
-                        const char* type_param,
+  TestCase* GetTestCase(const char* test_case_name, const char* type_param,
                        internal::SetUpTestSuiteFunc set_up_tc,
                        internal::TearDownTestSuiteFunc tear_down_tc) {
    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
@@ -684,13 +681,13 @@ class GTEST_API_ UnitTestImpl {
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
-      original_working_dir_ = FilePath::GetCurrentDir();
+      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }
 #endif  // GTEST_HAS_FILE_SYSTEM

-    GetTestSuite(test_info->test_suite_name_, test_info->type_param(),
+    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
                 set_up_tc, tear_down_tc)
        ->AddTestInfo(test_info);
  }
@@ -712,6 +709,18 @@ class GTEST_API_ UnitTestImpl {
    return type_parameterized_test_registry_;
  }

+  // Sets the TestSuite object for the test that's currently running.
+  void set_current_test_suite(TestSuite* a_current_test_suite) {
+    current_test_suite_ = a_current_test_suite;
+  }
+
+  // Sets the TestInfo object for the test that's currently running.  If
+  // current_test_info is NULL, the assertion results will be stored in
+  // ad_hoc_test_result_.
+  void set_current_test_info(TestInfo* a_current_test_info) {
+    current_test_info_ = a_current_test_info;
+  }
+
  // Registers all parameterized tests defined using TEST_P and
  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter
  // combination. This method can be called more then once; it has guards
@@ -826,30 +835,12 @@ class GTEST_API_ UnitTestImpl {
  bool catch_exceptions() const { return catch_exceptions_; }

 private:
-  struct CompareTestSuitesByPointer {
-    bool operator()(const TestSuite* lhs, const TestSuite* rhs) const {
-      return lhs->name_ < rhs->name_;
-    }
-  };
-
  friend class ::testing::UnitTest;

  // Used by UnitTest::Run() to capture the state of
  // GTEST_FLAG(catch_exceptions) at the moment it starts.
  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }

-  // Sets the TestSuite object for the test that's currently running.
-  void set_current_test_suite(TestSuite* a_current_test_suite) {
-    current_test_suite_ = a_current_test_suite;
-  }
-
-  // Sets the TestInfo object for the test that's currently running.  If
-  // current_test_info is NULL, the assertion results will be stored in
-  // ad_hoc_test_result_.
-  void set_current_test_info(TestInfo* a_current_test_info) {
-    current_test_info_ = a_current_test_info;
-  }
-
  // The UnitTest object that owns this implementation object.
  UnitTest* const parent_;

@@ -882,9 +873,6 @@ class GTEST_API_ UnitTestImpl {
  // elements in the vector.
  std::vector<TestSuite*> test_suites_;

-  // The set of TestSuites by name.
-  std::unordered_map<std::string, TestSuite*> test_suites_by_name_;
-
  // Provides a level of indirection for the test suite list to allow
  // easy shuffling and restoring the test suite order.  The i-th
  // element of this vector is the index of the i-th test suite in the
--- a/3rdparty/googletest/googletest/src/gtest-port.cc
+++ b/3rdparty/googletest/googletest/src/gtest-port.cc
@@ -158,13 +158,13 @@ size_t GetThreadCount() {
 // we cannot detect it.
 size_t GetThreadCount() {
  int mib[] = {
-      CTL_KERN,
-      KERN_PROC,
-      KERN_PROC_PID,
-      getpid(),
+    CTL_KERN,
+    KERN_PROC,
+    KERN_PROC_PID,
+    getpid(),
 #ifdef GTEST_OS_NETBSD
-      sizeof(struct kinfo_proc),
-      1,
+    sizeof(struct kinfo_proc),
+    1,
 #endif
  };
  u_int miblen = sizeof(mib) / sizeof(mib[0]);
@@ -587,11 +587,9 @@ class ThreadLocalRegistryImpl {
  // thread's ID.
  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;

-  struct WatcherThreadParams {
-    DWORD thread_id;
-    HANDLE handle;
-    Notification has_initialized;
-  };
+  // Holds the thread id and thread handle that we pass from
+  // StartWatcherThreadFor to WatcherThreadFunc.
+  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;

  static void StartWatcherThreadFor(DWORD thread_id) {
    // The returned handle will be kept in thread_map and closed by
@@ -599,20 +597,15 @@ class ThreadLocalRegistryImpl {
    HANDLE thread =
        ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION, FALSE, thread_id);
    GTEST_CHECK_(thread != nullptr);
-
-    WatcherThreadParams* watcher_thread_params = new WatcherThreadParams;
-    watcher_thread_params->thread_id = thread_id;
-    watcher_thread_params->handle = thread;
-
    // We need to pass a valid thread ID pointer into CreateThread for it
    // to work correctly under Win98.
    DWORD watcher_thread_id;
-    HANDLE watcher_thread =
-        ::CreateThread(nullptr,  // Default security.
-                       0,        // Default stack size
-                       &ThreadLocalRegistryImpl::WatcherThreadFunc,
-                       reinterpret_cast<LPVOID>(watcher_thread_params),
-                       CREATE_SUSPENDED, &watcher_thread_id);
+    HANDLE watcher_thread = ::CreateThread(
+        nullptr,  // Default security.
+        0,        // Default stack size
+        &ThreadLocalRegistryImpl::WatcherThreadFunc,
+        reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
+        CREATE_SUSPENDED, &watcher_thread_id);
    GTEST_CHECK_(watcher_thread != nullptr)
        << "CreateThread failed with error " << ::GetLastError() << ".";
    // Give the watcher thread the same priority as ours to avoid being
@@ -621,25 +614,17 @@ class ThreadLocalRegistryImpl {
                        ::GetThreadPriority(::GetCurrentThread()));
    ::ResumeThread(watcher_thread);
    ::CloseHandle(watcher_thread);
-
-    // Wait for the watcher thread to start to avoid race conditions.
-    // One specific race condition that can happen is that we have returned
-    // from main and have started to tear down, the newly spawned watcher
-    // thread may access already-freed variables, like global shared_ptrs.
-    watcher_thread_params->has_initialized.WaitForNotification();
  }

  // Monitors exit from a given thread and notifies those
  // ThreadIdToThreadLocals about thread termination.
  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
-    WatcherThreadParams* watcher_thread_params =
-        reinterpret_cast<WatcherThreadParams*>(param);
-    watcher_thread_params->has_initialized.Notify();
-    GTEST_CHECK_(::WaitForSingleObject(watcher_thread_params->handle,
-                                       INFINITE) == WAIT_OBJECT_0);
-    OnThreadExit(watcher_thread_params->thread_id);
-    ::CloseHandle(watcher_thread_params->handle);
-    delete watcher_thread_params;
+    const ThreadIdAndHandle* tah =
+        reinterpret_cast<const ThreadIdAndHandle*>(param);
+    GTEST_CHECK_(::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
+    OnThreadExit(tah->first);
+    ::CloseHandle(tah->second);
+    delete tah;
    return 0;
  }

@@ -712,24 +697,13 @@ bool RE::PartialMatch(const char* str, const RE& re) {
 void RE::Init(const char* regex) {
  pattern_ = regex;

-  // NetBSD (and Android, which takes its regex implemntation from NetBSD) does
-  // not include the GNU regex extensions (such as Perl style character classes
-  // like \w) in REG_EXTENDED. REG_EXTENDED is only specified to include the
-  // [[:alpha:]] style character classes. Enable REG_GNU wherever it is defined
-  // so users can use those extensions.
-#if defined(REG_GNU)
-  constexpr int reg_flags = REG_EXTENDED | REG_GNU;
-#else
-  constexpr int reg_flags = REG_EXTENDED;
-#endif
-
  // Reserves enough bytes to hold the regular expression used for a
  // full match.
  const size_t full_regex_len = strlen(regex) + 10;
  char* const full_pattern = new char[full_regex_len];

  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
-  is_valid_ = regcomp(&full_regex_, full_pattern, reg_flags) == 0;
+  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
  // We want to call regcomp(&partial_regex_, ...) even if the
  // previous expression returns false.  Otherwise partial_regex_ may
  // not be properly initialized can may cause trouble when it's
@@ -740,7 +714,7 @@ void RE::Init(const char* regex) {
  // regex.  We change it to an equivalent form "()" to be safe.
  if (is_valid_) {
    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
-    is_valid_ = regcomp(&partial_regex_, partial_regex, reg_flags) == 0;
+    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
  }
  EXPECT_TRUE(is_valid_)
      << "Regular expression \"" << regex
@@ -1048,21 +1022,11 @@ GTestLog::~GTestLog() {
  }
 }

-#if GTEST_HAS_STREAM_REDIRECTION
-
 // Disable Microsoft deprecation warnings for POSIX functions called from
 // this class (creat, dup, dup2, and close)
 GTEST_DISABLE_MSC_DEPRECATED_PUSH_()

-namespace {
-
-#if defined(GTEST_OS_LINUX_ANDROID) || defined(GTEST_OS_IOS)
-bool EndsWithPathSeparator(const std::string& path) {
-  return !path.empty() && path.back() == GTEST_PATH_SEP_[0];
-}
-#endif
-
-}  // namespace
+#if GTEST_HAS_STREAM_REDIRECTION

 // Object that captures an output stream (stdout/stderr).
 class CapturedStream {
@@ -1100,13 +1064,7 @@ class CapturedStream {
    // The location /data/local/tmp is directly accessible from native code.
    // '/sdcard' and other variants cannot be relied on, as they are not
    // guaranteed to be mounted, or may have a delay in mounting.
-    //
-    // However, prefer using the TMPDIR environment variable if set, as newer
-    // devices may have /data/local/tmp read-only.
-    name_template = TempDir();
-    if (!EndsWithPathSeparator(name_template))
-      name_template.push_back(GTEST_PATH_SEP_[0]);
-
+    name_template = "/data/local/tmp/";
 #elif defined(GTEST_OS_IOS)
    char user_temp_dir[PATH_MAX + 1];

@@ -1126,7 +1084,7 @@ class CapturedStream {
    ::confstr(_CS_DARWIN_USER_TEMP_DIR, user_temp_dir, sizeof(user_temp_dir));

    name_template = user_temp_dir;
-    if (!EndsWithPathSeparator(name_template))
+    if (name_template.back() != GTEST_PATH_SEP_[0])
      name_template.push_back(GTEST_PATH_SEP_[0]);
 #else
    name_template = "/tmp/";
@@ -1348,8 +1306,8 @@ bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
  ) {
    Message msg;
    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually" << " has value "
-        << str << ", which overflows.\n";
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value " << str << ", which overflows.\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
--- a/3rdparty/googletest/googletest/src/gtest.cc
+++ b/3rdparty/googletest/googletest/src/gtest.cc
@@ -43,7 +43,6 @@
 #include <algorithm>
 #include <chrono>  // NOLINT
 #include <cmath>
-#include <csignal>  // NOLINT: raise(3) is used on some platforms
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
@@ -162,10 +161,6 @@
 #define GTEST_HAS_BUILTIN(x) 0
 #endif  // defined(__has_builtin)

-#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
-#define GTEST_HAS_ABSL_FLAGS
-#endif
-
 namespace testing {

 using internal::CountIf;
@@ -379,7 +374,7 @@ GTEST_DEFINE_string_(
    testing::internal::StringFromGTestEnv("stream_result_to", ""),
    "This flag specifies the host name and the port number on which to stream "
    "test results. Example: \"localhost:555\". The flag is effective only on "
-    "Linux and macOS.");
+    "Linux.");

 GTEST_DEFINE_bool_(
    throw_on_failure,
@@ -451,19 +446,6 @@ static bool ShouldRunTestSuite(const TestSuite* test_suite) {
  return test_suite->should_run();
 }

-namespace {
-
-// Returns true if test part results of type `type` should include a stack
-// trace.
-bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
-  // Suppress emission of the stack trace for SUCCEED() since it likely never
-  // requires investigation, and GTEST_SKIP() since skipping is an intentional
-  // act by the developer rather than a failure requiring investigation.
-  return type != TestPartResult::kSuccess && type != TestPartResult::kSkip;
-}
-
-}  // namespace
-
 // AssertHelper constructor.
 AssertHelper::AssertHelper(TestPartResult::Type type, const char* file,
                           int line, const char* message)
@@ -476,9 +458,7 @@ void AssertHelper::operator=(const Message& message) const {
  UnitTest::GetInstance()->AddTestPartResult(
      data_->type, data_->file, data_->line,
      AppendUserMessage(data_->message, message),
-      ShouldEmitStackTraceForResultType(data_->type)
-          ? UnitTest::GetInstance()->impl()->CurrentOsStackTraceExceptTop(1)
-          : ""
+      UnitTest::GetInstance()->impl()->CurrentOsStackTraceExceptTop(1)
      // Skips the stack frame for this function itself.
  );  // NOLINT
 }
@@ -536,8 +516,7 @@ void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
  if (ignored.find(name) != ignored.end()) return;

  const char kMissingInstantiation[] =  //
-      " is defined via TEST_P, but never instantiated. None of the test "
-      "cases "
+      " is defined via TEST_P, but never instantiated. None of the test cases "
      "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
      "ones provided expand to nothing."
      "\n\n"
@@ -578,7 +557,7 @@ void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
 void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
                                        CodeLocation code_location) {
  GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
-      test_suite_name, std::move(code_location));
+      test_suite_name, code_location);
 }

 void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
@@ -589,7 +568,7 @@ void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
 void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
    const char* test_suite_name, CodeLocation code_location) {
  suites_.emplace(std::string(test_suite_name),
-                  TypeParameterizedTestSuiteInfo(std::move(code_location)));
+                  TypeParameterizedTestSuiteInfo(code_location));
 }

 void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
@@ -616,12 +595,10 @@ void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
        "\n\n"
        "Ideally, TYPED_TEST_P definitions should only ever be included as "
        "part of binaries that intend to use them. (As opposed to, for "
-        "example, being placed in a library that may be linked in to get "
-        "other "
+        "example, being placed in a library that may be linked in to get other "
        "utilities.)"
        "\n\n"
-        "To suppress this error for this test suite, insert the following "
-        "line "
+        "To suppress this error for this test suite, insert the following line "
        "(in a non-header) in the namespace it is defined in:"
        "\n\n"
        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
@@ -661,14 +638,11 @@ static ::std::vector<std::string> g_argvs;
 FilePath GetCurrentExecutableName() {
  FilePath result;

-  auto args = GetArgvs();
-  if (!args.empty()) {
 #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_OS2)
-    result.Set(FilePath(args[0]).RemoveExtension("exe"));
+  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
 #else
-    result.Set(FilePath(args[0]));
+  result.Set(FilePath(GetArgvs()[0]));
 #endif  // GTEST_OS_WINDOWS
-  }

  return result.RemoveDirectoryName();
 }
@@ -804,7 +778,7 @@ class UnitTestFilter {
  // Returns true if and only if name matches at least one of the patterns in
  // the filter.
  bool MatchesName(const std::string& name) const {
-    return exact_match_patterns_.find(name) != exact_match_patterns_.end() ||
+    return exact_match_patterns_.count(name) > 0 ||
           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
                       [&name](const std::string& pattern) {
                         return PatternMatchesString(
@@ -905,7 +879,7 @@ int UnitTestOptions::GTestProcessSEH(DWORD seh_code, const char* location) {
  //      apparently).
  //
  // SEH exception code for C++ exceptions.
-  // (see https://support.microsoft.com/kb/185294 for more information).
+  // (see http://support.microsoft.com/kb/185294 for more information).
  const DWORD kCxxExceptionCode = 0xe06d7363;

  if (!GTEST_FLAG_GET(catch_exceptions) || seh_code == kCxxExceptionCode ||
@@ -2343,7 +2317,7 @@ static const char* const kReservedTestCaseAttributes[] = {
    "type_param", "value_param", "file",   "line"};

 // Use a slightly different set for allowed output to ensure existing tests can
-// still RecordProperty("result") or RecordProperty("timestamp")
+// still RecordProperty("result") or "RecordProperty(timestamp")
 static const char* const kReservedOutputTestCaseAttributes[] = {
    "classname",   "name", "status", "time",   "type_param",
    "value_param", "file", "line",   "result", "timestamp"};
@@ -2743,16 +2717,18 @@ bool Test::IsSkipped() {

 // Constructs a TestInfo object. It assumes ownership of the test factory
 // object.
-TestInfo::TestInfo(std::string a_test_suite_name, std::string a_name,
-                   const char* a_type_param, const char* a_value_param,
+TestInfo::TestInfo(const std::string& a_test_suite_name,
+                   const std::string& a_name, const char* a_type_param,
+                   const char* a_value_param,
                   internal::CodeLocation a_code_location,
                   internal::TypeId fixture_class_id,
                   internal::TestFactoryBase* factory)
-    : test_suite_name_(std::move(a_test_suite_name)),
-      name_(std::move(a_name)),
+    : test_suite_name_(a_test_suite_name),
+      // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997)
+      name_(a_name.begin(), a_name.end()),
      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
-      location_(std::move(a_code_location)),
+      location_(a_code_location),
      fixture_class_id_(fixture_class_id),
      should_run_(false),
      is_disabled_(false),
@@ -2785,19 +2761,19 @@ namespace internal {
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 TestInfo* MakeAndRegisterTestInfo(
-    std::string test_suite_name, const char* name, const char* type_param,
+    const char* test_suite_name, const char* name, const char* type_param,
    const char* value_param, CodeLocation code_location,
    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
  TestInfo* const test_info =
-      new TestInfo(std::move(test_suite_name), name, type_param, value_param,
-                   std::move(code_location), fixture_class_id, factory);
+      new TestInfo(test_suite_name, name, type_param, value_param,
+                   code_location, fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
 }

 void ReportInvalidTestSuiteType(const char* test_suite_name,
-                                const CodeLocation& code_location) {
+                                CodeLocation code_location) {
  Message errors;
  errors
      << "Attempted redefinition of test suite " << test_suite_name << ".\n"
@@ -2837,13 +2813,14 @@ void TestInfo::Run() {
  }

  // Tells UnitTest where to store test result.
-  UnitTest::GetInstance()->set_current_test_info(this);
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_info(this);

  // Notifies the unit test event listeners that a test is about to start.
  repeater->OnTestStart(*this);
  result_.set_start_timestamp(internal::GetTimeInMillis());
  internal::Timer timer;
-  UnitTest::GetInstance()->UponLeavingGTest();
+  impl->os_stack_trace_getter()->UponLeavingGTest();

  // Creates the test object.
  Test* const test = internal::HandleExceptionsInMethodIfSupported(
@@ -2861,7 +2838,7 @@ void TestInfo::Run() {

  if (test != nullptr) {
    // Deletes the test object.
-    UnitTest::GetInstance()->UponLeavingGTest();
+    impl->os_stack_trace_getter()->UponLeavingGTest();
    internal::HandleExceptionsInMethodIfSupported(
        test, &Test::DeleteSelf_, "the test fixture's destructor");
  }
@@ -2873,14 +2850,15 @@ void TestInfo::Run() {

  // Tells UnitTest to stop associating assertion results to this
  // test.
-  UnitTest::GetInstance()->set_current_test_info(nullptr);
+  impl->set_current_test_info(nullptr);
 }

 // Skip and records a skipped test result for this object.
 void TestInfo::Skip() {
  if (!should_run_) return;

-  UnitTest::GetInstance()->set_current_test_info(this);
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_info(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

@@ -2889,13 +2867,12 @@ void TestInfo::Skip() {

  const TestPartResult test_part_result =
      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
-  internal::GetUnitTestImpl()
-      ->GetTestPartResultReporterForCurrentThread()
-      ->ReportTestPartResult(test_part_result);
+  impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
+      test_part_result);

  // Notifies the unit test event listener that a test has just finished.
  repeater->OnTestEnd(*this);
-  UnitTest::GetInstance()->set_current_test_info(nullptr);
+  impl->set_current_test_info(nullptr);
 }

 // class TestSuite
@@ -2949,7 +2926,7 @@ int TestSuite::total_test_count() const {
 //                 this is not a typed or a type-parameterized test suite.
 //   set_up_tc:    pointer to the function that sets up the test suite
 //   tear_down_tc: pointer to the function that tears down the test suite
-TestSuite::TestSuite(const std::string& a_name, const char* a_type_param,
+TestSuite::TestSuite(const char* a_name, const char* a_type_param,
                     internal::SetUpTestSuiteFunc set_up_tc,
                     internal::TearDownTestSuiteFunc tear_down_tc)
    : name_(a_name),
@@ -2991,7 +2968,8 @@ void TestSuite::AddTestInfo(TestInfo* test_info) {
 void TestSuite::Run() {
  if (!should_run_) return;

-  UnitTest::GetInstance()->set_current_test_suite(this);
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_suite(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

@@ -3021,7 +2999,7 @@ void TestSuite::Run() {
  repeater->OnTestCaseStart(*this);
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

-  UnitTest::GetInstance()->UponLeavingGTest();
+  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");

@@ -3046,7 +3024,7 @@ void TestSuite::Run() {
  }
  elapsed_time_ = timer.Elapsed();

-  UnitTest::GetInstance()->UponLeavingGTest();
+  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");

@@ -3057,14 +3035,15 @@ void TestSuite::Run() {
  repeater->OnTestCaseEnd(*this);
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

-  UnitTest::GetInstance()->set_current_test_suite(nullptr);
+  impl->set_current_test_suite(nullptr);
 }

 // Skips all tests under this TestSuite.
 void TestSuite::Skip() {
  if (!should_run_) return;

-  UnitTest::GetInstance()->set_current_test_suite(this);
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_suite(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

@@ -3086,7 +3065,7 @@ void TestSuite::Skip() {
  repeater->OnTestCaseEnd(*this);
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

-  UnitTest::GetInstance()->set_current_test_suite(nullptr);
+  impl->set_current_test_suite(nullptr);
 }

 // Clears the results of all tests in this test suite.
@@ -3187,9 +3166,9 @@ static void PrintTestPartResult(const TestPartResult& test_part_result) {
 }

 // class PrettyUnitTestResultPrinter
-#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) &&       \
-    !defined(GTEST_OS_WINDOWS_GAMES) && !defined(GTEST_OS_WINDOWS_PHONE) && \
-    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_MINGW)
+#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) &&    \
+    !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
+    !defined(GTEST_OS_WINDOWS_MINGW)

 // Returns the character attribute for the given color.
 static WORD GetColorAttribute(GTestColor color) {
@@ -3249,8 +3228,7 @@ static const char* GetAnsiColorCode(GTestColor color) {
    case GTestColor::kYellow:
      return "3";
    default:
-      assert(false);
-      return "9";
+      return nullptr;
  }
 }

@@ -3273,7 +3251,6 @@ bool ShouldUseColor(bool stdout_is_tty) {
        term != nullptr && (String::CStringEquals(term, "xterm") ||
                            String::CStringEquals(term, "xterm-color") ||
                            String::CStringEquals(term, "xterm-kitty") ||
-                            String::CStringEquals(term, "alacritty") ||
                            String::CStringEquals(term, "screen") ||
                            String::CStringEquals(term, "tmux") ||
                            String::CStringEquals(term, "rxvt-unicode") ||
@@ -3304,9 +3281,11 @@ static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
  va_start(args, fmt);

  static const bool in_color_mode =
-      // We don't condition this on GTEST_HAS_FILE_SYSTEM because we still need
-      // to be able to detect terminal I/O regardless.
+#if GTEST_HAS_FILE_SYSTEM
      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
+#else
+      false;
+#endif  // GTEST_HAS_FILE_SYSTEM

  const bool use_color = in_color_mode && (color != GTestColor::kDefault);

@@ -3316,9 +3295,9 @@ static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    return;
  }

-#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) &&       \
-    !defined(GTEST_OS_WINDOWS_GAMES) && !defined(GTEST_OS_WINDOWS_PHONE) && \
-    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_MINGW)
+#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) &&    \
+    !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
+    !defined(GTEST_OS_WINDOWS_MINGW)
  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);

  // Gets the current text color.
@@ -4441,8 +4420,8 @@ std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
-    attributes << " " << property.key() << "=" << "\""
-               << EscapeXmlAttribute(property.value()) << "\"";
+    attributes << " " << property.key() << "="
+               << "\"" << EscapeXmlAttribute(property.value()) << "\"";
  }
  return attributes.GetString();
 }
@@ -4746,53 +4725,28 @@ void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
                                                     const TestResult& result) {
  const std::string kIndent = Indent(10);

-  {
-    int failures = 0;
-    for (int i = 0; i < result.total_part_count(); ++i) {
-      const TestPartResult& part = result.GetTestPartResult(i);
-      if (part.failed()) {
-        *stream << ",\n";
-        if (++failures == 1) {
-          *stream << kIndent << "\"" << "failures" << "\": [\n";
-        }
-        const std::string location =
-            internal::FormatCompilerIndependentFileLocation(part.file_name(),
-                                                            part.line_number());
-        const std::string message =
-            EscapeJson(location + "\n" + part.message());
-        *stream << kIndent << "  {\n"
-                << kIndent << "    \"failure\": \"" << message << "\",\n"
-                << kIndent << "    \"type\": \"\"\n"
-                << kIndent << "  }";
+  int failures = 0;
+  for (int i = 0; i < result.total_part_count(); ++i) {
+    const TestPartResult& part = result.GetTestPartResult(i);
+    if (part.failed()) {
+      *stream << ",\n";
+      if (++failures == 1) {
+        *stream << kIndent << "\""
+                << "failures"
+                << "\": [\n";
      }
+      const std::string location =
+          internal::FormatCompilerIndependentFileLocation(part.file_name(),
+                                                          part.line_number());
+      const std::string message = EscapeJson(location + "\n" + part.message());
+      *stream << kIndent << "  {\n"
+              << kIndent << "    \"failure\": \"" << message << "\",\n"
+              << kIndent << "    \"type\": \"\"\n"
+              << kIndent << "  }";
    }
-
-    if (failures > 0) *stream << "\n" << kIndent << "]";
-  }
-
-  {
-    int skipped = 0;
-    for (int i = 0; i < result.total_part_count(); ++i) {
-      const TestPartResult& part = result.GetTestPartResult(i);
-      if (part.skipped()) {
-        *stream << ",\n";
-        if (++skipped == 1) {
-          *stream << kIndent << "\"" << "skipped" << "\": [\n";
-        }
-        const std::string location =
-            internal::FormatCompilerIndependentFileLocation(part.file_name(),
-                                                            part.line_number());
-        const std::string message =
-            EscapeJson(location + "\n" + part.message());
-        *stream << kIndent << "  {\n"
-                << kIndent << "    \"message\": \"" << message << "\"\n"
-                << kIndent << "  }";
-      }
-    }
-
-    if (skipped > 0) *stream << "\n" << kIndent << "]";
  }

+  if (failures > 0) *stream << "\n" << kIndent << "]";
  *stream << "\n" << Indent(8) << "}";
 }

@@ -4929,8 +4883,8 @@ std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << ",\n"
-               << indent << "\"" << property.key() << "\": " << "\""
-               << EscapeJson(property.value()) << "\"";
+               << indent << "\"" << property.key() << "\": "
+               << "\"" << EscapeJson(property.value()) << "\"";
  }
  return attributes.GetString();
 }
@@ -5328,22 +5282,6 @@ TestSuite* UnitTest::GetMutableTestSuite(int i) {
  return impl()->GetMutableSuiteCase(i);
 }

-void UnitTest::UponLeavingGTest() {
-  impl()->os_stack_trace_getter()->UponLeavingGTest();
-}
-
-// Sets the TestSuite object for the test that's currently running.
-void UnitTest::set_current_test_suite(TestSuite* a_current_test_suite) {
-  internal::MutexLock lock(&mutex_);
-  impl_->set_current_test_suite(a_current_test_suite);
-}
-
-// Sets the TestInfo object for the test that's currently running.
-void UnitTest::set_current_test_info(TestInfo* a_current_test_info) {
-  internal::MutexLock lock(&mutex_);
-  impl_->set_current_test_info(a_current_test_info);
-}
-
 // Returns the list of event listeners that can be used to track events
 // inside Google Test.
 TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); }
@@ -5461,7 +5399,7 @@ void UnitTest::RecordProperty(const std::string& key,
 int UnitTest::Run() {
 #ifdef GTEST_HAS_DEATH_TEST
  const bool in_death_test_child_process =
-      !GTEST_FLAG_GET(internal_run_death_test).empty();
+      GTEST_FLAG_GET(internal_run_death_test).length() > 0;

  // Google Test implements this protocol for catching that a test
  // program exits before returning control to Google Test:
@@ -5503,7 +5441,7 @@ int UnitTest::Run() {
  // about crashes - they are expected.
  if (impl()->catch_exceptions() || in_death_test_child_process) {
 #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
-    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_GAMES)
+    !defined(GTEST_OS_WINDOWS_RT)
    // SetErrorMode doesn't exist on CE.
    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
@@ -5773,6 +5711,29 @@ void UnitTestImpl::PostFlagParsingInit() {
  }
 }

+// A predicate that checks the name of a TestSuite against a known
+// value.
+//
+// This is used for implementation of the UnitTest class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestSuiteNameIs is copyable.
+class TestSuiteNameIs {
+ public:
+  // Constructor.
+  explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
+
+  // Returns true if and only if the name of test_suite matches name_.
+  bool operator()(const TestSuite* test_suite) const {
+    return test_suite != nullptr &&
+           strcmp(test_suite->name(), name_.c_str()) == 0;
+  }
+
+ private:
+  std::string name_;
+};
+
 // Finds and returns a TestSuite with the given name.  If one doesn't
 // exist, creates one and returns it.  It's the CALLER'S
 // RESPONSIBILITY to ensure that this function is only called WHEN THE
@@ -5786,27 +5747,19 @@ void UnitTestImpl::PostFlagParsingInit() {
 //   set_up_tc:       pointer to the function that sets up the test suite
 //   tear_down_tc:    pointer to the function that tears down the test suite
 TestSuite* UnitTestImpl::GetTestSuite(
-    const std::string& test_suite_name, const char* type_param,
+    const char* test_suite_name, const char* type_param,
    internal::SetUpTestSuiteFunc set_up_tc,
    internal::TearDownTestSuiteFunc tear_down_tc) {
-  // During initialization, all TestInfos for a given suite are added in
-  // sequence. To optimize this case, see if the most recently added suite is
-  // the one being requested now.
-  if (!test_suites_.empty() &&
-      (*test_suites_.rbegin())->name_ == test_suite_name) {
-    return *test_suites_.rbegin();
-  }
+  // Can we find a TestSuite with the given name?
+  const auto test_suite =
+      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
+                   TestSuiteNameIs(test_suite_name));

-  // Fall back to searching the collection.
-  auto item_it = test_suites_by_name_.find(test_suite_name);
-  if (item_it != test_suites_by_name_.end()) {
-    return item_it->second;
-  }
+  if (test_suite != test_suites_.rend()) return *test_suite;

-  // Not found. Create a new instance.
+  // No.  Let's create one.
  auto* const new_test_suite =
      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
-  test_suites_by_name_.emplace(test_suite_name, new_test_suite);

  const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter);
  // Is this a death test suite?
@@ -6019,12 +5972,6 @@ bool UnitTestImpl::RunAllTests() {
  }

  repeater->OnTestProgramEnd(*parent_);
-  // Destroy environments in normal code, not in static teardown.
-  bool delete_environment_on_teardown = true;
-  if (delete_environment_on_teardown) {
-    ForEach(environments_, internal::Delete<Environment>);
-    environments_.clear();
-  }

  if (!gtest_is_initialized_before_run_all_tests) {
    ColoredPrintf(
@@ -6158,11 +6105,12 @@ int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
  int num_runnable_tests = 0;
  int num_selected_tests = 0;
  for (auto* test_suite : test_suites_) {
-    const std::string& test_suite_name = test_suite->name_;
+    const std::string& test_suite_name = test_suite->name();
    test_suite->set_should_run(false);

-    for (TestInfo* test_info : test_suite->test_info_list()) {
-      const std::string& test_name = test_info->name_;
+    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
+      TestInfo* const test_info = test_suite->test_info_list()[j];
+      const std::string test_name(test_info->name());
      // A test is disabled if test suite name or test name matches
      // kDisableTestFilter.
      const bool is_disabled =
@@ -6253,8 +6201,8 @@ void UnitTestImpl::ListTestsMatchingFilter() {
 #if GTEST_HAS_FILE_SYSTEM
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml" || output_format == "json") {
-    FILE* fileout =
-        OpenFileForWriting(UnitTestOptions::GetAbsolutePathToOutputFile());
+    FILE* fileout = OpenFileForWriting(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
    std::stringstream stream;
    if (output_format == "xml") {
      XmlUnitTestResultPrinter(
@@ -6703,17 +6651,17 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    }

    if (remove_flag) {
-      // Shift the remainder of the argv list left by one.
-      for (int j = i + 1; j < *argc; ++j) {
-        argv[j - 1] = argv[j];
+      // Shift the remainder of the argv list left by one.  Note
+      // that argv has (*argc + 1) elements, the last one always being
+      // NULL.  The following loop moves the trailing NULL element as
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
      }

      // Decrements the argument count.
      (*argc)--;

-      // Terminate the array with nullptr.
-      argv[*argc] = nullptr;
-
      // We also need to decrement the iterator as we just removed
      // an element.
      i--;
@@ -6735,7 +6683,7 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
 // remain in place. Unrecognized flags are not reported and do not cause the
 // program to exit.
 void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
-#ifdef GTEST_HAS_ABSL_FLAGS
+#ifdef GTEST_HAS_ABSL
  if (*argc <= 0) return;

  std::vector<char*> positional_args;
@@ -6821,13 +6769,11 @@ void InitGoogleTestImpl(int* argc, CharType** argv) {
 #ifdef GTEST_HAS_ABSL
  absl::InitializeSymbolizer(g_argvs[0].c_str());

-#ifdef GTEST_HAS_ABSL_FLAGS
  // When using the Abseil Flags library, set the program usage message to the
  // help message, but remove the color-encoding from the message first.
  absl::SetProgramUsageMessage(absl::StrReplaceAll(
      kColorEncodedHelpMessage,
      {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
-#endif  // GTEST_HAS_ABSL_FLAGS
 #endif  // GTEST_HAS_ABSL

  ParseGoogleTestFlagsOnly(argc, argv);
--- a/3rdparty/include/xxhash.h
+++ b/3rdparty/include/xxhash.h
--- a/3rdparty/libchdr/include/libchdr/cdrom.h
+++ b/3rdparty/libchdr/include/libchdr/cdrom.h
@@ -10,10 +10,12 @@

 #pragma once

-#ifndef __CDROM_H__
-#define __CDROM_H__
+#ifdef __cplusplus
+extern "C" {
+#endif

 #include <stdint.h>
+#include <stdbool.h>
 #include <libchdr/chdconfig.h>

 /***************************************************************************
@@ -47,11 +49,15 @@ enum

 enum
 {
-	CD_SUB_NORMAL = 0,          /* "cooked" 96 bytes per sector */
-	CD_SUB_RAW,                 /* raw uninterleaved 96 bytes per sector */
-	CD_SUB_NONE                 /* no subcode data stored */
+	CD_SUB_NONE = 0,            /* no subcode data stored */
+	CD_SUB_RAW_INTERLEAVED,     /* raw interleaved 96 bytes per sector */
+	CD_SUB_RAW,                 /* raw non-interleaved 96 bytes per sector */
 };

+const char* cdrom_get_subtype_string(uint32_t subtype);
+bool cdrom_parse_subtype_string(const char* typestring, uint32_t* subtype, uint32_t* subsize);
+
+
 #define CD_FLAG_GDROM   0x00000001  /* disc is a GD-ROM, all tracks should be stored with GD-ROM metadata */
 #define CD_FLAG_GDROMLE 0x00000002  /* legacy GD-ROM, with little-endian CDDA data */

@@ -81,10 +87,10 @@ static inline uint32_t lba_to_msf(uint32_t lba)
 {
 	uint8_t m, s, f;

-	m = lba / (60 * 75);
+	m = (uint8_t)(lba / (60 * 75));
 	lba -= m * (60 * 75);
-	s = lba / 75;
-	f = lba % 75;
+	s = (uint8_t)(lba / 75);
+	f = (uint8_t)(lba % 75);

 	return ((m / 10) << 20) | ((m % 10) << 16) |
 			((s / 10) << 12) | ((s % 10) <<  8) |
@@ -107,4 +113,6 @@ static inline uint32_t lba_to_msf_alt(int lba)
 	return ret;
 }

-#endif  /* __CDROM_H__ */
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- a/3rdparty/libchdr/include/libchdr/chd.h
+++ b/3rdparty/libchdr/include/libchdr/chd.h
@@ -48,6 +48,7 @@ extern "C" {

 #include <libchdr/coretypes.h>
 #include <libchdr/chdconfig.h>
+#include <stdbool.h>

 /***************************************************************************

@@ -58,67 +59,67 @@ extern "C" {
    V1 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] uint32_t length;        // length of header (including tag and length fields)
-    [ 12] uint32_t version;       // drive format version
-    [ 16] uint32_t flags;         // flags (see below)
-    [ 20] uint32_t compression;   // compression type
-    [ 24] uint32_t hunksize;      // 512-byte sectors per hunk
-    [ 28] uint32_t totalhunks;    // total # of hunks represented
-    [ 32] uint32_t cylinders;     // number of cylinders on hard disk
-    [ 36] uint32_t heads;         // number of heads on hard disk
-    [ 40] uint32_t sectors;       // number of sectors on hard disk
-    [ 44] uint8_t  md5[16];       // MD5 checksum of raw data
-    [ 60] uint8_t  parentmd5[16]; // MD5 checksum of parent file
+    [  8] UINT32 length;        // length of header (including tag and length fields)
+    [ 12] UINT32 version;       // drive format version
+    [ 16] UINT32 flags;         // flags (see below)
+    [ 20] UINT32 compression;   // compression type
+    [ 24] UINT32 hunksize;      // 512-byte sectors per hunk
+    [ 28] UINT32 totalhunks;    // total # of hunks represented
+    [ 32] UINT32 cylinders;     // number of cylinders on hard disk
+    [ 36] UINT32 heads;         // number of heads on hard disk
+    [ 40] UINT32 sectors;       // number of sectors on hard disk
+    [ 44] UINT8  md5[16];       // MD5 checksum of raw data
+    [ 60] UINT8  parentmd5[16]; // MD5 checksum of parent file
    [ 76] (V1 header length)

    V2 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] uint32_t length;        // length of header (including tag and length fields)
-    [ 12] uint32_t version;       // drive format version
-    [ 16] uint32_t flags;         // flags (see below)
-    [ 20] uint32_t compression;   // compression type
-    [ 24] uint32_t hunksize;      // seclen-byte sectors per hunk
-    [ 28] uint32_t totalhunks;    // total # of hunks represented
-    [ 32] uint32_t cylinders;     // number of cylinders on hard disk
-    [ 36] uint32_t heads;         // number of heads on hard disk
-    [ 40] uint32_t sectors;       // number of sectors on hard disk
-    [ 44] uint8_t  md5[16];       // MD5 checksum of raw data
-    [ 60] uint8_t  parentmd5[16]; // MD5 checksum of parent file
-    [ 76] uint32_t seclen;        // number of bytes per sector
+    [  8] UINT32 length;        // length of header (including tag and length fields)
+    [ 12] UINT32 version;       // drive format version
+    [ 16] UINT32 flags;         // flags (see below)
+    [ 20] UINT32 compression;   // compression type
+    [ 24] UINT32 hunksize;      // seclen-byte sectors per hunk
+    [ 28] UINT32 totalhunks;    // total # of hunks represented
+    [ 32] UINT32 cylinders;     // number of cylinders on hard disk
+    [ 36] UINT32 heads;         // number of heads on hard disk
+    [ 40] UINT32 sectors;       // number of sectors on hard disk
+    [ 44] UINT8  md5[16];       // MD5 checksum of raw data
+    [ 60] UINT8  parentmd5[16]; // MD5 checksum of parent file
+    [ 76] UINT32 seclen;        // number of bytes per sector
    [ 80] (V2 header length)

    V3 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] uint32_t length;        // length of header (including tag and length fields)
-    [ 12] uint32_t version;       // drive format version
-    [ 16] uint32_t flags;         // flags (see below)
-    [ 20] uint32_t compression;   // compression type
-    [ 24] uint32_t totalhunks;    // total # of hunks represented
-    [ 28] uint64_t logicalbytes;  // logical size of the data (in bytes)
-    [ 36] uint64_t metaoffset;    // offset to the first blob of metadata
-    [ 44] uint8_t  md5[16];       // MD5 checksum of raw data
-    [ 60] uint8_t  parentmd5[16]; // MD5 checksum of parent file
-    [ 76] uint32_t hunkbytes;     // number of bytes per hunk
-    [ 80] uint8_t  sha1[20];      // SHA1 checksum of raw data
-    [100] uint8_t  parentsha1[20];// SHA1 checksum of parent file
+    [  8] UINT32 length;        // length of header (including tag and length fields)
+    [ 12] UINT32 version;       // drive format version
+    [ 16] UINT32 flags;         // flags (see below)
+    [ 20] UINT32 compression;   // compression type
+    [ 24] UINT32 totalhunks;    // total # of hunks represented
+    [ 28] UINT64 logicalbytes;  // logical size of the data (in bytes)
+    [ 36] UINT64 metaoffset;    // offset to the first blob of metadata
+    [ 44] UINT8  md5[16];       // MD5 checksum of raw data
+    [ 60] UINT8  parentmd5[16]; // MD5 checksum of parent file
+    [ 76] UINT32 hunkbytes;     // number of bytes per hunk
+    [ 80] UINT8  sha1[20];      // SHA1 checksum of raw data
+    [100] UINT8  parentsha1[20];// SHA1 checksum of parent file
    [120] (V3 header length)

    V4 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] uint32_t length;        // length of header (including tag and length fields)
-    [ 12] uint32_t version;       // drive format version
-    [ 16] uint32_t flags;         // flags (see below)
-    [ 20] uint32_t compression;   // compression type
-    [ 24] uint32_t totalhunks;    // total # of hunks represented
-    [ 28] uint64_t logicalbytes;  // logical size of the data (in bytes)
-    [ 36] uint64_t metaoffset;    // offset to the first blob of metadata
-    [ 44] uint32_t hunkbytes;     // number of bytes per hunk
-    [ 48] uint8_t  sha1[20];      // combined raw+meta SHA1
-    [ 68] uint8_t  parentsha1[20];// combined raw+meta SHA1 of parent
-    [ 88] uint8_t  rawsha1[20];   // raw data SHA1
+    [  8] UINT32 length;        // length of header (including tag and length fields)
+    [ 12] UINT32 version;       // drive format version
+    [ 16] UINT32 flags;         // flags (see below)
+    [ 20] UINT32 compression;   // compression type
+    [ 24] UINT32 totalhunks;    // total # of hunks represented
+    [ 28] UINT64 logicalbytes;  // logical size of the data (in bytes)
+    [ 36] UINT64 metaoffset;    // offset to the first blob of metadata
+    [ 44] UINT32 hunkbytes;     // number of bytes per hunk
+    [ 48] UINT8  sha1[20];      // combined raw+meta SHA1
+    [ 68] UINT8  parentsha1[20];// combined raw+meta SHA1 of parent
+    [ 88] UINT8  rawsha1[20];   // raw data SHA1
    [108] (V4 header length)

    Flags:
@@ -130,17 +131,17 @@ extern "C" {
    V5 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] uint32_t_t length;        // length of header (including tag and length fields)
-    [ 12] uint32_t_t version;       // drive format version
-    [ 16] uint32_t_t compressors[4];// which custom compressors are used?
-    [ 32] uint64_t_t logicalbytes;  // logical size of the data (in bytes)
-    [ 40] uint64_t_t mapoffset;     // offset to the map
-    [ 48] uint64_t_t metaoffset;    // offset to the first blob of metadata
-    [ 56] uint32_t_t hunkbytes;     // number of bytes per hunk (512k maximum)
-    [ 60] uint32_t_t unitbytes;     // number of bytes per unit within each hunk
-    [ 64] uint8_t_t  rawsha1[20];   // raw data SHA1
-    [ 84] uint8_t_t  sha1[20];      // combined raw+meta SHA1
-    [104] uint8_t_t  parentsha1[20];// combined raw+meta SHA1 of parent
+    [  8] uint32_t length;        // length of header (including tag and length fields)
+    [ 12] uint32_t version;       // drive format version
+    [ 16] uint32_t compressors[4];// which custom compressors are used?
+    [ 32] uint64_t logicalbytes;  // logical size of the data (in bytes)
+    [ 40] uint64_t mapoffset;     // offset to the map
+    [ 48] uint64_t metaoffset;    // offset to the first blob of metadata
+    [ 56] uint32_t hunkbytes;     // number of bytes per hunk (512k maximum)
+    [ 60] uint32_t unitbytes;     // number of bytes per unit within each hunk
+    [ 64] uint8_t  rawsha1[20];   // raw data SHA1
+    [ 84] uint8_t  sha1[20];      // combined raw+meta SHA1
+    [104] uint8_t  parentsha1[20];// combined raw+meta SHA1 of parent
    [124] (V5 header length)

    If parentsha1 != 0, we have a parent (no need for flags)
@@ -148,22 +149,22 @@ extern "C" {

    V5 uncompressed map format:

-    [  0] uint32_t_t offset;        // starting offset / hunk size
+    [  0] uint32_t offset;        // starting offset / hunk size

    V5 compressed map format header:

-    [  0] uint32_t_t length;        // length of compressed map
+    [  0] uint32_t length;        // length of compressed map
    [  4] UINT48 datastart;     // offset of first block
    [ 10] uint16_t crc;           // crc-16 of the map
-    [ 12] uint8_t_t lengthbits;     // bits used to encode complength
-    [ 13] uint8_t_t hunkbits;       // bits used to encode self-refs
-    [ 14] uint8_t_t parentunitbits; // bits used to encode parent unit refs
-    [ 15] uint8_t_t reserved;       // future use
+    [ 12] uint8_t lengthbits;     // bits used to encode complength
+    [ 13] uint8_t hunkbits;       // bits used to encode self-refs
+    [ 14] uint8_t parentunitbits; // bits used to encode parent unit refs
+    [ 15] uint8_t reserved;       // future use
    [ 16] (compressed header length)

    Each compressed map entry, once expanded, looks like:

-    [  0] uint8_t_t compression;    // compression type
+    [  0] uint8_t compression;    // compression type
    [  1] UINT24 complength;    // compressed length
    [  4] UINT48 offset;        // offset
    [ 10] uint16_t crc;           // crc-16 of the data
@@ -220,7 +221,7 @@ extern "C" {

 /* metadata parameters */
 #define CHDMETATAG_WILDCARD			0
-#define CHD_METAINDEX_APPEND		((uint32_t)-1)
+#define CHD_METAINDEX_APPEND		((UINT32)-1)

 /* metadata flags */
 #define CHD_MDFLAGS_CHECKSUM		0x01		/* indicates data is checksummed */
@@ -258,6 +259,7 @@ extern "C" {
 /* CHD open values */
 #define CHD_OPEN_READ				1
 #define CHD_OPEN_READWRITE			2
+#define CHD_OPEN_TRANSFER_FILE 4 /* Freeing of the FILE* is now libchdr's responsibility if open was successful */

 /* error types */
 enum _chd_error
@@ -289,7 +291,8 @@ enum _chd_error
 	CHDERR_INVALID_STATE,
 	CHDERR_OPERATION_PENDING,
 	CHDERR_NO_ASYNC_OPERATION,
-	CHDERR_UNSUPPORTED_FORMAT
+	CHDERR_UNSUPPORTED_FORMAT,
+	CHDERR_CANCELLED,
 };
 typedef enum _chd_error chd_error;

@@ -307,32 +310,32 @@ typedef struct _chd_file chd_file;
 typedef struct _chd_header chd_header;
 struct _chd_header
 {
-	uint32_t		length;						/* length of header data */
-	uint32_t		version;					/* drive format version */
-	uint32_t		flags;						/* flags field */
-	uint32_t		compression[4];				/* compression type */
-	uint32_t		hunkbytes;					/* number of bytes per hunk */
-	uint32_t		totalhunks;					/* total # of hunks represented */
-	uint64_t		logicalbytes;				/* logical size of the data */
-	uint64_t		metaoffset;					/* offset in file of first metadata */
-	uint64_t		mapoffset;					/* TOOD V5 */
-	uint8_t		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
-	uint8_t		parentmd5[CHD_MD5_BYTES];	/* overall MD5 checksum of parent */
-	uint8_t		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
-	uint8_t		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
-	uint8_t		parentsha1[CHD_SHA1_BYTES];	/* overall SHA1 checksum of parent */
-	uint32_t		unitbytes;					/* TODO V5 */
-	uint64_t		unitcount;					/* TODO V5 */
-    uint32_t      hunkcount;                  /* TODO V5 */
+	UINT32		length;						/* length of header data */
+	UINT32		version;					/* drive format version */
+	UINT32		flags;						/* flags field */
+	UINT32		compression[4];				/* compression type */
+	UINT32		hunkbytes;					/* number of bytes per hunk */
+	UINT32		totalhunks;					/* total # of hunks represented */
+	UINT64		logicalbytes;				/* logical size of the data */
+	UINT64		metaoffset;					/* offset in file of first metadata */
+	UINT64		mapoffset;					/* TOOD V5 */
+	UINT8		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
+	UINT8		parentmd5[CHD_MD5_BYTES];	/* overall MD5 checksum of parent */
+	UINT8		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
+	UINT8		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
+	UINT8		parentsha1[CHD_SHA1_BYTES];	/* overall SHA1 checksum of parent */
+	UINT32		unitbytes;					/* TODO V5 */
+	UINT64		unitcount;					/* TODO V5 */
+    UINT32      hunkcount;                  /* TODO V5 */

    /* map information */
-    uint32_t      mapentrybytes;              /* length of each entry in a map (V5) */
-    uint8_t*      rawmap;                     /* raw map data */
+    UINT32      mapentrybytes;              /* length of each entry in a map (V5) */
+    UINT8*      rawmap;                     /* raw map data */

-	uint32_t		obsolete_cylinders;			/* obsolete field -- do not use! */
-	uint32_t		obsolete_sectors;			/* obsolete field -- do not use! */
-	uint32_t		obsolete_heads;				/* obsolete field -- do not use! */
-	uint32_t		obsolete_hunksize;			/* obsolete field -- do not use! */
+	UINT32		obsolete_cylinders;			/* obsolete field -- do not use! */
+	UINT32		obsolete_sectors;			/* obsolete field -- do not use! */
+	UINT32		obsolete_heads;				/* obsolete field -- do not use! */
+	UINT32		obsolete_hunksize;			/* obsolete field -- do not use! */
 };


@@ -340,10 +343,10 @@ struct _chd_header
 typedef struct _chd_verify_result chd_verify_result;
 struct _chd_verify_result
 {
-	uint8_t		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
-	uint8_t		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
-	uint8_t		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
-	uint8_t		metasha1[CHD_SHA1_BYTES];	/* SHA1 checksum of metadata */
+	UINT8		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
+	UINT8		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
+	UINT8		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
+	UINT8		metasha1[CHD_SHA1_BYTES];	/* SHA1 checksum of metadata */
 };


@@ -369,10 +372,10 @@ struct _chd_verify_result
 /* ----- CHD file management ----- */

 /* create a new CHD file fitting the given description */
-/* chd_error chd_create(const char *filename, uint64_t logicalbytes, uint32_t hunkbytes, uint32_t compression, chd_file *parent); */
+/* chd_error chd_create(const char *filename, UINT64 logicalbytes, UINT32 hunkbytes, UINT32 compression, chd_file *parent); */

 /* same as chd_create(), but accepts an already-opened core_file object */
-/* chd_error chd_create_file(core_file *file, uint64_t logicalbytes, uint32_t hunkbytes, uint32_t compression, chd_file *parent); */
+/* chd_error chd_create_file(core_file *file, UINT64 logicalbytes, UINT32 hunkbytes, UINT32 compression, chd_file *parent); */

 /* open an existing CHD file */
 CHD_EXPORT chd_error chd_open_core_file(core_file *file, int mode, chd_file *parent, chd_file **chd);
@@ -381,6 +384,7 @@ CHD_EXPORT chd_error chd_open(const char *filename, int mode, chd_file *parent,

 /* precache underlying file */
 CHD_EXPORT chd_error chd_precache(chd_file *chd);
+CHD_EXPORT chd_error chd_precache_progress(chd_file* chd, bool(*progress)(size_t pos, size_t total, void* param), void* param);

 /* close a CHD file */
 CHD_EXPORT void chd_close(chd_file *chd);
@@ -388,11 +392,13 @@ CHD_EXPORT void chd_close(chd_file *chd);
 /* return the associated core_file */
 CHD_EXPORT core_file *chd_core_file(chd_file *chd);

+/* return the overall size of a CHD, and any of its parents */
+CHD_EXPORT UINT64 chd_get_compressed_size(chd_file* chd);
+
 /* return an error string for the given CHD error */
 CHD_EXPORT const char *chd_error_string(chd_error err);


-
 /* ----- CHD header management ----- */

 /* return a pointer to the extracted CHD header data */
@@ -402,20 +408,21 @@ CHD_EXPORT const chd_header *chd_get_header(chd_file *chd);
 CHD_EXPORT chd_error chd_read_header_core_file(core_file *file, chd_header *header);
 CHD_EXPORT chd_error chd_read_header_file(FILE *file, chd_header *header);
 CHD_EXPORT chd_error chd_read_header(const char *filename, chd_header *header);
+CHD_EXPORT bool chd_is_matching_parent(const chd_header* header, const chd_header* parent_header);



 /* ----- core data read/write ----- */

 /* read one hunk from the CHD file */
-CHD_EXPORT chd_error chd_read(chd_file *chd, uint32_t hunknum, void *buffer);
+CHD_EXPORT chd_error chd_read(chd_file *chd, UINT32 hunknum, void *buffer);



 /* ----- metadata management ----- */

 /* get indexed metadata of a particular sort */
-CHD_EXPORT chd_error chd_get_metadata(chd_file *chd, uint32_t searchtag, uint32_t searchindex, void *output, uint32_t outputlen, uint32_t *resultlen, uint32_t *resulttag, uint8_t *resultflags);
+CHD_EXPORT chd_error chd_get_metadata(chd_file *chd, UINT32 searchtag, UINT32 searchindex, void *output, UINT32 outputlen, UINT32 *resultlen, UINT32 *resulttag, UINT8 *resultflags);



@@ -426,7 +433,7 @@ CHD_EXPORT chd_error chd_get_metadata(chd_file *chd, uint32_t searchtag, uint32_
 CHD_EXPORT chd_error chd_codec_config(chd_file *chd, int param, void *config);

 /* return a string description of a codec */
-CHD_EXPORT const char *chd_get_codec_name(uint32_t codec);
+CHD_EXPORT const char *chd_get_codec_name(UINT32 codec);

 #ifdef __cplusplus
 }
--- a/3rdparty/libchdr/include/libchdr/coretypes.h
+++ b/3rdparty/libchdr/include/libchdr/coretypes.h
@@ -8,13 +8,26 @@
 #include <streams/file_stream_transforms.h>
 #endif

-#ifndef ARRAY_LENGTH
 #define ARRAY_LENGTH(x) (sizeof(x)/sizeof(x[0]))
+
+#if defined(__PS3__) || defined(__PSL1GHT__)
+#undef UINT32
+#undef UINT16
+#undef UINT8
+#undef INT32
+#undef INT16
+#undef INT8
 #endif

-#ifndef ARRAY_SIZE
-#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
-#endif
+typedef uint64_t UINT64;
+typedef uint32_t UINT32;
+typedef uint16_t UINT16;
+typedef uint8_t UINT8;
+
+typedef int64_t INT64;
+typedef int32_t INT32;
+typedef int16_t INT16;
+typedef int8_t INT8;

 typedef struct chd_core_file {
 	/*
@@ -28,9 +41,9 @@ typedef struct chd_core_file {
 	 * undefined because many implementations will seek to the end of the
 	 * file and call ftell.
 	 *
-	 * on error, (uint64_t)-1 is returned.
+	 * on error, (UINT64)-1 is returned.
 	 */
-	uint64_t(*fsize)(struct chd_core_file*);
+	UINT64(*fsize)(struct chd_core_file*);

 	/*
 	 * should match the behavior of fread, except the FILE* argument at the end
@@ -42,7 +55,7 @@ typedef struct chd_core_file {
 	int (*fclose)(struct chd_core_file*);

 	// fseek clone
-	int (*fseek)(struct chd_core_file*, int64_t, int);
+	int (*fseek)(struct chd_core_file*, INT64, int);
 } core_file;

 static inline int core_fclose(core_file *fp) {
@@ -53,11 +66,11 @@ static inline size_t core_fread(core_file *fp, void *ptr, size_t len) {
 	return fp->fread(ptr, 1, len, fp);
 }

-static inline int core_fseek(core_file* fp, int64_t offset, int whence) {
+static inline int core_fseek(core_file* fp, INT64 offset, int whence) {
 	return fp->fseek(fp, offset, whence);
 }

-static inline uint64_t core_fsize(core_file *fp)
+static inline UINT64 core_fsize(core_file *fp)
 {
 	return fp->fsize(fp);
 }
--- a/3rdparty/libchdr/include/libchdr/huffman.h
+++ b/3rdparty/libchdr/include/libchdr/huffman.h
@@ -85,6 +85,6 @@ int huffman_build_tree(struct huffman_decoder* decoder, uint32_t totaldata, uint
 enum huffman_error huffman_assign_canonical_codes(struct huffman_decoder* decoder);
 enum huffman_error huffman_compute_tree_from_histo(struct huffman_decoder* decoder);

-enum huffman_error huffman_build_lookup_table(struct huffman_decoder* decoder);
+void huffman_build_lookup_table(struct huffman_decoder* decoder);

 #endif
--- a/3rdparty/libchdr/src/libchdr_cdrom.c
+++ b/3rdparty/libchdr/src/libchdr_cdrom.c
@@ -20,6 +20,35 @@

 #include <libchdr/cdrom.h>

+const char* cdrom_get_subtype_string(uint32_t subtype)
+{
+	switch (subtype)
+	{
+	case CD_SUB_RAW:              return "RW";
+	case CD_SUB_RAW_INTERLEAVED:  return "RW_RAW";
+	default:                      return "NONE";
+	}
+}
+
+bool cdrom_parse_subtype_string(const char* typestring, uint32_t* subtype, uint32_t* subsize)
+{
+	// https://github.com/mamedev/mame/blob/d2d54fb8ed53a2e86d308067da8414f85b5929b0/src/lib/util/cdrom.cpp#L767
+  if (!strcmp(typestring, "RW"))
+  {
+    *subtype = CD_SUB_RAW;
+    *subsize = 96;
+		return true;
+  }
+  else if (!strcmp(typestring, "RW_RAW"))
+  {
+    *subtype = CD_SUB_RAW_INTERLEAVED;
+    *subsize = 96;
+		return true;
+  }
+
+	return false;
+}
+
 #ifdef WANT_RAW_DATA_SECTOR

 /***************************************************************************
--- a/3rdparty/libchdr/src/libchdr_chd.c
+++ b/3rdparty/libchdr/src/libchdr_chd.c
--- a/3rdparty/libchdr/src/libchdr_huffman.c
+++ b/3rdparty/libchdr/src/libchdr_huffman.c
@@ -230,9 +230,7 @@ enum huffman_error huffman_import_tree_rle(struct huffman_decoder* decoder, stru
 		return error;

 	/* build the lookup table */
-	error = huffman_build_lookup_table(decoder);
-	if (error != HUFFERR_NONE)
-		return error;
+	huffman_build_lookup_table(decoder);

 	/* determine final input length and report errors */
 	return bitstream_overflow(bitbuf) ? HUFFERR_INPUT_BUFFER_TOO_SMALL : HUFFERR_NONE;
@@ -273,16 +271,8 @@ enum huffman_error huffman_import_tree_huffman(struct huffman_decoder* decoder,
 	/* then regenerate the tree */
 	error = huffman_assign_canonical_codes(smallhuff);
 	if (error != HUFFERR_NONE)
-	{
-		delete_huffman_decoder(smallhuff);
 		return error;
-	}
-	error = huffman_build_lookup_table(smallhuff);
-	if (error != HUFFERR_NONE)
-	{
-		delete_huffman_decoder(smallhuff);
-		return error;
-	}
+	huffman_build_lookup_table(smallhuff);

 	/* determine the maximum length of an RLE count */
 	temp = decoder->numcodes - 9;
@@ -318,9 +308,7 @@ enum huffman_error huffman_import_tree_huffman(struct huffman_decoder* decoder,
 		return error;

 	/* build the lookup table */
-	error = huffman_build_lookup_table(decoder);
-	if (error != HUFFERR_NONE)
-		return error;
+	huffman_build_lookup_table(decoder);

 	/* determine final input length and report errors */
 	return bitstream_overflow(bitbuf) ? HUFFERR_INPUT_BUFFER_TOO_SMALL : HUFFERR_NONE;
@@ -535,9 +523,8 @@ enum huffman_error huffman_assign_canonical_codes(struct huffman_decoder* decode
 *-------------------------------------------------
 */

-enum huffman_error huffman_build_lookup_table(struct huffman_decoder* decoder)
+void huffman_build_lookup_table(struct huffman_decoder* decoder)
 {
-	const lookup_value* lookupend = &decoder->lookup[(1u << decoder->maxbits)];
 	uint32_t curcode;
 	/* iterate over all codes */
 	for (curcode = 0; curcode < decoder->numcodes; curcode++)
@@ -546,10 +533,9 @@ enum huffman_error huffman_build_lookup_table(struct huffman_decoder* decoder)
 		struct node_t* node = &decoder->huffnode[curcode];
 		if (node->numbits > 0)
 		{
-			int shift;
-			lookup_value *dest;
-			lookup_value *destend;
-
+         int shift;
+         lookup_value *dest;
+         lookup_value *destend;
 			/* set up the entry */
 			lookup_value value = MAKE_LOOKUP(curcode, node->numbits);

@@ -557,12 +543,8 @@ enum huffman_error huffman_build_lookup_table(struct huffman_decoder* decoder)
 			shift = decoder->maxbits - node->numbits;
 			dest = &decoder->lookup[node->bits << shift];
 			destend = &decoder->lookup[((node->bits + 1) << shift) - 1];
-			if (dest >= lookupend || destend >= lookupend || destend < dest)
-				return HUFFERR_INTERNAL_INCONSISTENCY;
 			while (dest <= destend)
 				*dest++ = value;
 		}
 	}
-
-	return HUFFERR_NONE;
 }
--- a/3rdparty/libzip/lib/compat.h
+++ b/3rdparty/libzip/lib/compat.h
@@ -123,64 +123,14 @@ typedef char bool;
 #endif
 #endif

-
-#if defined(HAVE__FSEEKI64) && defined(HAVE__FSTAT64) && defined(HAVE__SEEK64)
-/* Windows API using int64 */
-typedef zip_int64_t zip_off_t;
-typedef struct _stat64 zip_os_stat_t;
-#define zip_os_stat _stat64
-#define zip_os_fstat _fstat64
-#define zip_os_seek _fseeki64
-#define ZIP_FSEEK_MAX ZIP_INT64_MAX
-#define ZIP_FSEEK_MIN ZIP_INT64_MIN
-#else
-
-/* Normal API */
-#include <sys/stat.h>
-typedef struct stat zip_os_stat_t;
-#define zip_os_fstat fstat
-#define zip_os_stat stat
-
-#if defined(HAVE_FTELLO) && defined(HAVE_FSEEKO)
-/* Using off_t */
-typedef off_t zip_off_t;
-#if SIZEOF_OFF_T == 8
-#define ZIP_OFF_MAX ZIP_INT64_MAX
-#define ZIP_OFF_MIN ZIP_INT64_MIN
-#elif SIZEOF_OFF_T == 4
-#define ZIP_OFF_MAX ZIP_INT32_MAX
-#define ZIP_OFF_MIN ZIP_INT32_MIN
-#elif SIZEOF_OFF_T == 2
-#define ZIP_OFF_MAX ZIP_INT16_MAX
-#define ZIP_OFF_MIN ZIP_INT16_MIN
-#else
-#error unsupported size of off_t
-#endif
-
-#define ZIP_FSEEK_MAX ZIP_OFF_MAX
-#define ZIP_FSEEK_MIN ZIP_OFF_MIN
-
-#define zip_os_fseek fseeko
-#define zip_os_ftell ftello
-#else
-
-/* Using long */
-typedef long zip_off_t;
-#include <limits.h>
-#define ZIP_FSEEK_MAX LONG_MAX
-#define ZIP_FSEEK_MIN LONG_MIN
-
-#define zip_os_fseek fseek
-#define zip_os_ftell ftell
-#endif
-
+#ifndef HAVE_FSEEKO
+#define fseeko(s, o, w) (fseek((s), (long int)(o), (w)))
 #endif

 #ifndef HAVE_FTELLO
 #define ftello(s) ((long)ftell((s)))
 #endif

-
 #ifdef HAVE_LOCALTIME_S
 #ifdef _WIN32
 /* Windows is incompatible to the C11 standard, hurray! */
@@ -229,6 +179,27 @@ typedef long zip_off_t;
 #endif
 #endif

+#if SIZEOF_OFF_T == 8
+#define ZIP_OFF_MAX ZIP_INT64_MAX
+#define ZIP_OFF_MIN ZIP_INT64_MIN
+#elif SIZEOF_OFF_T == 4
+#define ZIP_OFF_MAX ZIP_INT32_MAX
+#define ZIP_OFF_MIN ZIP_INT32_MIN
+#elif SIZEOF_OFF_T == 2
+#define ZIP_OFF_MAX ZIP_INT16_MAX
+#define ZIP_OFF_MIN ZIP_INT16_MIN
+#else
+#error unsupported size of off_t
+#endif
+
+#if defined(HAVE_FTELLO) && defined(HAVE_FSEEKO)
+#define ZIP_FSEEK_MAX ZIP_OFF_MAX
+#define ZIP_FSEEK_MIN ZIP_OFF_MIN
+#else
+#include <limits.h>
+#define ZIP_FSEEK_MAX LONG_MAX
+#define ZIP_FSEEK_MIN LONG_MIN
+#endif

 #ifndef SIZE_MAX
 #if SIZEOF_SIZE_T == 8
--- a/3rdparty/libzip/lib/zip_dirent.c
+++ b/3rdparty/libzip/lib/zip_dirent.c
@@ -39,6 +39,7 @@
 #include <time.h>
 #include <zlib.h>

+#include "zip.h"
 #include "zipint.h"

 static zip_string_t *_zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str, bool check_consistency);
@@ -282,7 +283,6 @@ _zip_dirent_init(zip_dirent_t *de) {
    de->cloned = 0;

    de->crc_valid = true;
-    de->last_mod_mtime_valid = false;
    de->version_madeby = 63 | (ZIP_OPSYS_DEFAULT << 8);
    de->version_needed = 10; /* 1.0 */
    de->bitflags = 0;
@@ -1264,12 +1264,3 @@ zip_dirent_check_consistency(zip_dirent_t *dirent) {
    }
    return 0;
 }
-
-time_t zip_dirent_get_last_mod_mtime(zip_dirent_t *de) {
-    if (!de->last_mod_mtime_valid) {
-        de->last_mod_mtime = _zip_d2u_time(&de->last_mod);
-        de->last_mod_mtime_valid = true;
-    }
-
-    return de->last_mod_mtime;
-}
--- a/3rdparty/libzip/lib/zip_file_set_mtime.c
+++ b/3rdparty/libzip/lib/zip_file_set_mtime.c
@@ -33,7 +33,8 @@

 #include "zipint.h"

-static int zip_file_set_time(zip_t *za, zip_uint64_t idx, zip_uint16_t dtime, zip_uint16_t ddate, zip_flags_t flags, time_t *mtime) {
+ZIP_EXTERN int
+zip_file_set_dostime(zip_t *za, zip_uint64_t idx, zip_uint16_t dtime, zip_uint16_t ddate, zip_flags_t flags) {
    zip_entry_t *e;

    if (_zip_get_dirent(za, idx, 0, NULL) == NULL) {
@@ -65,29 +66,18 @@ static int zip_file_set_time(zip_t *za, zip_uint64_t idx, zip_uint16_t dtime, zi

    e->changes->last_mod.time = dtime;
    e->changes->last_mod.date = ddate;
-    if (mtime != NULL) {
-        e->changes->last_mod_mtime = *mtime;
-        e->changes->last_mod_mtime_valid = true;
-    }
-    else {
-        e->changes->last_mod_mtime_valid = false;
-    }
    e->changes->changed |= ZIP_DIRENT_LAST_MOD;

    return 0;
 }

-ZIP_EXTERN int zip_file_set_dostime(zip_t *za, zip_uint64_t idx, zip_uint16_t dtime, zip_uint16_t ddate, zip_flags_t flags) {
-    return zip_file_set_time(za, idx, dtime, ddate, flags, NULL);
-}
-
-
-ZIP_EXTERN int zip_file_set_mtime(zip_t *za, zip_uint64_t idx, time_t mtime, zip_flags_t flags) {
+ZIP_EXTERN int
+zip_file_set_mtime(zip_t *za, zip_uint64_t idx, time_t mtime, zip_flags_t flags) {
    zip_dostime_t dostime;

    if (_zip_u2d_time(mtime, &dostime, &za->error) < 0) {
        return -1;
    }

-    return zip_file_set_time(za, idx, dostime.time, dostime.date, flags, &mtime);
+    return zip_file_set_dostime(za, idx, dostime.time, dostime.date, flags);
 }
--- a/3rdparty/libzip/lib/zip_new.c
+++ b/3rdparty/libzip/lib/zip_new.c
@@ -68,7 +68,6 @@ _zip_new(zip_error_t *error) {
    za->nopen_source = za->nopen_source_alloc = 0;
    za->open_source = NULL;
    za->progress = NULL;
-    za->torrent_mtime = 0;

    return za;
 }
--- a/3rdparty/libzip/lib/zip_source_file_stdio.c
+++ b/3rdparty/libzip/lib/zip_source_file_stdio.c
@@ -39,6 +39,7 @@
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/stat.h>

 #ifdef _WIN32
 #ifndef S_IWUSR
@@ -119,7 +120,7 @@ _zip_stdio_op_seek(zip_source_file_context_t *ctx, void *f, zip_int64_t offset,
    }
 #endif

-    if (zip_os_fseek((FILE *)f, (zip_off_t)offset, whence) < 0) {
+    if (fseeko((FILE *)f, (off_t)offset, whence) < 0) {
        zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);
        return false;
    }
@@ -129,15 +130,15 @@ _zip_stdio_op_seek(zip_source_file_context_t *ctx, void *f, zip_int64_t offset,

 bool
 _zip_stdio_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st) {
-    zip_os_stat_t sb;
+    struct stat sb;

    int ret;

    if (ctx->fname) {
-        ret = zip_os_stat(ctx->fname, &sb);
+        ret = stat(ctx->fname, &sb);
    }
    else {
-        ret = zip_os_fstat(fileno((FILE *)ctx->f), &sb);
+        ret = fstat(fileno((FILE *)ctx->f), &sb);
    }

    if (ret < 0) {
@@ -167,7 +168,7 @@ _zip_stdio_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st) {

 zip_int64_t
 _zip_stdio_op_tell(zip_source_file_context_t *ctx, void *f) {
-    zip_off_t offset = zip_os_ftell((FILE *)f);
+    off_t offset = ftello((FILE *)f);

    if (offset < 0) {
        zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);
--- a/3rdparty/libzip/lib/zip_source_file_stdio_named.c
+++ b/3rdparty/libzip/lib/zip_source_file_stdio_named.c
@@ -178,9 +178,9 @@ _zip_stdio_op_create_temp_output_cloning(zip_source_file_context_t *ctx, zip_uin
    {
        int fd;
        struct file_clone_range range;
-        zip_os_stat_t st;
+        struct stat st;
        
-        if (zip_os_fstat(fileno(ctx->f), &st) < 0) {
+        if (fstat(fileno(ctx->f), &st) < 0) {
            zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
            return -1;
        }
@@ -223,7 +223,7 @@ _zip_stdio_op_create_temp_output_cloning(zip_source_file_context_t *ctx, zip_uin
        ctx->tmpname = NULL;
        return -1;
    }
-    if (zip_os_fseek(tfp, (zip_off_t)offset, SEEK_SET) < 0) {
+    if (fseeko(tfp, (off_t)offset, SEEK_SET) < 0) {
        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
        (void)fclose(tfp);
        (void)remove(ctx->tmpname);
@@ -290,11 +290,11 @@ _zip_stdio_op_write(zip_source_file_context_t *ctx, const void *data, zip_uint64
 static int create_temp_file(zip_source_file_context_t *ctx, bool create_file) {
    char *temp;
    int mode;
-    zip_os_stat_t st;
+    struct stat st;
    int fd = 0;
    char *start, *end;
    
-    if (zip_os_stat(ctx->fname, &st) == 0) {
+    if (stat(ctx->fname, &st) == 0) {
        mode = st.st_mode;
    }
    else {
@@ -344,7 +344,7 @@ static int create_temp_file(zip_source_file_context_t *ctx, bool create_file) {
            }
        }
        else {
-            if (zip_os_stat(temp, &st) < 0) {
+            if (stat(temp, &st) < 0) {
                if (errno == ENOENT) {
                    break;
                }
--- a/3rdparty/libzip/lib/zip_stat_index.c
+++ b/3rdparty/libzip/lib/zip_stat_index.c
@@ -77,7 +77,7 @@ zip_stat_index(zip_t *za, zip_uint64_t index, zip_flags_t flags, zip_stat_t *st)
        }

        if (entry->changes != NULL && entry->changes->changed & ZIP_DIRENT_LAST_MOD) {
-            st->mtime = zip_dirent_get_last_mod_mtime(de);
+            st->mtime = _zip_d2u_time(&de->last_mod);
            st->valid |= ZIP_STAT_MTIME;
        }
    }
@@ -86,7 +86,7 @@ zip_stat_index(zip_t *za, zip_uint64_t index, zip_flags_t flags, zip_stat_t *st)

        st->crc = de->crc;
        st->size = de->uncomp_size;
-        st->mtime = zip_dirent_get_last_mod_mtime(de);
+        st->mtime = _zip_d2u_time(&de->last_mod);
        st->comp_size = de->comp_size;
        st->comp_method = (zip_uint16_t)de->comp_method;
        st->encryption_method = de->encryption_method;
@@ -97,12 +97,9 @@ zip_stat_index(zip_t *za, zip_uint64_t index, zip_flags_t flags, zip_stat_t *st)
    }

    if ((za->ch_flags & ZIP_AFL_WANT_TORRENTZIP) && (flags & ZIP_FL_UNCHANGED) == 0) {
-        if (za->torrent_mtime == 0) {
-            zip_dostime_t dostime = {0xbc00, 0x2198};
-            za->torrent_mtime = _zip_d2u_time(&dostime);
-        }
+        zip_dostime_t dostime = {0xbc00, 0x2198};
        st->comp_method = ZIP_CM_DEFLATE;
-        st->mtime = za->torrent_mtime;
+        st->mtime = _zip_d2u_time(&dostime);
        st->valid |= ZIP_STAT_MTIME | ZIP_STAT_COMP_METHOD;
        st->valid &= ~ZIP_STAT_COMP_SIZE;
    }
--- a/3rdparty/libzip/lib/zipint.h
+++ b/3rdparty/libzip/lib/zipint.h
@@ -314,7 +314,6 @@ struct zip {
    zip_progress_t *progress; /* progress callback for zip_close() */

    zip_uint32_t* write_crc; /* have _zip_write() compute CRC */
-    time_t torrent_mtime;
 };

 /* file in zip archive, part of API */
@@ -347,7 +346,6 @@ struct zip_dirent {
    bool cloned;                  /*      whether this instance is cloned, and thus shares non-changed strings */

    bool crc_valid; /*      if CRC is valid (sometimes not for encrypted archives) */
-    bool last_mod_mtime_valid;

    zip_uint16_t version_madeby;     /* (c)  version of creator */
    zip_uint16_t version_needed;     /* (cl) version needed to extract */
@@ -368,8 +366,6 @@ struct zip_dirent {
    zip_uint32_t compression_level; /*      level of compression to use (never valid in orig) */
    zip_uint16_t encryption_method; /*      encryption method, computed from other fields */
    char *password;                 /*      file specific encryption password */
-
-    time_t last_mod_mtime;          /*      cached last_mod in Unix time format */
 };

 /* zip archive central directory */
@@ -557,7 +553,6 @@ int zip_dirent_check_consistency(zip_dirent_t *dirent);
 zip_dirent_t *_zip_dirent_clone(const zip_dirent_t *);
 void _zip_dirent_free(zip_dirent_t *);
 void _zip_dirent_finalize(zip_dirent_t *);
-time_t zip_dirent_get_last_mod_mtime(zip_dirent_t *de);
 void _zip_dirent_init(zip_dirent_t *);
 bool _zip_dirent_needs_zip64(const zip_dirent_t *, zip_flags_t);
 zip_dirent_t *_zip_dirent_new(void);
--- a/3rdparty/promptfont/promptfont.sfd
+++ b/3rdparty/promptfont/promptfont.sfd
@@ -23,7 +23,7 @@ OS2Version: 0
 OS2_WeightWidthSlopeOnly: 0
 OS2_UseTypoMetrics: 0
 CreationTime: 1544355305
-ModificationTime: 1736751870
+ModificationTime: 1712653578
 PfmFamily: 33
 TTFWeight: 400
 TTFWidth: 5
@@ -65,7 +65,7 @@ NameList: AGL For New Fonts
 DisplaySize: -48
 AntiAlias: 1
 FitToEm: 0
-WinInfo: 8360 38 14
+WinInfo: 8816 38 14
 BeginPrivate: 8
 BlueValues 29 [0 0 380 380 490 490 660 660]
 OtherBlues 39 [-210 -210 -180 -180 -160 -160 280 280]
@@ -77,7 +77,7 @@ StemSnapV 13 [140 180 200]
 ForceBold 4 true
 EndPrivate
 TeXData: 1 0 0 335544 167772 111848 513802 1048576 111848 783286 444596 497025 792723 393216 433062 380633 303038 157286 324010 404750 52429 2506097 1059062 262144
-BeginChars: 1114112 733
+BeginChars: 1114112 731

 StartChar: exclam
 Encoding: 33 33 0
@@ -19511,40 +19511,40 @@ VStem: 92.5596 41.7305<171.236 408.764> 189.39 149.051<176.142 403.858> 699.66 1
 LayerCount: 2
 Fore
 SplineSet
-500 600.610351562 m 5
- 671.459960938 600.610351562 810.610351562 461.459960938 810.610351562 290 c 4
- 810.610351562 118.540039062 671.459960938 -20.6103515625 500 -20.6103515625 c 4
- 328.540039062 -20.6103515625 189.389648438 118.540039062 189.389648438 290 c 4
- 189.389648438 461.459960938 328.540039062 600.610351562 500 600.610351562 c 5
-699.66015625 102.129882812 m 5
- 699.66015625 167.830078125 l 5
- 456.870117188 167.830078125 l 5
- 456.870117188 463.459960938 l 5
- 338.440429688 463.459960938 l 5
- 338.440429688 102.129882812 l 5
- 699.66015625 102.129882812 l 5
-500 -117.440429688 m 4
- 445 -117.440429688 391.639648438 -106.66015625 341.400390625 -85.41015625 c 4
- 292.879882812 -64.8896484375 249.309570312 -35.509765625 211.900390625 1.900390625 c 4
- 174.490234375 39.3095703125 145.110351562 82.8798828125 124.58984375 131.400390625 c 4
- 103.33984375 181.639648438 92.5595703125 235.009765625 92.5595703125 290 c 4
- 92.5595703125 344.990234375 103.33984375 398.360351562 124.58984375 448.599609375 c 4
- 145.110351562 497.120117188 174.490234375 540.690429688 211.900390625 578.099609375 c 4
- 249.309570312 615.509765625 292.879882812 644.889648438 341.400390625 665.41015625 c 4
- 391.639648438 686.66015625 445.009765625 697.440429688 500 697.440429688 c 4
- 554.990234375 697.440429688 608.360351562 686.66015625 658.599609375 665.41015625 c 4
- 707.120117188 644.889648438 750.690429688 615.509765625 788.099609375 578.099609375 c 4
- 825.509765625 540.690429688 854.889648438 497.120117188 875.41015625 448.599609375 c 4
- 896.66015625 398.360351562 907.440429688 344.990234375 907.440429688 290 c 4
- 907.440429688 235.009765625 896.66015625 181.639648438 875.41015625 131.400390625 c 4
- 854.889648438 82.8798828125 825.509765625 39.3095703125 788.099609375 1.900390625 c 4
- 750.690429688 -35.509765625 707.120117188 -64.8896484375 658.599609375 -85.41015625 c 4
- 608.360351562 -106.66015625 554.990234375 -117.440429688 500 -117.440429688 c 4
-500 655.709960938 m 4
- 298.349609375 655.709960938 134.290039062 491.66015625 134.290039062 290 c 4
- 134.290039062 88.33984375 298.33984375 -75.7099609375 500 -75.7099609375 c 4
- 701.66015625 -75.7099609375 865.709960938 88.349609375 865.709960938 290 c 4
- 865.709960938 491.650390625 701.66015625 655.709960938 500 655.709960938 c 4
+500 600.610351562 m 1
+ 671.459960938 600.610351562 810.610351562 461.459960938 810.610351562 290 c 0
+ 810.610351562 118.540039062 671.459960938 -20.6103515625 500 -20.6103515625 c 0
+ 328.540039062 -20.6103515625 189.389648438 118.540039062 189.389648438 290 c 0
+ 189.389648438 461.459960938 328.540039062 600.610351562 500 600.610351562 c 1
+699.66015625 102.129882812 m 1
+ 699.66015625 167.830078125 l 1
+ 456.870117188 167.830078125 l 1
+ 456.870117188 463.459960938 l 1
+ 338.440429688 463.459960938 l 1
+ 338.440429688 102.129882812 l 1
+ 699.66015625 102.129882812 l 1
+500 -117.440429688 m 0
+ 445 -117.440429688 391.639648438 -106.66015625 341.400390625 -85.41015625 c 0
+ 292.879882812 -64.8896484375 249.309570312 -35.509765625 211.900390625 1.900390625 c 0
+ 174.490234375 39.3095703125 145.110351562 82.8798828125 124.58984375 131.400390625 c 0
+ 103.33984375 181.639648438 92.5595703125 235.009765625 92.5595703125 290 c 0
+ 92.5595703125 344.990234375 103.33984375 398.360351562 124.58984375 448.599609375 c 0
+ 145.110351562 497.120117188 174.490234375 540.690429688 211.900390625 578.099609375 c 0
+ 249.309570312 615.509765625 292.879882812 644.889648438 341.400390625 665.41015625 c 0
+ 391.639648438 686.66015625 445.009765625 697.440429688 500 697.440429688 c 0
+ 554.990234375 697.440429688 608.360351562 686.66015625 658.599609375 665.41015625 c 0
+ 707.120117188 644.889648438 750.690429688 615.509765625 788.099609375 578.099609375 c 0
+ 825.509765625 540.690429688 854.889648438 497.120117188 875.41015625 448.599609375 c 0
+ 896.66015625 398.360351562 907.440429688 344.990234375 907.440429688 290 c 0
+ 907.440429688 235.009765625 896.66015625 181.639648438 875.41015625 131.400390625 c 0
+ 854.889648438 82.8798828125 825.509765625 39.3095703125 788.099609375 1.900390625 c 0
+ 750.690429688 -35.509765625 707.120117188 -64.8896484375 658.599609375 -85.41015625 c 0
+ 608.360351562 -106.66015625 554.990234375 -117.440429688 500 -117.440429688 c 0
+500 655.709960938 m 0
+ 298.349609375 655.709960938 134.290039062 491.66015625 134.290039062 290 c 0
+ 134.290039062 88.33984375 298.33984375 -75.7099609375 500 -75.7099609375 c 0
+ 701.66015625 -75.7099609375 865.709960938 88.349609375 865.709960938 290 c 0
+ 865.709960938 491.650390625 701.66015625 655.709960938 500 655.709960938 c 0
 EndSplineSet
 Validated: 5
 EndChar
@@ -30101,7 +30101,7 @@ SplineSet
 79 -59.400390625 120 -102.200195312 170.799804688 -102.200195312 c 2
 838.200195312 -102.200195312 l 2
 EndSplineSet
-Validated: 33
+Validated: 524321
 EndChar

 StartChar: uni23F6
@@ -30171,7 +30171,7 @@ SplineSet
 79 -59.400390625 120 -102.200195312 170.799804688 -102.200195312 c 2
 838.200195312 -102.200195312 l 1
 EndSplineSet
-Validated: 33
+Validated: 524321
 EndChar

 StartChar: uni23F7
@@ -35271,218 +35271,5 @@ SplineSet
 EndSplineSet
 Validated: 1
 EndChar
-
-StartChar: uni2446
-Encoding: 9286 9286 731
-Width: 1000
-HStem: 98.667 78.666<441.304 558.479> 298.667 80.666<211.095 321.99 686.039 796.635> 364 81.333<440.808 559.266> 544.667 80.666<210.809 321.868 685.514 796.925>
-VStem: 104 80<406.859 516.049> 326.667 80<269.844 311.038> 349.333 80<429.563 517.407> 578.667 80<424.535 517.66> 593.333 80.667<270.25 314.708> 824 80<406.439 515.845>
-LayerCount: 2
-Fore
-SplineSet
-869.333007812 361.333007812 m 1x9840
- 887.333007812 310.666992188 925.333007812 194 915.333007812 116.666992188 c 0
- 902 10.6669921875 842.666992188 -30.6669921875 836 -35.3330078125 c 0
- 832 -38.6669921875 827.333007812 -40 822 -41.3330078125 c 0
- 812 -43.3330078125 802 -44 792 -44 c 0
- 770.666992188 -44 750 -39.3330078125 732.666992188 -30.6669921875 c 0
- 708 -18.6669921875 690 1.3330078125 676 30 c 0
- 654 76 656 148 662 194.666992188 c 1
- 661.333007812 194 658.666992188 194.666992188 655.333007812 195.333007812 c 0
- 627.333007812 138 568 98.6669921875 500 98.6669921875 c 0
- 431.333007812 98.6669921875 372 138.666992188 344 196 c 0
- 340 195.333007812 336 194 334.666992188 194.666992188 c 1
- 342.666992188 135.333007812 344.666992188 73.3330078125 324 30 c 0
- 310 1.3330078125 291.333007812 -18.6669921875 267.333007812 -30.6669921875 c 0
- 241.333007812 -43.3330078125 210 -46.6669921875 178 -40.6669921875 c 0
- 172.666992188 -40 168 -38 164 -35.3330078125 c 0
- 157.333007812 -31.3330078125 98 10.6669921875 84.6669921875 116.666992188 c 0
- 74.6669921875 199.333007812 116 323.333007812 133.333007812 369.333007812 c 1
- 114.666992188 396 104 428 104 462.666992188 c 0
- 104 552 176.666992188 625.333007812 266.666992188 625.333007812 c 0
- 299.333007812 625.333007812 329.333007812 615.333007812 354.666992188 599.333007812 c 1
- 385.333007812 646 436 677.333007812 492.666992188 681.333007812 c 0
- 557.333007812 685.333007812 619.333007812 653.333007812 655.333007812 600 c 1
- 680.666992188 615.333007812 710 624.666992188 741.333007812 624.666992188 c 0
- 830.666992188 624.666992188 904 552 904 462 c 0
- 904 424 891.333007812 389.333007812 869.333007812 361.333007812 c 1x9840
-741.333007812 544.666992188 m 0
- 695.333007812 544.666992188 658.666992188 507.333007812 658.666992188 462 c 0
- 658.666992188 416.666992188 696 379.333007812 741.333007812 379.333007812 c 0xd940
- 786.666992188 379.333007812 824 416.666992188 824 462 c 0
- 824 507.333007812 786.666992188 544.666992188 741.333007812 544.666992188 c 0
-498 601.333007812 m 0
- 459.333007812 598.666992188 426 572.666992188 411.333007812 536.666992188 c 0
- 422.666992188 514.666992188 429.333007812 489.333007812 429.333007812 462.666992188 c 0
- 429.333007812 450.666992188 428 439.333007812 426 428.666992188 c 1
- 448 439.333007812 473.333007812 445.333007812 500 445.333007812 c 0xbb40
- 530.666992188 445.333007812 558.666992188 437.333007812 583.333007812 424 c 1
- 580 436 578.666992188 448.666992188 578.666992188 462 c 0
- 578.666992188 490 585.333007812 516 598 539.333007812 c 0
- 580 579.333007812 540 604 498 601.333007812 c 0
-266.666992188 544.666992188 m 0
- 220.666992188 544.666992188 184 507.333007812 184 462 c 0
- 184 416.666992188 221.333007812 379.333007812 266.666992188 379.333007812 c 0xda40
- 312 379.333007812 349.333007812 416.666992188 349.333007812 462 c 0
- 349.333007812 507.333007812 312 544.666992188 266.666992188 544.666992188 c 0
-305.333007812 270 m 2
- 310.666992188 271.333007812 318.666992188 273.333007812 326.666992188 274 c 0xdc40
- 326.666992188 287.333007812 328 300 331.333007812 312 c 1
- 311.333007812 303.333007812 290 298.666992188 266.666992188 298.666992188 c 0
- 240.666992188 298.666992188 216 305.333007812 194 316 c 1
- 174.666992188 259.333007812 152.666992188 176 159.333007812 123.333007812 c 0
- 164 82.6669921875 178 56 189.333007812 39.3330078125 c 0
- 198.666992188 26.6669921875 216 20.6669921875 230.666992188 28 c 1
- 234 29.3330078125 244 34.6669921875 254 56 c 0
- 273.333007812 96 260 180 255.333007812 212 c 2
- 255.333007812 212.666992188 l 2
- 251.333007812 236.666992188 267.333007812 259.333007812 293.333007812 266.666992188 c 2
- 305.333007812 270 l 2
-500 177.333007812 m 0
- 551.333007812 177.333007812 593.333007812 219.333007812 593.333007812 270.666992188 c 0
- 593.333007812 322 551.333007812 364 500 364 c 0xbcc0
- 448.666992188 364 406.666992188 322 406.666992188 270.666992188 c 0
- 406.666992188 219.333007812 448.666992188 177.333007812 500 177.333007812 c 0
-840.666992188 123.333007812 m 0
- 846.666992188 174.666992188 826 256 808 311.333007812 c 1
- 788 302.666992188 765.333007812 297.333007812 742 297.333007812 c 0
- 715.333007812 297.333007812 690 304 668 315.333007812 c 1
- 671.333007812 302 673.333007812 288 674 274 c 0
- 684 273.333007812 694.666992188 271.333007812 701.333007812 268 c 2
- 708.666992188 264.666992188 l 2
- 729.333007812 254.666992188 741.333007812 234.666992188 738 213.333007812 c 2
- 738 212 l 2
- 734 183.333007812 726.666992188 95.3330078125 746 55.3330078125 c 0
- 756 34 766 29.3330078125 769.333007812 27.3330078125 c 1
- 784 20.6669921875 801.333007812 26 810.666992188 39.3330078125 c 0
- 822 56 835.333007812 82.6669921875 840.666992188 123.333007812 c 0
-EndSplineSet
-Validated: 524321
-EndChar
-
-StartChar: uni221B
-Encoding: 8731 8731 732
-Width: 1000
-HStem: -209.992 21.2588<741.927 862.934> -160.664 62.5283<723.687 881.174> 85.9395 69.8691<723.687 780.459> 183.879 21.2588<741.929 862.934>
-VStem: 594.865 21.2588<-62.9303 58.0754> 644.194 75.9316<-81.1715 76.316> 904.145 56.5225<-89.7754 -64.665> 988.736 21.2598<-62.9292 58.0743>
-LayerCount: 2
-Fore
-SplineSet
-133.1953125 240.114257812 m 1
- 128.731445312 224.2734375 135.630859375 215.740234375 135.630859375 215.740234375 c 1
- 158.787109375 176.336914062 l 1
- 148.629882812 119.875976562 174.627929688 78.4345703125 190.466796875 57.7236328125 c 0
- 206.305664062 37.001953125 310.713867188 -99.0751953125 323.712890625 -114.518554688 c 0
- 336.711914062 -129.954101562 389.11328125 -183.991210938 445.583984375 -142.953125 c 0
- 502.044921875 -101.926757812 483.362304688 -32.052734375 483.362304688 -32.052734375 c 1
- 459.1875 57.931640625 l 1
- 589.7890625 74.3857421875 547.140625 186.911132812 547.140625 186.911132812 c 1
- 601.831054688 241.602539062 l 1
- 601.831054688 241.602539062 714.356445312 198.951171875 730.811523438 329.545898438 c 1
- 820.79296875 305.37890625 l 1
- 820.79296875 305.37890625 890.669921875 286.688476562 931.6953125 343.159179688 c 0
- 972.721679688 399.619140625 918.696289062 452.03125 903.262695312 465.030273438 c 0
- 887.829101562 478.029296875 751.73828125 582.424804688 731.018554688 598.275390625 c 0
- 710.296875 614.114257812 668.864257812 640.114257812 612.404296875 629.965820312 c 1
- 573.001953125 653.122070312 l 1
- 573.001953125 653.122070312 564.466796875 660.03125 548.627929688 655.55859375 c 2
- 548.627929688 655.55859375 543.954101562 661.450195312 532.172851562 654.5390625 c 0
- 520.391601562 647.627929688 493.986328125 630.569335938 477.126953125 596.651367188 c 1
- 477.126953125 596.651367188 474.28515625 591.78125 480.166015625 586.296875 c 1
- 480.166015625 586.296875 474.078125 568.424804688 482.6015625 555.021484375 c 0
- 491.13671875 541.616210938 501.688476562 524.559570312 501.688476562 524.559570312 c 1
- 264.205078125 287.03125 l 1
- 264.205078125 287.03125 247.146484375 297.59375 233.741210938 306.119140625 c 0
- 220.337890625 314.654296875 202.465820312 308.553710938 202.465820312 308.553710938 c 1
- 196.981445312 314.444335938 192.1015625 311.604492188 192.1015625 311.604492188 c 1
- 158.18359375 294.744140625 141.125 268.340820312 134.213867188 256.559570312 c 0
- 127.3046875 244.786132812 133.1953125 240.114257812 133.1953125 240.114257812 c 1
-829.455078125 781.646484375 m 1
- 829.455078125 781.645507812 l 1
- 792.041015625 795.248046875 760.869140625 792.16796875 741.635742188 772.922851562 c 0
- 733.508789062 764.796875 733.508789062 751.620117188 741.635742188 743.482421875 c 0
- 749.764648438 735.364257812 762.939453125 735.354492188 771.069335938 743.482421875 c 0
- 777.907226562 750.30859375 794.809570312 749.956054688 815.208007812 742.526367188 c 0
- 841.3828125 732.993164062 871.2109375 712.708007812 897.041015625 686.876953125 c 0
- 952.763671875 631.153320312 967.78125 575.046875 953.635742188 560.903320312 c 0
- 945.508789062 552.776367188 945.508789062 539.599609375 953.635742188 531.4609375 c 0
- 957.70703125 527.401367188 963.024414062 525.373046875 968.352539062 525.373046875 c 0
- 973.680664062 525.373046875 979 527.401367188 983.067382812 531.47265625 c 0
- 1019.61816406 568.0234375 995.288085938 647.485351562 926.47265625 716.319335938 c 0
- 896.052734375 746.73046875 861.592773438 769.926757812 829.455078125 781.646484375 c 1
-748.963867188 663.739257812 m 1
- 748.96484375 663.73828125 l 1
- 755.135742188 669.899414062 792.102539062 663.115234375 832.69140625 622.525390625 c 0
- 873.270507812 581.946289062 880.076171875 544.970703125 873.904296875 538.798828125 c 0
- 865.788085938 530.669921875 865.788085938 517.484375 873.915039062 509.357421875 c 0
- 877.984375 505.297851562 883.303710938 503.268554688 888.631835938 503.268554688 c 0
- 893.958984375 503.268554688 899.2890625 505.297851562 903.356445312 509.3671875 c 0
- 932.717773438 538.74609375 915.375976562 598.71484375 862.123046875 651.959960938 c 0
- 808.888671875 705.224609375 748.888671875 722.555664062 719.528320312 693.184570312 c 0
- 711.401367188 685.056640625 711.401367188 671.879882812 719.528320312 663.743164062 c 0
- 727.661132812 655.600585938 740.825195312 655.62109375 748.963867188 663.739257812 c 1
-213.166015625 -210 m 1
- 231.399414062 -210 247.083984375 -204.524414062 258.532226562 -193.078125 c 0
- 266.661132812 -184.94921875 266.661132812 -171.772460938 258.532226562 -163.635742188 c 0
- 250.403320312 -155.497070312 237.227539062 -155.506835938 229.098632812 -163.635742188 c 0
- 214.944335938 -177.799804688 158.858398438 -162.770507812 103.127929688 -107.0390625 c 0
- 77.3056640625 -81.208984375 57.01171875 -51.380859375 47.478515625 -25.2060546875 c 0
- 40.046875 -4.818359375 39.6826171875 12.095703125 46.5205078125 18.931640625 c 0
- 54.6494140625 27.0595703125 54.6494140625 40.2353515625 46.5205078125 48.3740234375 c 0
- 38.3935546875 56.5126953125 25.2177734375 56.5009765625 17.0888671875 48.3740234375 c 0
- -2.1630859375 29.1337890625 -5.2548828125 -2.056640625 8.3583984375 -39.4521484375 c 0
- 20.06640625 -71.5888671875 43.2763671875 -106.049804688 73.6953125 -136.470703125 c 0
- 120.946289062 -183.729492188 173.2109375 -210.008789062 213.166015625 -210 c 1
-138.03515625 -72.1201171875 m 1
- 160.764648438 -94.8388671875 186.5859375 -112.198242188 210.741210938 -120.9921875 c 0
- 223.53125 -125.655273438 234.375976562 -127.456054688 243.53515625 -127.456054688 c 0
- 262.7890625 -127.456054688 274.487304688 -119.473632812 280.627929688 -113.333007812 c 0
- 288.744140625 -105.204101562 288.744140625 -92.017578125 280.6171875 -83.890625 c 0
- 272.490234375 -75.7744140625 259.302734375 -75.7626953125 251.17578125 -83.890625 c 0
- 248.990234375 -86.1083984375 240.174804688 -87.408203125 224.979492188 -81.880859375 c 0
- 206.673828125 -75.2099609375 185.711914062 -60.921875 167.458007812 -42.67578125 c 0
- 149.212890625 -24.4306640625 134.924804688 -3.458984375 128.252929688 14.845703125 c 0
- 122.7265625 30.01953125 124.02734375 38.8251953125 126.245117188 41.041015625 c 0
- 134.374023438 49.16796875 134.374023438 62.34375 126.245117188 70.4833984375 c 0
- 118.116210938 78.6220703125 104.940429688 78.6103515625 96.8134765625 70.4833984375 c 0
- 87.748046875 61.4169921875 74.6875 40.279296875 89.1416015625 0.5966796875 c 0
- 97.9560546875 -23.5703125 115.315429688 -49.400390625 138.03515625 -72.1201171875 c 1
-802.430664062 155.80859375 m 0
- 715.083007812 155.80859375 644.194335938 84.919921875 644.194335938 -2.427734375 c 0
- 644.194335938 -89.775390625 715.083007812 -160.6640625 802.430664062 -160.6640625 c 0
- 889.778320312 -160.6640625 960.666992188 -89.775390625 960.666992188 -2.427734375 c 0
- 960.666992188 84.919921875 889.778320312 155.80859375 802.430664062 155.80859375 c 0
-904.14453125 -98.1357421875 m 1
- 720.125976562 -98.1357421875 l 1
- 720.125976562 85.939453125 l 1
- 780.458984375 85.939453125 l 1
- 780.458984375 -64.6650390625 l 1
- 904.14453125 -64.6650390625 l 1
- 904.14453125 -98.1357421875 l 1
-802.430664062 -209.9921875 m 0
- 830.4453125 -209.9921875 857.633789062 -204.500976562 883.227539062 -193.674804688 c 0
- 907.9453125 -183.221679688 930.141601562 -168.25390625 949.19921875 -149.196289062 c 0
- 968.2578125 -130.138671875 983.224609375 -107.942382812 993.678710938 -83.2236328125 c 0
- 1004.50390625 -57.6298828125 1009.99609375 -30.44140625 1009.99609375 -2.427734375 c 0
- 1009.99609375 25.5869140625 1004.50390625 52.775390625 993.678710938 78.369140625 c 0
- 983.224609375 103.087890625 968.2578125 125.284179688 949.19921875 144.341796875 c 0
- 930.141601562 163.399414062 907.9453125 178.3671875 883.227539062 188.8203125 c 0
- 857.6328125 199.646484375 830.4453125 205.137695312 802.430664062 205.137695312 c 0
- 774.416015625 205.137695312 747.227539062 199.646484375 721.633789062 188.8203125 c 0
- 696.916015625 178.3671875 674.719726562 163.399414062 655.662109375 144.341796875 c 0
- 636.603515625 125.284179688 621.63671875 103.087890625 611.182617188 78.369140625 c 0
- 600.357421875 52.775390625 594.865234375 25.5869140625 594.865234375 -2.427734375 c 0
- 594.865234375 -30.44140625 600.357421875 -57.6298828125 611.182617188 -83.2236328125 c 0
- 621.63671875 -107.942382812 636.603515625 -130.138671875 655.662109375 -149.196289062 c 0
- 674.719726562 -168.25390625 696.916015625 -183.221679688 721.633789062 -193.674804688 c 0
- 747.228515625 -204.500976562 774.411132812 -209.9921875 802.430664062 -209.9921875 c 0
-802.430664062 183.87890625 m 0
- 905.1640625 183.87890625 988.736328125 100.299804688 988.736328125 -2.427734375 c 0
- 988.736328125 -105.155273438 905.1640625 -188.733398438 802.430664062 -188.733398438 c 0
- 699.697265625 -188.733398438 616.124023438 -105.161132812 616.124023438 -2.427734375 c 0
- 616.124023438 100.305664062 699.703125 183.87890625 802.430664062 183.87890625 c 0
-EndSplineSet
-Validated: 524325
-EndChar
 EndChars
 EndSplineFont
--- a/3rdparty/rcheevos/include/rc_api_runtime.h
+++ b/3rdparty/rcheevos/include/rc_api_runtime.h
@@ -220,8 +220,6 @@ typedef struct rc_api_award_achievement_request_t {
  uint32_t hardcore;
  /* The hash associated to the game being played */
  const char* game_hash;
-  /* The number of seconds since the achievement was unlocked */
-  uint32_t seconds_since_unlock;
 }
 rc_api_award_achievement_request_t;

@@ -265,8 +263,6 @@ typedef struct rc_api_submit_lboard_entry_request_t {
  int32_t score;
  /* The hash associated to the game being played */
  const char* game_hash;
-  /* The number of seconds since the leaderboard attempt was completed */
-  uint32_t seconds_since_completion;
 }
 rc_api_submit_lboard_entry_request_t;

--- a/3rdparty/rcheevos/src/rapi/rc_api_runtime.c
+++ b/3rdparty/rcheevos/src/rapi/rc_api_runtime.c
@@ -412,8 +412,6 @@ int rc_api_init_award_achievement_request(rc_api_request_t* request, const rc_ap
    rc_url_builder_append_unum_param(&builder, "h", api_params->hardcore ? 1 : 0);
    if (api_params->game_hash && *api_params->game_hash)
      rc_url_builder_append_str_param(&builder, "m", api_params->game_hash);
-    if (api_params->seconds_since_unlock)
-      rc_url_builder_append_unum_param(&builder, "o", api_params->seconds_since_unlock);

    /* Evaluate the signature. */
    md5_init(&md5);
@@ -422,14 +420,6 @@ int rc_api_init_award_achievement_request(rc_api_request_t* request, const rc_ap
    md5_append(&md5, (md5_byte_t*)api_params->username, (int)strlen(api_params->username));
    snprintf(buffer, sizeof(buffer), "%d", api_params->hardcore ? 1 : 0);
    md5_append(&md5, (md5_byte_t*)buffer, (int)strlen(buffer));
-    if (api_params->seconds_since_unlock) {
-      /* second achievement id is needed by delegated unlock. including it here allows overloading
-       * the hash generating code on the server */
-      snprintf(buffer, sizeof(buffer), "%u", api_params->achievement_id);
-      md5_append(&md5, (md5_byte_t*)buffer, (int)strlen(buffer));
-      snprintf(buffer, sizeof(buffer), "%u", api_params->seconds_since_unlock);
-      md5_append(&md5, (md5_byte_t*)buffer, (int)strlen(buffer));
-    }
    md5_finish(&md5, digest);
    rc_format_md5(buffer, digest);
    rc_url_builder_append_str_param(&builder, "v", buffer);
@@ -515,9 +505,6 @@ int rc_api_init_submit_lboard_entry_request(rc_api_request_t* request, const rc_
    if (api_params->game_hash && *api_params->game_hash)
      rc_url_builder_append_str_param(&builder, "m", api_params->game_hash);

-    if (api_params->seconds_since_completion)
-      rc_url_builder_append_unum_param(&builder, "o", api_params->seconds_since_completion);
-
    /* Evaluate the signature. */
    md5_init(&md5);
    snprintf(buffer, sizeof(buffer), "%u", api_params->leaderboard_id);
@@ -525,10 +512,6 @@ int rc_api_init_submit_lboard_entry_request(rc_api_request_t* request, const rc_
    md5_append(&md5, (md5_byte_t*)api_params->username, (int)strlen(api_params->username));
    snprintf(buffer, sizeof(buffer), "%d", api_params->score);
    md5_append(&md5, (md5_byte_t*)buffer, (int)strlen(buffer));
-    if (api_params->seconds_since_completion) {
-      snprintf(buffer, sizeof(buffer), "%u", api_params->seconds_since_completion);
-      md5_append(&md5, (md5_byte_t*)buffer, (int)strlen(buffer));
-    }
    md5_finish(&md5, digest);
    rc_format_md5(buffer, digest);
    rc_url_builder_append_str_param(&builder, "v", buffer);
--- a/3rdparty/rcheevos/src/rc_client.c
+++ b/3rdparty/rcheevos/src/rc_client.c
@@ -578,7 +578,13 @@ static int rc_client_get_image_url(char buffer[], size_t buffer_size, int image_
  image_request.image_name = image_name;
  result = rc_api_init_fetch_image_request(&request, &image_request);
  if (result == RC_OK)
-    snprintf(buffer, buffer_size, "%s", request.url);
+  {
+    const size_t url_length = strlen(request.url);
+    if (url_length >= buffer_size)
+      result = RC_INSUFFICIENT_BUFFER;
+    else
+      memcpy(buffer, request.url, url_length + 1);
+  }

  rc_api_destroy_request(&request);
  return result;
@@ -1434,6 +1440,7 @@ static void rc_client_activate_game(rc_client_load_state_t* load_state, rc_api_s
  rc_mutex_lock(&client->state.mutex);
  load_state->progress = (client->state.load == load_state) ?
      RC_CLIENT_LOAD_GAME_STATE_DONE : RC_CLIENT_LOAD_GAME_STATE_ABORTED;
+  client->state.load = NULL;
  rc_mutex_unlock(&client->state.mutex);

  if (load_state->progress != RC_CLIENT_LOAD_GAME_STATE_DONE) {
@@ -1454,15 +1461,17 @@ static void rc_client_activate_game(rc_client_load_state_t* load_state, rc_api_s
          start_session_response->num_unlocks, RC_CLIENT_ACHIEVEMENT_UNLOCKED_SOFTCORE);
    }

-    /* make the loaded game active if another game is not aleady being loaded. */
    rc_mutex_lock(&client->state.mutex);
-    if (client->state.load == load_state)
+    if (client->state.load == NULL)
      client->game = load_state->game;
-    else
-      load_state->progress = RC_CLIENT_LOAD_GAME_STATE_ABORTED;
    rc_mutex_unlock(&client->state.mutex);

-    if (load_state->progress != RC_CLIENT_LOAD_GAME_STATE_ABORTED) {
+    if (client->game != load_state->game) {
+      /* previous load state was aborted */
+      if (load_state->callback)
+        load_state->callback(RC_ABORTED, "The requested game is no longer active", client, load_state->callback_userdata);
+    }
+    else {
      /* if a change media request is pending, kick it off */
      rc_client_pending_media_t* pending_media;

@@ -1472,9 +1481,6 @@ static void rc_client_activate_game(rc_client_load_state_t* load_state, rc_api_s
      rc_mutex_unlock(&load_state->client->state.mutex);

      if (pending_media) {
-        /* rc_client_check_pending_media will fail if it can't find the game in client->game or
-         * client->state.load->game. since we've detached the load_state, this has to occur after
-         * we've made the game active. */
        if (pending_media->hash) {
          rc_client_begin_change_media_from_hash(client, pending_media->hash,
            pending_media->callback, pending_media->callback_userdata);
@@ -1488,50 +1494,12 @@ static void rc_client_activate_game(rc_client_load_state_t* load_state, rc_api_s
        rc_client_free_pending_media(pending_media);
      }

-      rc_mutex_lock(&client->state.mutex);
-      if (client->state.load != load_state)
-        load_state->progress = RC_CLIENT_LOAD_GAME_STATE_ABORTED;
-      rc_mutex_unlock(&client->state.mutex);
-    }
-
-    /* if the game is still being loaded, make sure all the required memory addresses are accessible
-     * so we can mark achievements as unsupported before loading them into the runtime. */
-    if (load_state->progress != RC_CLIENT_LOAD_GAME_STATE_ABORTED) {
-      /* TODO: it is desirable to not do memory reads from a background thread. Some emulators (like Dolphin) don't
-       *       allow it. Dolphin's solution is to use a dummy read function that says all addresses are valid and
-       *       switches to the actual read function after the callback is called. latter invalid reads will
-       *       mark achievements as unsupported. */
-
-      /* ASSERT: client->game must be set before calling this function so the read_memory callback can query the console_id */
+      /* client->game must be set before calling this function so it can query the console_id */
      rc_client_validate_addresses(load_state->game, client);

-      rc_mutex_lock(&client->state.mutex);
-      if (client->state.load != load_state)
-        load_state->progress = RC_CLIENT_LOAD_GAME_STATE_ABORTED;
-      rc_mutex_unlock(&client->state.mutex);
-    }
-
-    /* if the game is still being loaded, load any active acheivements/leaderboards into the runtime */
-    if (load_state->progress != RC_CLIENT_LOAD_GAME_STATE_ABORTED) {
      rc_client_activate_achievements(load_state->game, client);
      rc_client_activate_leaderboards(load_state->game, client);

-      /* detach the load state to indicate that loading is fully complete */
-      rc_mutex_lock(&client->state.mutex);
-      if (client->state.load == load_state)
-        client->state.load = NULL;
-      else
-        load_state->progress = RC_CLIENT_LOAD_GAME_STATE_ABORTED;
-      rc_mutex_unlock(&client->state.mutex);
-    }
-
-    /* one last sanity check to make sure the game is still being loaded. */
-    if (load_state->progress == RC_CLIENT_LOAD_GAME_STATE_ABORTED) {
-      /* game has been unloaded, or another game is being loaded over the top of this game */
-      if (load_state->callback)
-        load_state->callback(RC_ABORTED, "The requested game is no longer active", client, load_state->callback_userdata);
-    }
-    else {
      if (load_state->hash->hash[0] != '[') {
        if (load_state->client->state.spectator_mode != RC_CLIENT_SPECTATOR_MODE_LOCKED) {
          /* schedule the periodic ping */
@@ -2039,6 +2007,7 @@ static int rc_client_attach_load_state(rc_client_t* client, rc_client_load_state
 {
  if (client->state.load == NULL) {
    rc_client_unload_game(client);
+    client->state.load = load_state;

    if (load_state->game == NULL) {
      load_state->game = rc_client_allocate_game();
@@ -2049,10 +2018,6 @@ static int rc_client_attach_load_state(rc_client_t* client, rc_client_load_state
        return 0;
      }
    }
-
-    rc_mutex_lock(&client->state.mutex);
-    client->state.load = load_state;
-    rc_mutex_unlock(&client->state.mutex);
  }
  else if (client->state.load != load_state) {
    /* previous load was aborted */
@@ -2656,6 +2621,8 @@ static void rc_client_game_mark_ui_to_be_hidden(rc_client_t* client, rc_client_g
 void rc_client_unload_game(rc_client_t* client)
 {
  rc_client_game_info_t* game;
+  rc_client_scheduled_callback_data_t** last;
+  rc_client_scheduled_callback_data_t* next;

  if (!client)
    return;
@@ -2682,38 +2649,29 @@ void rc_client_unload_game(rc_client_t* client)
  if (client->state.load) {
    /* this mimics rc_client_abort_async without nesting the lock */
    client->state.load->async_handle.aborted = RC_CLIENT_ASYNC_ABORTED;
-
-    /* if the game is still being loaded, let the load process clean it up */
-    if (client->state.load->game == game)
-      game = NULL;
-
    client->state.load = NULL;
  }

  if (client->state.spectator_mode == RC_CLIENT_SPECTATOR_MODE_LOCKED)
    client->state.spectator_mode = RC_CLIENT_SPECTATOR_MODE_ON;

-  if (game != NULL) {
-    rc_client_scheduled_callback_data_t** last;
-    rc_client_scheduled_callback_data_t* next;
-
+  if (game != NULL)
    rc_client_game_mark_ui_to_be_hidden(client, game);

-    last = &client->state.scheduled_callbacks;
-    do {
-      next = *last;
-      if (!next)
-        break;
+  last = &client->state.scheduled_callbacks;
+  do {
+    next = *last;
+    if (!next)
+      break;

-      /* remove rich presence ping scheduled event for game */
-      if (next->callback == rc_client_ping && next->related_id == game->public_.id) {
-        *last = next->next;
-        continue;
-      }
+    /* remove rich presence ping scheduled event for game */
+    if (next->callback == rc_client_ping && game && next->related_id == game->public_.id) {
+      *last = next->next;
+      continue;
+    }

-      last = &next->next;
-    } while (1);
-  }
+    last = &next->next;
+  } while (1);

  rc_mutex_unlock(&client->state.mutex);

@@ -3576,7 +3534,7 @@ typedef struct rc_client_award_achievement_callback_data_t
  uint32_t retry_count;
  uint8_t hardcore;
  const char* game_hash;
-  rc_clock_t unlock_time;
+  time_t unlock_time;
  rc_client_t* client;
  rc_client_scheduled_callback_data_t* scheduled_callback_data;
 } rc_client_award_achievement_callback_data_t;
@@ -3727,11 +3685,6 @@ static void rc_client_award_achievement_server_call(rc_client_award_achievement_
  api_params.hardcore = ach_data->hardcore;
  api_params.game_hash = ach_data->game_hash;

-  if (ach_data->retry_count) {
-    const rc_clock_t now = ach_data->client->callbacks.get_time_millisecs(ach_data->client);
-    api_params.seconds_since_unlock = (uint32_t)((now - ach_data->unlock_time) / 1000);
-  }
-
  result = rc_api_init_award_achievement_request(&request, &api_params);
  if (result != RC_OK) {
    RC_CLIENT_LOG_ERR_FORMATTED(ach_data->client, "Error constructing unlock request for achievement %u: %s", ach_data->id, rc_error_str(result));
@@ -3798,8 +3751,7 @@ static void rc_client_award_achievement(rc_client_t* client, rc_client_achieveme
  callback_data->client = client;
  callback_data->id = achievement->public_.id;
  callback_data->hardcore = client->state.hardcore;
-  callback_data->game_hash = client->game->public_.hash;
-  callback_data->unlock_time = client->callbacks.get_time_millisecs(client);
+  callback_data->unlock_time = achievement->public_.unlock_time;

  if (client->game) /* may be NULL if this gets called while unloading the game (from another thread - events are raised outside the lock) */
    callback_data->game_hash = client->game->public_.hash;
@@ -4233,7 +4185,7 @@ typedef struct rc_client_submit_leaderboard_entry_callback_data_t
  int32_t score;
  uint32_t retry_count;
  const char* game_hash;
-  rc_clock_t submit_time;
+  time_t submit_time;
  rc_client_t* client;
  rc_client_scheduled_callback_data_t* scheduled_callback_data;
 } rc_client_submit_leaderboard_entry_callback_data_t;
@@ -4388,11 +4340,6 @@ static void rc_client_submit_leaderboard_entry_server_call(rc_client_submit_lead
  api_params.score = lboard_data->score;
  api_params.game_hash = lboard_data->game_hash;

-  if (lboard_data->retry_count) {
-    const rc_clock_t now = lboard_data->client->callbacks.get_time_millisecs(lboard_data->client);
-    api_params.seconds_since_completion = (uint32_t)((now - lboard_data->submit_time) / 1000);
-  }
-
  result = rc_api_init_submit_lboard_entry_request(&request, &api_params);
  if (result != RC_OK) {
    RC_CLIENT_LOG_ERR_FORMATTED(lboard_data->client, "Error constructing submit leaderboard entry for leaderboard %u: %s", lboard_data->id, rc_error_str(result));
@@ -4436,7 +4383,7 @@ static void rc_client_submit_leaderboard_entry(rc_client_t* client, rc_client_le
  callback_data->id = leaderboard->public_.id;
  callback_data->score = leaderboard->value;
  callback_data->game_hash = client->game->public_.hash;
-  callback_data->submit_time = client->callbacks.get_time_millisecs(client);
+  callback_data->submit_time = time(NULL);

  RC_CLIENT_LOG_INFO_FORMATTED(client, "Submitting %s (%d) for leaderboard %u: %s",
      leaderboard->public_.tracker_value, leaderboard->value, leaderboard->public_.id, leaderboard->public_.title);
--- a/3rdparty/rcheevos/src/rc_libretro.c
+++ b/3rdparty/rcheevos/src/rc_libretro.c
@@ -36,17 +36,6 @@ typedef struct rc_disallowed_core_settings_t
  const rc_disallowed_setting_t* disallowed_settings;
 } rc_disallowed_core_settings_t;

-
-static const rc_disallowed_setting_t _rc_disallowed_beetle_psx_settings[] = {
-  { "beetle_psx_cpu_freq_scale", "<100" },
-  { NULL, NULL }
-};
-
-static const rc_disallowed_setting_t _rc_disallowed_beetle_psx_hw_settings[] = {
-  { "beetle_psx_hw_cpu_freq_scale", "<100" },
-  { NULL, NULL }
-};
-
 static const rc_disallowed_setting_t _rc_disallowed_bsnes_settings[] = {
  { "bsnes_region", "pal" },
  { NULL, NULL }
@@ -91,11 +80,6 @@ static const rc_disallowed_setting_t _rc_disallowed_fceumm_settings[] = {
  { NULL, NULL }
 };

-static const rc_disallowed_setting_t _rc_disallowed_flycast_settings[] = {
-  { "reicast_sh4clock", "<200" },
-  { NULL, NULL }
-};
-
 static const rc_disallowed_setting_t _rc_disallowed_gpgx_settings[] = {
  { "genesis_plus_gx_lock_on", ",action replay (pro),game genie" },
  { "genesis_plus_gx_region_detect", "pal" },
@@ -124,7 +108,6 @@ static const rc_disallowed_setting_t _rc_disallowed_neocd_settings[] = {
 };

 static const rc_disallowed_setting_t _rc_disallowed_pcsx_rearmed_settings[] = {
-  { "pcsx_rearmed_psxclock", "<55" },
  { "pcsx_rearmed_region", "pal" },
  { NULL, NULL }
 };
@@ -157,11 +140,6 @@ static const rc_disallowed_setting_t _rc_disallowed_snes9x_settings[] = {
  { NULL, NULL }
 };

-static const rc_disallowed_setting_t _rc_disallowed_swanstation_settings[] = {
-  { "swanstation_CPU_Overclock", "<100" },
-  { NULL, NULL }
-};
-
 static const rc_disallowed_setting_t _rc_disallowed_vice_settings[] = {
  { "vice_autostart", "disabled" }, /* autostart dictates initial load and reset from menu */
  { "vice_reset", "!autostart" }, /* reset dictates behavior when pressing reset button (END) */
@@ -174,8 +152,6 @@ static const rc_disallowed_setting_t _rc_disallowed_virtual_jaguar_settings[] =
 };

 static const rc_disallowed_core_settings_t rc_disallowed_core_settings[] = {
-  { "Beetle PSX", _rc_disallowed_beetle_psx_settings },
-  { "Beetle PSX HW", _rc_disallowed_beetle_psx_hw_settings },
  { "bsnes-mercury", _rc_disallowed_bsnes_settings },
  { "cap32", _rc_disallowed_cap32_settings },
  { "dolphin-emu", _rc_disallowed_dolphin_settings },
@@ -184,7 +160,6 @@ static const rc_disallowed_core_settings_t rc_disallowed_core_settings[] = {
  { "ecwolf", _rc_disallowed_ecwolf_settings },
  { "FCEUmm", _rc_disallowed_fceumm_settings },
  { "FinalBurn Neo", _rc_disallowed_fbneo_settings },
-  { "Flycast", _rc_disallowed_flycast_settings },
  { "Genesis Plus GX", _rc_disallowed_gpgx_settings },
  { "Genesis Plus GX Wide", _rc_disallowed_gpgx_wide_settings },
  { "Mesen", _rc_disallowed_mesen_settings },
@@ -196,7 +171,6 @@ static const rc_disallowed_core_settings_t rc_disallowed_core_settings[] = {
  { "QUASI88", _rc_disallowed_quasi88_settings },
  { "SMS Plus GX", _rc_disallowed_smsplus_settings },
  { "Snes9x", _rc_disallowed_snes9x_settings },
-  { "SwanStation", _rc_disallowed_swanstation_settings },
  { "VICE x64", _rc_disallowed_vice_settings },
  { "Virtual Jaguar", _rc_disallowed_virtual_jaguar_settings },
  { NULL, NULL }
@@ -212,12 +186,6 @@ static int rc_libretro_string_equal_nocase_wildcard(const char* test, const char
  return (*value == '\0');
 }

-static int rc_libretro_numeric_less_than(const char* test, const char* value) {
-  int test_num = atoi(test);
-  int value_num = atoi(value);
-  return (test_num < value_num);
-}
-
 static int rc_libretro_match_value(const char* val, const char* match) {
  /* if value starts with a comma, it's a CSV list of potential matches */
  if (*match == ',') {
@@ -250,10 +218,6 @@ static int rc_libretro_match_value(const char* val, const char* match) {
  if (*match == '!')
    return !rc_libretro_match_value(val, &match[1]);

-  /* a leading less tahn means the provided value is the minimum allowed */
-  if (*match == '<')
-    return rc_libretro_numeric_less_than(val, &match[1]);
-
  /* just a single value, attempt to match it */
  return rc_libretro_string_equal_nocase_wildcard(val, match);
 }
--- a/3rdparty/rcheevos/src/rc_version.h
+++ b/3rdparty/rcheevos/src/rc_version.h
@@ -8,7 +8,7 @@
 RC_BEGIN_C_DECLS

 #define RCHEEVOS_VERSION_MAJOR 11
-#define RCHEEVOS_VERSION_MINOR 6
+#define RCHEEVOS_VERSION_MINOR 5
 #define RCHEEVOS_VERSION_PATCH 0

 #define RCHEEVOS_MAKE_VERSION(major, minor, patch) (major * 1000000 + minor * 1000 + patch)
--- a/3rdparty/rcheevos/src/rcheevos/consoleinfo.c
+++ b/3rdparty/rcheevos/src/rcheevos/consoleinfo.c
@@ -721,29 +721,16 @@ static const rc_memory_regions_t rc_memory_regions_n64 = { _rc_memory_regions_n6
 /* ===== Nintendo DS ===== */
 /* https://www.akkit.org/info/gbatek.htm#dsmemorymaps */
 static const rc_memory_region_t _rc_memory_regions_nintendo_ds[] = {
-    { 0x0000000U, 0x03FFFFFU, 0x02000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" },
-    /* To keep DS/DSi memory maps aligned, padding is set here for the DSi's extra RAM */
-    { 0x0400000U, 0x0FFFFFFU, 0x02400000U, RC_MEMORY_TYPE_UNUSED, "Unused (DSi exclusive)" },
-    /* The DS/DSi have "tightly coupled memory": very fast memory directly connected to the CPU.
-     * This memory has an instruction variant (ITCM) and a data variant (DTCM).
-     * For achievement purposes it is useful to be able to access the data variant.
-     * This memory does not have a fixed address on console, being able to be moved to any $0xxxx000 region.
-     * While normally this kind of memory is addressed outside of the possible native addressing space, this is simply not possible,
-     * as the DS/DSi's address space covers all possible uint32_t values.
-     * $0E000000 is used here as a "pseudo-end," as this is nearly the end of all the memory actually mapped to addresses
-     * This means that (with the exception of $FFFF0000 onwards, which has the ARM9 BIOS mapped) $0E000000 onwards has nothing mapped to it
-     */
-    { 0x1000000U, 0x1003FFFU, 0x0E000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "Data TCM" }
+    { 0x000000U, 0x3FFFFFU, 0x02000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }
 };
-static const rc_memory_regions_t rc_memory_regions_nintendo_ds = { _rc_memory_regions_nintendo_ds, 3 };
+static const rc_memory_regions_t rc_memory_regions_nintendo_ds = { _rc_memory_regions_nintendo_ds, 1 };

 /* ===== Nintendo DSi ===== */
 /* https://problemkaputt.de/gbatek.htm#dsiiomap */
 static const rc_memory_region_t _rc_memory_regions_nintendo_dsi[] = {
-    { 0x0000000U, 0x0FFFFFFU, 0x02000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" },
-    { 0x1000000U, 0x1003FFFU, 0x0E000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "Data TCM" }
+    { 0x000000U, 0xFFFFFFU, 0x02000000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }
 };
-static const rc_memory_regions_t rc_memory_regions_nintendo_dsi = { _rc_memory_regions_nintendo_dsi, 2 };
+static const rc_memory_regions_t rc_memory_regions_nintendo_dsi = { _rc_memory_regions_nintendo_dsi, 1 };

 /* ===== Oric ===== */
 static const rc_memory_region_t _rc_memory_regions_oric[] = {
@@ -969,31 +956,6 @@ static const rc_memory_region_t _rc_memory_regions_wonderswan[] = {
 };
 static const rc_memory_regions_t rc_memory_regions_wonderswan = { _rc_memory_regions_wonderswan, 2 };

-/* ===== ZX Spectrum ===== */
-/* https://github.com/TASEmulators/BizHawk/blob/3a3b22c/src/BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/ZXSpectrum16K/ZX16.cs
- * https://github.com/TASEmulators/BizHawk/blob/3a3b22c/src/BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/ZXSpectrum48K/ZX48.Memory.cs
- * https://worldofspectrum.org/faq/reference/128kreference.htm */
-static const rc_memory_region_t _rc_memory_regions_zx_spectrum[] = {
-    /* ZX Spectrum is complicated as multiple models exist with varying amounts of memory.
-     * In practice, this can be reduced to two categories: 16K/48K units, and 128K units.
-     * 16K/48K units have RAM starting at $4000 onwards, 16K ending at $7FFF, 48K ending at $FFFF.
-     * 128K units have banked memory, with $4000-$7FFF normally having RAM bank 5, and $8000-$BFFF normally having RAM bank 2.
-     * $C000-$FFFF is normally reserved for banked RAM, having any of banks 0-7.
-     * For the purposes of the RAM map, $C000-$FFFF is assumed to be bank 0, and $10000 onwards has the other banks in order (1, 3, 4, 6, 7)
-     * Doing it this way always for 16K/48K games to have the same memory map on the 128K, and thus avoid issues due to the model selected.
-     * Later 128K units also have a special banking mode that changes up banking completely, but for 16K/48K compatibility purposes this doesn't matter, and so is irrelevant.
-     */
-    { 0x00000U, 0x03FFFU, 0x04000U, RC_MEMORY_TYPE_SYSTEM_RAM, "Screen RAM" }, /* RAM bank 5 on 128K units */
-    { 0x04000U, 0x07FFFU, 0x08000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }, /* RAM bank 2 on 128K units */
-    { 0x08000U, 0x0BFFFU, 0x0C000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }, /* RAM bank 0-7 on 128K units, assumed to be bank 0 here */
-    { 0x0C000U, 0x0FFFFU, 0x10000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }, /* RAM bank 1 on 128K units */
-    { 0x10000U, 0x13FFFU, 0x14000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }, /* RAM bank 3 on 128K units */
-    { 0x14000U, 0x17FFFU, 0x18000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }, /* RAM bank 4 on 128K units */
-    { 0x18000U, 0x1BFFFU, 0x1C000U, RC_MEMORY_TYPE_SYSTEM_RAM, "System RAM" }, /* RAM bank 6 on 128K units */
-    { 0x1C000U, 0x1FFFFU, 0x20000U, RC_MEMORY_TYPE_SYSTEM_RAM, "Screen RAM" } /* RAM bank 7 on 128K units */
-};
-static const rc_memory_regions_t rc_memory_regions_zx_spectrum = { _rc_memory_regions_zx_spectrum, 8 };
-
 /* ===== default ===== */
 static const rc_memory_regions_t rc_memory_regions_none = { 0, 0 };

@@ -1179,9 +1141,6 @@ const rc_memory_regions_t* rc_console_memory_regions(uint32_t console_id)
    case RC_CONSOLE_WONDERSWAN:
      return &rc_memory_regions_wonderswan;

-    case RC_CONSOLE_ZX_SPECTRUM:
-      return &rc_memory_regions_zx_spectrum;
-
    default:
      return &rc_memory_regions_none;
  }
--- a/3rdparty/rcheevos/src/rcheevos/lboard.c
+++ b/3rdparty/rcheevos/src/rcheevos/lboard.c
@@ -199,19 +199,19 @@ int rc_evaluate_lboard(rc_lboard_t* self, int32_t* value, rc_peek_t peek, void*
          /* start and submit are both true in the same frame, just submit without announcing the leaderboard is available */
          self->state = RC_LBOARD_STATE_TRIGGERED;
        }
-        else if (!self->start.requirement && !self->start.alternative) {
-          /* start trigger is empty. assume the leaderboard is in development and ignore */
+        else if (self->start.requirement == 0 && self->start.alternative == 0) {
+          /* start condition is empty - this leaderboard is submit-only with no measured progress */
        }
        else {
          /* start the leaderboard attempt */
          self->state = RC_LBOARD_STATE_STARTED;
+
+          /* reset any hit counts in the value */
+          if (self->progress)
+            rc_reset_value(self->progress);
+
+          rc_reset_value(&self->value);
        }
-
-        /* reset any hit counts in the value */
-        if (self->progress)
-          rc_reset_value(self->progress);
-
-        rc_reset_value(&self->value);
      }
      break;

--- a/3rdparty/rcheevos/src/rcheevos/rc_validate.c
+++ b/3rdparty/rcheevos/src/rcheevos/rc_validate.c
@@ -726,7 +726,6 @@ static int rc_validate_conflicting_conditions(const rc_condset_t* conditions, co
  const rc_condition_t* condition;
  const rc_condition_t* condition_chain_start;
  int overlap;
-  int chain_matches;

  /* empty group */
  if (conditions == NULL || compare_conditions == NULL)
@@ -778,9 +777,9 @@ static int rc_validate_conflicting_conditions(const rc_condset_t* conditions, co

      /* if combining conditions exist, make sure the same combining conditions exist in the
       * compare logic. conflicts can only occur if the combinining conditions match. */
-      chain_matches = 1;
      if (condition_chain_start != condition)
      {
+        int chain_matches = 1;
        const rc_condition_t* condition_chain_iter = condition_chain_start;
        while (condition_chain_iter != condition)
        {
@@ -796,8 +795,11 @@ static int rc_validate_conflicting_conditions(const rc_condset_t* conditions, co
          if (compare_condition->oper != RC_OPERATOR_NONE &&
            !rc_validate_are_operands_equal(&compare_condition->operand2, &condition_chain_iter->operand2))
          {
-            chain_matches = 0;
-            break;
+            if (compare_condition->operand2.type != condition_chain_iter->operand2.type)
+            {
+              chain_matches = 0;
+              break;
+            }
          }

          if (!compare_condition->next)
@@ -806,27 +808,17 @@ static int rc_validate_conflicting_conditions(const rc_condset_t* conditions, co
            break;
          }

-          if (compare_condition->type != RC_CONDITION_ADD_ADDRESS &&
-              compare_condition->type != RC_CONDITION_ADD_SOURCE &&
-              compare_condition->type != RC_CONDITION_SUB_SOURCE &&
-              compare_condition->type != RC_CONDITION_AND_NEXT)
-          {
-            /* things like AddHits and OrNext are hard to definitively detect conflicts. ignore them. */
-            chain_matches = 0;
-            break;
-          }
-
          compare_condition = compare_condition->next;
          condition_chain_iter = condition_chain_iter->next;
        }
-      }

-      /* combining field didn't match, or there's more unmatched combining fields. ignore this condition */
-      if (!chain_matches || rc_validate_is_combining_condition(compare_condition))
-      {
-        while (compare_condition->next && rc_validate_is_combining_condition(compare_condition))
-          compare_condition = compare_condition->next;
-        continue;
+        /* combining field didn't match, or there's more unmatched combining fields. ignore this condition */
+        if (!chain_matches || rc_validate_is_combining_condition(compare_condition))
+        {
+          while (compare_condition->next && rc_validate_is_combining_condition(compare_condition))
+            compare_condition = compare_condition->next;
+          continue;
+        }
      }

      if (compare_condition->required_hits)
--- a/3rdparty/rcheevos/src/rcheevos/richpresence.c
+++ b/3rdparty/rcheevos/src/rcheevos/richpresence.c
@@ -360,9 +360,6 @@ static const char* rc_parse_richpresence_lookup(rc_richpresence_lookup_t* lookup
  do
  {
    line = nextline;
-    if (line == NULL)
-      break;
-
    nextline = rc_parse_line(line, &endline, parse);

    if (endline - line < 2) {
@@ -441,9 +438,6 @@ static const char* rc_parse_richpresence_lookup(rc_richpresence_lookup_t* lookup

      /* insert the current item and continue scanning the next one */
      rc_insert_richpresence_lookup_item(lookup, first, last, label, (int)(endline - label), parse);
-      if (parse->offset < 0)
-        break;
-
      line = endptr + 1;
    } while (line < endline);

--- a/3rdparty/rcheevos/src/rhash/hash.c
+++ b/3rdparty/rcheevos/src/rhash/hash.c
@@ -3113,7 +3113,6 @@ int rc_hash_generate_from_buffer(char hash[33], uint32_t console_id, const uint8
    case RC_CONSOLE_VIRTUAL_BOY:
    case RC_CONSOLE_WASM4:
    case RC_CONSOLE_WONDERSWAN:
-    case RC_CONSOLE_ZX_SPECTRUM:
      return rc_hash_buffer(hash, buffer, buffer_size);

    case RC_CONSOLE_ARDUBOY:
@@ -3412,7 +3411,6 @@ int rc_hash_generate_from_file(char hash[33], uint32_t console_id, const char* p
    case RC_CONSOLE_VIRTUAL_BOY:
    case RC_CONSOLE_WASM4:
    case RC_CONSOLE_WONDERSWAN:
-    case RC_CONSOLE_ZX_SPECTRUM:
      /* generic whole-file hash - don't buffer */
      return rc_hash_whole_file(hash, path);

@@ -3468,9 +3466,6 @@ int rc_hash_generate_from_file(char hash[33], uint32_t console_id, const char* p
    case RC_CONSOLE_NINTENDO_64:
      return rc_hash_n64(hash, path);

-    case RC_CONSOLE_NINTENDO_3DS:
-      return rc_hash_nintendo_3ds(hash, path);
-
    case RC_CONSOLE_NINTENDO_DS:
    case RC_CONSOLE_NINTENDO_DSI:
      return rc_hash_nintendo_ds(hash, path);
@@ -3578,7 +3573,6 @@ static void rc_hash_initialize_dsk_iterator(struct rc_hash_iterator* iterator, c
  /* check MSX first, as Apple II isn't supported by RetroArch, and RAppleWin won't use the iterator */
  rc_hash_iterator_append_console(iterator, RC_CONSOLE_MSX);
  rc_hash_iterator_append_console(iterator, RC_CONSOLE_AMSTRAD_PC);
-  rc_hash_iterator_append_console(iterator, RC_CONSOLE_ZX_SPECTRUM);
  rc_hash_iterator_append_console(iterator, RC_CONSOLE_APPLE_II);
 }

@@ -3731,10 +3725,6 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
        {
          iterator->consoles[0] = RC_CONSOLE_NINTENDO_3DS;
        }
-        else if (rc_path_compare_extension(ext, "csw"))
-        {
-          iterator->consoles[0] = RC_CONSOLE_ZX_SPECTRUM;
-        }
        break;

      case 'd':
@@ -3818,7 +3808,6 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
          iterator->consoles[1] = RC_CONSOLE_PSP;
          iterator->consoles[2] = RC_CONSOLE_3DO;
          iterator->consoles[3] = RC_CONSOLE_SEGA_CD; /* ASSERT: handles both Sega CD and Saturn */
-          iterator->consoles[4] = RC_CONSOLE_GAMECUBE;
          need_path = 1;
        }
        break;
@@ -3920,10 +3909,6 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
        {
          iterator->consoles[0] = RC_CONSOLE_ELEKTOR_TV_GAMES_COMPUTER;
        }
-        else if (rc_path_compare_extension(ext, "pzx"))
-        {
-          iterator->consoles[0] = RC_CONSOLE_ZX_SPECTRUM;
-        }
        break;

      case 'r':
@@ -3962,16 +3947,11 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
        {
          iterator->consoles[0] = RC_CONSOLE_THOMSONTO8; /* disk */
        }
-        else if (rc_path_compare_extension(ext, "scl"))
-        {
-          iterator->consoles[0] = RC_CONSOLE_ZX_SPECTRUM;
-        }
        break;

      case 't':
        if (rc_path_compare_extension(ext, "tap"))
        {
-          /* also Commodore 64 and ZX Spectrum, but all are full file hashes */
          iterator->consoles[0] = RC_CONSOLE_ORIC;
        }
        else if (rc_path_compare_extension(ext, "tic"))
@@ -3982,11 +3962,6 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
        {
          iterator->consoles[0] = RC_CONSOLE_ELEKTOR_TV_GAMES_COMPUTER;
        }
-        else if (rc_path_compare_extension(ext, "trd") ||
-                 rc_path_compare_extension(ext, "tzx"))
-        {
-          iterator->consoles[0] = RC_CONSOLE_ZX_SPECTRUM;
-        }
        break;

      case 'u':
--- a/3rdparty/vulkan/include/CHANGELOG.md
+++ b/3rdparty/vulkan/include/CHANGELOG.md
@@ -1,217 +0,0 @@
-# 3.2.0 (2024-12-30)
-
-Additions to the library API:
-
- Added support for Vulkan 1.4.
- Added support for VK_KHR_external_memory_win32 extension - `VMA_ALLOCATOR_CREATE_KHR_EXTERNAL_MEMORY_WIN32_BIT` flag, `vmaGetMemoryWin32Handle` function, and a whole new documentation chapter about it (#442).
-
-Other changes:
-
- Fixed thread safety issue (#451).
- Many other bug fixes and improvements in the library code, documentation, sample app, Cmake script, mostly to improve compatibility with various compilers and GPUs.
-
-# 3.1.0 (2024-05-27)
-
-This release gathers fixes and improvements made during many months of continuous development on the main branch, mostly based on issues and pull requests on GitHub.
-
-Additions to the library API:
-
- Added convenience functions `vmaCopyMemoryToAllocation`, `vmaCopyAllocationToMemory`.
- Added functions `vmaCreateAliasingBuffer2`, `vmaCreateAliasingImage2` that offer creating a buffer/image in an existing allocation with additional `allocationLocalOffset`.
- Added function `vmaGetAllocationInfo2`, structure `VmaAllocationInfo2` that return additional information about an allocation, useful for interop with other APIs (#383, #340).
- Added callback `VmaDefragmentationInfo::pfnBreakCallback` that allows breaking long execution of `vmaBeginDefragmentation`.
-  Also added `PFN_vmaCheckDefragmentationBreakFunction`, `VmaDefragmentationInfo::pBreakCallbackUserData`.
- Added support for VK_KHR_maintenance4 extension - `VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT` flag (#397).
- Added support for VK_KHR_maintenance5 extension - `VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT` flag (#411).
-
-Other changes:
-
- Changes in debug and configuration macros:
-  - Split macros into separate `VMA_DEBUG_LOG` and `VMA_DEBUG_LOG_FORMAT` (#297).
-  - Added macros `VMA_ASSERT_LEAK`, `VMA_LEAK_LOG_FORMAT` separate from normal `VMA_ASSERT`, `VMA_DEBUG_LOG_FORMAT` (#379, #385).
-  - Added macro `VMA_EXTENDS_VK_STRUCT` (#347).
- Countless bug fixes and improvements in the code and documentation, mostly to improve compatibility with various compilers and GPUs, including:
-  - Fixed missing `#include` that resulted in compilation error about `snprintf` not declared on some compilers (#312).
-  - Fixed main memory type selection algorithm for GPUs that have no `HOST_CACHED` memory type, like Raspberry Pi (#362).
- Major changes in Cmake script.
- Fixes in GpuMemDumpVis.py script.
-
-# 3.0.1 (2022-05-26)
-
- Fixes in defragmentation algorithm.
- Fixes in GpuMemDumpVis.py regarding image height calculation.
- Other bug fixes, optimizations, and improvements in the code and documentation.
-
-# 3.0.0 (2022-03-25)
-
-It has been a long time since the previous official release, so hopefully everyone has been using the latest code from "master" branch, which is always maintained in a good state, not the old version. For completeness, here is the list of changes since v2.3.0. The major version number has changed, so there are some compatibility-breaking changes, but the basic API stays the same and is mostly backward-compatible.
-
-Major features added (some compatibility-breaking):
-
- Added new API for selecting preferred memory type: flags `VMA_MEMORY_USAGE_AUTO`, `VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE`, `VMA_MEMORY_USAGE_AUTO_PREFER_HOST`, `VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT`, `VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT`, `VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT`. Old values like `VMA_MEMORY_USAGE_GPU_ONLY` still work as before, for backward compatibility, but are not recommended.
- Added new defragmentation API and algorithm, replacing the old one. See structure `VmaDefragmentationInfo`, `VmaDefragmentationMove`, `VmaDefragmentationPassMoveInfo`, `VmaDefragmentationStats`, function `vmaBeginDefragmentation`, `vmaEndDefragmentation`, `vmaBeginDefragmentationPass`, `vmaEndDefragmentationPass`.
- Redesigned API for statistics, replacing the old one. See structures: `VmaStatistics`, `VmaDetailedStatistics`, `VmaTotalStatistics`. `VmaBudget`, functions: `vmaGetHeapBudgets`, `vmaCalculateStatistics`, `vmaGetPoolStatistics`, `vmaCalculatePoolStatistics`, `vmaGetVirtualBlockStatistics`, `vmaCalculateVirtualBlockStatistics`.
- Added "Virtual allocator" feature - possibility to use core allocation algorithms for allocation of custom memory, not necessarily Vulkan device memory. See functions like `vmaCreateVirtualBlock`, `vmaDestroyVirtualBlock` and many more.
- `VmaAllocation` now keeps both `void* pUserData` and `char* pName`. Added function `vmaSetAllocationName`, member `VmaAllocationInfo::pName`. Flag `VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT` is now deprecated.
- Clarified and cleaned up various ways of importing Vulkan functions. See macros `VMA_STATIC_VULKAN_FUNCTIONS`, `VMA_DYNAMIC_VULKAN_FUNCTIONS`, structure `VmaVulkanFunctions`. Added members `VmaVulkanFunctions::vkGetInstanceProcAddr`, `vkGetDeviceProcAddr`, which are now required when using `VMA_DYNAMIC_VULKAN_FUNCTIONS`.
-
-Removed (compatibility-breaking):
-
- Removed whole "lost allocations" feature. Removed from the interface: `VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT`, `VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT`, `vmaCreateLostAllocation`, `vmaMakePoolAllocationsLost`, `vmaTouchAllocation`, `VmaAllocatorCreateInfo::frameInUseCount`, `VmaPoolCreateInfo::frameInUseCount`.
- Removed whole "record & replay" feature. Removed from the API: `VmaAllocatorCreateInfo::pRecordSettings`, `VmaRecordSettings`, `VmaRecordFlagBits`, `VmaRecordFlags`. Removed VmaReplay application.
- Removed "buddy" algorithm - removed flag `VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT`.
-
-Minor but compatibility-breaking changes:
-
- Changes in `ALLOCATION_CREATE_STRATEGY` flags. Removed flags: `VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT`, `VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT`, `VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT`, which were aliases to other existing flags.
- Added a member `void* pUserData` to `VmaDeviceMemoryCallbacks`. Updated `PFN_vmaAllocateDeviceMemoryFunction`, `PFN_vmaFreeDeviceMemoryFunction` to use the new `pUserData` member.
- Removed function `vmaResizeAllocation` that was already deprecated.
-
-Other major changes:
-
- Added new features to custom pools: support for dedicated allocations, new member `VmaPoolCreateInfo::pMemoryAllocateNext`, `minAllocationAlignment`.
- Added support for Vulkan 1.2, 1.3.
- Added support for VK_KHR_buffer_device_address extension - flag `VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT`.
- Added support for VK_EXT_memory_priority extension - flag `VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT`, members `VmaAllocationCreateInfo::priority`, `VmaPoolCreateInfo::priority`.
- Added support for VK_AMD_device_coherent_memory extension - flag `VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT`.
- Added member `VmaAllocatorCreateInfo::pTypeExternalMemoryHandleTypes`.
- Added function `vmaGetAllocatorInfo`, structure `VmaAllocatorInfo`.
- Added functions `vmaFlushAllocations`, `vmaInvalidateAllocations` for multiple allocations at once.
- Added flag `VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT`.
- Added function `vmaCreateBufferWithAlignment`.
- Added convenience function `vmaGetAllocationMemoryProperties`.
- Added convenience functions: `vmaCreateAliasingBuffer`, `vmaCreateAliasingImage`.
-
-Other minor changes:
-
- Implemented Two-Level Segregated Fit (TLSF) allocation algorithm, replacing previous default one. It is much faster, especially when freeing many allocations at once or when `bufferImageGranularity` is large.
- Renamed debug macro `VMA_DEBUG_ALIGNMENT` to `VMA_MIN_ALIGNMENT`.
- Added CMake support - CMakeLists.txt files. Removed Premake support.
- Changed `vmaInvalidateAllocation` and `vmaFlushAllocation` to return `VkResult`.
- Added nullability annotations for Clang: `VMA_NULLABLE`, `VMA_NOT_NULL`, `VMA_NULLABLE_NON_DISPATCHABLE`, `VMA_NOT_NULL_NON_DISPATCHABLE`, `VMA_LEN_IF_NOT_NULL`.
- JSON dump format has changed.
- Countless fixes and improvements, including performance optimizations, compatibility with various platforms and compilers, documentation.
-
-# 2.3.0 (2019-12-04)
-
-Major release after a year of development in "master" branch and feature branches. Notable new features: supporting Vulkan 1.1, supporting query for memory budget.
-
-Major changes:
-
- Added support for Vulkan 1.1.
-    - Added member `VmaAllocatorCreateInfo::vulkanApiVersion`.
-    - When Vulkan 1.1 is used, there is no need to enable VK_KHR_dedicated_allocation or VK_KHR_bind_memory2 extensions, as they are promoted to Vulkan itself.
- Added support for query for memory budget and staying within the budget.
-    - Added function `vmaGetBudget`, structure `VmaBudget`. This can also serve as simple statistics, more efficient than `vmaCalculateStats`.
-    - By default the budget it is estimated based on memory heap sizes. It may be queried from the system using VK_EXT_memory_budget extension if you use `VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT` flag and `VmaAllocatorCreateInfo::instance` member.
-    - Added flag `VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT` that fails an allocation if it would exceed the budget.
- Added new memory usage options:
-    - `VMA_MEMORY_USAGE_CPU_COPY` for memory that is preferably not `DEVICE_LOCAL` but not guaranteed to be `HOST_VISIBLE`.
-    - `VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED` for memory that is `LAZILY_ALLOCATED`.
- Added support for VK_KHR_bind_memory2 extension:
-    - Added `VMA_ALLOCATION_CREATE_DONT_BIND_BIT` flag that lets you create both buffer/image and allocation, but don't bind them together.
-    - Added flag `VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT`, functions `vmaBindBufferMemory2`, `vmaBindImageMemory2` that let you specify additional local offset and `pNext` pointer while binding.
- Added functions `vmaSetPoolName`, `vmaGetPoolName` that let you assign string names to custom pools. JSON dump file format and VmaDumpVis tool is updated to show these names.
- Defragmentation is legal only on buffers and images in `VK_IMAGE_TILING_LINEAR`. This is due to the way it is currently implemented in the library and the restrictions of the Vulkan specification. Clarified documentation in this regard. See discussion in #59.
-
-Minor changes:
-
- Made `vmaResizeAllocation` function deprecated, always returning failure.
- Made changes in the internal algorithm for the choice of memory type. Be careful! You may now get a type that is not `HOST_VISIBLE` or `HOST_COHERENT` if it's not stated as always ensured by some `VMA_MEMORY_USAGE_*` flag.
- Extended VmaReplay application with more detailed statistics printed at the end.
- Added macros `VMA_CALL_PRE`, `VMA_CALL_POST` that let you decorate declarations of all library functions if you want to e.g. export/import them as dynamically linked library.
- Optimized `VmaAllocation` objects to be allocated out of an internal free-list allocator. This makes allocation and deallocation causing 0 dynamic CPU heap allocations on average.
- Updated recording CSV file format version to 1.8, to support new functions.
- Many additions and fixes in documentation. Many compatibility fixes for various compilers and platforms. Other internal bugfixes, optimizations, updates, refactoring...
-
-# 2.2.0 (2018-12-13)
-
-Major release after many months of development in "master" branch and feature branches. Notable new features: defragmentation of GPU memory, buddy algorithm, convenience functions for sparse binding.
-
-Major changes:
-
- New, more powerful defragmentation:
-  - Added structure `VmaDefragmentationInfo2`, functions `vmaDefragmentationBegin`, `vmaDefragmentationEnd`.
-  - Added support for defragmentation of GPU memory.
-  - Defragmentation of CPU memory now uses `memmove`, so it can move data to overlapping regions.
-  - Defragmentation of CPU memory is now available for memory types that are `HOST_VISIBLE` but not `HOST_COHERENT`.
-  - Added structure member `VmaVulkanFunctions::vkCmdCopyBuffer`.
-  - Major internal changes in defragmentation algorithm.
-  - VmaReplay: added parameters: `--DefragmentAfterLine`, `--DefragmentationFlags`.
-  - Old interface (structure `VmaDefragmentationInfo`, function `vmaDefragment`) is now deprecated.
- Added buddy algorithm, available for custom pools - flag `VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT`.
- Added convenience functions for multiple allocations and deallocations at once, intended for sparse binding resources - functions `vmaAllocateMemoryPages`, `vmaFreeMemoryPages`.
- Added function that tries to resize existing allocation in place: `vmaResizeAllocation`.
- Added flags for allocation strategy: `VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT`, `VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT`, `VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT`, and their aliases: `VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT`, `VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT`, `VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT`.
-
-Minor changes:
-
- Changed behavior of allocation functions to return `VK_ERROR_VALIDATION_FAILED_EXT` when trying to allocate memory of size 0, create buffer with size 0, or image with one of the dimensions 0.
- VmaReplay: Added support for Windows end of lines.
- Updated recording CSV file format version to 1.5, to support new functions.
- Internal optimization: using read-write mutex on some platforms.
- Many additions and fixes in documentation. Many compatibility fixes for various compilers. Other internal bugfixes, optimizations, refactoring, added more internal validation...
-
-# 2.1.0 (2018-09-10)
-
-Minor bugfixes.
-
-# 2.1.0-beta.1 (2018-08-27)
-
-Major release after many months of development in "development" branch and features branches. Many new features added, some bugs fixed. API stays backward-compatible.
-
-Major changes:
-
- Added linear allocation algorithm, accessible for custom pools, that can be used as free-at-once, stack, double stack, or ring buffer. See "Linear allocation algorithm" documentation chapter.
-  - Added `VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT`, `VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT`.
- Added feature to record sequence of calls to the library to a file and replay it using dedicated application. See documentation chapter "Record and replay".
-  - Recording: added `VmaAllocatorCreateInfo::pRecordSettings`.
-  - Replaying: added VmaReplay project.
-  - Recording file format: added document "docs/Recording file format.md".
- Improved support for non-coherent memory.
-  - Added functions: `vmaFlushAllocation`, `vmaInvalidateAllocation`.
-  - `nonCoherentAtomSize` is now respected automatically.
-  - Added `VmaVulkanFunctions::vkFlushMappedMemoryRanges`, `vkInvalidateMappedMemoryRanges`.
- Improved debug features related to detecting incorrect mapped memory usage. See documentation chapter "Debugging incorrect memory usage".
-  - Added debug macro `VMA_DEBUG_DETECT_CORRUPTION`, functions `vmaCheckCorruption`, `vmaCheckPoolCorruption`.
-  - Added debug macro `VMA_DEBUG_INITIALIZE_ALLOCATIONS` to initialize contents of allocations with a bit pattern.
-  - Changed behavior of `VMA_DEBUG_MARGIN` macro - it now adds margin also before first and after last allocation in a block.
- Changed format of JSON dump returned by `vmaBuildStatsString` (not backward compatible!).
-  - Custom pools and memory blocks now have IDs that don't change after sorting.
-  - Added properties: "CreationFrameIndex", "LastUseFrameIndex", "Usage".
-  - Changed VmaDumpVis tool to use these new properties for better coloring.
-  - Changed behavior of `vmaGetAllocationInfo` and `vmaTouchAllocation` to update `allocation.lastUseFrameIndex` even if allocation cannot become lost.
-
-Minor changes:
-
- Changes in custom pools:
-  - Added new structure member `VmaPoolStats::blockCount`.
-  - Changed behavior of `VmaPoolCreateInfo::blockSize` = 0 (default) - it now means that pool may use variable block sizes, just like default pools do.
- Improved logic of `vmaFindMemoryTypeIndex` for some cases, especially integrated GPUs.
- VulkanSample application: Removed dependency on external library MathFu. Added own vector and matrix structures.
- Changes that improve compatibility with various platforms, including: Visual Studio 2012, 32-bit code, C compilers.
-  - Changed usage of "VK_KHR_dedicated_allocation" extension in the code to be optional, driven by macro `VMA_DEDICATED_ALLOCATION`, for compatibility with Android.
- Many additions and fixes in documentation, including description of new features, as well as "Validation layer warnings".
- Other bugfixes.
-
-# 2.0.0 (2018-03-19)
-
-A major release with many compatibility-breaking changes.
-
-Notable new features:
-
- Introduction of `VmaAllocation` handle that you must retrieve from allocation functions and pass to deallocation functions next to normal `VkBuffer` and `VkImage`.
- Introduction of `VmaAllocationInfo` structure that you can retrieve from `VmaAllocation` handle to access parameters of the allocation (like `VkDeviceMemory` and offset) instead of retrieving them directly from allocation functions.
- Support for reference-counted mapping and persistently mapped allocations - see `vmaMapMemory`, `VMA_ALLOCATION_CREATE_MAPPED_BIT`.
- Support for custom memory pools - see `VmaPool` handle, `VmaPoolCreateInfo` structure, `vmaCreatePool` function.
- Support for defragmentation (compaction) of allocations - see function `vmaDefragment` and related structures.
- Support for "lost allocations" - see appropriate chapter on documentation Main Page.
-
-# 1.0.1 (2017-07-04)
-
- Fixes for Linux GCC compilation.
- Changed "CONFIGURATION SECTION" to contain #ifndef so you can define these macros before including this header, not necessarily change them in the file.
-
-# 1.0.0 (2017-06-16)
-
-First public release.
--- a/3rdparty/vulkan/include/README.md
+++ b/3rdparty/vulkan/include/README.md
@@ -1,196 +0,0 @@
-# Vulkan Memory Allocator
-
-Easy to integrate Vulkan memory allocation library.
-
-**Documentation:** Browse online: [Vulkan Memory Allocator](https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/) (generated from Doxygen-style comments in [include/vk_mem_alloc.h](include/vk_mem_alloc.h))
-
-**License:** MIT. See [LICENSE.txt](LICENSE.txt)
-
-**Changelog:** See [CHANGELOG.md](CHANGELOG.md)
-
-**Product page:** [Vulkan Memory Allocator on GPUOpen](https://gpuopen.com/gaming-product/vulkan-memory-allocator/)
-
-**Build status:**
-
- Windows: [![Build status](https://ci.appveyor.com/api/projects/status/4vlcrb0emkaio2pn/branch/master?svg=true)](https://ci.appveyor.com/project/adam-sawicki-amd/vulkanmemoryallocator/branch/master)  
- Linux: [![Build Status](https://app.travis-ci.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.svg?branch=master)](https://app.travis-ci.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
-
-[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.svg)](http://isitmaintained.com/project/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator "Average time to resolve an issue")
-
-# Problem
-
-Memory allocation and resource (buffer and image) creation in Vulkan is difficult (comparing to older graphics APIs, like D3D11 or OpenGL) for several reasons:
-
- It requires a lot of boilerplate code, just like everything else in Vulkan, because it is a low-level and high-performance API.
- There is additional level of indirection: `VkDeviceMemory` is allocated separately from creating `VkBuffer`/`VkImage` and they must be bound together.
- Driver must be queried for supported memory heaps and memory types. Different GPU vendors provide different types of it.
- It is recommended to allocate bigger chunks of memory and assign parts of them to particular resources, as there is a limit on maximum number of memory blocks that can be allocated.
-
-# Features
-
-This library can help game developers to manage memory allocations and resource creation by offering some higher-level functions:
-
-1. Functions that help to choose correct and optimal memory type based on intended usage of the memory.
-   - Required or preferred traits of the memory are expressed using higher-level description comparing to Vulkan flags.
-2. Functions that allocate memory blocks, reserve and return parts of them (`VkDeviceMemory` + offset + size) to the user.
-   - Library keeps track of allocated memory blocks, used and unused ranges inside them, finds best matching unused ranges for new allocations, respects all the rules of alignment and buffer/image granularity.
-3. Functions that can create an image/buffer, allocate memory for it and bind them together - all in one call.
-
-Additional features:
-
- Well-documented - description of all functions and structures provided, along with chapters that contain general description and example code.
- Thread-safety: Library is designed to be used in multithreaded code. Access to a single device memory block referred by different buffers and textures (binding, mapping) is synchronized internally. Memory mapping is reference-counted.
- Configuration: Fill optional members of `VmaAllocatorCreateInfo` structure to provide custom CPU memory allocator, pointers to Vulkan functions and other parameters.
- Customization and integration with custom engines: Predefine appropriate macros to provide your own implementation of all external facilities used by the library like assert, mutex, atomic.
- Support for memory mapping, reference-counted internally. Support for persistently mapped memory: Just allocate with appropriate flag and access the pointer to already mapped memory.
- Support for non-coherent memory. Functions that flush/invalidate memory. `nonCoherentAtomSize` is respected automatically.
- Support for resource aliasing (overlap).
- Support for sparse binding and sparse residency: Convenience functions that allocate or free multiple memory pages at once.
- Custom memory pools: Create a pool with desired parameters (e.g. fixed or limited maximum size) and allocate memory out of it.
- Linear allocator: Create a pool with linear algorithm and use it for much faster allocations and deallocations in free-at-once, stack, double stack, or ring buffer fashion.
- Support for Vulkan 1.0...1.4.
- Support for extensions (and equivalent functionality included in new Vulkan versions):
-   - VK_KHR_dedicated_allocation: Just enable it and it will be used automatically by the library.
-   - VK_KHR_bind_memory2.
-   - VK_KHR_maintenance4.
-   - VK_KHR_maintenance5, including `VkBufferUsageFlags2CreateInfoKHR`.
-   - VK_EXT_memory_budget: Used internally if available to query for current usage and budget. If not available, it falls back to an estimation based on memory heap sizes.
-   - VK_KHR_buffer_device_address: Flag `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR` is automatically added to memory allocations where needed.
-   - VK_EXT_memory_priority: Set `priority` of allocations or custom pools and it will be set automatically using this extension.
-   - VK_AMD_device_coherent_memory.
-   - VK_KHR_external_memory_win32.
- Defragmentation of GPU and CPU memory: Let the library move data around to free some memory blocks and make your allocations better compacted.
- Statistics: Obtain brief or detailed statistics about the amount of memory used, unused, number of allocated blocks, number of allocations etc. - globally, per memory heap, and per memory type.
- Debug annotations: Associate custom `void* pUserData` and debug `char* pName` with each allocation.
- JSON dump: Obtain a string in JSON format with detailed map of internal state, including list of allocations, their string names, and gaps between them.
- Convert this JSON dump into a picture to visualize your memory. See [tools/GpuMemDumpVis](tools/GpuMemDumpVis/README.md).
- Debugging incorrect memory usage: Enable initialization of all allocated memory with a bit pattern to detect usage of uninitialized or freed memory. Enable validation of a magic number after every allocation to detect out-of-bounds memory corruption.
- Support for interoperability with OpenGL.
- Virtual allocator: Interface for using core allocation algorithm to allocate any custom data, e.g. pieces of one large buffer.
-
-# Prerequisites
-
- Self-contained C++ library in single header file. No external dependencies other than standard C and C++ library and of course Vulkan. Some features of C++14 used. STL containers, RTTI, or C++ exceptions are not used.
- Public interface in C, in same convention as Vulkan API. Implementation in C++.
- Error handling implemented by returning `VkResult` error codes - same way as in Vulkan.
- Interface documented using Doxygen-style comments.
- Platform-independent, but developed and tested on Windows using Visual Studio. Continuous integration setup for Windows and Linux. Used also on Android, MacOS, and other platforms.
-
-# Example
-
-Basic usage of this library is very simple. Advanced features are optional. After you created global `VmaAllocator` object, a complete code needed to create a buffer may look like this:
-
-```cpp
-VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
-bufferInfo.size = 65536;
-bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-
-VmaAllocationCreateInfo allocInfo = {};
-allocInfo.usage = VMA_MEMORY_USAGE_AUTO;
-
-VkBuffer buffer;
-VmaAllocation allocation;
-vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
-```
-
-With this one function call:
-
-1. `VkBuffer` is created.
-2. `VkDeviceMemory` block is allocated if needed.
-3. An unused region of the memory block is bound to this buffer.
-
-`VmaAllocation` is an object that represents memory assigned to this buffer. It can be queried for parameters like `VkDeviceMemory` handle and offset.
-
-# How to build
-
-On Windows it is recommended to use [CMake GUI](https://cmake.org/runningcmake/).
-
-Alternatively you can generate/open a Visual Studio from the command line:
-
-```sh
-# By default CMake picks the newest version of Visual Studio it can use
-cmake -S .  -B build -D VMA_BUILD_SAMPLES=ON
-cmake --open build
-```
-
-On Linux:
-
-```sh
-cmake -S . -B build
-# Since VMA has no source files, you can skip to installation immediately
-cmake --install build --prefix build/install
-```
-
-## How to use
-
-After calling either `find_package` or `add_subdirectory` simply link the library.
-This automatically handles configuring the include directory. Example:
-
-```cmake
-find_package(VulkanMemoryAllocator CONFIG REQUIRED)
-target_link_libraries(YourGameEngine PRIVATE GPUOpen::VulkanMemoryAllocator)
-```
-
-For more info on using CMake visit the official [CMake documentation](https://cmake.org/cmake/help/latest/index.html).
-
-## Building using vcpkg
-
-You can download and install VulkanMemoryAllocator using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
-
-    git clone https://github.com/Microsoft/vcpkg.git
-    cd vcpkg
-    ./bootstrap-vcpkg.sh
-    ./vcpkg integrate install
-    ./vcpkg install vulkan-memory-allocator
-
-The VulkanMemoryAllocator port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
-
-# Binaries
-
-The release comes with precompiled binary executable for "VulkanSample" application which contains test suite. It is compiled using Visual Studio 2022, so it requires appropriate libraries to work, including "MSVCP140.dll", "VCRUNTIME140.dll", "VCRUNTIME140_1.dll". If the launch fails with error message telling about those files missing, please download and install [Microsoft Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads), "X64" version.
-
-# Read more
-
-See **[Documentation](https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/)**.
-
-# Software using this library
-
- **[Blender](https://www.blender.org)**
- **[Qt Project](https://github.com/qt)**
- **[Baldur's Gate III](https://www.mobygames.com/game/150689/baldurs-gate-iii/credits/windows/?autoplatform=true)**
- **[Cyberpunk 2077](https://www.mobygames.com/game/128136/cyberpunk-2077/credits/windows/?autoplatform=true)**
- **[X-Plane](https://x-plane.com/)**
- **[Detroit: Become Human](https://gpuopen.com/learn/porting-detroit-3/)**
- **[Vulkan Samples](https://github.com/LunarG/VulkanSamples)** - official Khronos Vulkan samples. License: Apache-style.
- **[GFXReconstruct](https://github.com/LunarG/gfxreconstruct)** - a tools for the capture and replay of graphics API calls. License: MIT.
- **[Anvil](https://github.com/GPUOpen-LibrariesAndSDKs/Anvil)** - cross-platform framework for Vulkan. License: MIT.
- **[Filament](https://github.com/google/filament)** - physically based rendering engine for Android, Windows, Linux and macOS, from Google. Apache License 2.0.
- **[Atypical Games - proprietary game engine](https://developer.samsung.com/galaxy-gamedev/gamedev-blog/infinitejet.html)**
- **[Flax Engine](https://flaxengine.com/)**
- **[Godot Engine](https://github.com/godotengine/godot/)** - multi-platform 2D and 3D game engine. License: MIT.
- **[Lightweight Java Game Library (LWJGL)](https://www.lwjgl.org/)** - includes binding of the library for Java. License: BSD.
- **[LightweightVK](https://github.com/corporateshark/lightweightvk)** - lightweight C++ bindless Vulkan 1.3 wrapper. License: MIT.
- **[PowerVR SDK](https://github.com/powervr-graphics/Native_SDK)** - C++ cross-platform 3D graphics SDK, from Imagination. License: MIT.
- **[Skia](https://github.com/google/skia)** - complete 2D graphic library for drawing Text, Geometries, and Images, from Google.
- **[The Forge](https://github.com/ConfettiFX/The-Forge)** - cross-platform rendering framework. Apache License 2.0.
- **[VK9](https://github.com/disks86/VK9)** - Direct3D 9 compatibility layer using Vulkan. Zlib license.
- **[vkDOOM3](https://github.com/DustinHLand/vkDOOM3)** - Vulkan port of GPL DOOM 3 BFG Edition. License: GNU GPL.
- **[vkQuake2](https://github.com/kondrak/vkQuake2)** - vanilla Quake 2 with Vulkan support. License: GNU GPL.
- **[Vulkan Best Practice for Mobile Developers](https://github.com/ARM-software/vulkan_best_practice_for_mobile_developers)** from ARM. License: MIT.
- **[RPCS3](https://github.com/RPCS3/rpcs3)** - PlayStation 3 emulator/debugger. License: GNU GPLv2.
- **[PPSSPP](https://github.com/hrydgard/ppsspp)** - Playstation Portable emulator/debugger. License: GNU GPLv2+.
- **[Wicked Engine](https://github.com/turanszkij/WickedEngine)** - 3D engine with modern graphics 
-
-[Many other projects on GitHub](https://github.com/search?q=AMD_VULKAN_MEMORY_ALLOCATOR_H&type=Code) and some game development studios that use Vulkan in their games.
-
-# See also
-
- **[D3D12 Memory Allocator](https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator)** - equivalent library for Direct3D 12. License: MIT.
- **[Awesome Vulkan](https://github.com/vinjn/awesome-vulkan)** - a curated list of awesome Vulkan libraries, debuggers and resources.
- **[vcpkg](https://github.com/Microsoft/vcpkg)** dependency manager from Microsoft also offers a port of this library.
- **[VulkanMemoryAllocator-Hpp](https://github.com/YaaZ/VulkanMemoryAllocator-Hpp)** - C++ binding for this library. License: CC0-1.0.
- **[PyVMA](https://github.com/realitix/pyvma)** - Python wrapper for this library. Author: Jean-Sébastien B. (@realitix). License: Apache 2.0.
- **[vk-mem](https://github.com/gwihlidal/vk-mem-rs)** - Rust binding for this library. Author: Graham Wihlidal. License: Apache 2.0 or MIT.
- **[Haskell bindings](https://hackage.haskell.org/package/VulkanMemoryAllocator)**, **[github](https://github.com/expipiplus1/vulkan/tree/master/VulkanMemoryAllocator)** - Haskell bindings for this library. Author: Ellie Hermaszewska (@expipiplus1). License BSD-3-Clause.
- **[vma_sample_sdl](https://github.com/rextimmy/vma_sample_sdl)** - SDL port of the sample app of this library (with the goal of running it on multiple platforms, including MacOS). Author: @rextimmy. License: MIT.
- **[vulkan-malloc](https://github.com/dylanede/vulkan-malloc)** - Vulkan memory allocation library for Rust. Based on version 1 of this library. Author: Dylan Ede (@dylanede). License: MIT / Apache 2.0.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ty Lamontagne	37555e3048	CDVD \| CHD: Account for pre/post gap offsets when filling TOC This will fix discs with tracks with both an INDEX 00 and INDEX 01	2024-11-27 15:55:11 -05:00
Ty Lamontagne	d8f18a3318	CDVD: Byte swap hack. CHD CD audio with OSDSYS is working	2024-11-27 15:54:56 -05:00
Ty Lamontagne	47a732d0fe	CDVD: CHD cue support for audio CDs experimental and will blow out your ears	2024-11-27 15:25:59 -05:00