"Merge Tagged PR 1012"

"Merge Tagged PR 1340"
"Merge Tagged PR 1703"
2019-10-05 23:47:35 +00:00 · 2019-10-05 23:47:34 +00:00 · 2019-10-05 23:47:33 +00:00 · 2019-10-05 23:47:32 +00:00 · 2019-10-05 23:47:32 +00:00 · 2019-10-05 23:47:31 +00:00
271 changed files with 115425 additions and 79842 deletions
@@ -1,12 +1,12 @@
 #!/bin/bash -ex

 # Copy documentation
-cp license.txt "$DIR_NAME"
-cp README.md "$DIR_NAME"
+cp license.txt "$REV_NAME"
+cp README.md "$REV_NAME"

-tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$DIR_NAME"
+tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$REV_NAME"

-mv "$DIR_NAME" $RELEASE_NAME
+mv "$REV_NAME" $RELEASE_NAME

 7z a "$REV_NAME.7z" $RELEASE_NAME

@@ -11,4 +11,5 @@ ninja

 ccache -s

-ctest -VV -C Release
+# Ignore zlib's tests, since they aren't gated behind a CMake option.
+ctest -VV -E "(example|example64)" -C Release
@@ -6,15 +6,9 @@ REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
 ARCHIVE_NAME="${REV_NAME}.tar.xz"
 COMPRESSION_FLAGS="-cJvf"

-if [ "${RELEASE_NAME}" = "mainline" ]; then
-    DIR_NAME="${REV_NAME}"
-else
-    DIR_NAME="${REV_NAME}_${RELEASE_NAME}"
-fi
+mkdir "$REV_NAME"

-mkdir "$DIR_NAME"
-
-cp build/bin/yuzu-cmd "$DIR_NAME"
-cp build/bin/yuzu "$DIR_NAME"
+cp build/bin/yuzu-cmd "$REV_NAME"
+cp build/bin/yuzu "$REV_NAME"

 . .ci/scripts/common/post-upload.sh
@@ -1,19 +1,10 @@
-param($BUILD_NAME)
-
 $GITDATE = $(git show -s --date=short --format='%ad') -replace "-",""
 $GITREV = $(git show -s --format='%h')
-
-if ("$BUILD_NAME" -eq "mainline") {
-    $RELEASE_DIST = "yuzu-windows-msvc"
-} else {
-    $RELEASE_DIST = "yuzu-windows-msvc-$BUILD_NAME"
-}
+$RELEASE_DIST = "yuzu-windows-msvc"

 $MSVC_BUILD_ZIP = "yuzu-windows-msvc-$GITDATE-$GITREV.zip" -replace " ", ""
 $MSVC_BUILD_PDB = "yuzu-windows-msvc-$GITDATE-$GITREV-debugsymbols.zip" -replace " ", ""
 $MSVC_SEVENZIP = "yuzu-windows-msvc-$GITDATE-$GITREV.7z" -replace " ", ""
-$MSVC_TAR = "yuzu-windows-msvc-$GITDATE-$GITREV.tar" -replace " ", ""
-$MSVC_TARXZ = "yuzu-windows-msvc-$GITDATE-$GITREV.tar.xz" -replace " ", ""

 $env:BUILD_ZIP = $MSVC_BUILD_ZIP
 $env:BUILD_SYMBOLS = $MSVC_BUILD_PDB
@@ -37,9 +28,5 @@ Copy-Item .\README.md -Destination $RELEASE_DIST
 7z a -tzip $MSVC_BUILD_ZIP $RELEASE_DIST\*
 7z a $MSVC_SEVENZIP $RELEASE_DIST

-7z a -r -ttar $MSVC_TAR $RELEASE_DIST
-7z a -r -txz $MSVC_TARXZ $MSVC_TAR
-
 Get-ChildItem . -Filter "*.zip" | Copy-Item -destination "artifacts"
-Get-ChildItem . -Filter "*.7z" | Copy-Item -destination "artifacts"
-Get-ChildItem . -Filter "*.tar.xz" | Copy-Item -destination "artifacts"
+Get-ChildItem . -Filter "*.7z" | Copy-Item -destination "artifacts"
@@ -6,14 +6,8 @@ REV_NAME="yuzu-windows-mingw-${GITDATE}-${GITREV}"
 ARCHIVE_NAME="${REV_NAME}.tar.gz"
 COMPRESSION_FLAGS="-czvf"

-if [ "${RELEASE_NAME}" = "mainline" ]; then
-    DIR_NAME="${REV_NAME}"
-else
-    DIR_NAME="${REV_NAME}_${RELEASE_NAME}"
-fi
-
-mkdir "$DIR_NAME"
+mkdir "$REV_NAME"
 # get around the permission issues
-cp -r package/* "$DIR_NAME"
+cp -r package/* "$REV_NAME"

 . .ci/scripts/common/post-upload.sh
@@ -1,5 +1,5 @@
 steps:
  - script: mkdir artifacts || echo 'X' > artifacts/T1.txt
  - publish: artifacts
-    artifact: 'yuzu-$(BuildName)-mock'
+    artifact: 'yuzu-$(BuildName)-$(BuildSuffix)'
    displayName: 'Upload Artifacts'
@@ -17,7 +17,6 @@ steps:
  inputs:
    targetType: 'filePath'
    filePath: './.ci/scripts/windows/upload.ps1'
-    arguments: '$(BuildName)'
 - publish: artifacts
  artifact: 'yuzu-$(BuildName)-windows-msvc'
  displayName: 'Upload Artifacts'
@@ -31,7 +31,17 @@ jobs:
      needSubmodules: 'true'
  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
    displayName: 'Apply Git Configuration'
+  - script: git tag -a $(BuildName)-$(Build.BuildId) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName)"
+    displayName: 'Tag Source'
  - script: git remote add other $(GitRepoPushChangesURL)
    displayName: 'Register Repository'
-  - script: git push --force other HEAD:$(GitPushBranch)
+  - script: git push --follow-tags --force other HEAD:$(GitPushBranch)
    displayName: 'Update Code'
+  - script: git rev-list -n 1 $(BuildName)-$(Build.BuildId) > $(Build.ArtifactStagingDirectory)/tag-commit.sha
+    displayName: 'Calculate Release Point'
+  - task: PublishPipelineArtifact@1
+    displayName: 'Upload Release Point'
+    inputs:
+      targetPath: '$(Build.ArtifactStagingDirectory)/tag-commit.sha'
+      artifact: 'yuzu-$(BuildName)-release-point'
+      replaceExistingArchive: true
@@ -30,7 +30,17 @@ jobs:
      needSubmodules: 'true'
  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
    displayName: 'Apply Git Configuration'
+  - script: git tag -a $(BuildName)-$(Build.BuildId) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName)"
+    displayName: 'Tag Source'
  - script: git remote add other $(GitRepoPushChangesURL)
    displayName: 'Register Repository'
-  - script: git push --force other HEAD:$(GitPushBranch)
+  - script: git push --follow-tags --force other HEAD:$(GitPushBranch)
    displayName: 'Update Code'
+  - script: git rev-list -n 1 $(BuildName)-$(Build.BuildId) > $(Build.ArtifactStagingDirectory)/tag-commit.sha
+    displayName: 'Calculate Release Point'
+  - task: PublishPipelineArtifact@1
+    displayName: 'Upload Release Point'
+    inputs:
+      targetPath: '$(Build.ArtifactStagingDirectory)/tag-commit.sha'
+      artifact: 'yuzu-$(BuildName)-release-point'
+      replaceExistingArchive: true
@@ -1,13 +1,11 @@
 steps:
  - template: ./release-download.yml
  - task: GitHubRelease@0
-    displayName: 'GitHub Release'
    inputs:
      action: 'create'
-      title: '$(ReleasePrefix) $(DisplayVersion)'
+      title: 'yuzu $(BuildName) #$(Build.BuildId)'
      assets: '$(Build.ArtifactStagingDirectory)/*'
      gitHubConnection: $(GitHubReleaseConnectionName)
      repositoryName: '$(Build.Repository.Name)'
      target: '$(Build.SourceVersion)'
-      tagSource: manual
-      tag: $(BuildName)-$(DisplayPrefix)-$(DisplayVersion)
+      tagSource: 'auto'
@@ -1,9 +0,0 @@
-steps:
-  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
-    displayName: 'Apply Git Configuration'
-  - script: git tag -a $(BuildName)-$(DisplayPrefix)-$(DisplayVersion) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName) $(DisplayPrefix)-$(DisplayVersion)"
-    displayName: 'Tag Source'
-  - script: git remote add other $(GitRepoPushChangesURL)
-    displayName: 'Register Repository'
-  - script: git push other $(BuildName)-$(DisplayPrefix)-$(DisplayVersion)
-    displayName: 'Update Code'
@@ -57,12 +57,12 @@ stages:
        cache: 'true'
        version: $(DisplayVersion)
 - stage: release
-  displayName: 'release'
+  displayName: 'Release'
  dependsOn:
  - build
  - build_win
  jobs:
  - job: github
-    displayName: 'github'
+    displayName: 'GitHub Release'
    steps:
    - template: ./templates/release-github.yml
@@ -32,11 +32,3 @@ stages:
        artifactSource: 'false'
        cache: $(parameters.cache)
        version: $(DisplayVersion)
- stage: release
-  displayName: 'release'
-  dependsOn: build
-  jobs:
-    - job: release
-      displayName: 'source'
-      steps:
-        - template: ./templates/release-private-tag.yml
@@ -26,11 +26,11 @@
    path = externals/mbedtls
    url = https://github.com/DarkLordZach/mbedtls
 [submodule "opus"]
-    path = externals/opus/opus
-    url = https://github.com/xiph/opus.git
+    path = externals/opus
+    url = https://github.com/ogniK5377/opus.git
 [submodule "soundtouch"]
-    path = externals/soundtouch
-    url = https://github.com/citra-emu/ext-soundtouch.git
+	path = externals/soundtouch
+	url = https://github.com/citra-emu/ext-soundtouch.git
 [submodule "libressl"]
    path = externals/libressl
    url = https://github.com/citra-emu/ext-libressl-portable.git
@@ -47,8 +47,8 @@
    path = externals/sirit
    url = https://github.com/ReinUsesLisp/sirit
 [submodule "libzip"]
-    path = externals/libzip/libzip
-    url = https://github.com/nih-at/libzip.git
+    path = externals/libzip
+    url = https://github.com/DarkLordZach/libzip
 [submodule "zlib"]
-    path = externals/zlib/zlib
-    url = https://github.com/madler/zlib.git
+    path = externals/zlib
+    url = https://github.com/madler/zlib
@@ -85,12 +85,10 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/decode/xmad.cpp"
    "${VIDEO_CORE}/shader/ast.cpp"
    "${VIDEO_CORE}/shader/ast.h"
-    "${VIDEO_CORE}/shader/compiler_settings.cpp"
-    "${VIDEO_CORE}/shader/compiler_settings.h"
-    "${VIDEO_CORE}/shader/const_buffer_locker.cpp"
-    "${VIDEO_CORE}/shader/const_buffer_locker.h"
    "${VIDEO_CORE}/shader/control_flow.cpp"
    "${VIDEO_CORE}/shader/control_flow.h"
+    "${VIDEO_CORE}/shader/compiler_settings.cpp"
+    "${VIDEO_CORE}/shader/compiler_settings.h"
    "${VIDEO_CORE}/shader/decode.cpp"
    "${VIDEO_CORE}/shader/expr.cpp"
    "${VIDEO_CORE}/shader/expr.h"
@@ -1 +1 @@
-**The Contributor's Guide has moved to [the Yuzu wiki](https://github.com/yuzu-emu/yuzu/wiki/Contributing).**
+**The Contributor's Guide has moved to [the Citra wiki](https://github.com/citra-emu/citra/wiki/Contributing).**
@@ -1 +1,86 @@
-<svg id="svg815" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 614.4 682.67"><defs><style>.cls-1{fill:none;}.cls-2{clip-path:url(#clip-path);}.cls-3{fill:#ff3c28;}.cls-4{fill:#0ab9e6;}</style><clipPath id="clip-path"><rect class="cls-1" x="-43" y="-46.67" width="699.6" height="777.33"/></clipPath></defs><title>Artboard 1</title><g id="g823"><g id="right"><g class="cls-2"><g id="g827"><g id="g833"><path id="path835" class="cls-3" d="M340.81,138V682.08c150.26,0,272.06-121.81,272.06-272.06S491.07,138,340.81,138M394,197.55a219.06,219.06,0,0,1,0,424.94V197.55"/></g></g></g></g><g id="left"><g class="cls-2"><g id="g839"><g id="g845"><path id="path847" class="cls-4" d="M272.79,1.92C122.53,1.92.73,123.73.73,274s121.8,272.07,272.06,272.07ZM219.65,61.51v425A219,219,0,0,1,118,119.18,217.51,217.51,0,0,1,219.65,61.51"/></g></g></g></g></g></svg>
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   version="1.1"
+   id="svg815"
+   xml:space="preserve"
+   width="72"
+   height="80"
+   viewBox="0 0 72 80"
+   sodipodi:docname="center-logo-v3.svg"
+   inkscape:version="0.92.2 (5c3e80d, 2017-08-06)"><metadata
+     id="metadata821"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
+     id="defs819"><clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath831"><path
+         d="M 0,60 H 54 V 0 H 0 Z"
+         id="path829"
+         inkscape:connector-curvature="0" /></clipPath><clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath843"><path
+         d="M 0,60 H 54 V 0 H 0 Z"
+         id="path841"
+         inkscape:connector-curvature="0" /></clipPath><clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath855"><path
+         d="M 0,60 H 54 V 0 H 0 Z"
+         id="path853"
+         inkscape:connector-curvature="0" /></clipPath><clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath867"><path
+         d="M 0,60 H 54 V 0 H 0 Z"
+         id="path865"
+         inkscape:connector-curvature="0" /></clipPath></defs><sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="1017"
+     id="namedview817"
+     showgrid="false"
+     inkscape:zoom="7.4953319"
+     inkscape:cx="28.177201"
+     inkscape:cy="44.348084"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="g823" /><g
+     id="g823"
+     inkscape:groupmode="layer"
+     inkscape:label="center-logo-v3"
+     transform="matrix(1.3333333,0,0,-1.3333333,0,80)"><g
+       id="right"
+       inkscape:label="#g825"><g
+         id="g827"
+         clip-path="url(#clipPath831)"><g
+           id="g833"
+           transform="translate(30,48)"><path
+             d="m 0,0 v -48 c 13.255,0 24,10.745 24,24 C 24,-10.745 13.255,0 0,0 M 3,-3.214 C 13.163,-4.674 21,-13.439 21,-24 21,-34.561 13.163,-43.326 3,-44.786 v 41.572"
+             style="fill:#ff3c28;fill-opacity:1;fill-rule:nonzero;stroke:none"
+             id="path835"
+             inkscape:connector-curvature="0" /></g></g></g><g
+       id="left"
+       inkscape:label="#g837"><g
+         id="g839"
+         clip-path="url(#clipPath843)"><g
+           id="g845"
+           transform="translate(24,60)"><path
+             d="m 0,0 c -13.255,0 -24,-10.745 -24,-24 0,-13.255 10.745,-24 24,-24 z m -3,-3.214 v -41.572 c -10.163,1.46 -18,10.225 -18,20.786 0,10.561 7.837,19.326 18,20.786"
+             style="fill:#0ab9e6;fill-opacity:1;fill-rule:nonzero;stroke:none"
+             id="path847"
+             inkscape:connector-curvature="0" /></g></g></g></g></svg>
@@ -42,6 +42,9 @@ target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)

+# Open Source Archives
+add_subdirectory(open_source_archives EXCLUDE_FROM_ALL)
+
 # Unicorn
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
@@ -76,7 +79,6 @@ endif()

 # zlib
 add_subdirectory(zlib EXCLUDE_FROM_ALL)
-set(ZLIB_LIBRARIES z)

 # libzip
 add_subdirectory(libzip EXCLUDE_FROM_ALL)
@@ -1,564 +0,0 @@
-# TODO:
-# create usable libtool .la file
-
-CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)
-
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/libzip")
-
-PROJECT(libzip C)
-
-OPTION(ENABLE_COMMONCRYPTO "Enable use of CommonCrypto" ON)
-OPTION(ENABLE_GNUTLS "Enable use of GnuTLS" ON)
-OPTION(ENABLE_MBEDTLS "Enable use of mbed TLS" ON)
-OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON)
-OPTION(ENABLE_WINDOWS_CRYPTO "Enable use of Windows cryptography libraries" ON)
-
-OPTION(ENABLE_BZIP2 "Enable use of BZip2" OFF)
-OPTION(ENABLE_LZMA "Enable use of LZMA" OFF)
-
-INCLUDE(CheckFunctionExists)
-INCLUDE(CheckIncludeFiles)
-INCLUDE(CheckSymbolExists)
-INCLUDE(CheckTypeSize)
-INCLUDE(CheckCSourceRuns)
-INCLUDE(CheckCSourceCompiles)
-INCLUDE(CheckStructHasMember)
-INCLUDE(TestBigEndian)
-INCLUDE(GNUInstallDirs)
-IF(ENABLE_COMMONCRYPTO)
-  CHECK_INCLUDE_FILES(CommonCrypto/CommonCrypto.h COMMONCRYPTO_FOUND)
-ELSE()
-  SET(COMMONCRYPTO_FOUND FALSE)
-ENDIF()
-IF(ENABLE_GNUTLS)
-  INCLUDE(FindNettle)
-  INCLUDE(FindGnuTLS)
-ELSE()
-  SET(GNUTLS_FOUND FALSE)
-ENDIF()
-IF(ENABLE_MBEDTLS)
-  FIND_PATH(MBEDTLS_INCLUDE_DIR mbedtls/aes.h)
-  FIND_LIBRARY(MBEDTLS_LIBRARIES NAMES mbedcrypto)
-ELSE()
-  SET(MBEDTLS_LIBRARIES FALSE)
-ENDIF()
-IF(ENABLE_OPENSSL)
-  INCLUDE(FindOpenSSL)
-ELSE()
-  SET(OPENSSL_FOUND FALSE)
-ENDIF()
-IF(WIN32)
-  IF(ENABLE_WINDOWS_CRYPTO)
-    SET(WINDOWS_CRYPTO_FOUND TRUE)
-  ENDIF()
-ELSE()
-  SET(WINDOWS_CRYPTO_FOUND FALSE)
-ENDIF()
-
-OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
-OPTION(SHARED_LIB_VERSIONNING "Add SO version in .so build" ON)
-
-SET(PACKAGE "libzip")
-SET(PACKAGE_NAME ${PACKAGE})
-SET(PACKAGE_VERSION_MAJOR "1")
-SET(PACKAGE_VERSION_MINOR "5")
-SET(PACKAGE_VERSION_MICRO "2a")
-#SET(VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}")
-SET(VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_MICRO}")
-SET(PACKAGE_VERSION ${VERSION})
-SET(LIBZIP_VERSION ${PACKAGE_VERSION})
-SET(LIBZIP_VERSION_MAJOR ${PACKAGE_VERSION_MAJOR})
-SET(LIBZIP_VERSION_MINOR ${PACKAGE_VERSION_MINOR})
-SET(LIBZIP_VERSION_MICRO ${PACKAGE_VERSION_MICRO})
-SET(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-
-SET(ARCHIVE_NAME ${PACKAGE_NAME}-${PACKAGE_VERSION})
-IF(NOT TARGET dist)
-ADD_CUSTOM_TARGET(dist
-  COMMAND git config tar.tar.xz.command "xz -c"
-  COMMAND git archive --prefix=${ARCHIVE_NAME}/ -o ${ARCHIVE_NAME}.tar.gz HEAD
-  COMMAND git archive --prefix=${ARCHIVE_NAME}/ -o ${ARCHIVE_NAME}.tar.xz HEAD
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  )
-ADD_CUSTOM_TARGET(distcheck
-  COMMAND chmod -R u+w ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest 2>/dev/null || true
-  COMMAND rm -rf ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
-  COMMAND cmake -E tar xf ${ARCHIVE_NAME}.tar.gz
-  COMMAND chmod -R u-w ${ARCHIVE_NAME}
-  COMMAND mkdir ${ARCHIVE_NAME}-build
-  COMMAND mkdir ${ARCHIVE_NAME}-dest
-  COMMAND cd ${ARCHIVE_NAME}-build && cmake -DCMAKE_INSTALL_PREFIX=../${ARCHIVE_NAME}-dest ../${ARCHIVE_NAME}
-  COMMAND cd ${ARCHIVE_NAME}-build && make -j4
-  COMMAND cd ${ARCHIVE_NAME}-build && make test
-  COMMAND cd ${ARCHIVE_NAME}-build && make install
-#  COMMAND cd ${ARCHIVE_NAME}-build && make uninstall
-#  COMMAND if [ `find ${ARCHIVE_NAME}-dest ! -type d | wc -l` -ne 0 ]; then echo leftover files in ${ARCHIVE_NAME}-dest; false; fi
-  COMMAND cd ${ARCHIVE_NAME}-build && make clean
-  COMMAND chmod -R u+w ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
-  COMMAND rm -rf ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
-  COMMAND echo "${ARCHIVE_NAME}.tar.gz is ready for distribution."
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  )
-ADD_DEPENDENCIES(distcheck dist)
-ENDIF(NOT TARGET dist)
-
-IF(BUILD_SHARED_LIBS)
-  SET(HAVE_SHARED TRUE)
-ELSE()
-  SET(ZIP_STATIC TRUE)
-ENDIF()
-
-# Checks
-
-CHECK_FUNCTION_EXISTS(_chmod HAVE__CHMOD)
-CHECK_FUNCTION_EXISTS(_close HAVE__CLOSE)
-CHECK_FUNCTION_EXISTS(_dup HAVE__DUP)
-CHECK_FUNCTION_EXISTS(_fdopen HAVE__FDOPEN)
-CHECK_FUNCTION_EXISTS(_fileno HAVE__FILENO)
-CHECK_FUNCTION_EXISTS(_open HAVE__OPEN)
-CHECK_FUNCTION_EXISTS(_setmode HAVE__SETMODE)
-CHECK_FUNCTION_EXISTS(_snprintf HAVE__SNPRINTF)
-CHECK_FUNCTION_EXISTS(_strdup HAVE__STRDUP)
-CHECK_FUNCTION_EXISTS(_stricmp HAVE__STRICMP)
-CHECK_FUNCTION_EXISTS(_strtoi64 HAVE__STRTOI64)
-CHECK_FUNCTION_EXISTS(_strtoui64 HAVE__STRTOUI64)
-CHECK_FUNCTION_EXISTS(_unlink HAVE__UNLINK)
-CHECK_FUNCTION_EXISTS(arc4random HAVE_ARC4RANDOM)
-CHECK_FUNCTION_EXISTS(clonefile HAVE_CLONEFILE)
-CHECK_FUNCTION_EXISTS(explicit_bzero HAVE_EXPLICIT_BZERO)
-CHECK_FUNCTION_EXISTS(explicit_memset HAVE_EXPLICIT_MEMSET)
-CHECK_FUNCTION_EXISTS(fileno HAVE_FILENO)
-CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO)
-CHECK_FUNCTION_EXISTS(ftello HAVE_FTELLO)
-CHECK_FUNCTION_EXISTS(getprogname HAVE_GETPROGNAME)
-CHECK_FUNCTION_EXISTS(localtime_r HAVE_LOCALTIME_R)
-CHECK_FUNCTION_EXISTS(open HAVE_OPEN)
-CHECK_FUNCTION_EXISTS(setmode HAVE_SETMODE)
-CHECK_FUNCTION_EXISTS(snprintf HAVE_SNPRINTF)
-CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
-CHECK_FUNCTION_EXISTS(strdup HAVE_STRDUP)
-CHECK_FUNCTION_EXISTS(stricmp HAVE_STRICMP)
-CHECK_FUNCTION_EXISTS(strtoll HAVE_STRTOLL)
-CHECK_FUNCTION_EXISTS(strtoull HAVE_STRTOULL)
-
-CHECK_INCLUDE_FILES("sys/types.h;sys/stat.h;fts.h" HAVE_FTS_H)
-CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H)
-CHECK_INCLUDE_FILES(strings.h HAVE_STRINGS_H)
-CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H)
-
-CHECK_INCLUDE_FILES(inttypes.h HAVE_INTTYPES_H_LIBZIP)
-CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H_LIBZIP)
-CHECK_INCLUDE_FILES(sys/types.h HAVE_SYS_TYPES_H_LIBZIP)
-
-# TODO: fix test
-# this test does not find __progname even when it exists
-#CHECK_SYMBOL_EXISTS(__progname stdlib.h HAVE___PROGNAME)
-
-CHECK_TYPE_SIZE(__int8 __INT8_LIBZIP)
-CHECK_TYPE_SIZE(int8_t INT8_T_LIBZIP)
-CHECK_TYPE_SIZE(uint8_t UINT8_T_LIBZIP)
-CHECK_TYPE_SIZE(__int16 __INT16_LIBZIP)
-CHECK_TYPE_SIZE(int16_t INT16_T_LIBZIP)
-CHECK_TYPE_SIZE(uint16_t UINT16_T_LIBZIP)
-CHECK_TYPE_SIZE(__int32 __INT32_LIBZIP)
-CHECK_TYPE_SIZE(int32_t INT32_T_LIBZIP)
-CHECK_TYPE_SIZE(uint32_t UINT32_T_LIBZIP)
-CHECK_TYPE_SIZE(__int64 __INT64_LIBZIP)
-CHECK_TYPE_SIZE(int64_t INT64_T_LIBZIP)
-CHECK_TYPE_SIZE(uint64_t UINT64_T_LIBZIP)
-CHECK_TYPE_SIZE("short" SHORT_LIBZIP)
-CHECK_TYPE_SIZE("int" INT_LIBZIP)
-CHECK_TYPE_SIZE("long" LONG_LIBZIP)
-CHECK_TYPE_SIZE("long long" LONG_LONG_LIBZIP)
-CHECK_TYPE_SIZE("off_t" SIZEOF_OFF_T)
-CHECK_TYPE_SIZE("size_t" SIZE_T_LIBZIP)
-CHECK_TYPE_SIZE("ssize_t" SSIZE_T_LIBZIP)
-
-CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h>
-#include <linux/fs.h>
-int main(int argc, char *argv[]) { unsigned long x = FICLONERANGE; }" HAVE_FICLONERANGE)
-
-CHECK_C_SOURCE_COMPILES("
-int foo(char * _Nullable bar);
-int main(int argc, char *argv[]) { }" HAVE_NULLABLE)
-
-TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
-
-#FIND_PACKAGE(ZLIB 1.1.2 REQUIRED)
-INCLUDE_DIRECTORIES(../zlib/zlib)
-SET(CMAKE_REQUIRED_INCLUDES ../zlib/zlib)
-
-IF(ENABLE_BZIP2)
-  FIND_PACKAGE(BZip2)
-  IF(BZIP2_FOUND)
-    SET (HAVE_LIBBZ2 1)
-
-    INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR})
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${BZIP2_LIBRARIES})
-  ELSE()
-    MESSAGE(WARNING "-- bzip2 library not found; bzip2 support disabled")
-  ENDIF(BZIP2_FOUND)
-ENDIF(ENABLE_BZIP2)
-
-IF(ENABLE_LZMA)
-  FIND_PACKAGE(LibLZMA)
-  IF(LIBLZMA_FOUND)
-    SET (HAVE_LIBLZMA 1)
-
-    INCLUDE_DIRECTORIES(${LIBLZMA_INCLUDE_DIR})
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${LIBLZMA_LIBRARY})
-  ELSE()
-    MESSAGE(WARNING "-- lzma library not found; lzma support disabled")
-  ENDIF(LIBLZMA_FOUND)
-ENDIF(ENABLE_LZMA)
-
-
-IF (COMMONCRYPTO_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_COMMONCRYPTO 1)
-ELSEIF (WINDOWS_CRYPTO_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_WINDOWS_CRYPTO 1)
-ELSEIF (GNUTLS_FOUND AND NETTLE_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_GNUTLS 1)
-  INCLUDE_DIRECTORIES(${GNUTLS_INCLUDE_DIR} ${NETTLE_INCLUDE_DIR})
-  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${GNUTLS_LIBRARY} ${NETTLE_LIBRARY})
-ELSEIF (OPENSSL_FOUND)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_OPENSSL 1)
-  INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
-  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${OPENSSL_LIBRARIES})
-ELSEIF (MBEDTLS_LIBRARIES)
-  SET (HAVE_CRYPTO 1)
-  SET (HAVE_MBEDTLS 1)
-  INCLUDE_DIRECTORIES(${MBEDTLS_INCLUDE_DIR})
-  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${MBEDTLS_LIBRARIES})
-ENDIF()
-
-IF (NOT HAVE_CRYPTO)
-  MESSAGE(WARNING "-- neither Common Crypto, GnuTLS, mbed TLS, OpenSSL, nor Windows Cryptography found; AES support disabled")
-ENDIF()
-
-IF(MSVC)
-ADD_DEFINITIONS("-D_CRT_SECURE_NO_WARNINGS")
-ADD_DEFINITIONS("-D_CRT_NONSTDC_NO_DEPRECATE")
-ENDIF(MSVC)
-
-if(WIN32)
-  if(HAVE_WINDOWS_CRYPTO)
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} bcrypt)
-  endif()
-  if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-    ADD_DEFINITIONS(-DMS_UWP)
-  else(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} advapi32)
-  endif(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-endif(WIN32)
-
-ADD_DEFINITIONS("-DHAVE_CONFIG_H")
-
-# rpath handling: use rpath in installed binaries
-IF(NOT CMAKE_SYSTEM_NAME MATCHES Linux)
-	SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
-	SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-ENDIF()
-
-# fixed size integral types
-
-IF(HAVE_INTTYPES_H_LIBZIP)
-  SET(LIBZIP_TYPES_INCLUDE "#define __STDC_FORMAT_MACROS 1
-#include <inttypes.h>")
-ELSEIF(HAVE_STDINT_H_LIBZIP)
-  SET(LIBZIP_TYPES_INCLUDE "#include <stdint.h>")
-ELSEIF(HAVE_SYS_TYPES_H_LIBZIP)
-  SET(LIBZIP_TYPES_INCLUDE "#include <sys/types.h>")
-ENDIF()
-
-IF(HAVE_INT8_T_LIBZIP)
-  SET(ZIP_INT8_T int8_t)
-ELSEIF(HAVE___INT8_LIBZIP)
-  SET(ZIP_INT8_T __int8)
-ELSE()
-  SET(ZIP_INT8_T "signed char")
-ENDIF()
-
-IF(HAVE_UINT8_T_LIBZIP)
-  SET(ZIP_UINT8_T uint8_t)
-ELSEIF(HAVE___INT8_LIBZIP)
-  SET(ZIP_UINT8_T "unsigned __int8")
-ELSE()
-  SET(ZIP_UINT8_T "unsigned char")
-ENDIF()
-
-IF(HAVE_INT16_T_LIBZIP)
-  SET(ZIP_INT16_T int16_t)
-ELSEIF(HAVE___INT16_LIBZIP)
-  SET(INT16_T_LIBZIP __int16)
-ELSEIF(SHORT_LIBZIP EQUAL 2)
-  SET(INT16_T_LIBZIP short)
-ENDIF()
-
-IF(HAVE_UINT16_T_LIBZIP)
-  SET(ZIP_UINT16_T uint16_t)
-ELSEIF(HAVE___INT16_LIBZIP)
-  SET(UINT16_T_LIBZIP "unsigned __int16")
-ELSEIF(SHORT_LIBZIP EQUAL 2)
-  SET(UINT16_T_LIBZIP "unsigned short")
-ENDIF()
-
-IF(HAVE_INT32_T_LIBZIP)
-  SET(ZIP_INT32_T int32_t)
-ELSEIF(HAVE___INT32_LIBZIP)
-  SET(ZIP_INT32_T __int32)
-ELSEIF(INT_LIBZIP EQUAL 4)
-  SET(ZIP_INT32_T int)
-ELSEIF(LONG_LIBZIP EQUAL 4)
-  SET(ZIP_INT32_T long)
-ENDIF()
-
-IF(HAVE_UINT32_T_LIBZIP)
-SET(ZIP_UINT32_T uint32_t)
-ELSEIF(HAVE___INT32_LIBZIP)
-SET(ZIP_UINT32_T "unsigned __int32")
-ELSEIF(INT_LIBZIP EQUAL 4)
-SET(ZIP_UINT32_T "unsigned int")
-ELSEIF(LONG_LIBZIP EQUAL 4)
-SET(ZIP_UINT32_T "unsigned long")
-ENDIF()
-
-IF(HAVE_INT64_T_LIBZIP)
-  SET(ZIP_INT64_T int64_t)
-ELSEIF(HAVE___INT64_LIBZIP)
-  SET(ZIP_INT64_T __int64)
-ELSEIF(LONG_LIBZIP EQUAL 8)
-  SET(ZIP_INT64_T long)
-ELSEIF(LONG_LONG_LIBZIP EQUAL 8)
-  SET(ZIP_INT64_T "long long")
-ENDIF()
-
-IF(HAVE_UINT64_T_LIBZIP)
-  SET(ZIP_UINT64_T uint64_t)
-ELSEIF(HAVE___INT64_LIBZIP)
-  SET(ZIP_UINT64_T "unsigned __int64")
-ELSEIF(LONG_LIBZIP EQUAL 8)
-  SET(ZIP_UINT64_T "unsigned long")
-ELSEIF(LONG_LONG_LIBZIP EQUAL 8)
-  SET(ZIP_UINT64_T "unsigned long long")
-ENDIF()
-
-IF(HAVE_NULLABLE)
-  SET(ZIP_NULLABLE_DEFINES)
-ELSE()
-  SET(ZIP_NULLABLE_DEFINES "#define _Nullable
-#define _Nonnull")
-ENDIF()
-
-# write out config file
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libzip/cmake-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/libzip/config.h)
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libzip/cmake-zipconf.h.in ${CMAKE_CURRENT_BINARY_DIR}/libzip/zipconf.h)
-
-# installation
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libzip/zipconf.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-INSTALL(FILES libzip/lib/zip.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-SET(CMAKE_C_VISIBILITY_PRESET hidden)
-
-ADD_LIBRARY(zip
-  libzip/lib/zip_add.c
-  libzip/lib/zip_add_dir.c
-  libzip/lib/zip_add_entry.c
-  libzip/lib/zip_algorithm_deflate.c
-  libzip/lib/zip_buffer.c
-  libzip/lib/zip_close.c
-  libzip/lib/zip_delete.c
-  libzip/lib/zip_dir_add.c
-  libzip/lib/zip_dirent.c
-  libzip/lib/zip_discard.c
-  libzip/lib/zip_entry.c
-  libzip/lib/zip_err_str.c
-  libzip/lib/zip_error.c
-  libzip/lib/zip_error_clear.c
-  libzip/lib/zip_error_get.c
-  libzip/lib/zip_error_get_sys_type.c
-  libzip/lib/zip_error_strerror.c
-  libzip/lib/zip_error_to_str.c
-  libzip/lib/zip_extra_field.c
-  libzip/lib/zip_extra_field_api.c
-  libzip/lib/zip_fclose.c
-  libzip/lib/zip_fdopen.c
-  libzip/lib/zip_file_add.c
-  libzip/lib/zip_file_error_clear.c
-  libzip/lib/zip_file_error_get.c
-  libzip/lib/zip_file_get_comment.c
-  libzip/lib/zip_file_get_external_attributes.c
-  libzip/lib/zip_file_get_offset.c
-  libzip/lib/zip_file_rename.c
-  libzip/lib/zip_file_replace.c
-  libzip/lib/zip_file_set_comment.c
-  libzip/lib/zip_file_set_encryption.c
-  libzip/lib/zip_file_set_external_attributes.c
-  libzip/lib/zip_file_set_mtime.c
-  libzip/lib/zip_file_strerror.c
-  libzip/lib/zip_filerange_crc.c
-  libzip/lib/zip_fopen.c
-  libzip/lib/zip_fopen_encrypted.c
-  libzip/lib/zip_fopen_index.c
-  libzip/lib/zip_fopen_index_encrypted.c
-  libzip/lib/zip_fread.c
-  libzip/lib/zip_fseek.c
-  libzip/lib/zip_ftell.c
-  libzip/lib/zip_get_archive_comment.c
-  libzip/lib/zip_get_archive_flag.c
-  libzip/lib/zip_get_encryption_implementation.c
-  libzip/lib/zip_get_file_comment.c
-  libzip/lib/zip_get_name.c
-  libzip/lib/zip_get_num_entries.c
-  libzip/lib/zip_get_num_files.c
-  libzip/lib/zip_hash.c
-  libzip/lib/zip_io_util.c
-  libzip/lib/zip_libzip_version.c
-  libzip/lib/zip_memdup.c
-  libzip/lib/zip_name_locate.c
-  libzip/lib/zip_new.c
-  libzip/lib/zip_open.c
-  libzip/lib/zip_progress.c
-  libzip/lib/zip_rename.c
-  libzip/lib/zip_replace.c
-  libzip/lib/zip_set_archive_comment.c
-  libzip/lib/zip_set_archive_flag.c
-  libzip/lib/zip_set_default_password.c
-  libzip/lib/zip_set_file_comment.c
-  libzip/lib/zip_set_file_compression.c
-  libzip/lib/zip_set_name.c
-  libzip/lib/zip_source_accept_empty.c
-  libzip/lib/zip_source_begin_write.c
-  libzip/lib/zip_source_begin_write_cloning.c
-  libzip/lib/zip_source_buffer.c
-  libzip/lib/zip_source_call.c
-  libzip/lib/zip_source_close.c
-  libzip/lib/zip_source_commit_write.c
-  libzip/lib/zip_source_compress.c
-  libzip/lib/zip_source_crc.c
-  libzip/lib/zip_source_error.c
-  libzip/lib/zip_source_filep.c
-  libzip/lib/zip_source_free.c
-  libzip/lib/zip_source_function.c
-  libzip/lib/zip_source_get_compression_flags.c
-  libzip/lib/zip_source_is_deleted.c
-  libzip/lib/zip_source_layered.c
-  libzip/lib/zip_source_open.c
-  libzip/lib/zip_source_pkware.c
-  libzip/lib/zip_source_read.c
-  libzip/lib/zip_source_remove.c
-  libzip/lib/zip_source_rollback_write.c
-  libzip/lib/zip_source_seek.c
-  libzip/lib/zip_source_seek_write.c
-  libzip/lib/zip_source_stat.c
-  libzip/lib/zip_source_supports.c
-  libzip/lib/zip_source_tell.c
-  libzip/lib/zip_source_tell_write.c
-  libzip/lib/zip_source_window.c
-  libzip/lib/zip_source_write.c
-  libzip/lib/zip_source_zip.c
-  libzip/lib/zip_source_zip_new.c
-  libzip/lib/zip_stat.c
-  libzip/lib/zip_stat_index.c
-  libzip/lib/zip_stat_init.c
-  libzip/lib/zip_strerror.c
-  libzip/lib/zip_string.c
-  libzip/lib/zip_unchange.c
-  libzip/lib/zip_unchange_all.c
-  libzip/lib/zip_unchange_archive.c
-  libzip/lib/zip_unchange_data.c
-  libzip/lib/zip_utf-8.c
-)
-
-IF(WIN32)
-  target_sources(zip PRIVATE
-    libzip/lib/zip_source_win32handle.c
-    libzip/lib/zip_source_win32utf8.c
-    libzip/lib/zip_source_win32w.c
-  )
-  IF(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
-  ELSE()
-    target_sources(zip PRIVATE libzip/lib/zip_source_win32a.c)
-  ENDIF()
-ELSE()
-  target_sources(zip PRIVATE
-    libzip/lib/zip_mkstempm.c
-    libzip/lib/zip_source_file.c
-    libzip/lib/zip_random_unix.c
-  )
-ENDIF()
-
-IF(HAVE_LIBBZ2)
-  target_sources(zip PRIVATE libzip/lib/zip_algorithm_bzip2.c)
-ENDIF()
-
-IF(HAVE_LIBLZMA)
-  target_sources(zip PRIVATE libzip/lib/zip_algorithm_xz.c)
-ENDIF()
-
-IF(HAVE_COMMONCRYPTO)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_commoncrypto.c)
-ELSEIF(HAVE_WINDOWS_CRYPTO)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_win.c)
-ELSEIF(HAVE_GNUTLS)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_gnutls.c)
-ELSEIF(HAVE_OPENSSL)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_openssl.c)
-ELSEIF(HAVE_MBEDTLS)
-  target_sources(zip PRIVATE libzip/lib/zip_crypto_mbedtls.c)
-ENDIF()
-
-IF(HAVE_CRYPTO)
-  target_sources(zip PRIVATE
-    libzip/lib/zip_winzip_aes.c
-    libzip/lib/zip_source_winzip_aes_decode.c
-    libzip/lib/zip_source_winzip_aes_encode.c
-  )
-ENDIF()
-
-target_include_directories(zip
-PUBLIC
-  libzip/lib
-  ${CMAKE_CURRENT_BINARY_DIR}/libzip
-)
-
-# pkgconfig file
-SET(prefix ${CMAKE_INSTALL_PREFIX})
-SET(exec_prefix \${prefix})
-SET(bindir \${exec_prefix}/${CMAKE_INSTALL_BINDIR})
-SET(libdir \${exec_prefix}/${CMAKE_INSTALL_LIBDIR})
-SET(includedir \${prefix}/${CMAKE_INSTALL_INCLUDEDIR})
-IF(CMAKE_SYSTEM_NAME MATCHES BSD)
-  SET(PKG_CONFIG_RPATH "-Wl,-R\${libdir}")
-ENDIF(CMAKE_SYSTEM_NAME MATCHES BSD)
-get_target_property(LIBS_PRIVATE zip LINK_LIBRARIES)
-foreach(LIB ${LIBS_PRIVATE})
-  if(LIB MATCHES "^/")
-    get_filename_component(LIB ${LIB} NAME_WE)
-    string(REGEX REPLACE "^lib" "" LIB ${LIB})
-  endif()
-  set(LIBS "${LIBS} -l${LIB}")
-endforeach()
-CONFIGURE_FILE(libzip/libzip.pc.in libzip/libzip.pc @ONLY)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libzip.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-
-ADD_CUSTOM_TARGET(update_zip_err_str
-  COMMAND sh ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/make_zip_err_str.sh ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip.h ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip_err_str.c
-  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip.h ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/make_zip_err_str.sh
-)
-
-IF(SHARED_LIB_VERSIONNING)
-SET_TARGET_PROPERTIES(zip PROPERTIES VERSION 5.0 SOVERSION 5)
-ENDIF()
-
-TARGET_LINK_LIBRARIES(zip ${ZLIB_LIBRARIES} ${OPTIONAL_LIBRARY})
-INSTALL(TARGETS zip
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
-
@@ -0,0 +1,16 @@
+add_library(open_source_archives
+    src/FontChineseSimplified.cpp
+    src/FontChineseTraditional.cpp
+    src/FontExtendedChineseSimplified.cpp
+    src/FontKorean.cpp
+    src/FontNintendoExtended.cpp
+    src/FontStandard.cpp
+    include/FontChineseSimplified.h
+    include/FontChineseTraditional.h
+    include/FontExtendedChineseSimplified.h
+    include/FontKorean.h
+    include/FontNintendoExtended.h
+    include/FontStandard.h
+)
+
+target_include_directories(open_source_archives PUBLIC include)
@@ -0,0 +1,4 @@
+These files were generated by https://github.com/FearlessTobi/yuzu_system_archives at git commit 0a24b0c9f38d71fb2c4bba5645a39029e539a5ec. To generate the files use the run.sh inside that repository.  
+
+The follwing system archives are currently included:
+ - JPN/EUR/USA System Font
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <array>
+
+extern const std::array<unsigned char, 217276> FontChineseSimplified;
+
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <array>
+
+extern const std::array<unsigned char, 222236> FontChineseTraditional;
+
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <array>
+
+extern const std::array<unsigned char, 293516> FontExtendedChineseSimplified;
+
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <array>
+
+extern const std::array<unsigned char, 217276> FontKorean;
+
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <array>
+
+extern const std::array<unsigned char, 172064> FontNintendoExtended;
+
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <array>
+
+extern const std::array<unsigned char, 217276> FontStandard;
+
@@ -1,250 +0,0 @@
-cmake_minimum_required(VERSION 3.8)
-
-project(opus)
-
-option(OPUS_STACK_PROTECTOR "Use stack protection" OFF)
-option(OPUS_USE_ALLOCA "Use alloca for stack arrays (on non-C99 compilers)" OFF)
-option(OPUS_CUSTOM_MODES "Enable non-Opus modes, e.g. 44.1 kHz & 2^n frames" OFF)
-option(OPUS_FIXED_POINT "Compile as fixed-point (for machines without a fast enough FPU)" OFF)
-option(OPUS_ENABLE_FLOAT_API "Compile with the floating point API (for machines with float library" ON)
-
-include(opus/opus_functions.cmake)
-
-if(OPUS_STACK_PROTECTOR)
-    if(NOT MSVC) # GC on by default on MSVC
-        check_and_set_flag(STACK_PROTECTION_STRONG -fstack-protector-strong)
-    endif()
-else()
-    if(MSVC)
-        check_and_set_flag(BUFFER_SECURITY_CHECK /GS-)
-    endif()
-endif()
-
-add_library(opus STATIC
-    # CELT sources
-    opus/celt/bands.c
-    opus/celt/celt.c
-    opus/celt/celt_decoder.c
-    opus/celt/celt_encoder.c
-    opus/celt/celt_lpc.c
-    opus/celt/cwrs.c
-    opus/celt/entcode.c
-    opus/celt/entdec.c
-    opus/celt/entenc.c
-    opus/celt/kiss_fft.c
-    opus/celt/laplace.c
-    opus/celt/mathops.c
-    opus/celt/mdct.c
-    opus/celt/modes.c
-    opus/celt/pitch.c
-    opus/celt/quant_bands.c
-    opus/celt/rate.c
-    opus/celt/vq.c
-
-    # SILK sources
-    opus/silk/A2NLSF.c
-    opus/silk/CNG.c
-    opus/silk/HP_variable_cutoff.c
-    opus/silk/LPC_analysis_filter.c
-    opus/silk/LPC_fit.c
-    opus/silk/LPC_inv_pred_gain.c
-    opus/silk/LP_variable_cutoff.c
-    opus/silk/NLSF2A.c
-    opus/silk/NLSF_VQ.c
-    opus/silk/NLSF_VQ_weights_laroia.c
-    opus/silk/NLSF_decode.c
-    opus/silk/NLSF_del_dec_quant.c
-    opus/silk/NLSF_encode.c
-    opus/silk/NLSF_stabilize.c
-    opus/silk/NLSF_unpack.c
-    opus/silk/NSQ.c
-    opus/silk/NSQ_del_dec.c
-    opus/silk/PLC.c
-    opus/silk/VAD.c
-    opus/silk/VQ_WMat_EC.c
-    opus/silk/ana_filt_bank_1.c
-    opus/silk/biquad_alt.c
-    opus/silk/bwexpander.c
-    opus/silk/bwexpander_32.c
-    opus/silk/check_control_input.c
-    opus/silk/code_signs.c
-    opus/silk/control_SNR.c
-    opus/silk/control_audio_bandwidth.c
-    opus/silk/control_codec.c
-    opus/silk/dec_API.c
-    opus/silk/decode_core.c
-    opus/silk/decode_frame.c
-    opus/silk/decode_indices.c
-    opus/silk/decode_parameters.c
-    opus/silk/decode_pitch.c
-    opus/silk/decode_pulses.c
-    opus/silk/decoder_set_fs.c
-    opus/silk/enc_API.c
-    opus/silk/encode_indices.c
-    opus/silk/encode_pulses.c
-    opus/silk/gain_quant.c
-    opus/silk/init_decoder.c
-    opus/silk/init_encoder.c
-    opus/silk/inner_prod_aligned.c
-    opus/silk/interpolate.c
-    opus/silk/lin2log.c
-    opus/silk/log2lin.c
-    opus/silk/pitch_est_tables.c
-    opus/silk/process_NLSFs.c
-    opus/silk/quant_LTP_gains.c
-    opus/silk/resampler.c
-    opus/silk/resampler_down2.c
-    opus/silk/resampler_down2_3.c
-    opus/silk/resampler_private_AR2.c
-    opus/silk/resampler_private_IIR_FIR.c
-    opus/silk/resampler_private_down_FIR.c
-    opus/silk/resampler_private_up2_HQ.c
-    opus/silk/resampler_rom.c
-    opus/silk/shell_coder.c
-    opus/silk/sigm_Q15.c
-    opus/silk/sort.c
-    opus/silk/stereo_LR_to_MS.c
-    opus/silk/stereo_MS_to_LR.c
-    opus/silk/stereo_decode_pred.c
-    opus/silk/stereo_encode_pred.c
-    opus/silk/stereo_find_predictor.c
-    opus/silk/stereo_quant_pred.c
-    opus/silk/sum_sqr_shift.c
-    opus/silk/table_LSF_cos.c
-    opus/silk/tables_LTP.c
-    opus/silk/tables_NLSF_CB_NB_MB.c
-    opus/silk/tables_NLSF_CB_WB.c
-    opus/silk/tables_gain.c
-    opus/silk/tables_other.c
-    opus/silk/tables_pitch_lag.c
-    opus/silk/tables_pulses_per_block.c
-
-    # Opus sources
-    opus/src/analysis.c
-    opus/src/mapping_matrix.c
-    opus/src/mlp.c
-    opus/src/mlp_data.c
-    opus/src/opus.c
-    opus/src/opus_decoder.c
-    opus/src/opus_encoder.c
-    opus/src/opus_multistream.c
-    opus/src/opus_multistream_decoder.c
-    opus/src/opus_multistream_encoder.c
-    opus/src/opus_projection_decoder.c
-    opus/src/opus_projection_encoder.c
-    opus/src/repacketizer.c
-)
-
-if (DEBUG)
-    target_sources(opus PRIVATE opus/silk/debug.c)
-endif()
-
-if (OPUS_FIXED_POINT)
-    target_sources(opus PRIVATE
-        opus/silk/fixed/LTP_analysis_filter_FIX.c
-        opus/silk/fixed/LTP_scale_ctrl_FIX.c
-        opus/silk/fixed/apply_sine_window_FIX.c
-        opus/silk/fixed/autocorr_FIX.c
-        opus/silk/fixed/burg_modified_FIX.c
-        opus/silk/fixed/corrMatrix_FIX.c
-        opus/silk/fixed/encode_frame_FIX.c
-        opus/silk/fixed/find_LPC_FIX.c
-        opus/silk/fixed/find_LTP_FIX.c
-        opus/silk/fixed/find_pitch_lags_FIX.c
-        opus/silk/fixed/find_pred_coefs_FIX.c
-        opus/silk/fixed/k2a_FIX.c
-        opus/silk/fixed/k2a_Q16_FIX.c
-        opus/silk/fixed/noise_shape_analysis_FIX.c
-        opus/silk/fixed/pitch_analysis_core_FIX.c
-        opus/silk/fixed/prefilter_FIX.c
-        opus/silk/fixed/process_gains_FIX.c
-        opus/silk/fixed/regularize_correlations_FIX.c
-        opus/silk/fixed/residual_energy16_FIX.c
-        opus/silk/fixed/residual_energy_FIX.c
-        opus/silk/fixed/schur64_FIX.c
-        opus/silk/fixed/schur_FIX.c
-        opus/silk/fixed/solve_LS_FIX.c
-        opus/silk/fixed/vector_ops_FIX.c
-        opus/silk/fixed/warped_autocorrelation_FIX.c
-    )
-else()
-    target_sources(opus PRIVATE
-        opus/silk/float/LPC_analysis_filter_FLP.c
-        opus/silk/float/LPC_inv_pred_gain_FLP.c
-        opus/silk/float/LTP_analysis_filter_FLP.c
-        opus/silk/float/LTP_scale_ctrl_FLP.c
-        opus/silk/float/apply_sine_window_FLP.c
-        opus/silk/float/autocorrelation_FLP.c
-        opus/silk/float/burg_modified_FLP.c
-        opus/silk/float/bwexpander_FLP.c
-        opus/silk/float/corrMatrix_FLP.c
-        opus/silk/float/encode_frame_FLP.c
-        opus/silk/float/energy_FLP.c
-        opus/silk/float/find_LPC_FLP.c
-        opus/silk/float/find_LTP_FLP.c
-        opus/silk/float/find_pitch_lags_FLP.c
-        opus/silk/float/find_pred_coefs_FLP.c
-        opus/silk/float/inner_product_FLP.c
-        opus/silk/float/k2a_FLP.c
-        opus/silk/float/noise_shape_analysis_FLP.c
-        opus/silk/float/pitch_analysis_core_FLP.c
-        opus/silk/float/process_gains_FLP.c
-        opus/silk/float/regularize_correlations_FLP.c
-        opus/silk/float/residual_energy_FLP.c
-        opus/silk/float/scale_copy_vector_FLP.c
-        opus/silk/float/scale_vector_FLP.c
-        opus/silk/float/schur_FLP.c
-        opus/silk/float/sort_FLP.c
-        opus/silk/float/warped_autocorrelation_FLP.c
-        opus/silk/float/wrappers_FLP.c
-    )
-endif()
-
-target_compile_definitions(opus PRIVATE OPUS_BUILD ENABLE_HARDENING)
-
-if(NOT MSVC)
-    target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
-endif()
-
-# It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
-# variable-length arrays for stack allocation USE_ALLOCA: Use alloca() for stack
-# allocation If none is defined, then the fallback is a non-threadsafe global
-# array
-if(OPUS_USE_ALLOCA OR MSVC)
-    target_compile_definitions(opus PRIVATE USE_ALLOCA)
-else()
-    target_compile_definitions(opus PRIVATE VAR_ARRAYS)
-endif()
-
-if(OPUS_CUSTOM_MODES)
-    target_compile_definitions(opus PRIVATE CUSTOM_MODES)
-endif()
-
-if(NOT OPUS_ENABLE_FLOAT_API)
-    target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
-endif()
-
-target_compile_definitions(opus
-PUBLIC
-    -DOPUS_VERSION="\\"1.3.1\\""
-
-PRIVATE
-    # Use C99 intrinsics to speed up float-to-int conversion
-    HAVE_LRINTF
-)
-
-if (FIXED_POINT)
-    target_compile_definitions(opus PRIVATE -DFIXED_POINT=1 -DDISABLE_FLOAT_API)
-endif()
-
-target_include_directories(opus
-PUBLIC
-    opus/include
-
-PRIVATE
-    opus/celt
-    opus/silk
-    opus/silk/fixed
-    opus/silk/float
-    opus/src
-)
@@ -1,81 +0,0 @@
-project(zlib C)
-
-include(CheckTypeSize)
-include(CheckFunctionExists)
-include(CheckIncludeFile)
-
-check_include_file(sys/types.h HAVE_SYS_TYPES_H)
-check_include_file(stdint.h    HAVE_STDINT_H)
-check_include_file(stddef.h    HAVE_STDDEF_H)
-
-# Check to see if we have large file support
-set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
-# We add these other definitions here because CheckTypeSize.cmake
-# in CMake 2.4.x does not automatically do so and we want
-# compatibility with CMake 2.4.x.
-if(HAVE_SYS_TYPES_H)
-    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
-endif()
-if(HAVE_STDINT_H)
-    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
-endif()
-if(HAVE_STDDEF_H)
-    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
-endif()
-check_type_size(off64_t OFF64_T)
-if(HAVE_OFF64_T)
-   add_definitions(-D_LARGEFILE64_SOURCE=1)
-endif()
-set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
-
-# Check for fseeko
-check_function_exists(fseeko HAVE_FSEEKO)
-if(NOT HAVE_FSEEKO)
-    add_definitions(-DNO_FSEEKO)
-endif()
-
-# Check for unistd.h
-check_include_file(unistd.h HAVE_UNISTD_H)
-if(HAVE_UNISTD_H)
-    add_definitions(-DHAVE_UNISTD_H)
-endif()
-
-if(MSVC)
-    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
-    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
-endif()
-
-add_library(z STATIC
-    zlib/adler32.c
-    zlib/compress.c
-    zlib/crc32.c
-    zlib/crc32.h
-    zlib/deflate.c
-    zlib/deflate.h
-    zlib/gzclose.c
-    zlib/gzguts.h
-    zlib/gzlib.c
-    zlib/gzread.c
-    zlib/gzwrite.c
-    zlib/inffast.h
-    zlib/inffixed.h
-    zlib/inflate.c
-    zlib/inflate.h
-    zlib/infback.c
-    zlib/inftrees.c
-    zlib/inftrees.h
-    zlib/inffast.c
-    zlib/trees.c
-    zlib/trees.h
-    zlib/uncompr.c
-    zlib/zconf.h
-    zlib/zlib.h
-    zlib/zutil.c
-    zlib/zutil.h
-)
-add_library(ZLIB::ZLIB ALIAS z)
-
-target_include_directories(z
-PUBLIC
-    zlib/
-)
@@ -3,8 +3,17 @@
 # could affect the result, but much more unlikely than the following files. Keeping a list of files
 # like this allows for much better caching since it doesn't force the user to recompile binary shaders every update
 set(VIDEO_CORE "${CMAKE_SOURCE_DIR}/src/video_core")
-if (DEFINED ENV{AZURECIREPO})
-  set(BUILD_REPOSITORY $ENV{AZURECIREPO})
+if (DEFINED ENV{CI})
+  if (DEFINED ENV{TRAVIS})
+    set(BUILD_REPOSITORY $ENV{TRAVIS_REPO_SLUG})
+    set(BUILD_TAG $ENV{TRAVIS_TAG})
+  elseif(DEFINED ENV{APPVEYOR})
+    set(BUILD_REPOSITORY $ENV{APPVEYOR_REPO_NAME})
+    set(BUILD_TAG $ENV{APPVEYOR_REPO_TAG_NAME})
+  elseif(DEFINED ENV{AZURE})
+    set(BUILD_REPOSITORY $ENV{AZURE_REPO_NAME})
+    set(BUILD_TAG $ENV{AZURE_REPO_TAG})
+  endif()
 endif()
 if (DEFINED ENV{TITLEBARFORMATIDLE})
  set(TITLE_BAR_FORMAT_IDLE $ENV{TITLEBARFORMATIDLE})
@@ -65,12 +74,10 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/decode/xmad.cpp"
      "${VIDEO_CORE}/shader/ast.cpp"
      "${VIDEO_CORE}/shader/ast.h"
-      "${VIDEO_CORE}/shader/compiler_settings.cpp"
-      "${VIDEO_CORE}/shader/compiler_settings.h"
-      "${VIDEO_CORE}/shader/const_buffer_locker.cpp"
-      "${VIDEO_CORE}/shader/const_buffer_locker.h"
      "${VIDEO_CORE}/shader/control_flow.cpp"
      "${VIDEO_CORE}/shader/control_flow.h"
+      "${VIDEO_CORE}/shader/compiler_settings.cpp"
+      "${VIDEO_CORE}/shader/compiler_settings.h"
      "${VIDEO_CORE}/shader/decode.cpp"
      "${VIDEO_CORE}/shader/expr.cpp"
      "${VIDEO_CORE}/shader/expr.h"
@@ -88,11 +95,11 @@ add_custom_command(OUTPUT scm_rev.cpp
 )

 add_library(common STATIC
-    algorithm.h
    alignment.h
    assert.h
    detached_tasks.cpp
    detached_tasks.h
+    binary_find.h
    bit_field.h
    bit_util.h
    cityhash.cpp
@@ -51,17 +51,7 @@ public:
    using reference = T&;
    using const_reference = const T&;

-    using propagate_on_container_copy_assignment = std::true_type;
-    using propagate_on_container_move_assignment = std::true_type;
-    using propagate_on_container_swap = std::true_type;
-    using is_always_equal = std::true_type;
-
 public:
-    constexpr AlignmentAllocator() noexcept = default;
-
-    template <typename T2>
-    constexpr AlignmentAllocator(const AlignmentAllocator<T2, Align>&) noexcept {}
-
    pointer address(reference r) noexcept {
        return std::addressof(r);
    }
@@ -5,12 +5,6 @@
 #pragma once

 #include <algorithm>
-#include <functional>
-
-// Algorithms that operate on iterators, much like the <algorithm> header.
-//
-// Note: If the algorithm is not general-purpose and/or doesn't operate on iterators,
-//       it should probably not be placed within this header.

 namespace Common {

@@ -36,13 +36,6 @@
 #include "common/common_funcs.h"
 #include "common/swap.h"

-// Inlining
-#ifdef _WIN32
-#define FORCE_INLINE __forceinline
-#else
-#define FORCE_INLINE inline __attribute__((always_inline))
-#endif
-
 /*
 * Abstract bitfield class
 *
@@ -175,11 +168,11 @@ public:
    constexpr BitField(BitField&&) noexcept = default;
    constexpr BitField& operator=(BitField&&) noexcept = default;

-    constexpr operator T() const {
+    constexpr FORCE_INLINE operator T() const {
        return Value();
    }

-    constexpr void Assign(const T& value) {
+    constexpr FORCE_INLINE void Assign(const T& value) {
        storage = (static_cast<StorageType>(storage) & ~mask) | FormatValue(value);
    }

@@ -1,11 +1,10 @@
-// Copyright 2019 yuzu emulator team
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

 #pragma once

 #include <algorithm>
-#include <array>
 #include <string>

 #if !defined(ARCHITECTURE_x86_64)
@@ -17,15 +16,18 @@
 #define CONCAT2(x, y) DO_CONCAT2(x, y)
 #define DO_CONCAT2(x, y) x##y

-/// Helper macros to insert unused bytes or words to properly align structs. These values will be
-/// zero-initialized.
-#define INSERT_PADDING_BYTES(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__){};
-#define INSERT_PADDING_WORDS(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__){};
+// helper macro to properly align structure members.
+// Calling INSERT_PADDING_BYTES will add a new member variable with a name like "pad121",
+// depending on the current source line to make sure variable names are unique.
+#define INSERT_PADDING_BYTES(num_bytes) u8 CONCAT2(pad, __LINE__)[(num_bytes)]
+#define INSERT_PADDING_WORDS(num_words) u32 CONCAT2(pad, __LINE__)[(num_words)]

-/// These are similar to the INSERT_PADDING_* macros, but are needed for padding unions. This is
-/// because unions can only be initialized by one member.
-#define INSERT_UNION_PADDING_BYTES(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__);
-#define INSERT_UNION_PADDING_WORDS(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__);
+// Inlining
+#ifdef _WIN32
+#define FORCE_INLINE __forceinline
+#else
+#define FORCE_INLINE inline __attribute__((always_inline))
+#endif

 #ifndef _MSC_VER

@@ -713,6 +713,7 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
        case UserPath::RootDir:
            user_path = paths[UserPath::RootDir] + DIR_SEP;
            break;
+
        case UserPath::UserDir:
            user_path = paths[UserPath::RootDir] + DIR_SEP;
            paths[UserPath::ConfigDir] = user_path + CONFIG_DIR DIR_SEP;
@@ -720,8 +721,6 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
            paths[UserPath::SDMCDir] = user_path + SDMC_DIR DIR_SEP;
            paths[UserPath::NANDDir] = user_path + NAND_DIR DIR_SEP;
            break;
-        default:
-            break;
        }
    }

@@ -6,8 +6,6 @@

 #include <cstddef>
 #include <cstring>
-#include <utility>
-#include <boost/functional/hash.hpp>
 #include "common/cityhash.h"
 #include "common/common_types.h"

@@ -70,13 +68,4 @@ struct HashableStruct {
    }
 };

-struct PairHash {
-    template <class T1, class T2>
-    std::size_t operator()(const std::pair<T1, T2>& pair) const noexcept {
-        std::size_t seed = std::hash<T1>()(pair.first);
-        boost::hash_combine(seed, std::hash<T2>()(pair.second));
-        return seed;
-    }
-};
-
 } // namespace Common
@@ -304,13 +304,6 @@ public:
        return levels[priority == Depth ? 63 : priority].back();
    }

-    void clear() {
-        used_priorities = 0;
-        for (std::size_t i = 0; i < Depth; i++) {
-            levels[i].clear();
-        }
-    }
-
 private:
    using const_list_iterator = typename std::list<T>::const_iterator;

@@ -74,24 +74,10 @@ add_library(core STATIC
    file_sys/sdmc_factory.h
    file_sys/submission_package.cpp
    file_sys/submission_package.h
-    file_sys/system_archive/data/font_chinese_simplified.cpp
-    file_sys/system_archive/data/font_chinese_simplified.h
-    file_sys/system_archive/data/font_chinese_traditional.cpp
-    file_sys/system_archive/data/font_chinese_traditional.h
-    file_sys/system_archive/data/font_extended_chinese_simplified.cpp
-    file_sys/system_archive/data/font_extended_chinese_simplified.h
-    file_sys/system_archive/data/font_korean.cpp
-    file_sys/system_archive/data/font_korean.h
-    file_sys/system_archive/data/font_nintendo_extended.cpp
-    file_sys/system_archive/data/font_nintendo_extended.h
-    file_sys/system_archive/data/font_standard.cpp
-    file_sys/system_archive/data/font_standard.h
    file_sys/system_archive/mii_model.cpp
    file_sys/system_archive/mii_model.h
    file_sys/system_archive/ng_word.cpp
    file_sys/system_archive/ng_word.h
-    file_sys/system_archive/shared_font.cpp
-    file_sys/system_archive/shared_font.h
    file_sys/system_archive/system_archive.cpp
    file_sys/system_archive/system_archive.h
    file_sys/system_archive/system_version.cpp
@@ -349,8 +335,6 @@ add_library(core STATIC
    hle/service/ldr/ldr.h
    hle/service/lm/lm.cpp
    hle/service/lm/lm.h
-    hle/service/lm/manager.cpp
-    hle/service/lm/manager.h
    hle/service/mig/mig.cpp
    hle/service/mig/mig.h
    hle/service/mii/mii.cpp
@@ -525,7 +509,7 @@ add_library(core STATIC
 create_target_directory_groups(core)

 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn open_source_archives)

 if (YUZU_ENABLE_BOXCAT)
    get_directory_property(OPENSSL_LIBS
@@ -116,7 +116,7 @@ public:
        num_interpreted_instructions = 0;
    }
    u64 GetTicksRemaining() override {
-        return std::max(parent.system.CoreTiming().GetDowncount(), s64{0});
+        return std::max(parent.system.CoreTiming().GetDowncount(), 0);
    }
    u64 GetCNTPCT() override {
        return Timing::CpuCyclesToClockCycles(parent.system.CoreTiming().GetTicks());
@@ -156,7 +156,7 @@ void ARM_Unicorn::Run() {
    if (GDBStub::IsServerEnabled()) {
        ExecuteInstructions(std::max(4000000, 0));
    } else {
-        ExecuteInstructions(std::max(system.CoreTiming().GetDowncount(), s64{0}));
+        ExecuteInstructions(std::max(system.CoreTiming().GetDowncount(), 0));
    }
 }

@@ -35,7 +35,6 @@
 #include "core/hle/service/apm/controller.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/glue/manager.h"
-#include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
@@ -112,8 +111,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 }
 struct System::Impl {
    explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, cpu_core_manager{system}, reporter{system},
-          applet_manager{system} {}
+        : kernel{system}, cpu_core_manager{system}, applet_manager{system}, reporter{system} {}

    Cpu& CurrentCpuCore() {
        return cpu_core_manager.GetCurrentCore();
@@ -240,21 +238,16 @@ struct System::Impl {
    }

    void Shutdown() {
-        // Log last frame performance stats if game was loded
-        if (perf_stats) {
-            const auto perf_results = GetAndResetPerfStats();
-            telemetry_session->AddField(Telemetry::FieldType::Performance,
-                                        "Shutdown_EmulationSpeed",
-                                        perf_results.emulation_speed * 100.0);
-            telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
-                                        perf_results.game_fps);
-            telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
-                                        perf_results.frametime * 1000.0);
-            telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS",
-                                        perf_stats->GetMeanFrametime());
-        }
-
-        lm_manager.Flush();
+        // Log last frame performance stats
+        const auto perf_results = GetAndResetPerfStats();
+        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
+                                    perf_results.emulation_speed * 100.0);
+        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
+                                    perf_results.game_fps);
+        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
+                                    perf_results.frametime * 1000.0);
+        telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS",
+                                    perf_stats->GetMeanFrametime());

        is_powered_on = false;
        exit_lock = false;
@@ -346,7 +339,6 @@ struct System::Impl {
    bool is_powered_on = false;
    bool exit_lock = false;

-    Reporter reporter;
    std::unique_ptr<Memory::CheatEngine> cheat_engine;
    std::unique_ptr<Tools::Freezer> memory_freezer;
    std::array<u8, 0x20> build_id{};
@@ -357,9 +349,8 @@ struct System::Impl {
    /// APM (Performance) services
    Service::APM::Controller apm_controller{core_timing};

-    /// Service State
+    /// Glue services
    Service::Glue::ARPManager arp_manager;
-    Service::LM::Manager lm_manager{reporter};

    /// Service manager
    std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -367,6 +358,8 @@ struct System::Impl {
    /// Telemetry session for this emulation session
    std::unique_ptr<Core::TelemetrySession> telemetry_session;

+    Reporter reporter;
+
    ResultStatus status = ResultStatus::Success;
    std::string status_details = "";

@@ -409,12 +402,6 @@ void System::PrepareReschedule() {
    CurrentCpuCore().PrepareReschedule();
 }

-void System::PrepareReschedule(const u32 core_index) {
-    if (core_index < GlobalScheduler().CpuCoresCount()) {
-        CpuCore(core_index).PrepareReschedule();
-    }
-}
-
 PerfStatsResults System::GetAndResetPerfStats() {
    return impl->GetAndResetPerfStats();
 }
@@ -455,16 +442,6 @@ const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
    return CpuCore(core_index).Scheduler();
 }

-/// Gets the global scheduler
-Kernel::GlobalScheduler& System::GlobalScheduler() {
-    return impl->kernel.GlobalScheduler();
-}
-
-/// Gets the global scheduler
-const Kernel::GlobalScheduler& System::GlobalScheduler() const {
-    return impl->kernel.GlobalScheduler();
-}
-
 Kernel::Process* System::CurrentProcess() {
    return impl->kernel.CurrentProcess();
 }
@@ -658,14 +635,6 @@ const Service::APM::Controller& System::GetAPMController() const {
    return impl->apm_controller;
 }

-Service::LM::Manager& System::GetLogManager() {
-    return impl->lm_manager;
-}
-
-const Service::LM::Manager& System::GetLogManager() const {
-    return impl->lm_manager;
-}
-
 void System::SetExitLock(bool locked) {
    impl->exit_lock = locked;
 }
@@ -674,11 +643,11 @@ bool System::GetExitLock() const {
    return impl->exit_lock;
 }

-void System::SetCurrentProcessBuildID(const CurrentBuildProcessID& id) {
+void System::SetCurrentProcessBuildID(std::array<u8, 32> id) {
    impl->build_id = id;
 }

-const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
+const std::array<u8, 32>& System::GetCurrentProcessBuildID() const {
    return impl->build_id;
 }

@@ -8,6 +8,7 @@
 #include <memory>
 #include <string>

+#include <map>
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
@@ -24,7 +25,6 @@ class VfsFilesystem;
 } // namespace FileSys

 namespace Kernel {
-class GlobalScheduler;
 class KernelCore;
 class Process;
 class Scheduler;
@@ -58,10 +58,6 @@ namespace Glue {
 class ARPManager;
 }

-namespace LM {
-class Manager;
-} // namespace LM
-
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -102,8 +98,6 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,

 class System {
 public:
-    using CurrentBuildProcessID = std::array<u8, 0x20>;
-
    System(const System&) = delete;
    System& operator=(const System&) = delete;

@@ -185,9 +179,6 @@ public:
    /// Prepare the core emulation for a reschedule
    void PrepareReschedule();

-    /// Prepare the core emulation for a reschedule
-    void PrepareReschedule(u32 core_index);
-
    /// Gets and resets core performance statistics
    PerfStatsResults GetAndResetPerfStats();

@@ -242,12 +233,6 @@ public:
    /// Gets the scheduler for the CPU core with the specified index
    const Kernel::Scheduler& Scheduler(std::size_t core_index) const;

-    /// Gets the global scheduler
-    Kernel::GlobalScheduler& GlobalScheduler();
-
-    /// Gets the global scheduler
-    const Kernel::GlobalScheduler& GlobalScheduler() const;
-
    /// Provides a pointer to the current process
    Kernel::Process* CurrentProcess();

@@ -341,17 +326,13 @@ public:

    const Service::APM::Controller& GetAPMController() const;

-    Service::LM::Manager& GetLogManager();
-
-    const Service::LM::Manager& GetLogManager() const;
-
    void SetExitLock(bool locked);

    bool GetExitLock() const;

-    void SetCurrentProcessBuildID(const CurrentBuildProcessID& id);
+    void SetCurrentProcessBuildID(std::array<u8, 0x20> id);

-    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
+    const std::array<u8, 0x20>& GetCurrentProcessBuildID() const;

 private:
    System();
@@ -376,4 +357,8 @@ private:
    static System s_instance;
 };

+inline Kernel::Process* CurrentProcess() {
+    return System::GetInstance().CurrentProcess();
+}
+
 } // namespace Core
@@ -52,8 +52,7 @@ bool CpuBarrier::Rendezvous() {

 Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
         std::size_t core_index)
-    : cpu_barrier{cpu_barrier}, global_scheduler{system.GlobalScheduler()},
-      core_timing{system.CoreTiming()}, core_index{core_index} {
+    : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
 #ifdef ARCHITECTURE_x86_64
    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
@@ -61,7 +60,7 @@ Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_ba
    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif

-    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
+    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
 }

 Cpu::~Cpu() = default;
@@ -82,21 +81,29 @@ void Cpu::RunLoop(bool tight_loop) {
        return;
    }

-    Reschedule();
-
    // If we don't have a currently active thread then don't execute instructions,
    // instead advance to the next event and try to yield to the next thread
    if (Kernel::GetCurrentThread() == nullptr) {
        LOG_TRACE(Core, "Core-{} idling", core_index);
-        core_timing.Idle();
+
+        if (IsMainCore()) {
+            // TODO(Subv): Only let CoreTiming idle if all 4 cores are idling.
+            core_timing.Idle();
+            core_timing.Advance();
+        }
+
+        PrepareReschedule();
    } else {
+        if (IsMainCore()) {
+            core_timing.Advance();
+        }
+
        if (tight_loop) {
            arm_interface->Run();
        } else {
            arm_interface->Step();
        }
    }
-    core_timing.Advance();

    Reschedule();
 }
@@ -107,18 +114,18 @@ void Cpu::SingleStep() {

 void Cpu::PrepareReschedule() {
    arm_interface->PrepareReschedule();
+    reschedule_pending = true;
 }

 void Cpu::Reschedule() {
+    if (!reschedule_pending) {
+        return;
+    }
+
+    reschedule_pending = false;
    // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard lock(HLE::g_hle_lock);
-
-    global_scheduler.SelectThread(core_index);
-    scheduler->TryDoContextSwitch();
-}
-
-void Cpu::Shutdown() {
-    scheduler->Shutdown();
+    std::lock_guard lock{HLE::g_hle_lock};
+    scheduler->Reschedule();
 }

 } // namespace Core
@@ -12,9 +12,8 @@
 #include "common/common_types.h"

 namespace Kernel {
-class GlobalScheduler;
 class Scheduler;
-} // namespace Kernel
+}

 namespace Core {
 class System;
@@ -84,8 +83,6 @@ public:
        return core_index;
    }

-    void Shutdown();
-
    static std::unique_ptr<ExclusiveMonitor> MakeExclusiveMonitor(std::size_t num_cores);

 private:
@@ -93,7 +90,6 @@ private:

    std::unique_ptr<ARM_Interface> arm_interface;
    CpuBarrier& cpu_barrier;
-    Kernel::GlobalScheduler& global_scheduler;
    std::unique_ptr<Kernel::Scheduler> scheduler;
    Timing::CoreTiming& core_timing;

@@ -15,7 +15,7 @@

 namespace Core::Timing {

-constexpr int MAX_SLICE_LENGTH = 10000;
+constexpr int MAX_SLICE_LENGTH = 20000;

 struct CoreTiming::Event {
    s64 time;
@@ -38,12 +38,10 @@ CoreTiming::CoreTiming() = default;
 CoreTiming::~CoreTiming() = default;

 void CoreTiming::Initialize() {
-    downcounts.fill(MAX_SLICE_LENGTH);
-    time_slice.fill(MAX_SLICE_LENGTH);
+    downcount = MAX_SLICE_LENGTH;
    slice_length = MAX_SLICE_LENGTH;
    global_timer = 0;
    idled_cycles = 0;
-    current_context = 0;

    // The time between CoreTiming being initialized and the first call to Advance() is considered
    // the slice boundary between slice -1 and slice 0. Dispatcher loops must call Advance() before
@@ -112,7 +110,7 @@ void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
 u64 CoreTiming::GetTicks() const {
    u64 ticks = static_cast<u64>(global_timer);
    if (!is_global_timer_sane) {
-        ticks += accumulated_ticks;
+        ticks += slice_length - downcount;
    }
    return ticks;
 }
@@ -122,8 +120,7 @@ u64 CoreTiming::GetIdleTicks() const {
 }

 void CoreTiming::AddTicks(u64 ticks) {
-    accumulated_ticks += ticks;
-    downcounts[current_context] -= static_cast<s64>(ticks);
+    downcount -= static_cast<int>(ticks);
 }

 void CoreTiming::ClearPendingEvents() {
@@ -144,35 +141,22 @@ void CoreTiming::RemoveEvent(const EventType* event_type) {

 void CoreTiming::ForceExceptionCheck(s64 cycles) {
    cycles = std::max<s64>(0, cycles);
-    if (downcounts[current_context] <= cycles) {
+    if (downcount <= cycles) {
        return;
    }

    // downcount is always (much) smaller than MAX_INT so we can safely cast cycles to an int
    // here. Account for cycles already executed by adjusting the g.slice_length
-    downcounts[current_context] = static_cast<int>(cycles);
-}
-
-std::optional<u64> CoreTiming::NextAvailableCore(const s64 needed_ticks) const {
-    const u64 original_context = current_context;
-    u64 next_context = (original_context + 1) % num_cpu_cores;
-    while (next_context != original_context) {
-        if (time_slice[next_context] >= needed_ticks) {
-            return {next_context};
-        } else if (time_slice[next_context] >= 0) {
-            return std::nullopt;
-        }
-        next_context = (next_context + 1) % num_cpu_cores;
-    }
-    return std::nullopt;
+    slice_length -= downcount - static_cast<int>(cycles);
+    downcount = static_cast<int>(cycles);
 }

 void CoreTiming::Advance() {
    std::unique_lock<std::mutex> guard(inner_mutex);

-    const u64 cycles_executed = accumulated_ticks;
-    time_slice[current_context] = std::max<s64>(0, time_slice[current_context] - accumulated_ticks);
+    const int cycles_executed = slice_length - downcount;
    global_timer += cycles_executed;
+    slice_length = MAX_SLICE_LENGTH;

    is_global_timer_sane = true;

@@ -189,46 +173,24 @@ void CoreTiming::Advance() {

    // Still events left (scheduled in the future)
    if (!event_queue.empty()) {
-        const s64 needed_ticks =
-            std::min<s64>(event_queue.front().time - global_timer, MAX_SLICE_LENGTH);
-        const auto next_core = NextAvailableCore(needed_ticks);
-        if (next_core) {
-            downcounts[*next_core] = needed_ticks;
-        }
+        slice_length = static_cast<int>(
+            std::min<s64>(event_queue.front().time - global_timer, MAX_SLICE_LENGTH));
    }

-    accumulated_ticks = 0;
-
-    downcounts[current_context] = time_slice[current_context];
-}
-
-void CoreTiming::ResetRun() {
-    downcounts.fill(MAX_SLICE_LENGTH);
-    time_slice.fill(MAX_SLICE_LENGTH);
-    current_context = 0;
-    // Still events left (scheduled in the future)
-    if (!event_queue.empty()) {
-        const s64 needed_ticks =
-            std::min<s64>(event_queue.front().time - global_timer, MAX_SLICE_LENGTH);
-        downcounts[current_context] = needed_ticks;
-    }
-
-    is_global_timer_sane = false;
-    accumulated_ticks = 0;
+    downcount = slice_length;
 }

 void CoreTiming::Idle() {
-    accumulated_ticks += downcounts[current_context];
-    idled_cycles += downcounts[current_context];
-    downcounts[current_context] = 0;
+    idled_cycles += downcount;
+    downcount = 0;
 }

 std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const {
    return std::chrono::microseconds{GetTicks() * 1000000 / BASE_CLOCK_RATE};
 }

-s64 CoreTiming::GetDowncount() const {
-    return downcounts[current_context];
+int CoreTiming::GetDowncount() const {
+    return downcount;
 }

 } // namespace Core::Timing
@@ -7,7 +7,6 @@
 #include <chrono>
 #include <functional>
 #include <mutex>
-#include <optional>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -105,19 +104,7 @@ public:

    std::chrono::microseconds GetGlobalTimeUs() const;

-    void ResetRun();
-
-    s64 GetDowncount() const;
-
-    void SwitchContext(u64 new_context) {
-        current_context = new_context;
-    }
-
-    bool CanCurrentContextRun() const {
-        return time_slice[current_context] > 0;
-    }
-
-    std::optional<u64> NextAvailableCore(const s64 needed_ticks) const;
+    int GetDowncount() const;

 private:
    struct Event;
@@ -125,16 +112,10 @@ private:
    /// Clear all pending events. This should ONLY be done on exit.
    void ClearPendingEvents();

-    static constexpr u64 num_cpu_cores = 4;
-
    s64 global_timer = 0;
    s64 idled_cycles = 0;
-    s64 slice_length = 0;
-    u64 accumulated_ticks = 0;
-    std::array<s64, num_cpu_cores> downcounts{};
-    // Slice of time assigned to each core per run.
-    std::array<s64, num_cpu_cores> time_slice{};
-    u64 current_context = 0;
+    int slice_length = 0;
+    int downcount = 0;

    // Are we in a function that has been called from Advance()
    // If events are scheduled from a function that gets called from Advance(),
@@ -6,7 +6,6 @@
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_cpu.h"
-#include "core/core_timing.h"
 #include "core/cpu_core_manager.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/settings.h"
@@ -58,7 +57,6 @@ void CpuCoreManager::Shutdown() {

    thread_to_cpu.clear();
    for (auto& cpu_core : cores) {
-        cpu_core->Shutdown();
        cpu_core.reset();
    }

@@ -124,19 +122,13 @@ void CpuCoreManager::RunLoop(bool tight_loop) {
        }
    }

-    auto& core_timing = system.CoreTiming();
-    core_timing.ResetRun();
-    bool keep_running{};
-    do {
-        keep_running = false;
-        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-            core_timing.SwitchContext(active_core);
-            if (core_timing.CanCurrentContextRun()) {
-                cores[active_core]->RunLoop(tight_loop);
-            }
-            keep_running |= core_timing.CanCurrentContextRun();
+    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+        cores[active_core]->RunLoop(tight_loop);
+        if (Settings::values.use_multi_core) {
+            // Cores 1-3 are run on other threads in this mode
+            break;
        }
-    } while (keep_running);
+    }

    if (GDBStub::IsServerEnabled()) {
        GDBStub::SetCpuStepFlag(false);
@@ -31,7 +31,7 @@ constexpr std::array partition_names{

 XCI::XCI(VirtualFile file_)
    : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(partition_names.size()), partitions_raw(partition_names.size()) {
+      partitions(partition_names.size()) {
    if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
        status = Loader::ResultStatus::ErrorBadXCIHeader;
        return;
@@ -42,10 +42,8 @@ XCI::XCI(VirtualFile file_)
        return;
    }

-    PartitionFilesystem main_hfs(std::make_shared<OffsetVfsFile>(
-        file, file->GetSize() - header.hfs_offset, header.hfs_offset));
-
-    update_normal_partition_end = main_hfs.GetFileOffsets()["secure"];
+    PartitionFilesystem main_hfs(
+        std::make_shared<OffsetVfsFile>(file, header.hfs_size, header.hfs_offset));

    if (main_hfs.GetStatus() != Loader::ResultStatus::Success) {
        status = main_hfs.GetStatus();
@@ -57,7 +55,9 @@ XCI::XCI(VirtualFile file_)
        const auto partition_idx = static_cast<std::size_t>(partition);
        auto raw = main_hfs.GetFile(partition_names[partition_idx]);

-        partitions_raw[static_cast<std::size_t>(partition)] = std::move(raw);
+        if (raw != nullptr) {
+            partitions[partition_idx] = std::make_shared<PartitionFilesystem>(std::move(raw));
+        }
    }

    secure_partition = std::make_shared<NSP>(
@@ -71,7 +71,13 @@ XCI::XCI(VirtualFile file_)
        program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
    }

-    auto result = AddNCAFromPartition(XCIPartition::Normal);
+    auto result = AddNCAFromPartition(XCIPartition::Update);
+    if (result != Loader::ResultStatus::Success) {
+        status = result;
+        return;
+    }
+
+    result = AddNCAFromPartition(XCIPartition::Normal);
    if (result != Loader::ResultStatus::Success) {
        status = result;
        return;
@@ -98,114 +104,34 @@ Loader::ResultStatus XCI::GetProgramNCAStatus() const {
    return program_nca_status;
 }

-VirtualDir XCI::GetPartition(XCIPartition partition) {
-    const auto id = static_cast<std::size_t>(partition);
-    if (partitions[id] == nullptr && partitions_raw[id] != nullptr) {
-        partitions[id] = std::make_shared<PartitionFilesystem>(partitions_raw[id]);
-    }
-
+VirtualDir XCI::GetPartition(XCIPartition partition) const {
    return partitions[static_cast<std::size_t>(partition)];
 }

-std::vector<VirtualDir> XCI::GetPartitions() {
-    std::vector<VirtualDir> out;
-    for (const auto& id :
-         {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
-        const auto part = GetPartition(id);
-        if (part != nullptr) {
-            out.push_back(part);
-        }
-    }
-    return out;
-}
-
 std::shared_ptr<NSP> XCI::GetSecurePartitionNSP() const {
    return secure_partition;
 }

-VirtualDir XCI::GetSecurePartition() {
+VirtualDir XCI::GetSecurePartition() const {
    return GetPartition(XCIPartition::Secure);
 }

-VirtualDir XCI::GetNormalPartition() {
+VirtualDir XCI::GetNormalPartition() const {
    return GetPartition(XCIPartition::Normal);
 }

-VirtualDir XCI::GetUpdatePartition() {
+VirtualDir XCI::GetUpdatePartition() const {
    return GetPartition(XCIPartition::Update);
 }

-VirtualDir XCI::GetLogoPartition() {
+VirtualDir XCI::GetLogoPartition() const {
    return GetPartition(XCIPartition::Logo);
 }

-VirtualFile XCI::GetPartitionRaw(XCIPartition partition) const {
-    return partitions_raw[static_cast<std::size_t>(partition)];
-}
-
-VirtualFile XCI::GetSecurePartitionRaw() const {
-    return GetPartitionRaw(XCIPartition::Secure);
-}
-
-VirtualFile XCI::GetStoragePartition0() const {
-    return std::make_shared<OffsetVfsFile>(file, update_normal_partition_end, 0, "partition0");
-}
-
-VirtualFile XCI::GetStoragePartition1() const {
-    return std::make_shared<OffsetVfsFile>(file, file->GetSize() - update_normal_partition_end,
-                                           update_normal_partition_end, "partition1");
-}
-
-VirtualFile XCI::GetNormalPartitionRaw() const {
-    return GetPartitionRaw(XCIPartition::Normal);
-}
-
-VirtualFile XCI::GetUpdatePartitionRaw() const {
-    return GetPartitionRaw(XCIPartition::Update);
-}
-
-VirtualFile XCI::GetLogoPartitionRaw() const {
-    return GetPartitionRaw(XCIPartition::Logo);
-}
-
 u64 XCI::GetProgramTitleID() const {
    return secure_partition->GetProgramTitleID();
 }

-u32 XCI::GetSystemUpdateVersion() {
-    const auto update = GetPartition(XCIPartition::Update);
-    if (update == nullptr)
-        return 0;
-
-    for (const auto& file : update->GetFiles()) {
-        NCA nca{file, nullptr, 0, keys};
-
-        if (nca.GetStatus() != Loader::ResultStatus::Success)
-            continue;
-
-        if (nca.GetType() == NCAContentType::Meta && nca.GetTitleId() == 0x0100000000000816) {
-            const auto dir = nca.GetSubdirectories()[0];
-            const auto cnmt = dir->GetFile("SystemUpdate_0100000000000816.cnmt");
-            if (cnmt == nullptr)
-                continue;
-
-            CNMT cnmt_data{cnmt};
-
-            const auto metas = cnmt_data.GetMetaRecords();
-            if (metas.empty())
-                continue;
-
-            return metas[0].title_version;
-        }
-    }
-
-    return 0;
-}
-
-u64 XCI::GetSystemUpdateTitleID() const {
-    return 0x0100000000000816;
-}
-
 bool XCI::HasProgramNCA() const {
    return program != nullptr;
 }
@@ -275,7 +201,7 @@ std::array<u8, 0x200> XCI::GetCertificate() const {

 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
    const auto partition_index = static_cast<std::size_t>(part);
-    const auto partition = GetPartition(part);
+    const auto& partition = partitions[partition_index];

    if (partition == nullptr) {
        return Loader::ResultStatus::ErrorXCIMissingPartition;
@@ -306,7 +232,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
    return Loader::ResultStatus::Success;
 }

-u8 XCI::GetFormatVersion() {
+u8 XCI::GetFormatVersion() const {
    return GetLogoPartition() == nullptr ? 0x1 : 0x2;
 }
 } // namespace FileSys
@@ -81,24 +81,14 @@ public:
    Loader::ResultStatus GetStatus() const;
    Loader::ResultStatus GetProgramNCAStatus() const;

-    u8 GetFormatVersion();
-
-    VirtualDir GetPartition(XCIPartition partition);
-    std::vector<VirtualDir> GetPartitions();
+    u8 GetFormatVersion() const;

+    VirtualDir GetPartition(XCIPartition partition) const;
    std::shared_ptr<NSP> GetSecurePartitionNSP() const;
-    VirtualDir GetSecurePartition();
-    VirtualDir GetNormalPartition();
-    VirtualDir GetUpdatePartition();
-    VirtualDir GetLogoPartition();
-
-    VirtualFile GetPartitionRaw(XCIPartition partition) const;
-    VirtualFile GetSecurePartitionRaw() const;
-    VirtualFile GetStoragePartition0() const;
-    VirtualFile GetStoragePartition1() const;
-    VirtualFile GetNormalPartitionRaw() const;
-    VirtualFile GetUpdatePartitionRaw() const;
-    VirtualFile GetLogoPartitionRaw() const;
+    VirtualDir GetSecurePartition() const;
+    VirtualDir GetNormalPartition() const;
+    VirtualDir GetUpdatePartition() const;
+    VirtualDir GetLogoPartition() const;

    u64 GetProgramTitleID() const;
    u32 GetSystemUpdateVersion();
@@ -133,7 +123,6 @@ private:
    Loader::ResultStatus program_nca_status;

    std::vector<VirtualDir> partitions;
-    std::vector<VirtualFile> partitions_raw;
    std::shared_ptr<NSP> secure_partition;
    std::shared_ptr<NCA> program;
    std::vector<std::shared_ptr<NCA>> ncas;
@@ -32,28 +32,11 @@ enum class NCASectionFilesystemType : u8 {
    ROMFS = 0x3,
 };

-struct IVFCLevel {
-    u64_le offset;
-    u64_le size;
-    u32_le block_size;
-    u32_le reserved;
-};
-static_assert(sizeof(IVFCLevel) == 0x18, "IVFCLevel has incorrect size.");
-
-struct IVFCHeader {
-    u32_le magic;
-    u32_le magic_number;
-    INSERT_UNION_PADDING_BYTES(8);
-    std::array<IVFCLevel, 6> levels;
-    INSERT_UNION_PADDING_BYTES(64);
-};
-static_assert(sizeof(IVFCHeader) == 0xE0, "IVFCHeader has incorrect size.");
-
 struct NCASectionHeaderBlock {
-    INSERT_UNION_PADDING_BYTES(3);
+    INSERT_PADDING_BYTES(3);
    NCASectionFilesystemType filesystem_type;
    NCASectionCryptoType crypto_type;
-    INSERT_UNION_PADDING_BYTES(3);
+    INSERT_PADDING_BYTES(3);
 };
 static_assert(sizeof(NCASectionHeaderBlock) == 0x8, "NCASectionHeaderBlock has incorrect size.");

@@ -61,7 +44,7 @@ struct NCASectionRaw {
    NCASectionHeaderBlock header;
    std::array<u8, 0x138> block_data;
    std::array<u8, 0x8> section_ctr;
-    INSERT_UNION_PADDING_BYTES(0xB8);
+    INSERT_PADDING_BYTES(0xB8);
 };
 static_assert(sizeof(NCASectionRaw) == 0x200, "NCASectionRaw has incorrect size.");

@@ -69,19 +52,19 @@ struct PFS0Superblock {
    NCASectionHeaderBlock header_block;
    std::array<u8, 0x20> hash;
    u32_le size;
-    INSERT_UNION_PADDING_BYTES(4);
+    INSERT_PADDING_BYTES(4);
    u64_le hash_table_offset;
    u64_le hash_table_size;
    u64_le pfs0_header_offset;
    u64_le pfs0_size;
-    INSERT_UNION_PADDING_BYTES(0x1B0);
+    INSERT_PADDING_BYTES(0x1B0);
 };
 static_assert(sizeof(PFS0Superblock) == 0x200, "PFS0Superblock has incorrect size.");

 struct RomFSSuperblock {
    NCASectionHeaderBlock header_block;
    IVFCHeader ivfc;
-    INSERT_UNION_PADDING_BYTES(0x118);
+    INSERT_PADDING_BYTES(0x118);
 };
 static_assert(sizeof(RomFSSuperblock) == 0x200, "RomFSSuperblock has incorrect size.");

@@ -89,24 +72,24 @@ struct BKTRHeader {
    u64_le offset;
    u64_le size;
    u32_le magic;
-    INSERT_UNION_PADDING_BYTES(0x4);
+    INSERT_PADDING_BYTES(0x4);
    u32_le number_entries;
-    INSERT_UNION_PADDING_BYTES(0x4);
+    INSERT_PADDING_BYTES(0x4);
 };
 static_assert(sizeof(BKTRHeader) == 0x20, "BKTRHeader has incorrect size.");

 struct BKTRSuperblock {
    NCASectionHeaderBlock header_block;
    IVFCHeader ivfc;
-    INSERT_UNION_PADDING_BYTES(0x18);
+    INSERT_PADDING_BYTES(0x18);
    BKTRHeader relocation;
    BKTRHeader subsection;
-    INSERT_UNION_PADDING_BYTES(0xC0);
+    INSERT_PADDING_BYTES(0xC0);
 };
 static_assert(sizeof(BKTRSuperblock) == 0x200, "BKTRSuperblock has incorrect size.");

 union NCASectionHeader {
-    NCASectionRaw raw{};
+    NCASectionRaw raw;
    PFS0Superblock pfs0;
    RomFSSuperblock romfs;
    BKTRSuperblock bktr;
@@ -65,9 +65,6 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
        std::string name(
            reinterpret_cast<const char*>(&file_data[strtab_offset + entry.strtab_offset]));

-        offsets.insert_or_assign(name, content_offset + entry.offset);
-        sizes.insert_or_assign(name, entry.size);
-
        pfs_files.emplace_back(std::make_shared<OffsetVfsFile>(
            file, entry.size, content_offset + entry.offset, std::move(name)));
    }
@@ -81,14 +78,6 @@ Loader::ResultStatus PartitionFilesystem::GetStatus() const {
    return status;
 }

-std::map<std::string, u64> PartitionFilesystem::GetFileOffsets() const {
-    return offsets;
-}
-
-std::map<std::string, u64> PartitionFilesystem::GetFileSizes() const {
-    return sizes;
-}
-
 std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
    return pfs_files;
 }
@@ -29,9 +29,6 @@ public:

    Loader::ResultStatus GetStatus() const;

-    std::map<std::string, u64> GetFileOffsets() const;
-    std::map<std::string, u64> GetFileSizes() const;
-
    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
    std::string GetName() const override;
@@ -83,9 +80,6 @@ private:
    bool is_hfs = false;
    std::size_t content_offset = 0;

-    std::map<std::string, u64> offsets;
-    std::map<std::string, u64> sizes;
-
    std::vector<VirtualFile> pfs_files;
 };

@@ -13,6 +13,25 @@

 namespace FileSys {

+struct RomFSHeader;
+
+struct IVFCLevel {
+    u64_le offset;
+    u64_le size;
+    u32_le block_size;
+    u32_le reserved;
+};
+static_assert(sizeof(IVFCLevel) == 0x18, "IVFCLevel has incorrect size.");
+
+struct IVFCHeader {
+    u32_le magic;
+    u32_le magic_number;
+    INSERT_PADDING_BYTES(8);
+    std::array<IVFCLevel, 6> levels;
+    INSERT_PADDING_BYTES(64);
+};
+static_assert(sizeof(IVFCHeader) == 0xE0, "IVFCHeader has incorrect size.");
+
 enum class RomFSExtractionType {
    Full,          // Includes data directory
    Truncated,     // Traverses into data directory
@@ -35,11 +35,11 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
    this->update_raw = std::move(update_raw);
 }

-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
+ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() const {
    if (!updatable)
        return MakeResult<VirtualFile>(file);

-    const PatchManager patch_manager(current_process_title_id);
+    const PatchManager patch_manager(Core::CurrentProcess()->GetTitleID());
    return MakeResult<VirtualFile>(
        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
@@ -33,7 +33,7 @@ public:
    ~RomFSFactory();

    void SetPackedUpdate(VirtualFile update_raw);
-    ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    ResultVal<VirtualFile> OpenCurrentProcess() const;
    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type) const;

 private:
@@ -16,7 +16,6 @@ namespace FileSys {
 constexpr char SAVE_DATA_SIZE_FILENAME[] = ".yuzu_save_size";

 namespace {
-
 void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
    if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
        if (meta.zero_1 != 0) {
@@ -53,13 +52,6 @@ void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
                    meta.user_id[1], meta.user_id[0]);
    }
 }
-
-bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataDescriptor& desc) {
-    return desc.type == SaveDataType::CacheStorage || desc.type == SaveDataType::TemporaryStorage ||
-           (space == SaveDataSpaceId::NandUser && ///< Normal Save Data -- Current Title & User
-            desc.type == SaveDataType::SaveData && desc.title_id == 0 && desc.save_id == 0);
-}
-
 } // Anonymous namespace

 std::string SaveDataDescriptor::DebugInfo() const {
@@ -104,10 +96,6 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,

    auto out = dir->GetDirectoryRelative(save_directory);

-    if (out == nullptr && ShouldSaveDataBeAutomaticallyCreated(space, meta)) {
-        return Create(space, meta);
-    }
-
    // Return an error if the save data doesn't actually exist.
    if (out == nullptr) {
        // TODO(Subv): Find out correct error code.
@@ -139,9 +127,8 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
                                         u128 user_id, u64 save_id) {
    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
    // be interpreted as the title id of the current process.
-    if (type == SaveDataType::SaveData && title_id == 0) {
-        title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-    }
+    if (type == SaveDataType::SaveData && title_id == 0)
+        title_id = Core::CurrentProcess()->GetTitleID();

    std::string out = GetSaveDataSpaceIdPath(space);

@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-namespace FileSys::SystemArchive::SharedFontData {
-
-extern const std::array<unsigned char, 217276> FONT_CHINESE_SIMPLIFIED;
-
-} // namespace FileSys::SystemArchive::SharedFontData
@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-namespace FileSys::SystemArchive::SharedFontData {
-
-extern const std::array<unsigned char, 222236> FONT_CHINESE_TRADITIONAL;
-
-} // namespace FileSys::SystemArchive::SharedFontData
@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-namespace FileSys::SystemArchive::SharedFontData {
-
-extern const std::array<unsigned char, 293516> FONT_EXTENDED_CHINESE_SIMPLIFIED;
-
-} // namespace FileSys::SystemArchive::SharedFontData
@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-namespace FileSys::SystemArchive::SharedFontData {
-
-extern const std::array<unsigned char, 217276> FONT_KOREAN;
-
-} // namespace FileSys::SystemArchive::SharedFontData
@@ -1,196 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/file_sys/system_archive/data/font_nintendo_extended.h"
-
-namespace FileSys::SystemArchive::SharedFontData {
-
-const std::array<unsigned char, 2932> FONT_NINTENDO_EXTENDED{{
-    0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x80, 0x00, 0x03, 0x00, 0x70, 0x44, 0x53, 0x49, 0x47,
-    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0b, 0x6c, 0x00, 0x00, 0x00, 0x08, 0x4f, 0x53, 0x2f, 0x32,
-    0x33, 0x86, 0x1d, 0x9b, 0x00, 0x00, 0x01, 0x78, 0x00, 0x00, 0x00, 0x60, 0x63, 0x6d, 0x61, 0x70,
-    0xc2, 0x06, 0x20, 0xde, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x63, 0x76, 0x74, 0x20,
-    0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x04, 0x2c, 0x00, 0x00, 0x00, 0x06, 0x66, 0x70, 0x67, 0x6d,
-    0x06, 0x59, 0x9c, 0x37, 0x00, 0x00, 0x02, 0xa0, 0x00, 0x00, 0x01, 0x73, 0x67, 0x61, 0x73, 0x70,
-    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0b, 0x64, 0x00, 0x00, 0x00, 0x08, 0x67, 0x6c, 0x79, 0x66,
-    0x10, 0x31, 0x88, 0x00, 0x00, 0x00, 0x04, 0x34, 0x00, 0x00, 0x04, 0x64, 0x68, 0x65, 0x61, 0x64,
-    0x15, 0x9d, 0xef, 0x91, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x36, 0x68, 0x68, 0x65, 0x61,
-    0x09, 0x60, 0x03, 0x71, 0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x00, 0x24, 0x68, 0x6d, 0x74, 0x78,
-    0x0d, 0x2e, 0x03, 0xa7, 0x00, 0x00, 0x01, 0xd8, 0x00, 0x00, 0x00, 0x26, 0x6c, 0x6f, 0x63, 0x61,
-    0x05, 0xc0, 0x04, 0x6c, 0x00, 0x00, 0x08, 0x98, 0x00, 0x00, 0x00, 0x1e, 0x6d, 0x61, 0x78, 0x70,
-    0x02, 0x1c, 0x00, 0x5f, 0x00, 0x00, 0x01, 0x58, 0x00, 0x00, 0x00, 0x20, 0x6e, 0x61, 0x6d, 0x65,
-    0x7c, 0xe0, 0x84, 0x5c, 0x00, 0x00, 0x08, 0xb8, 0x00, 0x00, 0x02, 0x09, 0x70, 0x6f, 0x73, 0x74,
-    0x47, 0x4e, 0x74, 0x19, 0x00, 0x00, 0x0a, 0xc4, 0x00, 0x00, 0x00, 0x9e, 0x70, 0x72, 0x65, 0x70,
-    0x1c, 0xfc, 0x7d, 0x9c, 0x00, 0x00, 0x04, 0x14, 0x00, 0x00, 0x00, 0x16, 0x00, 0x01, 0x00, 0x00,
-    0x00, 0x01, 0x00, 0x00, 0x7c, 0xc7, 0xb1, 0x63, 0x5f, 0x0f, 0x3c, 0xf5, 0x00, 0x1b, 0x03, 0xe8,
-    0x00, 0x00, 0x00, 0x00, 0xd9, 0x44, 0x2f, 0x5d, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x45, 0x7b, 0x69,
-    0x00, 0x00, 0x00, 0x00, 0x03, 0xe6, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x06, 0x00, 0x02, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x84, 0xff, 0x83, 0x01, 0xf4, 0x03, 0xe8,
-    0x00, 0x00, 0x00, 0x00, 0x03, 0xe6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x5e,
-    0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x74, 0x01, 0x90, 0x00, 0x05,
-    0x00, 0x04, 0x00, 0xcd, 0x00, 0xcd, 0x00, 0x00, 0x01, 0x1f, 0x00, 0xcd, 0x00, 0xcd, 0x00, 0x00,
-    0x03, 0xc3, 0x00, 0x66, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0xc0, 0x00, 0x00, 0xe0, 0xe9, 0x03, 0x84, 0xff, 0x83,
-    0x01, 0xf4, 0x02, 0xee, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe8,
-    0x02, 0xbc, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xfa, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x03, 0xe8, 0x00, 0xeb, 0x01, 0x21, 0x00, 0xff,
-    0x00, 0xff, 0x01, 0x3d, 0x01, 0x17, 0x00, 0x42, 0x00, 0x1c, 0x00, 0x3e, 0x00, 0x17, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x68, 0x00, 0x01, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x1c, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x06, 0x00, 0x4c,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x00, 0x38, 0x00, 0x00, 0x00, 0x0a,
-    0x00, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x20, 0xe0, 0xe9, 0xff, 0xff,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x20, 0xe0, 0xe0, 0xff, 0xff, 0x00, 0x01, 0xff, 0xf5,
-    0xff, 0xe3, 0x1f, 0x24, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xb8, 0x00, 0x00, 0x2c, 0x4b, 0xb8, 0x00, 0x09, 0x50, 0x58, 0xb1, 0x01, 0x01, 0x8e, 0x59, 0xb8,
-    0x01, 0xff, 0x85, 0xb8, 0x00, 0x44, 0x1d, 0xb9, 0x00, 0x09, 0x00, 0x03, 0x5f, 0x5e, 0x2d, 0xb8,
-    0x00, 0x01, 0x2c, 0x20, 0x20, 0x45, 0x69, 0x44, 0xb0, 0x01, 0x60, 0x2d, 0xb8, 0x00, 0x02, 0x2c,
-    0xb8, 0x00, 0x01, 0x2a, 0x21, 0x2d, 0xb8, 0x00, 0x03, 0x2c, 0x20, 0x46, 0xb0, 0x03, 0x25, 0x46,
-    0x52, 0x58, 0x23, 0x59, 0x20, 0x8a, 0x20, 0x8a, 0x49, 0x64, 0x8a, 0x20, 0x46, 0x20, 0x68, 0x61,
-    0x64, 0xb0, 0x04, 0x25, 0x46, 0x20, 0x68, 0x61, 0x64, 0x52, 0x58, 0x23, 0x65, 0x8a, 0x59, 0x2f,
-    0x20, 0xb0, 0x00, 0x53, 0x58, 0x69, 0x20, 0xb0, 0x00, 0x54, 0x58, 0x21, 0xb0, 0x40, 0x59, 0x1b,
-    0x69, 0x20, 0xb0, 0x00, 0x54, 0x58, 0x21, 0xb0, 0x40, 0x65, 0x59, 0x59, 0x3a, 0x2d, 0xb8, 0x00,
-    0x04, 0x2c, 0x20, 0x46, 0xb0, 0x04, 0x25, 0x46, 0x52, 0x58, 0x23, 0x8a, 0x59, 0x20, 0x46, 0x20,
-    0x6a, 0x61, 0x64, 0xb0, 0x04, 0x25, 0x46, 0x20, 0x6a, 0x61, 0x64, 0x52, 0x58, 0x23, 0x8a, 0x59,
-    0x2f, 0xfd, 0x2d, 0xb8, 0x00, 0x05, 0x2c, 0x4b, 0x20, 0xb0, 0x03, 0x26, 0x50, 0x58, 0x51, 0x58,
-    0xb0, 0x80, 0x44, 0x1b, 0xb0, 0x40, 0x44, 0x59, 0x1b, 0x21, 0x21, 0x20, 0x45, 0xb0, 0xc0, 0x50,
-    0x58, 0xb0, 0xc0, 0x44, 0x1b, 0x21, 0x59, 0x59, 0x2d, 0xb8, 0x00, 0x06, 0x2c, 0x20, 0x20, 0x45,
-    0x69, 0x44, 0xb0, 0x01, 0x60, 0x20, 0x20, 0x45, 0x7d, 0x69, 0x18, 0x44, 0xb0, 0x01, 0x60, 0x2d,
-    0xb8, 0x00, 0x07, 0x2c, 0xb8, 0x00, 0x06, 0x2a, 0x2d, 0xb8, 0x00, 0x08, 0x2c, 0x4b, 0x20, 0xb0,
-    0x03, 0x26, 0x53, 0x58, 0xb0, 0x40, 0x1b, 0xb0, 0x00, 0x59, 0x8a, 0x8a, 0x20, 0xb0, 0x03, 0x26,
-    0x53, 0x58, 0x23, 0x21, 0xb0, 0x80, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, 0x59, 0x20, 0xb0, 0x03, 0x26,
-    0x53, 0x58, 0x23, 0x21, 0xb8, 0x00, 0xc0, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, 0x59, 0x20, 0xb0, 0x03,
-    0x26, 0x53, 0x58, 0x23, 0x21, 0xb8, 0x01, 0x00, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, 0x59, 0x20, 0xb0,
-    0x03, 0x26, 0x53, 0x58, 0x23, 0x21, 0xb8, 0x01, 0x40, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, 0x59, 0x20,
-    0xb8, 0x00, 0x03, 0x26, 0x53, 0x58, 0xb0, 0x03, 0x25, 0x45, 0xb8, 0x01, 0x80, 0x50, 0x58, 0x23,
-    0x21, 0xb8, 0x01, 0x80, 0x23, 0x21, 0x1b, 0xb0, 0x03, 0x25, 0x45, 0x23, 0x21, 0x23, 0x21, 0x59,
-    0x1b, 0x21, 0x59, 0x44, 0x2d, 0xb8, 0x00, 0x09, 0x2c, 0x4b, 0x53, 0x58, 0x45, 0x44, 0x1b, 0x21,
-    0x21, 0x59, 0x2d, 0x00, 0xb8, 0x00, 0x00, 0x2b, 0x00, 0xba, 0x00, 0x01, 0x00, 0x01, 0x00, 0x07,
-    0x2b, 0xb8, 0x00, 0x00, 0x20, 0x45, 0x7d, 0x69, 0x18, 0x44, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x03, 0xe6, 0x03, 0xe8, 0x00, 0x06,
-    0x00, 0x00, 0x35, 0x01, 0x33, 0x15, 0x01, 0x23, 0x35, 0x03, 0x52, 0x94, 0xfc, 0xa6, 0x8c, 0x90,
-    0x03, 0x58, 0x86, 0xfc, 0xa0, 0x8e, 0x00, 0x00, 0x00, 0x02, 0x00, 0xeb, 0x00, 0xcc, 0x02, 0xfb,
-    0x03, 0x1e, 0x00, 0x08, 0x00, 0x0f, 0x00, 0x00, 0x01, 0x33, 0x13, 0x23, 0x27, 0x23, 0x07, 0x23,
-    0x13, 0x17, 0x07, 0x06, 0x15, 0x33, 0x27, 0x07, 0x01, 0xbc, 0x6d, 0xd2, 0x7c, 0x26, 0xcc, 0x26,
-    0x7c, 0xd1, 0x35, 0x40, 0x02, 0x89, 0x45, 0x02, 0x03, 0x1e, 0xfd, 0xae, 0x77, 0x77, 0x02, 0x52,
-    0x9b, 0xcc, 0x08, 0x04, 0xda, 0x02, 0x00, 0x00, 0x00, 0x03, 0x01, 0x21, 0x00, 0xcc, 0x02, 0xc5,
-    0x03, 0x1e, 0x00, 0x15, 0x00, 0x1f, 0x00, 0x2b, 0x00, 0x00, 0x25, 0x11, 0x33, 0x32, 0x1e, 0x02,
-    0x15, 0x14, 0x0e, 0x02, 0x07, 0x1e, 0x01, 0x15, 0x14, 0x0e, 0x02, 0x2b, 0x01, 0x13, 0x33, 0x32,
-    0x36, 0x35, 0x34, 0x26, 0x2b, 0x01, 0x1d, 0x01, 0x33, 0x32, 0x3e, 0x02, 0x35, 0x34, 0x26, 0x2b,
-    0x01, 0x15, 0x01, 0x21, 0xea, 0x25, 0x3f, 0x2e, 0x1a, 0x0e, 0x15, 0x1b, 0x0e, 0x2d, 0x2d, 0x1a,
-    0x2e, 0x3f, 0x25, 0xf8, 0x76, 0x62, 0x20, 0x2a, 0x28, 0x22, 0x62, 0x76, 0x10, 0x18, 0x11, 0x09,
-    0x22, 0x22, 0x74, 0xcc, 0x02, 0x52, 0x18, 0x2b, 0x3c, 0x24, 0x1d, 0x1f, 0x17, 0x17, 0x14, 0x0f,
-    0x48, 0x2f, 0x24, 0x3f, 0x2e, 0x1a, 0x01, 0x5b, 0x29, 0x20, 0x20, 0x2b, 0x94, 0xf8, 0x0e, 0x16,
-    0x1c, 0x0e, 0x1f, 0x31, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0xcc, 0x02, 0xe7,
-    0x03, 0x1e, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x33, 0x17, 0x37, 0x33, 0x03, 0x13, 0x23, 0x27, 0x07,
-    0x23, 0x13, 0x03, 0x01, 0x04, 0x86, 0x69, 0x69, 0x86, 0xa3, 0xa8, 0x88, 0x6c, 0x6c, 0x88, 0xa8,
-    0xa3, 0x03, 0x1e, 0xcb, 0xcb, 0xfe, 0xda, 0xfe, 0xd4, 0xcf, 0xcf, 0x01, 0x2c, 0x01, 0x26, 0x00,
-    0x00, 0x01, 0x00, 0xff, 0x00, 0xcc, 0x02, 0xe7, 0x03, 0x1e, 0x00, 0x0f, 0x00, 0x00, 0x01, 0x03,
-    0x33, 0x17, 0x32, 0x15, 0x1e, 0x01, 0x15, 0x1b, 0x01, 0x33, 0x03, 0x15, 0x23, 0x35, 0x01, 0xb8,
-    0xb9, 0x7e, 0x01, 0x01, 0x01, 0x03, 0x70, 0x75, 0x7f, 0xb9, 0x76, 0x01, 0xa3, 0x01, 0x7b, 0x01,
-    0x01, 0x01, 0x05, 0x02, 0xff, 0x00, 0x01, 0x0a, 0xfe, 0x85, 0xd7, 0xd7, 0x00, 0x01, 0x01, 0x3d,
-    0x00, 0xcc, 0x02, 0xa9, 0x03, 0x1e, 0x00, 0x06, 0x00, 0x00, 0x25, 0x11, 0x33, 0x11, 0x33, 0x15,
-    0x21, 0x01, 0x3d, 0x75, 0xf7, 0xfe, 0x94, 0xcc, 0x02, 0x52, 0xfe, 0x10, 0x62, 0x00, 0x00, 0x00,
-    0x00, 0x02, 0x01, 0x17, 0x00, 0xbc, 0x02, 0xcf, 0x03, 0x0e, 0x00, 0x15, 0x00, 0x21, 0x00, 0x00,
-    0x25, 0x11, 0x33, 0x32, 0x1e, 0x02, 0x1d, 0x01, 0x0e, 0x03, 0x1d, 0x01, 0x17, 0x15, 0x23, 0x27,
-    0x23, 0x15, 0x23, 0x13, 0x33, 0x32, 0x3e, 0x02, 0x35, 0x34, 0x26, 0x2b, 0x01, 0x15, 0x01, 0x17,
-    0xf4, 0x27, 0x40, 0x2e, 0x19, 0x01, 0x1f, 0x24, 0x1e, 0x78, 0x7d, 0x6a, 0x5c, 0x75, 0x76, 0x72,
-    0x12, 0x19, 0x11, 0x08, 0x26, 0x26, 0x6a, 0xbc, 0x02, 0x52, 0x1d, 0x31, 0x42, 0x25, 0x16, 0x18,
-    0x32, 0x2a, 0x1b, 0x02, 0x01, 0xef, 0x06, 0xd7, 0xd7, 0x01, 0x3f, 0x10, 0x1a, 0x1e, 0x0f, 0x23,
-    0x36, 0xb0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x42, 0x00, 0xbc, 0x03, 0xa4, 0x03, 0x0e, 0x00, 0x0a,
-    0x00, 0x11, 0x00, 0x00, 0x13, 0x35, 0x21, 0x15, 0x01, 0x21, 0x15, 0x21, 0x35, 0x01, 0x21, 0x01,
-    0x11, 0x33, 0x11, 0x33, 0x15, 0x21, 0x42, 0x01, 0xa7, 0xfe, 0xeb, 0x01, 0x1b, 0xfe, 0x53, 0x01,
-    0x15, 0xfe, 0xeb, 0x01, 0xf7, 0x75, 0xf6, 0xfe, 0x95, 0x02, 0xac, 0x62, 0x45, 0xfe, 0x55, 0x62,
-    0x47, 0x01, 0xa9, 0xfe, 0x10, 0x02, 0x52, 0xfe, 0x10, 0x62, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1c,
-    0x00, 0xbc, 0x03, 0xca, 0x03, 0x0e, 0x00, 0x0a, 0x00, 0x21, 0x00, 0x2f, 0x00, 0x00, 0x13, 0x35,
-    0x21, 0x15, 0x01, 0x21, 0x15, 0x21, 0x35, 0x01, 0x21, 0x01, 0x11, 0x33, 0x32, 0x1e, 0x02, 0x15,
-    0x14, 0x06, 0x07, 0x0e, 0x03, 0x15, 0x17, 0x15, 0x23, 0x27, 0x23, 0x15, 0x23, 0x13, 0x33, 0x32,
-    0x3e, 0x02, 0x35, 0x34, 0x2e, 0x02, 0x2b, 0x01, 0x15, 0x1c, 0x01, 0xa7, 0xfe, 0xeb, 0x01, 0x1b,
-    0xfe, 0x53, 0x01, 0x15, 0xfe, 0xeb, 0x01, 0xf7, 0xf3, 0x27, 0x41, 0x2d, 0x19, 0x1c, 0x20, 0x01,
-    0x0d, 0x0e, 0x0a, 0x78, 0x7d, 0x69, 0x5c, 0x75, 0x76, 0x71, 0x11, 0x1a, 0x12, 0x09, 0x0a, 0x14,
-    0x1d, 0x13, 0x69, 0x02, 0xac, 0x62, 0x45, 0xfe, 0x55, 0x62, 0x47, 0x01, 0xa9, 0xfe, 0x10, 0x02,
-    0x52, 0x1d, 0x31, 0x42, 0x25, 0x2b, 0x44, 0x1d, 0x01, 0x08, 0x09, 0x07, 0x01, 0xf1, 0x06, 0xd7,
-    0xd7, 0x01, 0x3f, 0x11, 0x19, 0x1f, 0x0e, 0x11, 0x20, 0x19, 0x0f, 0xb0, 0x00, 0x02, 0x00, 0x3e,
-    0x00, 0xb3, 0x03, 0xa8, 0x03, 0x17, 0x00, 0x3a, 0x00, 0x41, 0x00, 0x00, 0x13, 0x34, 0x3e, 0x02,
-    0x33, 0x32, 0x1e, 0x02, 0x15, 0x23, 0x27, 0x34, 0x27, 0x2e, 0x01, 0x23, 0x22, 0x0e, 0x02, 0x15,
-    0x14, 0x16, 0x15, 0x1e, 0x05, 0x15, 0x14, 0x0e, 0x02, 0x23, 0x22, 0x2e, 0x02, 0x35, 0x33, 0x1e,
-    0x01, 0x33, 0x32, 0x3e, 0x02, 0x35, 0x34, 0x2e, 0x04, 0x35, 0x01, 0x11, 0x33, 0x11, 0x33, 0x15,
-    0x21, 0x50, 0x24, 0x3b, 0x4a, 0x27, 0x28, 0x4b, 0x39, 0x22, 0x73, 0x01, 0x01, 0x08, 0x2b, 0x29,
-    0x10, 0x20, 0x19, 0x0f, 0x01, 0x0b, 0x35, 0x41, 0x46, 0x3b, 0x25, 0x23, 0x3a, 0x4b, 0x27, 0x2b,
-    0x50, 0x3f, 0x26, 0x74, 0x05, 0x34, 0x33, 0x10, 0x20, 0x1a, 0x11, 0x2c, 0x42, 0x4d, 0x42, 0x2c,
-    0x01, 0xef, 0x73, 0xf6, 0xfe, 0x97, 0x02, 0x70, 0x2a, 0x3f, 0x2a, 0x14, 0x18, 0x2e, 0x44, 0x2c,
-    0x02, 0x03, 0x01, 0x27, 0x27, 0x07, 0x10, 0x1a, 0x12, 0x02, 0x0b, 0x02, 0x1f, 0x22, 0x19, 0x17,
-    0x27, 0x3f, 0x34, 0x2c, 0x3e, 0x28, 0x13, 0x1a, 0x32, 0x48, 0x2e, 0x30, 0x30, 0x06, 0x0f, 0x1a,
-    0x13, 0x21, 0x27, 0x1e, 0x1b, 0x29, 0x3e, 0x31, 0xfe, 0x4c, 0x02, 0x53, 0xfe, 0x10, 0x63, 0x00,
-    0x00, 0x03, 0x00, 0x17, 0x00, 0xb3, 0x03, 0xce, 0x03, 0x17, 0x00, 0x38, 0x00, 0x4f, 0x00, 0x5d,
-    0x00, 0x00, 0x13, 0x34, 0x3e, 0x02, 0x33, 0x32, 0x1e, 0x02, 0x15, 0x23, 0x27, 0x34, 0x23, 0x2e,
-    0x01, 0x23, 0x22, 0x0e, 0x02, 0x15, 0x14, 0x1e, 0x04, 0x15, 0x14, 0x0e, 0x02, 0x23, 0x22, 0x2e,
-    0x02, 0x35, 0x33, 0x1e, 0x01, 0x33, 0x32, 0x3e, 0x02, 0x35, 0x34, 0x26, 0x27, 0x2e, 0x03, 0x35,
-    0x01, 0x11, 0x33, 0x32, 0x1e, 0x02, 0x15, 0x14, 0x06, 0x07, 0x30, 0x0e, 0x02, 0x31, 0x17, 0x15,
-    0x23, 0x27, 0x23, 0x15, 0x23, 0x13, 0x33, 0x32, 0x3e, 0x02, 0x35, 0x34, 0x2e, 0x02, 0x2b, 0x01,
-    0x15, 0x2a, 0x24, 0x3a, 0x4a, 0x26, 0x29, 0x4b, 0x39, 0x23, 0x73, 0x01, 0x01, 0x08, 0x2a, 0x2a,
-    0x10, 0x1f, 0x1a, 0x10, 0x2c, 0x42, 0x4d, 0x42, 0x2c, 0x23, 0x39, 0x4b, 0x27, 0x2b, 0x51, 0x3f,
-    0x27, 0x75, 0x05, 0x34, 0x33, 0x10, 0x20, 0x1a, 0x10, 0x1f, 0x1c, 0x25, 0x53, 0x47, 0x2e, 0x01,
-    0xed, 0xf3, 0x27, 0x41, 0x2d, 0x19, 0x1c, 0x20, 0x0c, 0x0e, 0x0c, 0x78, 0x7d, 0x68, 0x5d, 0x75,
-    0x76, 0x71, 0x11, 0x1a, 0x12, 0x09, 0x0a, 0x14, 0x1d, 0x13, 0x69, 0x02, 0x71, 0x2a, 0x3e, 0x2a,
-    0x14, 0x18, 0x2e, 0x44, 0x2c, 0x02, 0x02, 0x27, 0x29, 0x07, 0x11, 0x1a, 0x12, 0x1d, 0x24, 0x1c,
-    0x1d, 0x2b, 0x40, 0x32, 0x2c, 0x3f, 0x29, 0x13, 0x1a, 0x31, 0x49, 0x2e, 0x30, 0x30, 0x06, 0x0f,
-    0x19, 0x13, 0x1e, 0x22, 0x0b, 0x0e, 0x20, 0x2f, 0x43, 0x30, 0xfe, 0x4b, 0x02, 0x52, 0x1d, 0x32,
-    0x42, 0x25, 0x2c, 0x42, 0x1d, 0x08, 0x0a, 0x08, 0xf1, 0x06, 0xd7, 0xd7, 0x01, 0x3f, 0x11, 0x19,
-    0x1f, 0x0e, 0x11, 0x20, 0x19, 0x0f, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12,
-    0x00, 0x12, 0x00, 0x32, 0x00, 0x72, 0x00, 0x8e, 0x00, 0xac, 0x00, 0xbe, 0x00, 0xf0, 0x01, 0x14,
-    0x01, 0x5c, 0x01, 0xb6, 0x02, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0xa2, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x02, 0x00, 0x07, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x2f,
-    0x00, 0x17, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x12, 0x00, 0x46, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x0d, 0x00, 0x58, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x06, 0x00, 0x12, 0x00, 0x65, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x01, 0x00, 0x20,
-    0x00, 0x77, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x02, 0x00, 0x0e, 0x00, 0x97, 0x00, 0x03,
-    0x00, 0x01, 0x04, 0x09, 0x00, 0x03, 0x00, 0x5e, 0x00, 0xa5, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09,
-    0x00, 0x04, 0x00, 0x24, 0x01, 0x03, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x05, 0x00, 0x1a,
-    0x01, 0x27, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x06, 0x00, 0x24, 0x01, 0x41, 0x00, 0x03,
-    0x00, 0x01, 0x04, 0x09, 0x00, 0x11, 0x00, 0x02, 0x01, 0x65, 0x59, 0x75, 0x7a, 0x75, 0x4f, 0x53,
-    0x53, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x67, 0x75, 0x6c, 0x61,
-    0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x31, 0x2e, 0x30, 0x30, 0x30, 0x3b, 0x3b,
-    0x59, 0x75, 0x7a, 0x75, 0x4f, 0x53, 0x53, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
-    0x2d, 0x52, 0x3b, 0x32, 0x30, 0x31, 0x39, 0x3b, 0x46, 0x4c, 0x56, 0x49, 0x2d, 0x36, 0x31, 0x34,
-    0x59, 0x75, 0x7a, 0x75, 0x4f, 0x53, 0x53, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
-    0x20, 0x52, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x31, 0x2e, 0x30, 0x30, 0x30, 0x59,
-    0x75, 0x7a, 0x75, 0x4f, 0x53, 0x53, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2d,
-    0x52, 0x00, 0x59, 0x00, 0x75, 0x00, 0x7a, 0x00, 0x75, 0x00, 0x4f, 0x00, 0x53, 0x00, 0x53, 0x00,
-    0x45, 0x00, 0x78, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00,
-    0x6e, 0x00, 0x52, 0x00, 0x65, 0x00, 0x67, 0x00, 0x75, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x72, 0x00,
-    0x56, 0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x20, 0x00,
-    0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x3b, 0x00, 0x3b, 0x00, 0x59, 0x00,
-    0x75, 0x00, 0x7a, 0x00, 0x75, 0x00, 0x4f, 0x00, 0x53, 0x00, 0x53, 0x00, 0x45, 0x00, 0x78, 0x00,
-    0x74, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x2d, 0x00,
-    0x52, 0x00, 0x3b, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x39, 0x00, 0x3b, 0x00, 0x46, 0x00,
-    0x4c, 0x00, 0x56, 0x00, 0x49, 0x00, 0x2d, 0x00, 0x36, 0x00, 0x31, 0x00, 0x34, 0x00, 0x59, 0x00,
-    0x75, 0x00, 0x7a, 0x00, 0x75, 0x00, 0x4f, 0x00, 0x53, 0x00, 0x53, 0x00, 0x45, 0x00, 0x78, 0x00,
-    0x74, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x20, 0x00,
-    0x52, 0x00, 0x56, 0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00,
-    0x20, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x59, 0x00, 0x75, 0x00,
-    0x7a, 0x00, 0x75, 0x00, 0x4f, 0x00, 0x53, 0x00, 0x53, 0x00, 0x45, 0x00, 0x78, 0x00, 0x74, 0x00,
-    0x65, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x2d, 0x00, 0x52, 0x00,
-    0x52, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x9c, 0x00, 0x32,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x01, 0x02, 0x01, 0x03, 0x00, 0x03, 0x01, 0x04,
-    0x01, 0x05, 0x01, 0x06, 0x01, 0x07, 0x01, 0x08, 0x01, 0x09, 0x01, 0x0a, 0x01, 0x0b, 0x01, 0x0c,
-    0x01, 0x0d, 0x07, 0x75, 0x6e, 0x69, 0x30, 0x30, 0x30, 0x30, 0x07, 0x75, 0x6e, 0x69, 0x30, 0x30,
-    0x30, 0x44, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30, 0x45, 0x30, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30,
-    0x45, 0x31, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30, 0x45, 0x32, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30,
-    0x45, 0x33, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30, 0x45, 0x34, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30,
-    0x45, 0x35, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30, 0x45, 0x36, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30,
-    0x45, 0x37, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30, 0x45, 0x38, 0x07, 0x75, 0x6e, 0x69, 0x45, 0x30,
-    0x45, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00,
-}};
-
-} // namespace FileSys::SystemArchive::SharedFontData
@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-namespace FileSys::SystemArchive::SharedFontData {
-
-extern const std::array<unsigned char, 2932> FONT_NINTENDO_EXTENDED;
-
-} // namespace FileSys::SystemArchive::SharedFontData
@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-namespace FileSys::SystemArchive::SharedFontData {
-
-extern const std::array<unsigned char, 217276> FONT_STANDARD;
-
-} // namespace FileSys::SystemArchive::SharedFontData
@@ -1,78 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/file_sys/system_archive/data/font_chinese_simplified.h"
-#include "core/file_sys/system_archive/data/font_chinese_traditional.h"
-#include "core/file_sys/system_archive/data/font_extended_chinese_simplified.h"
-#include "core/file_sys/system_archive/data/font_korean.h"
-#include "core/file_sys/system_archive/data/font_nintendo_extended.h"
-#include "core/file_sys/system_archive/data/font_standard.h"
-#include "core/file_sys/system_archive/shared_font.h"
-#include "core/file_sys/vfs_vector.h"
-#include "core/hle/service/ns/pl_u.h"
-
-namespace FileSys::SystemArchive {
-
-namespace {
-
-template <std::size_t Size>
-VirtualFile PackBFTTF(const std::array<u8, Size>& data, const std::string& name) {
-    std::vector<u32> vec(Size / sizeof(u32));
-    std::memcpy(vec.data(), data.data(), vec.size() * sizeof(u32));
-
-    std::vector<u8> bfttf(Size + sizeof(u64));
-
-    u64 offset = 0;
-    Service::NS::EncryptSharedFont(vec, bfttf, offset);
-    return std::make_shared<VectorVfsFile>(std::move(bfttf), name);
-}
-
-} // Anonymous namespace
-
-VirtualDir FontNintendoExtension() {
-    return std::make_shared<VectorVfsDirectory>(
-        std::vector<VirtualFile>{
-            PackBFTTF(SharedFontData::FONT_NINTENDO_EXTENDED, "nintendo_ext_003.bfttf"),
-            PackBFTTF(SharedFontData::FONT_NINTENDO_EXTENDED, "nintendo_ext2_003.bfttf"),
-        },
-        std::vector<VirtualDir>{});
-}
-
-VirtualDir FontStandard() {
-    return std::make_shared<VectorVfsDirectory>(
-        std::vector<VirtualFile>{
-            PackBFTTF(SharedFontData::FONT_STANDARD, "nintendo_udsg-r_std_003.bfttf"),
-        },
-        std::vector<VirtualDir>{});
-}
-
-VirtualDir FontKorean() {
-    return std::make_shared<VectorVfsDirectory>(
-        std::vector<VirtualFile>{
-            PackBFTTF(SharedFontData::FONT_KOREAN, "nintendo_udsg-r_ko_003.bfttf"),
-        },
-        std::vector<VirtualDir>{});
-}
-
-VirtualDir FontChineseTraditional() {
-    return std::make_shared<VectorVfsDirectory>(
-        std::vector<VirtualFile>{
-            PackBFTTF(SharedFontData::FONT_CHINESE_TRADITIONAL,
-                      "nintendo_udjxh-db_zh-tw_003.bfttf"),
-        },
-        std::vector<VirtualDir>{});
-}
-
-VirtualDir FontChineseSimple() {
-    return std::make_shared<VectorVfsDirectory>(
-        std::vector<VirtualFile>{
-            PackBFTTF(SharedFontData::FONT_CHINESE_SIMPLIFIED,
-                      "nintendo_udsg-r_org_zh-cn_003.bfttf"),
-            PackBFTTF(SharedFontData::FONT_EXTENDED_CHINESE_SIMPLIFIED,
-                      "nintendo_udsg-r_ext_zh-cn_003.bfttf"),
-        },
-        std::vector<VirtualDir>{});
-}
-
-} // namespace FileSys::SystemArchive
@@ -1,17 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/file_sys/vfs_types.h"
-
-namespace FileSys::SystemArchive {
-
-VirtualDir FontNintendoExtension();
-VirtualDir FontStandard();
-VirtualDir FontKorean();
-VirtualDir FontChineseTraditional();
-VirtualDir FontChineseSimple();
-
-} // namespace FileSys::SystemArchive
@@ -6,7 +6,6 @@
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/system_archive/mii_model.h"
 #include "core/file_sys/system_archive/ng_word.h"
-#include "core/file_sys/system_archive/shared_font.h"
 #include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/system_archive/system_version.h"

@@ -40,11 +39,11 @@ constexpr std::array<SystemArchiveDescriptor, SYSTEM_ARCHIVE_COUNT> SYSTEM_ARCHI
    {0x010000000000080D, "UrlBlackList", nullptr},
    {0x010000000000080E, "TimeZoneBinary", nullptr},
    {0x010000000000080F, "CertStoreCruiser", nullptr},
-    {0x0100000000000810, "FontNintendoExtension", &FontNintendoExtension},
-    {0x0100000000000811, "FontStandard", &FontStandard},
-    {0x0100000000000812, "FontKorean", &FontKorean},
-    {0x0100000000000813, "FontChineseTraditional", &FontChineseTraditional},
-    {0x0100000000000814, "FontChineseSimple", &FontChineseSimple},
+    {0x0100000000000810, "FontNintendoExtension", nullptr},
+    {0x0100000000000811, "FontStandard", nullptr},
+    {0x0100000000000812, "FontKorean", nullptr},
+    {0x0100000000000813, "FontChineseTraditional", nullptr},
+    {0x0100000000000814, "FontChineseSimple", nullptr},
    {0x0100000000000815, "FontBfcpx", nullptr},
    {0x0100000000000816, "SystemUpdate", nullptr},
    {0x0100000000000817, "0100000000000817", nullptr},
@@ -202,11 +202,13 @@ void RegisterModule(std::string name, VAddr beg, VAddr end, bool add_elf_ext) {
 }

 static Kernel::Thread* FindThreadById(s64 id) {
-    const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
-    for (auto& thread : threads) {
-        if (thread->GetThreadID() == static_cast<u64>(id)) {
-            current_core = thread->GetProcessorID();
-            return thread.get();
+    for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+        const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+        for (auto& thread : threads) {
+            if (thread->GetThreadID() == static_cast<u64>(id)) {
+                current_core = core;
+                return thread.get();
+            }
        }
    }
    return nullptr;
@@ -639,15 +641,16 @@ static void HandleQuery() {
                       strlen("Xfer:features:read:target.xml:")) == 0) {
        SendReply(target_xml);
    } else if (strncmp(query, "Offsets", strlen("Offsets")) == 0) {
-        const VAddr base_address =
-            Core::System::GetInstance().CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
+        const VAddr base_address = Core::CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
        std::string buffer = fmt::format("TextSeg={:0x}", base_address);
        SendReply(buffer.c_str());
    } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
        std::string val = "m";
-        const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
-        for (const auto& thread : threads) {
-            val += fmt::format("{:x},", thread->GetThreadID());
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+            for (const auto& thread : threads) {
+                val += fmt::format("{:x},", thread->GetThreadID());
+            }
        }
        val.pop_back();
        SendReply(val.c_str());
@@ -657,11 +660,13 @@ static void HandleQuery() {
        std::string buffer;
        buffer += "l<?xml version=\"1.0\"?>";
        buffer += "<threads>";
-        const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
-        for (const auto& thread : threads) {
-            buffer +=
-                fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
-                            thread->GetThreadID(), thread->GetProcessorID(), thread->GetThreadID());
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+            for (const auto& thread : threads) {
+                buffer +=
+                    fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
+                                thread->GetThreadID(), core, thread->GetThreadID());
+            }
        }
        buffer += "</threads>";
        SendReply(buffer.c_str());
@@ -160,7 +160,7 @@ struct DomainMessageHeader {
        // Used when responding to an IPC request, Server -> Client.
        struct {
            u32_le num_objects;
-            INSERT_UNION_PADDING_WORDS(3);
+            INSERT_PADDING_WORDS(3);
        };

        // Used when performing an IPC request, Client -> Server.
@@ -171,10 +171,8 @@ struct DomainMessageHeader {
                BitField<16, 16, u32> size;
            };
            u32_le object_id;
-            INSERT_UNION_PADDING_WORDS(2);
+            INSERT_PADDING_WORDS(2);
        };
-
-        std::array<u32, 4> raw{};
    };
 };
 static_assert(sizeof(DomainMessageHeader) == 16, "DomainMessageHeader size is incorrect");
@@ -22,7 +22,6 @@ namespace Kernel {
 namespace {
 // Wake up num_to_wake (or all) threads in a vector.
 void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
-    auto& system = Core::System::GetInstance();
    // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
    // them all.
    std::size_t last = waiting_threads.size();
@@ -36,7 +35,6 @@ void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_
        waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
        waiting_threads[i]->SetArbiterWaitAddress(0);
        waiting_threads[i]->ResumeFromWait();
-        system.PrepareReschedule(waiting_threads[i]->GetProcessorID());
    }
 }
 } // Anonymous namespace
@@ -91,20 +89,12 @@ ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr a

    // Determine the modified value depending on the waiting count.
    s32 updated_value;
-    if (num_to_wake <= 0) {
-        if (waiting_threads.empty()) {
-            updated_value = value + 1;
-        } else {
-            updated_value = value - 1;
-        }
+    if (waiting_threads.empty()) {
+        updated_value = value + 1;
+    } else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
+        updated_value = value - 1;
    } else {
-        if (waiting_threads.empty()) {
-            updated_value = value + 1;
-        } else if (waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
-            updated_value = value - 1;
-        } else {
-            updated_value = value;
-        }
+        updated_value = value;
    }

    if (static_cast<s32>(Memory::Read32(address)) != value) {
@@ -179,22 +169,30 @@ ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {

    current_thread->WakeAfterDelay(timeout);

-    system.PrepareReschedule(current_thread->GetProcessorID());
+    system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
    return RESULT_TIMEOUT;
 }

 std::vector<SharedPtr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) const {
+    const auto RetrieveWaitingThreads = [this](std::size_t core_index,
+                                               std::vector<SharedPtr<Thread>>& waiting_threads,
+                                               VAddr arb_addr) {
+        const auto& scheduler = system.Scheduler(core_index);
+        const auto& thread_list = scheduler.GetThreadList();
+
+        for (const auto& thread : thread_list) {
+            if (thread->GetArbiterWaitAddress() == arb_addr) {
+                waiting_threads.push_back(thread);
+            }
+        }
+    };

    // Retrieve all threads that are waiting for this address.
    std::vector<SharedPtr<Thread>> threads;
-    const auto& scheduler = system.GlobalScheduler();
-    const auto& thread_list = scheduler.GetThreadList();
-
-    for (const auto& thread : thread_list) {
-        if (thread->GetArbiterWaitAddress() == address) {
-            threads.push_back(thread);
-        }
-    }
+    RetrieveWaitingThreads(0, threads, address);
+    RetrieveWaitingThreads(1, threads, address);
+    RetrieveWaitingThreads(2, threads, address);
+    RetrieveWaitingThreads(3, threads, address);

    // Sort them by priority, such that the highest priority ones come first.
    std::sort(threads.begin(), threads.end(),
@@ -103,7 +103,7 @@ SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
    if (handle == CurrentThread) {
        return GetCurrentThread();
    } else if (handle == CurrentProcess) {
-        return Core::System::GetInstance().CurrentProcess();
+        return Core::CurrentProcess();
    }

    if (!IsValid(handle)) {
@@ -58,7 +58,8 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
    auto& kernel = Core::System::GetInstance().Kernel();
    if (!writable_event) {
        // Create event if not provided
-        const auto pair = WritableEvent::CreateEventPair(kernel, "HLE Pause Event: " + reason);
+        const auto pair = WritableEvent::CreateEventPair(kernel, ResetType::Automatic,
+                                                         "HLE Pause Event: " + reason);
        writable_event = pair.writable;
    }

@@ -12,15 +12,12 @@

 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/core_timing_util.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
@@ -61,8 +58,12 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
        if (thread->HasWakeupCallback()) {
            resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
        }
-    } else if (thread->GetStatus() == ThreadStatus::WaitMutex ||
-               thread->GetStatus() == ThreadStatus::WaitCondVar) {
+    }
+
+    if (thread->GetMutexWaitAddress() != 0 || thread->GetCondVarWaitAddress() != 0 ||
+        thread->GetWaitHandle() != 0) {
+        ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex ||
+               thread->GetStatus() == ThreadStatus::WaitCondVar);
        thread->SetMutexWaitAddress(0);
        thread->SetCondVarWaitAddress(0);
        thread->SetWaitHandle(0);
@@ -82,23 +83,18 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
    }

    if (resume) {
-        if (thread->GetStatus() == ThreadStatus::WaitCondVar ||
-            thread->GetStatus() == ThreadStatus::WaitArb) {
-            thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
-        }
        thread->ResumeFromWait();
    }
 }

 struct KernelCore::Impl {
-    explicit Impl(Core::System& system) : system{system}, global_scheduler{system} {}
+    explicit Impl(Core::System& system) : system{system} {}

    void Initialize(KernelCore& kernel) {
        Shutdown();

        InitializeSystemResourceLimit(kernel);
        InitializeThreads();
-        InitializePreemption();
    }

    void Shutdown() {
@@ -114,9 +110,6 @@ struct KernelCore::Impl {

        thread_wakeup_callback_handle_table.Clear();
        thread_wakeup_event_type = nullptr;
-        preemption_event = nullptr;
-
-        global_scheduler.Shutdown();

        named_ports.clear();
    }
@@ -139,18 +132,6 @@ struct KernelCore::Impl {
            system.CoreTiming().RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
    }

-    void InitializePreemption() {
-        preemption_event = system.CoreTiming().RegisterEvent(
-            "PreemptionCallback", [this](u64 userdata, s64 cycles_late) {
-                global_scheduler.PreemptThreads();
-                s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
-                system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
-            });
-
-        s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
-        system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
-    }
-
    std::atomic<u32> next_object_id{0};
    std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
    std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
@@ -159,12 +140,10 @@ struct KernelCore::Impl {
    // Lists all processes that exist in the current session.
    std::vector<SharedPtr<Process>> process_list;
    Process* current_process = nullptr;
-    Kernel::GlobalScheduler global_scheduler;

    SharedPtr<ResourceLimit> system_resource_limit;

    Core::Timing::EventType* thread_wakeup_event_type = nullptr;
-    Core::Timing::EventType* preemption_event = nullptr;
    // TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future,
    // allowing us to simply use a pool index or similar.
    Kernel::HandleTable thread_wakeup_callback_handle_table;
@@ -224,14 +203,6 @@ const std::vector<SharedPtr<Process>>& KernelCore::GetProcessList() const {
    return impl->process_list;
 }

-Kernel::GlobalScheduler& KernelCore::GlobalScheduler() {
-    return impl->global_scheduler;
-}
-
-const Kernel::GlobalScheduler& KernelCore::GlobalScheduler() const {
-    return impl->global_scheduler;
-}
-
 void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
    impl->named_ports.emplace(std::move(name), std::move(port));
 }
@@ -21,7 +21,6 @@ namespace Kernel {

 class AddressArbiter;
 class ClientPort;
-class GlobalScheduler;
 class HandleTable;
 class Process;
 class ResourceLimit;
@@ -76,12 +75,6 @@ public:
    /// Retrieves the list of processes.
    const std::vector<SharedPtr<Process>>& GetProcessList() const;

-    /// Gets the sole instance of the global scheduler
-    Kernel::GlobalScheduler& GlobalScheduler();
-
-    /// Gets the sole instance of the global scheduler
-    const Kernel::GlobalScheduler& GlobalScheduler() const;
-
    /// Adds a port to the named port table
    void AddNamedPort(std::string name, SharedPtr<ClientPort> port);

@@ -7,7 +7,6 @@

 #include "common/assert.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
@@ -79,7 +78,7 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
    // thread.
    ASSERT(requesting_thread == current_thread);

-    u32 addr_value = Memory::Read32(address);
+    const u32 addr_value = Memory::Read32(address);

    // If the mutex isn't being held, just return success.
    if (addr_value != (holding_thread_handle | Mutex::MutexHasWaitersFlag)) {
@@ -90,20 +89,6 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
        return ERR_INVALID_HANDLE;
    }

-    // This a workaround where an unknown bug writes the mutex value to give ownership to a cond var
-    // waiting thread.
-    if (holding_thread->GetStatus() == ThreadStatus::WaitCondVar) {
-        if (holding_thread->GetMutexWaitAddress() == address) {
-            Release(address, holding_thread.get());
-            addr_value = Memory::Read32(address);
-            if (addr_value == 0)
-                return RESULT_SUCCESS;
-            else {
-                holding_thread = handle_table.Get<Thread>(addr_value & Mutex::MutexOwnerMask);
-            }
-        }
-    }
-
    // Wait until the mutex is released
    current_thread->SetMutexWaitAddress(address);
    current_thread->SetWaitHandle(requesting_thread_handle);
@@ -119,13 +104,14 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
    return RESULT_SUCCESS;
 }

-ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
+ResultCode Mutex::Release(VAddr address) {
    // The mutex address must be 4-byte aligned
    if ((address % sizeof(u32)) != 0) {
        return ERR_INVALID_ADDRESS;
    }

-    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(holding_thread, address);
+    auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
+    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(current_thread, address);

    // There are no more threads waiting for the mutex, release it completely.
    if (thread == nullptr) {
@@ -134,7 +120,7 @@ ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
    }

    // Transfer the ownership of the mutex from the previous owner to the new one.
-    TransferMutexOwnership(address, holding_thread, thread);
+    TransferMutexOwnership(address, current_thread, thread);

    u32 mutex_value = thread->GetWaitHandle();

@@ -153,12 +139,6 @@ ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
    thread->SetCondVarWaitAddress(0);
    thread->SetMutexWaitAddress(0);
    thread->SetWaitHandle(0);
-    thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
-
-    if (thread->GetProcessorID() >= 0)
-        system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
-    if (holding_thread->GetProcessorID() >= 0)
-        system.CpuCore(holding_thread->GetProcessorID()).PrepareReschedule();

    return RESULT_SUCCESS;
 }
@@ -29,7 +29,7 @@ public:
                          Handle requesting_thread_handle);

    /// Releases the mutex at the specified address.
-    ResultCode Release(VAddr address, Thread* holding_thread);
+    ResultCode Release(VAddr address);

 private:
    Core::System& system;
@@ -32,6 +32,11 @@ enum class HandleType : u32 {
    ServerSession,
 };

+enum class ResetType {
+    Automatic, ///< Reset automatically on object acquisition
+    Manual,    ///< Never reset automatically
+};
+
 class Object : NonCopyable {
 public:
    explicit Object(KernelCore& kernel);
@@ -213,7 +213,10 @@ void Process::PrepareForTermination() {
        }
    };

-    stop_threads(system.GlobalScheduler().GetThreadList());
+    stop_threads(system.Scheduler(0).GetThreadList());
+    stop_threads(system.Scheduler(1).GetThreadList());
+    stop_threads(system.Scheduler(2).GetThreadList());
+    stop_threads(system.Scheduler(3).GetThreadList());

    FreeTLSRegion(tls_region_address);
    tls_region_address = 0;
@@ -20,13 +20,15 @@ bool ReadableEvent::ShouldWait(const Thread* thread) const {

 void ReadableEvent::Acquire(Thread* thread) {
    ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
+
+    if (reset_type == ResetType::Automatic) {
+        signaled = false;
+    }
 }

 void ReadableEvent::Signal() {
-    if (!signaled) {
-        signaled = true;
-        WakeupAllWaitingThreads();
-    };
+    signaled = true;
+    WakeupAllWaitingThreads();
 }

 void ReadableEvent::Clear() {
@@ -27,6 +27,10 @@ public:
        return name;
    }

+    ResetType GetResetType() const {
+        return reset_type;
+    }
+
    static constexpr HandleType HANDLE_TYPE = HandleType::ReadableEvent;
    HandleType GetHandleType() const override {
        return HANDLE_TYPE;
@@ -51,7 +55,8 @@ private:

    void Signal();

-    bool signaled{};
+    ResetType reset_type;
+    bool signaled;

    std::string name; ///< Name of event (optional)
 };
@@ -1,13 +1,8 @@
 // Copyright 2018 yuzu emulator team
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-//
-// SelectThreads, Yield functions originally by TuxSH.
-// licensed under GPLv2 or later under exception provided by the author.

 #include <algorithm>
-#include <set>
-#include <unordered_set>
 #include <utility>

 #include "common/assert.h"
@@ -22,374 +17,56 @@

 namespace Kernel {

-GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {}
+std::mutex Scheduler::scheduler_mutex;

-GlobalScheduler::~GlobalScheduler() = default;
+Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core)
+    : cpu_core{cpu_core}, system{system} {}

-void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
-    thread_list.push_back(std::move(thread));
-}
-
-void GlobalScheduler::RemoveThread(const Thread* thread) {
-    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
-                      thread_list.end());
-}
-
-void GlobalScheduler::UnloadThread(s32 core) {
-    Scheduler& sched = system.Scheduler(core);
-    sched.UnloadThread();
-}
-
-void GlobalScheduler::SelectThread(u32 core) {
-    const auto update_thread = [](Thread* thread, Scheduler& sched) {
-        if (thread != sched.selected_thread) {
-            if (thread == nullptr) {
-                ++sched.idle_selection_count;
-            }
-            sched.selected_thread = thread;
-        }
-        sched.is_context_switch_pending = sched.selected_thread != sched.current_thread;
-        std::atomic_thread_fence(std::memory_order_seq_cst);
-    };
-    Scheduler& sched = system.Scheduler(core);
-    Thread* current_thread = nullptr;
-    // Step 1: Get top thread in schedule queue.
-    current_thread = scheduled_queue[core].empty() ? nullptr : scheduled_queue[core].front();
-    if (current_thread) {
-        update_thread(current_thread, sched);
-        return;
-    }
-    // Step 2: Try selecting a suggested thread.
-    Thread* winner = nullptr;
-    std::set<s32> sug_cores;
-    for (auto thread : suggested_queue[core]) {
-        s32 this_core = thread->GetProcessorID();
-        Thread* thread_on_core = nullptr;
-        if (this_core >= 0) {
-            thread_on_core = scheduled_queue[this_core].front();
-        }
-        if (this_core < 0 || thread != thread_on_core) {
-            winner = thread;
-            break;
-        }
-        sug_cores.insert(this_core);
-    }
-    // if we got a suggested thread, select it, else do a second pass.
-    if (winner && winner->GetPriority() > 2) {
-        if (winner->IsRunning()) {
-            UnloadThread(winner->GetProcessorID());
-        }
-        TransferToCore(winner->GetPriority(), core, winner);
-        update_thread(winner, sched);
-        return;
-    }
-    // Step 3: Select a suggested thread from another core
-    for (auto& src_core : sug_cores) {
-        auto it = scheduled_queue[src_core].begin();
-        it++;
-        if (it != scheduled_queue[src_core].end()) {
-            Thread* thread_on_core = scheduled_queue[src_core].front();
-            Thread* to_change = *it;
-            if (thread_on_core->IsRunning() || to_change->IsRunning()) {
-                UnloadThread(src_core);
-            }
-            TransferToCore(thread_on_core->GetPriority(), core, thread_on_core);
-            current_thread = thread_on_core;
-            break;
-        }
-    }
-    update_thread(current_thread, sched);
-}
-
-bool GlobalScheduler::YieldThread(Thread* yielding_thread) {
-    // Note: caller should use critical section, etc.
-    const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
-    const u32 priority = yielding_thread->GetPriority();
-
-    // Yield the thread
-    const Thread* const winner = scheduled_queue[core_id].front(priority);
-    ASSERT_MSG(yielding_thread == winner, "Thread yielding without being in front");
-    scheduled_queue[core_id].yield(priority);
-
-    return AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-bool GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
-    // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
-    // etc.
-    const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
-    const u32 priority = yielding_thread->GetPriority();
-
-    // Yield the thread
-    ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority),
-               "Thread yielding without being in front");
-    scheduled_queue[core_id].yield(priority);
-
-    std::array<Thread*, NUM_CPU_CORES> current_threads;
-    for (u32 i = 0; i < NUM_CPU_CORES; i++) {
-        current_threads[i] = scheduled_queue[i].empty() ? nullptr : scheduled_queue[i].front();
-    }
-
-    Thread* next_thread = scheduled_queue[core_id].front(priority);
-    Thread* winner = nullptr;
-    for (auto& thread : suggested_queue[core_id]) {
-        const s32 source_core = thread->GetProcessorID();
-        if (source_core >= 0) {
-            if (current_threads[source_core] != nullptr) {
-                if (thread == current_threads[source_core] ||
-                    current_threads[source_core]->GetPriority() < min_regular_priority) {
-                    continue;
-                }
-            }
-        }
-        if (next_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks() ||
-            next_thread->GetPriority() < thread->GetPriority()) {
-            if (thread->GetPriority() <= priority) {
-                winner = thread;
-                break;
-            }
-        }
-    }
-
-    if (winner != nullptr) {
-        if (winner != yielding_thread) {
-            if (winner->IsRunning()) {
-                UnloadThread(winner->GetProcessorID());
-            }
-            TransferToCore(winner->GetPriority(), core_id, winner);
-        }
-    } else {
-        winner = next_thread;
-    }
-
-    return AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-bool GlobalScheduler::YieldThreadAndWaitForLoadBalancing(Thread* yielding_thread) {
-    // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
-    // etc.
-    Thread* winner = nullptr;
-    const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
-
-    // Remove the thread from its scheduled mlq, put it on the corresponding "suggested" one instead
-    TransferToCore(yielding_thread->GetPriority(), -1, yielding_thread);
-
-    // If the core is idle, perform load balancing, excluding the threads that have just used this
-    // function...
-    if (scheduled_queue[core_id].empty()) {
-        // Here, "current_threads" is calculated after the ""yield"", unlike yield -1
-        std::array<Thread*, NUM_CPU_CORES> current_threads;
-        for (u32 i = 0; i < NUM_CPU_CORES; i++) {
-            current_threads[i] = scheduled_queue[i].empty() ? nullptr : scheduled_queue[i].front();
-        }
-        for (auto& thread : suggested_queue[core_id]) {
-            const s32 source_core = thread->GetProcessorID();
-            if (source_core < 0 || thread == current_threads[source_core]) {
-                continue;
-            }
-            if (current_threads[source_core] == nullptr ||
-                current_threads[source_core]->GetPriority() >= min_regular_priority) {
-                winner = thread;
-            }
-            break;
-        }
-        if (winner != nullptr) {
-            if (winner != yielding_thread) {
-                if (winner->IsRunning()) {
-                    UnloadThread(winner->GetProcessorID());
-                }
-                TransferToCore(winner->GetPriority(), core_id, winner);
-            }
-        } else {
-            winner = yielding_thread;
-        }
-    }
-
-    return AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-void GlobalScheduler::PreemptThreads() {
-    for (std::size_t core_id = 0; core_id < NUM_CPU_CORES; core_id++) {
-        const u32 priority = preemption_priorities[core_id];
-
-        if (scheduled_queue[core_id].size(priority) > 0) {
-            scheduled_queue[core_id].front(priority)->IncrementYieldCount();
-            scheduled_queue[core_id].yield(priority);
-            if (scheduled_queue[core_id].size(priority) > 1) {
-                scheduled_queue[core_id].front(priority)->IncrementYieldCount();
-            }
-        }
-
-        Thread* current_thread =
-            scheduled_queue[core_id].empty() ? nullptr : scheduled_queue[core_id].front();
-        Thread* winner = nullptr;
-        for (auto& thread : suggested_queue[core_id]) {
-            const s32 source_core = thread->GetProcessorID();
-            if (thread->GetPriority() != priority) {
-                continue;
-            }
-            if (source_core >= 0) {
-                Thread* next_thread = scheduled_queue[source_core].empty()
-                                          ? nullptr
-                                          : scheduled_queue[source_core].front();
-                if (next_thread != nullptr && next_thread->GetPriority() < 2) {
-                    break;
-                }
-                if (next_thread == thread) {
-                    continue;
-                }
-            }
-            if (current_thread != nullptr &&
-                current_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks()) {
-                winner = thread;
-                break;
-            }
-        }
-
-        if (winner != nullptr) {
-            if (winner->IsRunning()) {
-                UnloadThread(winner->GetProcessorID());
-            }
-            TransferToCore(winner->GetPriority(), s32(core_id), winner);
-            current_thread =
-                winner->GetPriority() <= current_thread->GetPriority() ? winner : current_thread;
-        }
-
-        if (current_thread != nullptr && current_thread->GetPriority() > priority) {
-            for (auto& thread : suggested_queue[core_id]) {
-                const s32 source_core = thread->GetProcessorID();
-                if (thread->GetPriority() < priority) {
-                    continue;
-                }
-                if (source_core >= 0) {
-                    Thread* next_thread = scheduled_queue[source_core].empty()
-                                              ? nullptr
-                                              : scheduled_queue[source_core].front();
-                    if (next_thread != nullptr && next_thread->GetPriority() < 2) {
-                        break;
-                    }
-                    if (next_thread == thread) {
-                        continue;
-                    }
-                }
-                if (current_thread != nullptr &&
-                    current_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks()) {
-                    winner = thread;
-                    break;
-                }
-            }
-
-            if (winner != nullptr) {
-                if (winner->IsRunning()) {
-                    UnloadThread(winner->GetProcessorID());
-                }
-                TransferToCore(winner->GetPriority(), s32(core_id), winner);
-                current_thread = winner;
-            }
-        }
-
-        is_reselection_pending.store(true, std::memory_order_release);
+Scheduler::~Scheduler() {
+    for (auto& thread : thread_list) {
+        thread->Stop();
    }
 }

-void GlobalScheduler::Suggest(u32 priority, u32 core, Thread* thread) {
-    suggested_queue[core].add(thread, priority);
-}
-
-void GlobalScheduler::Unsuggest(u32 priority, u32 core, Thread* thread) {
-    suggested_queue[core].remove(thread, priority);
-}
-
-void GlobalScheduler::Schedule(u32 priority, u32 core, Thread* thread) {
-    ASSERT_MSG(thread->GetProcessorID() == s32(core), "Thread must be assigned to this core.");
-    scheduled_queue[core].add(thread, priority);
-}
-
-void GlobalScheduler::SchedulePrepend(u32 priority, u32 core, Thread* thread) {
-    ASSERT_MSG(thread->GetProcessorID() == s32(core), "Thread must be assigned to this core.");
-    scheduled_queue[core].add(thread, priority, false);
-}
-
-void GlobalScheduler::Reschedule(u32 priority, u32 core, Thread* thread) {
-    scheduled_queue[core].remove(thread, priority);
-    scheduled_queue[core].add(thread, priority);
-}
-
-void GlobalScheduler::Unschedule(u32 priority, u32 core, Thread* thread) {
-    scheduled_queue[core].remove(thread, priority);
-}
-
-void GlobalScheduler::TransferToCore(u32 priority, s32 destination_core, Thread* thread) {
-    const bool schedulable = thread->GetPriority() < THREADPRIO_COUNT;
-    const s32 source_core = thread->GetProcessorID();
-    if (source_core == destination_core || !schedulable) {
-        return;
-    }
-    thread->SetProcessorID(destination_core);
-    if (source_core >= 0) {
-        Unschedule(priority, source_core, thread);
-    }
-    if (destination_core >= 0) {
-        Unsuggest(priority, destination_core, thread);
-        Schedule(priority, destination_core, thread);
-    }
-    if (source_core >= 0) {
-        Suggest(priority, source_core, thread);
-    }
-}
-
-bool GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread,
-                                                       const Thread* winner) {
-    if (current_thread == winner) {
-        current_thread->IncrementYieldCount();
-        return true;
-    } else {
-        is_reselection_pending.store(true, std::memory_order_release);
-        return false;
-    }
-}
-
-void GlobalScheduler::Shutdown() {
-    for (std::size_t core = 0; core < NUM_CPU_CORES; core++) {
-        scheduled_queue[core].clear();
-        suggested_queue[core].clear();
-    }
-    thread_list.clear();
-}
-
-Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id)
-    : system(system), cpu_core(cpu_core), core_id(core_id) {}
-
-Scheduler::~Scheduler() = default;
-
 bool Scheduler::HaveReadyThreads() const {
-    return system.GlobalScheduler().HaveReadyThreads(core_id);
+    std::lock_guard lock{scheduler_mutex};
+    return !ready_queue.empty();
 }

 Thread* Scheduler::GetCurrentThread() const {
    return current_thread.get();
 }

-Thread* Scheduler::GetSelectedThread() const {
-    return selected_thread.get();
-}
-
-void Scheduler::SelectThreads() {
-    system.GlobalScheduler().SelectThread(core_id);
-}
-
 u64 Scheduler::GetLastContextSwitchTicks() const {
    return last_context_switch_time;
 }

-void Scheduler::TryDoContextSwitch() {
-    if (is_context_switch_pending) {
-        SwitchContext();
+Thread* Scheduler::PopNextReadyThread() {
+    Thread* next = nullptr;
+    Thread* thread = GetCurrentThread();
+
+    if (thread && thread->GetStatus() == ThreadStatus::Running) {
+        if (ready_queue.empty()) {
+            return thread;
+        }
+        // We have to do better than the current thread.
+        // This call returns null when that's not possible.
+        next = ready_queue.front();
+        if (next == nullptr || next->GetPriority() >= thread->GetPriority()) {
+            next = thread;
+        }
+    } else {
+        if (ready_queue.empty()) {
+            return nullptr;
+        }
+        next = ready_queue.front();
    }
+
+    return next;
 }

-void Scheduler::UnloadThread() {
-    Thread* const previous_thread = GetCurrentThread();
+void Scheduler::SwitchContext(Thread* new_thread) {
+    Thread* previous_thread = GetCurrentThread();
    Process* const previous_process = system.Kernel().CurrentProcess();

    UpdateLastContextSwitchTime(previous_thread, previous_process);
@@ -403,52 +80,23 @@ void Scheduler::UnloadThread() {
        if (previous_thread->GetStatus() == ThreadStatus::Running) {
            // This is only the case when a reschedule is triggered without the current thread
            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
+            ready_queue.add(previous_thread, previous_thread->GetPriority(), false);
            previous_thread->SetStatus(ThreadStatus::Ready);
        }
-        previous_thread->SetIsRunning(false);
-    }
-    current_thread = nullptr;
-}
-
-void Scheduler::SwitchContext() {
-    Thread* const previous_thread = GetCurrentThread();
-    Thread* const new_thread = GetSelectedThread();
-
-    is_context_switch_pending = false;
-    if (new_thread == previous_thread) {
-        return;
-    }
-
-    Process* const previous_process = system.Kernel().CurrentProcess();
-
-    UpdateLastContextSwitchTime(previous_thread, previous_process);
-
-    // Save context for previous thread
-    if (previous_thread) {
-        cpu_core.SaveContext(previous_thread->GetContext());
-        // Save the TPIDR_EL0 system register in case it was modified.
-        previous_thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());
-
-        if (previous_thread->GetStatus() == ThreadStatus::Running) {
-            // This is only the case when a reschedule is triggered without the current thread
-            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
-            previous_thread->SetStatus(ThreadStatus::Ready);
-        }
-        previous_thread->SetIsRunning(false);
    }

    // Load context of new thread
    if (new_thread) {
-        ASSERT_MSG(new_thread->GetProcessorID() == s32(this->core_id),
-                   "Thread must be assigned to this core.");
        ASSERT_MSG(new_thread->GetStatus() == ThreadStatus::Ready,
                   "Thread must be ready to become running.");

        // Cancel any outstanding wakeup events for this thread
        new_thread->CancelWakeupTimer();
+
        current_thread = new_thread;
+
+        ready_queue.remove(new_thread, new_thread->GetPriority());
        new_thread->SetStatus(ThreadStatus::Running);
-        new_thread->SetIsRunning(true);

        auto* const thread_owner_process = current_thread->GetOwnerProcess();
        if (previous_process != thread_owner_process) {
@@ -482,9 +130,124 @@ void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
    last_context_switch_time = most_recent_switch_ticks;
 }

-void Scheduler::Shutdown() {
-    current_thread = nullptr;
-    selected_thread = nullptr;
+void Scheduler::Reschedule() {
+    std::lock_guard lock{scheduler_mutex};
+
+    Thread* cur = GetCurrentThread();
+    Thread* next = PopNextReadyThread();
+
+    if (cur && next) {
+        LOG_TRACE(Kernel, "context switch {} -> {}", cur->GetObjectId(), next->GetObjectId());
+    } else if (cur) {
+        LOG_TRACE(Kernel, "context switch {} -> idle", cur->GetObjectId());
+    } else if (next) {
+        LOG_TRACE(Kernel, "context switch idle -> {}", next->GetObjectId());
+    }
+
+    SwitchContext(next);
+}
+
+void Scheduler::AddThread(SharedPtr<Thread> thread) {
+    std::lock_guard lock{scheduler_mutex};
+
+    thread_list.push_back(std::move(thread));
+}
+
+void Scheduler::RemoveThread(Thread* thread) {
+    std::lock_guard lock{scheduler_mutex};
+
+    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
+                      thread_list.end());
+}
+
+void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
+    std::lock_guard lock{scheduler_mutex};
+
+    ASSERT(thread->GetStatus() == ThreadStatus::Ready);
+    ready_queue.add(thread, priority);
+}
+
+void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
+    std::lock_guard lock{scheduler_mutex};
+
+    ASSERT(thread->GetStatus() == ThreadStatus::Ready);
+    ready_queue.remove(thread, priority);
+}
+
+void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
+    std::lock_guard lock{scheduler_mutex};
+    if (thread->GetPriority() == priority) {
+        return;
+    }
+
+    // If thread was ready, adjust queues
+    if (thread->GetStatus() == ThreadStatus::Ready)
+        ready_queue.adjust(thread, thread->GetPriority(), priority);
+}
+
+Thread* Scheduler::GetNextSuggestedThread(u32 core, u32 maximum_priority) const {
+    std::lock_guard lock{scheduler_mutex};
+
+    const u32 mask = 1U << core;
+    for (auto* thread : ready_queue) {
+        if ((thread->GetAffinityMask() & mask) != 0 && thread->GetPriority() < maximum_priority) {
+            return thread;
+        }
+    }
+    return nullptr;
+}
+
+void Scheduler::YieldWithoutLoadBalancing(Thread* thread) {
+    ASSERT(thread != nullptr);
+    // Avoid yielding if the thread isn't even running.
+    ASSERT(thread->GetStatus() == ThreadStatus::Running);
+
+    // Sanity check that the priority is valid
+    ASSERT(thread->GetPriority() < THREADPRIO_COUNT);
+
+    // Yield this thread -- sleep for zero time and force reschedule to different thread
+    GetCurrentThread()->Sleep(0);
+}
+
+void Scheduler::YieldWithLoadBalancing(Thread* thread) {
+    ASSERT(thread != nullptr);
+    const auto priority = thread->GetPriority();
+    const auto core = static_cast<u32>(thread->GetProcessorID());
+
+    // Avoid yielding if the thread isn't even running.
+    ASSERT(thread->GetStatus() == ThreadStatus::Running);
+
+    // Sanity check that the priority is valid
+    ASSERT(priority < THREADPRIO_COUNT);
+
+    // Sleep for zero time to be able to force reschedule to different thread
+    GetCurrentThread()->Sleep(0);
+
+    Thread* suggested_thread = nullptr;
+
+    // Search through all of the cpu cores (except this one) for a suggested thread.
+    // Take the first non-nullptr one
+    for (unsigned cur_core = 0; cur_core < Core::NUM_CPU_CORES; ++cur_core) {
+        const auto res =
+            system.CpuCore(cur_core).Scheduler().GetNextSuggestedThread(core, priority);
+
+        // If scheduler provides a suggested thread
+        if (res != nullptr) {
+            // And its better than the current suggested thread (or is the first valid one)
+            if (suggested_thread == nullptr ||
+                suggested_thread->GetPriority() > res->GetPriority()) {
+                suggested_thread = res;
+            }
+        }
+    }
+
+    // If a suggested thread was found, queue that for this core
+    if (suggested_thread != nullptr)
+        suggested_thread->ChangeCore(core, suggested_thread->GetAffinityMask());
+}
+
+void Scheduler::YieldAndWaitForLoadBalancing(Thread* thread) {
+    UNIMPLEMENTED_MSG("Wait for load balancing thread yield type is not implemented!");
 }

 } // namespace Kernel
@@ -20,185 +20,124 @@ namespace Kernel {

 class Process;

-class GlobalScheduler final {
-public:
-    static constexpr u32 NUM_CPU_CORES = 4;
-
-    explicit GlobalScheduler(Core::System& system);
-    ~GlobalScheduler();
-
-    /// Adds a new thread to the scheduler
-    void AddThread(SharedPtr<Thread> thread);
-
-    /// Removes a thread from the scheduler
-    void RemoveThread(const Thread* thread);
-
-    /// Returns a list of all threads managed by the scheduler
-    const std::vector<SharedPtr<Thread>>& GetThreadList() const {
-        return thread_list;
-    }
-
-    /**
-     * Add a thread to the suggested queue of a cpu core. Suggested threads may be
-     * picked if no thread is scheduled to run on the core.
-     */
-    void Suggest(u32 priority, u32 core, Thread* thread);
-
-    /**
-     * Remove a thread to the suggested queue of a cpu core. Suggested threads may be
-     * picked if no thread is scheduled to run on the core.
-     */
-    void Unsuggest(u32 priority, u32 core, Thread* thread);
-
-    /**
-     * Add a thread to the scheduling queue of a cpu core. The thread is added at the
-     * back the queue in its priority level.
-     */
-    void Schedule(u32 priority, u32 core, Thread* thread);
-
-    /**
-     * Add a thread to the scheduling queue of a cpu core. The thread is added at the
-     * front the queue in its priority level.
-     */
-    void SchedulePrepend(u32 priority, u32 core, Thread* thread);
-
-    /// Reschedule an already scheduled thread based on a new priority
-    void Reschedule(u32 priority, u32 core, Thread* thread);
-
-    /// Unschedules a thread.
-    void Unschedule(u32 priority, u32 core, Thread* thread);
-
-    /**
-     * Transfers a thread into an specific core. If the destination_core is -1
-     * it will be unscheduled from its source code and added into its suggested
-     * queue.
-     */
-    void TransferToCore(u32 priority, s32 destination_core, Thread* thread);
-
-    /// Selects a core and forces it to unload its current thread's context
-    void UnloadThread(s32 core);
-
-    /**
-     * Takes care of selecting the new scheduled thread in three steps:
-     *
-     * 1. First a thread is selected from the top of the priority queue. If no thread
-     *    is obtained then we move to step two, else we are done.
-     *
-     * 2. Second we try to get a suggested thread that's not assigned to any core or
-     *    that is not the top thread in that core.
-     *
-     * 3. Third is no suggested thread is found, we do a second pass and pick a running
-     *    thread in another core and swap it with its current thread.
-     */
-    void SelectThread(u32 core);
-
-    bool HaveReadyThreads(u32 core_id) const {
-        return !scheduled_queue[core_id].empty();
-    }
-
-    /**
-     * Takes a thread and moves it to the back of the it's priority list.
-     *
-     * @note This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    bool YieldThread(Thread* thread);
-
-    /**
-     * Takes a thread and moves it to the back of the it's priority list.
-     * Afterwards, tries to pick a suggested thread from the suggested queue that has worse time or
-     * a better priority than the next thread in the core.
-     *
-     * @note This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    bool YieldThreadAndBalanceLoad(Thread* thread);
-
-    /**
-     * Takes a thread and moves it out of the scheduling queue.
-     * and into the suggested queue. If no thread can be scheduled afterwards in that core,
-     * a suggested thread is obtained instead.
-     *
-     * @note This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    bool YieldThreadAndWaitForLoadBalancing(Thread* thread);
-
-    /**
-     * Rotates the scheduling queues of threads at a preemption priority and then does
-     * some core rebalancing. Preemption priorities can be found in the array
-     * 'preemption_priorities'.
-     *
-     * @note This operation happens every 10ms.
-     */
-    void PreemptThreads();
-
-    u32 CpuCoresCount() const {
-        return NUM_CPU_CORES;
-    }
-
-    void SetReselectionPending() {
-        is_reselection_pending.store(true, std::memory_order_release);
-    }
-
-    bool IsReselectionPending() const {
-        return is_reselection_pending.load(std::memory_order_acquire);
-    }
-
-    void Shutdown();
-
-private:
-    bool AskForReselectionOrMarkRedundant(Thread* current_thread, const Thread* winner);
-
-    static constexpr u32 min_regular_priority = 2;
-    std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> scheduled_queue;
-    std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> suggested_queue;
-    std::atomic<bool> is_reselection_pending{false};
-
-    // The priority levels at which the global scheduler preempts threads every 10 ms. They are
-    // ordered from Core 0 to Core 3.
-    std::array<u32, NUM_CPU_CORES> preemption_priorities = {59, 59, 59, 62};
-
-    /// Lists all thread ids that aren't deleted/etc.
-    std::vector<SharedPtr<Thread>> thread_list;
-    Core::System& system;
-};
-
 class Scheduler final {
 public:
-    explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id);
+    explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core);
    ~Scheduler();

    /// Returns whether there are any threads that are ready to run.
    bool HaveReadyThreads() const;

    /// Reschedules to the next available thread (call after current thread is suspended)
-    void TryDoContextSwitch();
-
-    /// Unloads currently running thread
-    void UnloadThread();
-
-    /// Select the threads in top of the scheduling multilist.
-    void SelectThreads();
+    void Reschedule();

    /// Gets the current running thread
    Thread* GetCurrentThread() const;

-    /// Gets the currently selected thread from the top of the multilevel queue
-    Thread* GetSelectedThread() const;
-
    /// Gets the timestamp for the last context switch in ticks.
    u64 GetLastContextSwitchTicks() const;

-    bool ContextSwitchPending() const {
-        return is_context_switch_pending;
+    /// Adds a new thread to the scheduler
+    void AddThread(SharedPtr<Thread> thread);
+
+    /// Removes a thread from the scheduler
+    void RemoveThread(Thread* thread);
+
+    /// Schedules a thread that has become "ready"
+    void ScheduleThread(Thread* thread, u32 priority);
+
+    /// Unschedules a thread that was already scheduled
+    void UnscheduleThread(Thread* thread, u32 priority);
+
+    /// Sets the priority of a thread in the scheduler
+    void SetThreadPriority(Thread* thread, u32 priority);
+
+    /// Gets the next suggested thread for load balancing
+    Thread* GetNextSuggestedThread(u32 core, u32 minimum_priority) const;
+
+    /**
+     * YieldWithoutLoadBalancing -- analogous to normal yield on a system
+     * Moves the thread to the end of the ready queue for its priority, and then reschedules the
+     * system to the new head of the queue.
+     *
+     * Example (Single Core -- but can be extrapolated to multi):
+     * ready_queue[prio=0]: ThreadA, ThreadB, ThreadC (->exec order->)
+     * Currently Running: ThreadR
+     *
+     * ThreadR calls YieldWithoutLoadBalancing
+     *
+     * ThreadR is moved to the end of ready_queue[prio=0]:
+     * ready_queue[prio=0]: ThreadA, ThreadB, ThreadC, ThreadR (->exec order->)
+     * Currently Running: Nothing
+     *
+     * System is rescheduled (ThreadA is popped off of queue):
+     * ready_queue[prio=0]: ThreadB, ThreadC, ThreadR (->exec order->)
+     * Currently Running: ThreadA
+     *
+     * If the queue is empty at time of call, no yielding occurs. This does not cross between cores
+     * or priorities at all.
+     */
+    void YieldWithoutLoadBalancing(Thread* thread);
+
+    /**
+     * YieldWithLoadBalancing -- yield but with better selection of the new running thread
+     * Moves the current thread to the end of the ready queue for its priority, then selects a
+     * 'suggested thread' (a thread on a different core that could run on this core) from the
+     * scheduler, changes its core, and reschedules the current core to that thread.
+     *
+     * Example (Dual Core -- can be extrapolated to Quad Core, this is just normal yield if it were
+     * single core):
+     * ready_queue[core=0][prio=0]: ThreadA, ThreadB (affinities not pictured as irrelevant
+     * ready_queue[core=1][prio=0]: ThreadC[affinity=both], ThreadD[affinity=core1only]
+     * Currently Running: ThreadQ on Core 0 || ThreadP on Core 1
+     *
+     * ThreadQ calls YieldWithLoadBalancing
+     *
+     * ThreadQ is moved to the end of ready_queue[core=0][prio=0]:
+     * ready_queue[core=0][prio=0]: ThreadA, ThreadB
+     * ready_queue[core=1][prio=0]: ThreadC[affinity=both], ThreadD[affinity=core1only]
+     * Currently Running: ThreadQ on Core 0 || ThreadP on Core 1
+     *
+     * A list of suggested threads for each core is compiled
+     * Suggested Threads: {ThreadC on Core 1}
+     * If this were quad core (as the switch is), there could be between 0 and 3 threads in this
+     * list. If there are more than one, the thread is selected by highest prio.
+     *
+     * ThreadC is core changed to Core 0:
+     * ready_queue[core=0][prio=0]: ThreadC, ThreadA, ThreadB, ThreadQ
+     * ready_queue[core=1][prio=0]: ThreadD
+     * Currently Running: None on Core 0 || ThreadP on Core 1
+     *
+     * System is rescheduled (ThreadC is popped off of queue):
+     * ready_queue[core=0][prio=0]: ThreadA, ThreadB, ThreadQ
+     * ready_queue[core=1][prio=0]: ThreadD
+     * Currently Running: ThreadC on Core 0 || ThreadP on Core 1
+     *
+     * If no suggested threads can be found this will behave just as normal yield. If there are
+     * multiple candidates for the suggested thread on a core, the highest prio is taken.
+     */
+    void YieldWithLoadBalancing(Thread* thread);
+
+    /// Currently unknown -- asserts as unimplemented on call
+    void YieldAndWaitForLoadBalancing(Thread* thread);
+
+    /// Returns a list of all threads managed by the scheduler
+    const std::vector<SharedPtr<Thread>>& GetThreadList() const {
+        return thread_list;
    }

-    /// Shutdowns the scheduler.
-    void Shutdown();
-
 private:
-    friend class GlobalScheduler;
+    /**
+     * Pops and returns the next thread from the thread queue
+     * @return A pointer to the next ready thread
+     */
+    Thread* PopNextReadyThread();

-    /// Switches the CPU's active thread context to that of the specified thread
-    void SwitchContext();
+    /**
+     * Switches the CPU's active thread context to that of the specified thread
+     * @param new_thread The thread to switch to
+     */
+    void SwitchContext(Thread* new_thread);

    /**
     * Called on every context switch to update the internal timestamp
@@ -213,16 +152,19 @@ private:
     */
    void UpdateLastContextSwitchTime(Thread* thread, Process* process);

+    /// Lists all thread ids that aren't deleted/etc.
+    std::vector<SharedPtr<Thread>> thread_list;
+
+    /// Lists only ready thread ids.
+    Common::MultiLevelQueue<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
+
    SharedPtr<Thread> current_thread = nullptr;
-    SharedPtr<Thread> selected_thread = nullptr;

-    Core::System& system;
    Core::ARM_Interface& cpu_core;
    u64 last_context_switch_time = 0;
-    u64 idle_selection_count = 0;
-    const u32 core_id;

-    bool is_context_switch_pending = false;
+    Core::System& system;
+    static std::mutex scheduler_mutex;
 };

 } // namespace Kernel
Author	SHA1	Message	Date
yuzubot	b3d1bbd53e	"Merge Tagged PR 1012"	2019-10-05 23:47:35 +00:00
yuzubot	bd0ae09466	"Merge Tagged PR 1340"	2019-10-05 23:47:34 +00:00
yuzubot	6f295e0863	"Merge Tagged PR 1703"	2019-10-05 23:47:33 +00:00
yuzubot	54d4b0e3b7	"Merge Tagged PR 2542"	2019-10-05 23:47:32 +00:00
yuzubot	7d6292c134	"Merge Tagged PR 2710"	2019-10-05 23:47:32 +00:00
yuzubot	f31ef338ca	"Merge Tagged PR 2859"	2019-10-05 23:47:31 +00:00
yuzubot	561cbba9f4	"Merge Tagged PR 2912"	2019-10-05 23:47:30 +00:00
yuzubot	6db63df4c8	"Merge Tagged PR 2914"	2019-10-05 23:47:29 +00:00
yuzubot	656b8f64b8	"Merge Tagged PR 2927"	2019-10-05 23:47:28 +00:00