"Merge PR 1340"

2019-09-15 14:39:23 +00:00
319 changed files with 3181 additions and 12852 deletions
@@ -5,11 +5,10 @@ cd /yuzu
 ccache -s

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
+cmake .. -G Ninja -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON

 ninja

 ccache -s

-# Ignore zlib's tests, since they aren't gated behind a CMake option.
-ctest -VV -E "(example|example64)" -C Release
+ctest -VV -C Release
@@ -2,4 +2,4 @@

 mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/linux/docker.sh
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh $1
+docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh
@@ -1,45 +0,0 @@
-# Download all pull requests as patches that match a specific label
-# Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>
-
-import requests, sys, json, shutil, subprocess, os, traceback
-
-org = os.getenv("PRIVATEMERGEORG", "yuzu-emu")
-repo = os.getenv("PRIVATEMERGEREPO", "yuzu-private")
-tagline = sys.argv[3]
-user = sys.argv[1]
-
-dl_list = {}
-
-TAG_NAME = sys.argv[2]
-
-def check_individual(repo_id, pr_id):
-    url = 'https://%sdev.azure.com/%s/%s/_apis/git/repositories/%s/pullRequests/%s/labels?api-version=5.1-preview.1' % (user, org, repo, repo_id, pr_id)
-    response = requests.get(url)
-    if (response.ok):
-        try:
-            js = response.json()
-            return any(tag.get('name') == TAG_NAME for tag in js['value'])
-        except:
-            return False
-    return False
-
-def merge_pr(pn, ref):
-    print("Matched PR# %s" % pn)
-    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f"]))
-    print(subprocess.check_output(["git", "merge", "--squash", 'origin/' + ref.replace('refs/heads/','')]))
-    print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
-
-def main():
-    url = 'https://%sdev.azure.com/%s/%s/_apis/git/pullrequests?api-version=5.1' % (user, org, repo)
-    response = requests.get(url)
-    if (response.ok):
-        js = response.json()
-        tagged_prs = filter(lambda pr: check_individual(pr['repository']['id'], pr['pullRequestId']), js['value'])
-        map(lambda pr: merge_pr(pr['pullRequestId'], pr['sourceRefName']), tagged_prs)
-
-if __name__ == '__main__':
-    try:
-        main()
-    except:
-        traceback.print_exc(file=sys.stdout)
-        sys.exit(-1)
@@ -1,9 +1,7 @@
 # Download all pull requests as patches that match a specific label
 # Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>

-import requests, sys, json, urllib3.request, shutil, subprocess, os
-
-tagline = sys.argv[2]
+import requests, sys, json, urllib3.request, shutil, subprocess

 http = urllib3.PoolManager()
 dl_list = {}
@@ -14,23 +12,17 @@ def check_individual(labels):
            return True
    return False

-def do_page(page):
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls?page=%s' % page
+try:
+    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls'
    response = requests.get(url)
    if (response.ok):
        j = json.loads(response.content)
-        if j == []:
-            return
        for pr in j:
            if (check_individual(pr["labels"])):
                pn = pr["number"]
                print("Matched PR# %s" % pn)
                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f"]))
                print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
-                print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
-
-try:
-    for i in range(1,30):
-        do_page(i)
+                print(subprocess.check_output(["git", "commit", "-m\"Merge PR %s\"" % pn]))
 except:
    sys.exit(-1)
@@ -13,7 +13,7 @@ echo '' >> /bin/cmd
 chmod +x /bin/cmd

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja

 # Clean up the dirty hacks
@@ -2,4 +2,4 @@

 mkdir -p "ccache" || true
 chmod a+x ./.ci/scripts/windows/docker.sh
-docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh $1
+docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh
@@ -1,38 +0,0 @@
-$GITDATE = $(git show -s --date=short --format='%ad') -replace "-",""
-$GITREV = $(git show -s --format='%h')
-$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
-$env:BUILD_UPDATE = $MSVC_SEVENZIP
-
-$BUILD_DIR = ".\build\bin\Release"
-
-mkdir pdb
-Get-ChildItem "$BUILD_DIR\" -Recurse -Filter "*.pdb" | Copy-Item -destination .\pdb
-7z a -tzip $MSVC_BUILD_PDB .\pdb\*.pdb
-rm "$BUILD_DIR\*.pdb"
-mkdir $RELEASE_DIST
-mkdir "artifacts"
-
-Copy-Item "$BUILD_DIR\*" -Destination $RELEASE_DIST -Recurse
-rm "$RELEASE_DIST\*.exe"
-Get-ChildItem "$BUILD_DIR" -Recurse -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
-Get-ChildItem "$BUILD_DIR" -Recurse -Filter "QtWebEngineProcess*.exe" | Copy-Item -destination $RELEASE_DIST
-Copy-Item .\license.txt -Destination $RELEASE_DIST
-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"
@@ -1,5 +0,0 @@
-steps:
-  - script: mkdir artifacts || echo 'X' > artifacts/T1.txt
-  - publish: artifacts
-    artifact: 'yuzu-$(BuildName)-mock'
-    displayName: 'Upload Artifacts'
@@ -1,22 +0,0 @@
-parameters:
-  artifactSource: 'true'
-  cache: 'false'
-  version: ''
-
-steps:
- script: mkdir build && cd build && cmake -G "Visual Studio 15 2017 Win64" --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
-  displayName: 'Configure CMake'
- task: MSBuild@1
-  displayName: 'Build'
-  inputs:
-    solution: 'build/yuzu.sln'
-    maximumCpuCount: true
-    configuration: release
- task: PowerShell@2
-  displayName: 'Package Artifacts'
-  inputs:
-    targetType: 'filePath'
-    filePath: './.ci/scripts/windows/upload.ps1'
- publish: artifacts
-  artifact: 'yuzu-$(BuildName)-windows-msvc'
-  displayName: 'Upload Artifacts'
@@ -1,20 +1,20 @@
 parameters:
  artifactSource: 'true'
  cache: 'false'
-  version: ''

 steps:
 - task: DockerInstaller@0
  displayName: 'Prepare Environment'
  inputs:
    dockerVersion: '17.09.0-ce'
- task: CacheBeta@0
-  displayName: 'Cache Build System'
-  inputs:
-    key: yuzu-v1-$(BuildName)-$(BuildSuffix)-$(CacheSuffix)
-    path: $(System.DefaultWorkingDirectory)/ccache
-    cacheHitVar: CACHE_RESTORED
- script: chmod a+x ./.ci/scripts/$(ScriptFolder)/exec.sh && ./.ci/scripts/$(ScriptFolder)/exec.sh ${{ parameters['version'] }}
+- ${{ if eq(parameters.cache, 'true') }}:
+  - task: CacheBeta@0
+    displayName: 'Cache Build System'
+    inputs:
+      key: yuzu-v1-$(BuildName)-$(BuildSuffix)-$(CacheSuffix)
+      path: $(System.DefaultWorkingDirectory)/ccache
+      cacheHitVar: CACHE_RESTORED
+- script: chmod a+x ./.ci/scripts/$(ScriptFolder)/exec.sh && ./.ci/scripts/$(ScriptFolder)/exec.sh
  displayName: 'Build'
 - script: chmod a+x ./.ci/scripts/$(ScriptFolder)/upload.sh && RELEASE_NAME=$(BuildName) ./.ci/scripts/$(ScriptFolder)/upload.sh
  displayName: 'Package Artifacts'
@@ -1,6 +1,3 @@
-parameters:
-  version: ''
-
 jobs:
 - job: build
  displayName: 'standard'
@@ -23,5 +20,4 @@ jobs:
  - template: ./build-single.yml
    parameters:
      artifactSource: 'false'
-      cache: $(parameters.cache)
-      version: $(parameters.version)
+      cache: $(parameters.cache)
@@ -1,6 +1,3 @@
-parameters:
-  version: ''
-
 jobs:
 - job: build_test
  displayName: 'testing'
@@ -34,4 +31,3 @@ jobs:
      parameters:
        artifactSource: 'false'
        cache: 'false'
-        version: $(parameters.version)
@@ -1,37 +0,0 @@
-jobs:
- job: merge
-  displayName: 'pull requests'
-  steps:
-  - checkout: self
-    submodules: recursive
-  - template: ./mergebot-private.yml
-    parameters:
-      matchLabel: '$(BuildName)-merge'
-      matchLabelPublic: '$(PublicBuildName)-merge'
-  - task: ArchiveFiles@2
-    displayName: 'Package Source'
-    inputs:
-      rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
-      includeRootFolder: false
-      archiveType: '7z'
-      archiveFile: '$(Build.ArtifactStagingDirectory)/yuzu-$(BuildName)-source.7z'
-  - task: PublishPipelineArtifact@1
-    displayName: 'Upload Artifacts'
-    inputs:
-      targetPath: '$(Build.ArtifactStagingDirectory)/yuzu-$(BuildName)-source.7z'
-      artifact: 'yuzu-$(BuildName)-source'
-      replaceExistingArchive: true
- job: upload_source
-  displayName: 'upload'
-  dependsOn: merge
-  steps:
-  - template: ./sync-source.yml
-    parameters:
-      artifactSource: 'true'
-      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 remote add other $(GitRepoPushChangesURL)
-    displayName: 'Register Repository'
-  - script: git push --force other HEAD:$(GitPushBranch)
-    displayName: 'Update Code'
@@ -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,30 +0,0 @@
-parameters:
-  matchLabel: 'dummy-merge'
-  matchLabelPublic: 'dummy-merge'
-
-steps:
-  - script: mkdir $(System.DefaultWorkingDirectory)/patches && pip install requests urllib3
-    displayName: 'Prepare Environment'
-  - 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'
-  - task: PythonScript@0
-    displayName: 'Discover, Download, and Apply Patches (Mainline)'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
-      arguments: '${{ parameters.matchLabelPublic }} $(MergeTaglinePublic) patches-public'
-      workingDirectory: '$(System.DefaultWorkingDirectory)'
-  - task: PythonScript@0
-    displayName: 'Discover, Download, and Apply Patches (Patreon Public)'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
-      arguments: '${{ parameters.matchLabel }} "$(MergeTaglinePrivate) Public" patches-mixed-public'
-      workingDirectory: '$(System.DefaultWorkingDirectory)'
-  - task: PythonScript@0
-    displayName: 'Discover, Download, and Apply Patches (Patreon Private)'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '.ci/scripts/merge/apply-patches-by-label-private.py'
-      arguments: '$(PrivateMergeUser) ${{ parameters.matchLabel }} "$(MergeTaglinePrivate) Private" patches-private'
-      workingDirectory: '$(System.DefaultWorkingDirectory)'
@@ -11,5 +11,5 @@ steps:
    inputs:
      scriptSource: 'filePath'
      scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
-      arguments: '${{ parameters.matchLabel }} Tagged patches'
+      arguments: '${{ parameters.matchLabel }} patches'
      workingDirectory: '$(System.DefaultWorkingDirectory)'
@@ -1,13 +0,0 @@
-steps:
-  - task: DownloadPipelineArtifact@2
-    displayName: 'Download Windows Release'
-    inputs:
-      artifactName: 'yuzu-$(BuildName)-windows-msvc'
-      buildType: 'current'
-      targetPath: '$(Build.ArtifactStagingDirectory)'
-  - task: DownloadPipelineArtifact@2
-    displayName: 'Download Linux Release'
-    inputs:
-      artifactName: 'yuzu-$(BuildName)-linux'
-      buildType: 'current'
-      targetPath: '$(Build.ArtifactStagingDirectory)'
@@ -1,13 +0,0 @@
-steps:
-  - template: ./release-download.yml
-  - task: GitHubRelease@0
-    displayName: 'GitHub Release'
-    inputs:
-      action: 'create'
-      title: '$(ReleasePrefix) $(DisplayVersion)'
-      assets: '$(Build.ArtifactStagingDirectory)/*'
-      gitHubConnection: $(GitHubReleaseConnectionName)
-      repositoryName: '$(Build.Repository.Name)'
-      target: '$(Build.SourceVersion)'
-      tagSource: manual
-      tag: $(BuildName)-$(DisplayPrefix)-$(DisplayVersion)
@@ -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'
@@ -1,10 +0,0 @@
-steps:
-  - template: ./release-download.yml
-  - task: UniversalPackages@0
-    displayName: Publish Artifacts
-    inputs:
-      command: publish
-      publishDirectory: '$(Build.ArtifactStagingDirectory)'
-      vstsFeedPublish: 'yuzu-$(BuildName)'
-      vstsFeedPackagePublish: 'main'
-      packagePublishDescription: 'Yuzu Windows and Linux Executable Packages'
@@ -1,8 +0,0 @@
-trigger:
- master
-
-stages:
- stage: merge
-  displayName: 'merge'
-  jobs:
-  - template: ./templates/merge.yml
@@ -1,68 +0,0 @@
-trigger:
- master
-
-variables:
-  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]
-
-stages:
- stage: format
-  displayName: 'format'
-  jobs:
-  - job: format
-    displayName: 'clang'
-    pool:
-      vmImage: ubuntu-latest
-    steps:
-    - template: ./templates/format-check.yml
- stage: build
-  dependsOn: format
-  displayName: 'build'
-  jobs:
-  - job: build
-    displayName: 'standard'
-    pool:
-      vmImage: ubuntu-latest
-    strategy:
-      maxParallel: 10
-      matrix:
-        linux:
-          BuildSuffix: 'linux'
-          ScriptFolder: 'linux'
-    steps:
-    - template: ./templates/sync-source.yml
-      parameters:
-        artifactSource: $(parameters.artifactSource)
-        needSubmodules: 'true'
-    - template: ./templates/build-single.yml
-      parameters:
-        artifactSource: 'false'
-        cache: 'true'
-        version: $(DisplayVersion)
- stage: build_win
-  dependsOn: format
-  displayName: 'build-windows'
-  jobs:
-  - job: build
-    displayName: 'msvc'
-    pool:
-      vmImage: vs2017-win2016
-    steps:
-    - template: ./templates/sync-source.yml
-      parameters:
-        artifactSource: $(parameters.artifactSource)
-        needSubmodules: 'true'
-    - template: ./templates/build-msvc.yml
-      parameters:
-        artifactSource: 'false'
-        cache: 'true'
-        version: $(DisplayVersion)
- stage: release
-  displayName: 'release'
-  dependsOn:
-  - build
-  - build_win
-  jobs:
-  - job: github
-    displayName: 'github'
-    steps:
-    - template: ./templates/release-github.yml
@@ -0,0 +1,25 @@
+trigger:
+- master
+
+stages:
+- stage: merge
+  displayName: 'merge'
+  jobs:
+  - template: ./templates/merge.yml
+- stage: format
+  dependsOn: merge
+  displayName: 'format'
+  jobs:
+  - job: format
+    displayName: 'clang'
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - template: ./templates/format-check.yml
+- stage: build
+  displayName: 'build'
+  dependsOn: format
+  jobs:
+  - template: ./templates/build-standard.yml
+    parameters:
+      cache: 'true'
@@ -1,8 +0,0 @@
-trigger:
- master
-
-stages:
- stage: merge
-  displayName: 'merge'
-  jobs:
-  - template: ./templates/merge-private.yml
@@ -1,42 +0,0 @@
-trigger:
- master
-
-variables:
-  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]
-
-stages:
- stage: format
-  displayName: 'format'
-  jobs:
-  - job: format
-    displayName: 'clang'
-    pool:
-      vmImage: ubuntu-latest
-    steps:
-    - template: ./templates/format-check.yml
- stage: build
-  dependsOn: format
-  displayName: 'build'
-  jobs:
-  - job: build
-    displayName: 'windows-msvc'
-    pool:
-      vmImage: vs2017-win2016
-    steps:
-    - template: ./templates/sync-source.yml
-      parameters:
-        artifactSource: $(parameters.artifactSource)
-        needSubmodules: 'true'
-    - template: ./templates/build-msvc.yml
-      parameters:
-        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
@@ -0,0 +1,19 @@
+# Starter pipeline
+# Start with a minimal pipeline that you can customize to build and deploy your code.
+# Add steps that build, run tests, deploy, and more:
+# https://aka.ms/yaml
+
+trigger:
+- master
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+steps:
+- script: echo Hello, world!
+  displayName: 'Run a one-line script'
+
+- script: |
+    echo Add other tasks to build, test, and deploy your project.
+    echo See https://aka.ms/yaml
+  displayName: 'Run a multi-line script'
@@ -46,9 +46,3 @@
 [submodule "sirit"]
    path = externals/sirit
    url = https://github.com/ReinUsesLisp/sirit
-[submodule "libzip"]
-    path = externals/libzip
-    url = https://github.com/DarkLordZach/libzip
-[submodule "zlib"]
-    path = externals/zlib
-    url = https://github.com/madler/zlib
@@ -21,8 +21,6 @@ option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)

 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)

-option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
-
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)

 option(ENABLE_VULKAN "Enables Vulkan backend" ON)
@@ -83,15 +83,9 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/decode/video.cpp"
    "${VIDEO_CORE}/shader/decode/warp.cpp"
    "${VIDEO_CORE}/shader/decode/xmad.cpp"
-    "${VIDEO_CORE}/shader/ast.cpp"
-    "${VIDEO_CORE}/shader/ast.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"
    "${VIDEO_CORE}/shader/node.h"
    "${VIDEO_CORE}/shader/node_helper.cpp"
    "${VIDEO_CORE}/shader/node_helper.h"
@@ -1,15 +1,14 @@
 yuzu emulator
 =============
 [![Travis CI Build Status](https://travis-ci.org/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.org/yuzu-emu/yuzu)
+[![AppVeyor CI Build Status](https://ci.appveyor.com/api/projects/status/77k97svb2usreu68?svg=true)](https://ci.appveyor.com/project/bunnei/yuzu)
 [![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)

 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).

-It is written in C++ with portability in mind, with builds actively maintained for Windows and Linux. The emulator is capable of running several commercial games.
+It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.

-yuzu only emulates a subset of Switch hardware and therefore most commercial games **do not** run at full speed or are not fully functional.
-
-Do you want to check which games are compatible and which ones are not? Please visit our [Compatibility page](https://yuzu-emu.org/game/)!
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. yuzu can boot some games, to varying degrees of success.

 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.

@@ -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>
@@ -77,12 +77,6 @@ if (ENABLE_VULKAN)
    add_subdirectory(sirit)
 endif()

-# zlib
-add_subdirectory(zlib EXCLUDE_FROM_ALL)
-
-# libzip
-add_subdirectory(libzip EXCLUDE_FROM_ALL)
-
 if (ENABLE_WEB_SERVICE)
    # LibreSSL
    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
@@ -341,24 +341,15 @@ Public License instead of this License.

 The icons used in this project have the following licenses:

-Icon Name                                   | License       | Origin/Author
---                                         | ---           | ---
-checked.png                                 | Free for non-commercial use
-failed.png                                  | Free for non-commercial use
-lock.png                                    | CC BY-ND 3.0  | https://icons8.com
-plus_folder.png (Default, Dark)             | CC BY-ND 3.0  | https://icons8.com
-bad_folder.png (Default, Dark)              | CC BY-ND 3.0  | https://icons8.com
-chip.png (Default, Dark)                    | CC BY-ND 3.0  | https://icons8.com
-folder.png (Default, Dark)                  | CC BY-ND 3.0  | https://icons8.com
-plus.png (Default, Dark)                    | CC0 1.0       | Designed by BreadFish64 from the Citra team
-sd_card.png (Default, Dark)                 | CC BY-ND 3.0  | https://icons8.com
-plus_folder.png (Colorful, Colorful Dark)   | CC BY-ND 3.0  | https://icons8.com
-bad_folder.png (Colorful, Colorful Dark)    | CC BY-ND 3.0  | https://icons8.com
-chip.png (Colorful, Colorful Dark)          | CC BY-ND 3.0  | https://icons8.com
-folder.png (Colorful, Colorful Dark)        | CC BY-ND 3.0  | https://icons8.com
-plus.png (Colorful, Colorful Dark)          | CC BY-ND 3.0  | https://icons8.com
-sd_card.png (Colorful, Colorful Dark)       | CC BY-ND 3.0  | https://icons8.com
-
-Note:
-Some icons are different in different themes, and they are separately listed
-only when they have different licenses/origins.
+Icon Name                          | License       | Origin/Author
+---                                | ---           | ---
+checked.png                        | Free for non-commercial use
+failed.png                         | Free for non-commercial use
+lock.png                           | CC BY-ND 3.0  | https://icons8.com
+plus_folder.png                    | CC BY-ND 3.0  | https://icons8.com
+bad_folder.png                     | CC BY-ND 3.0  | https://icons8.com
+chip.png                           | CC BY-ND 3.0  | https://icons8.com
+folder.png                         | CC BY-ND 3.0  | https://icons8.com
+plus.png (Default, Dark)           | CC0 1.0       | Designed by BreadFish64 from the Citra team
+plus.png (Colorful, Colorful Dark) | CC BY-ND 3.0  | https://icons8.com
+sd_card.png | CC BY-ND 3.0 | https://icons8.com
@@ -107,11 +107,6 @@ Stream::State AudioRenderer::GetStreamState() const {
    return stream->GetState();
 }

-static constexpr u32 VersionFromRevision(u32_le rev) {
-    // "REV7" -> 7
-    return ((rev >> 24) & 0xff) - 0x30;
-}
-
 std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
    // Copy UpdateDataHeader struct
    UpdateDataHeader config{};
@@ -171,11 +166,6 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
    // Copy output header
    UpdateDataHeader response_data{worker_params};
    std::vector<u8> output_params(response_data.total_size);
-    const auto audren_revision = VersionFromRevision(config.revision);
-    if (audren_revision >= 5) {
-        response_data.frame_count = 0x10;
-        response_data.total_size += 0x10;
-    }
    std::memcpy(output_params.data(), &response_data, sizeof(UpdateDataHeader));

    // Copy output memory pool entries
@@ -194,24 +194,21 @@ struct UpdateDataHeader {
        mixes_size = 0x0;
        sinks_size = config.sink_count * 0x20;
        performance_manager_size = 0x10;
-        frame_count = 0;
        total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size + voices_size +
                     effects_size + sinks_size + performance_manager_size;
    }

-    u32_le revision{};
-    u32_le behavior_size{};
-    u32_le memory_pools_size{};
-    u32_le voices_size{};
-    u32_le voice_resource_size{};
-    u32_le effects_size{};
-    u32_le mixes_size{};
-    u32_le sinks_size{};
-    u32_le performance_manager_size{};
-    INSERT_PADDING_WORDS(1);
-    u32_le frame_count{};
-    INSERT_PADDING_WORDS(4);
-    u32_le total_size{};
+    u32_le revision;
+    u32_le behavior_size;
+    u32_le memory_pools_size;
+    u32_le voices_size;
+    u32_le voice_resource_size;
+    u32_le effects_size;
+    u32_le mixes_size;
+    u32_le sinks_size;
+    u32_le performance_manager_size;
+    INSERT_PADDING_WORDS(6);
+    u32_le total_size;
 };
 static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size");

@@ -10,28 +10,13 @@ if (DEFINED ENV{CI})
  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})
-endif ()
-if (DEFINED ENV{TITLEBARFORMATRUNNING})
-  set(TITLE_BAR_FORMAT_RUNNING $ENV{TITLEBARFORMATRUNNING})
-endif ()
-if (DEFINED ENV{DISPLAYVERSION})
-  set(DISPLAY_VERSION $ENV{DISPLAYVERSION})
-endif ()
 add_custom_command(OUTPUT scm_rev.cpp
    COMMAND ${CMAKE_COMMAND}
      -DSRC_DIR="${CMAKE_SOURCE_DIR}"
      -DBUILD_REPOSITORY="${BUILD_REPOSITORY}"
-      -DTITLE_BAR_FORMAT_IDLE="${TITLE_BAR_FORMAT_IDLE}"
-      -DTITLE_BAR_FORMAT_RUNNING="${TITLE_BAR_FORMAT_RUNNING}"
      -DBUILD_TAG="${BUILD_TAG}"
-      -DBUILD_ID="${DISPLAY_VERSION}"
      -P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
    DEPENDS
      # WARNING! It was too much work to try and make a common location for this list,
@@ -72,15 +57,9 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/decode/video.cpp"
      "${VIDEO_CORE}/shader/decode/warp.cpp"
      "${VIDEO_CORE}/shader/decode/xmad.cpp"
-      "${VIDEO_CORE}/shader/ast.cpp"
-      "${VIDEO_CORE}/shader/ast.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"
      "${VIDEO_CORE}/shader/node.h"
      "${VIDEO_CORE}/shader/node_helper.cpp"
      "${VIDEO_CORE}/shader/node_helper.h"
@@ -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);
    }
@@ -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;
        }
    }

@@ -255,7 +255,6 @@ void DebuggerBackend::Write(const Entry& entry) {
    CLS(Input)                                                                                     \
    CLS(Network)                                                                                   \
    CLS(Loader)                                                                                    \
-    CLS(CheatEngine)                                                                               \
    CLS(Crypto)                                                                                    \
    CLS(WebService)

@@ -117,7 +117,6 @@ enum class Class : ClassType {
    Audio_DSP,         ///< The HLE implementation of the DSP
    Audio_Sink,        ///< Emulator audio output backend
    Loader,            ///< ROM loader
-    CheatEngine,       ///< Memory manipulation and engine VM functions
    Crypto,            ///< Cryptographic engine/functions
    Input,             ///< Input emulation
    Network,           ///< Network emulation
@@ -11,9 +11,6 @@
 #define BUILD_DATE   "@BUILD_DATE@"
 #define BUILD_FULLNAME "@BUILD_FULLNAME@"
 #define BUILD_VERSION "@BUILD_VERSION@"
-#define BUILD_ID "@BUILD_ID@"
-#define TITLE_BAR_FORMAT_IDLE "@TITLE_BAR_FORMAT_IDLE@"
-#define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@"
 #define SHADER_CACHE_VERSION "@SHADER_CACHE_VERSION@"

 namespace Common {
@@ -25,9 +22,6 @@ const char g_build_name[]   = BUILD_NAME;
 const char g_build_date[]   = BUILD_DATE;
 const char g_build_fullname[] = BUILD_FULLNAME;
 const char g_build_version[]  = BUILD_VERSION;
-const char g_build_id[] = BUILD_ID;
-const char g_title_bar_format_idle[] = TITLE_BAR_FORMAT_IDLE;
-const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING;
 const char g_shader_cache_version[] = SHADER_CACHE_VERSION;

 } // namespace
@@ -13,9 +13,6 @@ extern const char g_build_name[];
 extern const char g_build_date[];
 extern const char g_build_fullname[];
 extern const char g_build_version[];
-extern const char g_build_id[];
-extern const char g_title_bar_format_idle[];
-extern const char g_title_bar_format_running[];
 extern const char g_shader_cache_version[];

 } // namespace Common
@@ -1,9 +1,3 @@
-if (YUZU_ENABLE_BOXCAT)
-    set(BCAT_BOXCAT_ADDITIONAL_SOURCES hle/service/bcat/backend/boxcat.cpp hle/service/bcat/backend/boxcat.h)
-else()
-    set(BCAT_BOXCAT_ADDITIONAL_SOURCES)
-endif()
-
 add_library(core STATIC
    arm/arm_interface.h
    arm/arm_interface.cpp
@@ -39,6 +33,8 @@ add_library(core STATIC
    file_sys/bis_factory.h
    file_sys/card_image.cpp
    file_sys/card_image.h
+    file_sys/cheat_engine.cpp
+    file_sys/cheat_engine.h
    file_sys/content_archive.cpp
    file_sys/content_archive.h
    file_sys/control_metadata.cpp
@@ -88,8 +84,6 @@ add_library(core STATIC
    file_sys/vfs_concat.h
    file_sys/vfs_layered.cpp
    file_sys/vfs_layered.h
-    file_sys/vfs_libzip.cpp
-    file_sys/vfs_libzip.h
    file_sys/vfs_offset.cpp
    file_sys/vfs_offset.h
    file_sys/vfs_real.cpp
@@ -249,9 +243,6 @@ add_library(core STATIC
    hle/service/audio/errors.h
    hle/service/audio/hwopus.cpp
    hle/service/audio/hwopus.h
-    hle/service/bcat/backend/backend.cpp
-    hle/service/bcat/backend/backend.h
-    ${BCAT_BOXCAT_ADDITIONAL_SOURCES}
    hle/service/bcat/bcat.cpp
    hle/service/bcat/bcat.h
    hle/service/bcat/module.cpp
@@ -335,8 +326,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
@@ -488,11 +477,6 @@ add_library(core STATIC
    loader/nsp.h
    loader/xci.cpp
    loader/xci.h
-    memory/cheat_engine.cpp
-    memory/cheat_engine.h
-    memory/dmnt_cheat_types.h
-    memory/dmnt_cheat_vm.cpp
-    memory/dmnt_cheat_vm.h
    memory.cpp
    memory.h
    memory_setup.h
@@ -512,15 +496,6 @@ 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 open_source_archives)
-
-if (YUZU_ENABLE_BOXCAT)
-    get_directory_property(OPENSSL_LIBS
-        DIRECTORY ${PROJECT_SOURCE_DIR}/externals/libressl
-        DEFINITION OPENSSL_LIBS)
-    target_compile_definitions(core PRIVATE -DCPPHTTPLIB_OPENSSL_SUPPORT -DYUZU_ENABLE_BOXCAT)
-    target_link_libraries(core PRIVATE httplib json-headers ${OPENSSL_LIBS} zip)
-endif()
-
 if (ENABLE_WEB_SERVICE)
    target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
    target_link_libraries(core PRIVATE web_service)
@@ -14,14 +14,8 @@
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/cpu_core_manager.h"
-#include "core/file_sys/bis_factory.h"
-#include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
-#include "core/file_sys/romfs_factory.h"
-#include "core/file_sys/savedata_factory.h"
-#include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
@@ -33,18 +27,17 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/am/applets/applets.h"
 #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"
-#include "core/memory/cheat_engine.h"
 #include "core/perf_stats.h"
 #include "core/reporter.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "core/tools/freezer.h"
+#include "file_sys/cheat_engine.h"
+#include "file_sys/patch_manager.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
@@ -112,8 +105,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 }
 struct System::Impl {
    explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, cpu_core_manager{system},
-          applet_manager{system}, reporter{system} {}
+        : kernel{system}, cpu_core_manager{system}, applet_manager{system}, reporter{system} {}

    Cpu& CurrentCpuCore() {
        return cpu_core_manager.GetCurrentCore();
@@ -165,10 +157,13 @@ struct System::Impl {
        gpu_core = VideoCore::CreateGPU(system);

        is_powered_on = true;
-        exit_lock = false;

        LOG_DEBUG(Core, "Initialized OK");

+        // Reset counters and set time origin to current frame
+        GetAndResetPerfStats();
+        perf_stats.BeginSystemFrame();
+
        return ResultStatus::Success;
    }

@@ -207,34 +202,10 @@ struct System::Impl {
        gpu_core->Start();
        cpu_core_manager.StartThreads();

-        // Initialize cheat engine
-        if (cheat_engine) {
-            cheat_engine->Initialize();
-        }
-
        // All threads are started, begin main process execution, now that we're in the clear.
        main_process->Run(load_parameters->main_thread_priority,
                          load_parameters->main_thread_stack_size);

-        if (Settings::values.gamecard_inserted) {
-            if (Settings::values.gamecard_current_game) {
-                fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, filepath));
-            } else if (!Settings::values.gamecard_path.empty()) {
-                fs_controller.SetGameCard(
-                    GetGameFileFromPath(virtual_filesystem, Settings::values.gamecard_path));
-            }
-        }
-
-        u64 title_id{0};
-        if (app_loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
-            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})",
-                      static_cast<u32>(load_result));
-        }
-        perf_stats = std::make_unique<PerfStats>(title_id);
-        // Reset counters and set time origin to current frame
-        GetAndResetPerfStats();
-        perf_stats->BeginSystemFrame();
-
        status = ResultStatus::Success;
        return status;
    }
@@ -248,15 +219,8 @@ struct System::Impl {
                                    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();

        is_powered_on = false;
-        exit_lock = false;
-
-        gpu_core->WaitIdle();

        // Shutdown emulation session
        renderer.reset();
@@ -265,7 +229,6 @@ struct System::Impl {
        service_manager.reset();
        cheat_engine.reset();
        telemetry_session.reset();
-        perf_stats.reset();
        gpu_core.reset();

        // Close all CPU/threading state
@@ -323,7 +286,7 @@ struct System::Impl {
    }

    PerfStatsResults GetAndResetPerfStats() {
-        return perf_stats->GetAndResetStats(core_timing.GetGlobalTimeUs());
+        return perf_stats.GetAndResetStats(core_timing.GetGlobalTimeUs());
    }

    Timing::CoreTiming core_timing;
@@ -332,7 +295,6 @@ struct System::Impl {
    FileSys::VirtualFilesystem virtual_filesystem;
    /// ContentProviderUnion instance
    std::unique_ptr<FileSys::ContentProviderUnion> content_provider;
-    Service::FileSystem::FileSystemController fs_controller;
    /// AppLoader used to load the current executing application
    std::unique_ptr<Loader::AppLoader> app_loader;
    std::unique_ptr<VideoCore::RendererBase> renderer;
@@ -341,12 +303,9 @@ struct System::Impl {
    std::unique_ptr<Core::Hardware::InterruptManager> interrupt_manager;
    CpuCoreManager cpu_core_manager;
    bool is_powered_on = false;
-    bool exit_lock = false;

-    Reporter reporter;
-    std::unique_ptr<Memory::CheatEngine> cheat_engine;
+    std::unique_ptr<FileSys::CheatEngine> cheat_engine;
    std::unique_ptr<Tools::Freezer> memory_freezer;
-    std::array<u8, 0x20> build_id{};

    /// Frontend applets
    Service::AM::Applets::AppletManager applet_manager;
@@ -354,9 +313,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;
@@ -364,10 +322,12 @@ 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 = "";

-    std::unique_ptr<Core::PerfStats> perf_stats;
+    Core::PerfStats perf_stats;
    Core::FrameLimiter frame_limiter;
 };

@@ -406,12 +366,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();
 }
@@ -452,16 +406,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();
 }
@@ -536,11 +480,11 @@ const Timing::CoreTiming& System::CoreTiming() const {
 }

 Core::PerfStats& System::GetPerfStats() {
-    return *impl->perf_stats;
+    return impl->perf_stats;
 }

 const Core::PerfStats& System::GetPerfStats() const {
-    return *impl->perf_stats;
+    return impl->perf_stats;
 }

 Core::FrameLimiter& System::FrameLimiter() {
@@ -575,6 +519,13 @@ Tegra::DebugContext* System::GetGPUDebugContext() const {
    return impl->debug_context.get();
 }

+void System::RegisterCheatList(const std::vector<FileSys::CheatList>& list,
+                               const std::string& build_id, VAddr code_region_start,
+                               VAddr code_region_end) {
+    impl->cheat_engine = std::make_unique<FileSys::CheatEngine>(*this, list, build_id,
+                                                                code_region_start, code_region_end);
+}
+
 void System::SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs) {
    impl->virtual_filesystem = std::move(vfs);
 }
@@ -583,13 +534,6 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
    return impl->virtual_filesystem;
 }

-void System::RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
-                               const std::array<u8, 32>& build_id, VAddr main_region_begin,
-                               u64 main_region_size) {
-    impl->cheat_engine = std::make_unique<Memory::CheatEngine>(*this, list, build_id);
-    impl->cheat_engine->SetMainMemoryParameters(main_region_begin, main_region_size);
-}
-
 void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
    impl->applet_manager.SetAppletFrontendSet(std::move(set));
 }
@@ -618,14 +562,6 @@ const FileSys::ContentProvider& System::GetContentProvider() const {
    return *impl->content_provider;
 }

-Service::FileSystem::FileSystemController& System::GetFileSystemController() {
-    return impl->fs_controller;
-}
-
-const Service::FileSystem::FileSystemController& System::GetFileSystemController() const {
-    return impl->fs_controller;
-}
-
 void System::RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
                                     FileSys::ContentProvider* provider) {
    impl->content_provider->SetSlot(slot, provider);
@@ -655,30 +591,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;
-}
-
-bool System::GetExitLock() const {
-    return impl->exit_lock;
-}
-
-void System::SetCurrentProcessBuildID(const CurrentBuildProcessID& id) {
-    impl->build_id = id;
-}
-
-const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
-    return impl->build_id;
-}
-
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
    return impl->Init(*this, emu_window);
 }
@@ -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"
@@ -17,6 +18,7 @@ class EmuWindow;
 } // namespace Core::Frontend

 namespace FileSys {
+class CheatList;
 class ContentProvider;
 class ContentProviderUnion;
 enum class ContentProviderUnionSlot;
@@ -24,7 +26,6 @@ class VfsFilesystem;
 } // namespace FileSys

 namespace Kernel {
-class GlobalScheduler;
 class KernelCore;
 class Process;
 class Scheduler;
@@ -35,10 +36,6 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader

-namespace Memory {
-struct CheatEntry;
-} // namespace Memory
-
 namespace Service {

 namespace AM::Applets {
@@ -50,18 +47,10 @@ namespace APM {
 class Controller;
 }

-namespace FileSystem {
-class FileSystemController;
-} // namespace FileSystem
-
 namespace Glue {
 class ARPManager;
 }

-namespace LM {
-class Manager;
-} // namespace LM
-
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -102,8 +91,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 +172,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 +226,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();

@@ -304,9 +282,8 @@ public:

    std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;

-    void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
-                           const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
-                           u64 main_region_size);
+    void RegisterCheatList(const std::vector<FileSys::CheatList>& list, const std::string& build_id,
+                           VAddr code_region_start, VAddr code_region_end);

    void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);

@@ -322,10 +299,6 @@ public:

    const FileSys::ContentProvider& GetContentProvider() const;

-    Service::FileSystem::FileSystemController& GetFileSystemController();
-
-    const Service::FileSystem::FileSystemController& GetFileSystemController() const;
-
    void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
                                 FileSys::ContentProvider* provider);

@@ -341,18 +314,6 @@ 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);
-
-    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
-
 private:
    System();

@@ -376,4 +337,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,8 +81,6 @@ 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) {
@@ -95,6 +92,7 @@ void Cpu::RunLoop(bool tight_loop) {
            core_timing.Advance();
        }

+        PrepareReschedule();
    } else {
        if (IsMainCore()) {
            core_timing.Advance();
@@ -116,14 +114,18 @@ void Cpu::SingleStep() {

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

 void Cpu::Reschedule() {
-    // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard lock(HLE::g_hle_lock);
+    if (!reschedule_pending) {
+        return;
+    }

-    global_scheduler.SelectThread(core_index);
-    scheduler->TryDoContextSwitch();
+    reschedule_pending = false;
+    // Lock the global kernel mutex when we manipulate the HLE state
+    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;
@@ -91,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;

@@ -423,7 +423,7 @@ static std::optional<u64> FindTicketOffset(const std::array<u8, size>& data) {
 std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
                                                     const RSAKeyPair<2048>& key) {
    const auto issuer = ticket.GetData().issuer;
-    if (IsAllZeroArray(issuer))
+    if (issuer == std::array<u8, 0x40>{})
        return {};
    if (issuer[0] != 'R' || issuer[1] != 'o' || issuer[2] != 'o' || issuer[3] != 't') {
        LOG_INFO(Crypto, "Attempting to parse ticket with non-standard certificate authority.");
@@ -480,10 +480,6 @@ void PartitionDataManager::DecryptProdInfo(std::array<u8, 0x20> bis_key) {
    prodinfo_decrypted = std::make_shared<XTSEncryptionLayer>(prodinfo, bis_key);
 }

-FileSys::VirtualFile PartitionDataManager::GetDecryptedProdInfo() const {
-    return prodinfo_decrypted;
-}
-
 std::array<u8, 576> PartitionDataManager::GetETicketExtendedKek() const {
    std::array<u8, 0x240> out{};
    if (prodinfo_decrypted != nullptr)
@@ -84,7 +84,6 @@ public:
    bool HasProdInfo() const;
    FileSys::VirtualFile GetProdInfoRaw() const;
    void DecryptProdInfo(std::array<u8, 0x20> bis_key);
-    FileSys::VirtualFile GetDecryptedProdInfo() const;
    std::array<u8, 0x240> GetETicketExtendedKek() const;

 private:
@@ -3,12 +3,8 @@
 // Refer to the license.txt file included.

 #include <fmt/format.h>
-#include "common/file_util.h"
-#include "core/core.h"
 #include "core/file_sys/bis_factory.h"
-#include "core/file_sys/mode.h"
 #include "core/file_sys/registered_cache.h"
-#include "core/settings.h"

 namespace FileSys {

@@ -18,22 +14,10 @@ BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_, VirtualDir
      sysnand_cache(std::make_unique<RegisteredCache>(
          GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
      usrnand_cache(std::make_unique<RegisteredCache>(
-          GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))),
-      sysnand_placeholder(std::make_unique<PlaceholderCache>(
-          GetOrCreateDirectoryRelative(nand_root, "/system/Contents/placehld"))),
-      usrnand_placeholder(std::make_unique<PlaceholderCache>(
-          GetOrCreateDirectoryRelative(nand_root, "/user/Contents/placehld"))) {}
+          GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))) {}

 BISFactory::~BISFactory() = default;

-VirtualDir BISFactory::GetSystemNANDContentDirectory() const {
-    return GetOrCreateDirectoryRelative(nand_root, "/system/Contents");
-}
-
-VirtualDir BISFactory::GetUserNANDContentDirectory() const {
-    return GetOrCreateDirectoryRelative(nand_root, "/user/Contents");
-}
-
 RegisteredCache* BISFactory::GetSystemNANDContents() const {
    return sysnand_cache.get();
 }
@@ -42,17 +26,9 @@ RegisteredCache* BISFactory::GetUserNANDContents() const {
    return usrnand_cache.get();
 }

-PlaceholderCache* BISFactory::GetSystemNANDPlaceholder() const {
-    return sysnand_placeholder.get();
-}
-
-PlaceholderCache* BISFactory::GetUserNANDPlaceholder() const {
-    return usrnand_placeholder.get();
-}
-
 VirtualDir BISFactory::GetModificationLoadRoot(u64 title_id) const {
    // LayeredFS doesn't work on updates and title id-less homebrew
-    if (title_id == 0 || (title_id & 0xFFF) == 0x800)
+    if (title_id == 0 || (title_id & 0x800) > 0)
        return nullptr;
    return GetOrCreateDirectoryRelative(load_root, fmt::format("/{:016X}", title_id));
 }
@@ -63,82 +39,4 @@ VirtualDir BISFactory::GetModificationDumpRoot(u64 title_id) const {
    return GetOrCreateDirectoryRelative(dump_root, fmt::format("/{:016X}", title_id));
 }

-VirtualDir BISFactory::OpenPartition(BisPartitionId id) const {
-    switch (id) {
-    case BisPartitionId::CalibrationFile:
-        return GetOrCreateDirectoryRelative(nand_root, "/prodinfof");
-    case BisPartitionId::SafeMode:
-        return GetOrCreateDirectoryRelative(nand_root, "/safe");
-    case BisPartitionId::System:
-        return GetOrCreateDirectoryRelative(nand_root, "/system");
-    case BisPartitionId::User:
-        return GetOrCreateDirectoryRelative(nand_root, "/user");
-    default:
-        return nullptr;
-    }
-}
-
-VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id) const {
-    Core::Crypto::KeyManager keys;
-    Core::Crypto::PartitionDataManager pdm{
-        Core::System::GetInstance().GetFilesystem()->OpenDirectory(
-            FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir), Mode::Read)};
-    keys.PopulateFromPartitionData(pdm);
-
-    switch (id) {
-    case BisPartitionId::CalibrationBinary:
-        return pdm.GetDecryptedProdInfo();
-    case BisPartitionId::BootConfigAndPackage2Part1:
-    case BisPartitionId::BootConfigAndPackage2Part2:
-    case BisPartitionId::BootConfigAndPackage2Part3:
-    case BisPartitionId::BootConfigAndPackage2Part4:
-    case BisPartitionId::BootConfigAndPackage2Part5:
-    case BisPartitionId::BootConfigAndPackage2Part6: {
-        const auto new_id = static_cast<u8>(id) -
-                            static_cast<u8>(BisPartitionId::BootConfigAndPackage2Part1) +
-                            static_cast<u8>(Core::Crypto::Package2Type::NormalMain);
-        return pdm.GetPackage2Raw(static_cast<Core::Crypto::Package2Type>(new_id));
-    }
-    default:
-        return nullptr;
-    }
-}
-
-VirtualDir BISFactory::GetImageDirectory() const {
-    return GetOrCreateDirectoryRelative(nand_root, "/user/Album");
-}
-
-u64 BISFactory::GetSystemNANDFreeSpace() const {
-    const auto sys_dir = GetOrCreateDirectoryRelative(nand_root, "/system");
-    if (sys_dir == nullptr)
-        return 0;
-
-    return GetSystemNANDTotalSpace() - sys_dir->GetSize();
-}
-
-u64 BISFactory::GetSystemNANDTotalSpace() const {
-    return static_cast<u64>(Settings::values.nand_system_size);
-}
-
-u64 BISFactory::GetUserNANDFreeSpace() const {
-    const auto usr_dir = GetOrCreateDirectoryRelative(nand_root, "/user");
-    if (usr_dir == nullptr)
-        return 0;
-
-    return GetUserNANDTotalSpace() - usr_dir->GetSize();
-}
-
-u64 BISFactory::GetUserNANDTotalSpace() const {
-    return static_cast<u64>(Settings::values.nand_user_size);
-}
-
-u64 BISFactory::GetFullNANDTotalSpace() const {
-    return static_cast<u64>(Settings::values.nand_total_size);
-}
-
-VirtualDir BISFactory::GetBCATDirectory(u64 title_id) const {
-    return GetOrCreateDirectoryRelative(nand_root,
-                                        fmt::format("/system/save/bcat/{:016X}", title_id));
-}
-
 } // namespace FileSys
@@ -10,25 +10,7 @@

 namespace FileSys {

-enum class BisPartitionId : u32 {
-    UserDataRoot = 20,
-    CalibrationBinary = 27,
-    CalibrationFile = 28,
-    BootConfigAndPackage2Part1 = 21,
-    BootConfigAndPackage2Part2 = 22,
-    BootConfigAndPackage2Part3 = 23,
-    BootConfigAndPackage2Part4 = 24,
-    BootConfigAndPackage2Part5 = 25,
-    BootConfigAndPackage2Part6 = 26,
-    SafeMode = 29,
-    System = 31,
-    SystemProperEncryption = 32,
-    SystemProperPartition = 33,
-    User = 30,
-};
-
 class RegisteredCache;
-class PlaceholderCache;

 /// File system interface to the Built-In Storage
 /// This is currently missing accessors to BIS partitions, but seemed like a good place for the NAND
@@ -38,31 +20,12 @@ public:
    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root, VirtualDir dump_root);
    ~BISFactory();

-    VirtualDir GetSystemNANDContentDirectory() const;
-    VirtualDir GetUserNANDContentDirectory() const;
-
    RegisteredCache* GetSystemNANDContents() const;
    RegisteredCache* GetUserNANDContents() const;

-    PlaceholderCache* GetSystemNANDPlaceholder() const;
-    PlaceholderCache* GetUserNANDPlaceholder() const;
-
    VirtualDir GetModificationLoadRoot(u64 title_id) const;
    VirtualDir GetModificationDumpRoot(u64 title_id) const;

-    VirtualDir OpenPartition(BisPartitionId id) const;
-    VirtualFile OpenPartitionStorage(BisPartitionId id) const;
-
-    VirtualDir GetImageDirectory() const;
-
-    u64 GetSystemNANDFreeSpace() const;
-    u64 GetSystemNANDTotalSpace() const;
-    u64 GetUserNANDFreeSpace() const;
-    u64 GetUserNANDTotalSpace() const;
-    u64 GetFullNANDTotalSpace() const;
-
-    VirtualDir GetBCATDirectory(u64 title_id) const;
-
 private:
    VirtualDir nand_root;
    VirtualDir load_root;
@@ -70,9 +33,6 @@ private:

    std::unique_ptr<RegisteredCache> sysnand_cache;
    std::unique_ptr<RegisteredCache> usrnand_cache;
-
-    std::unique_ptr<PlaceholderCache> sysnand_placeholder;
-    std::unique_ptr<PlaceholderCache> usrnand_placeholder;
 };

 } // namespace FileSys
@@ -12,16 +12,12 @@
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/romfs.h"
 #include "core/file_sys/submission_package.h"
-#include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_offset.h"
-#include "core/file_sys/vfs_vector.h"
 #include "core/loader/loader.h"

 namespace FileSys {

-constexpr u64 GAMECARD_CERTIFICATE_OFFSET = 0x7000;
 constexpr std::array partition_names{
    "update",
    "normal",
@@ -31,7 +27,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 +38,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 +51,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)] = raw;
+        if (raw != nullptr) {
+            partitions[partition_idx] = std::make_shared<PartitionFilesystem>(std::move(raw));
+        }
    }

    secure_partition = std::make_shared<NSP>(
@@ -71,7 +67,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 +100,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;
 }
@@ -253,29 +175,9 @@ VirtualDir XCI::GetParentDirectory() const {
    return file->GetContainingDirectory();
 }

-VirtualDir XCI::ConcatenatedPseudoDirectory() {
-    const auto out = std::make_shared<VectorVfsDirectory>();
-    for (const auto& part_id : {XCIPartition::Normal, XCIPartition::Logo, XCIPartition::Secure}) {
-        const auto& part = GetPartition(part_id);
-        if (part == nullptr)
-            continue;
-
-        for (const auto& file : part->GetFiles())
-            out->AddFile(file);
-    }
-
-    return out;
-}
-
-std::array<u8, 0x200> XCI::GetCertificate() const {
-    std::array<u8, 0x200> out;
-    file->Read(out.data(), out.size(), GAMECARD_CERTIFICATE_OFFSET);
-    return out;
-}
-
 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 +208,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,28 +81,16 @@ 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();
-    u64 GetSystemUpdateTitleID() const;

    bool HasProgramNCA() const;
    VirtualFile GetProgramNCAFile() const;
@@ -118,11 +106,6 @@ public:

    VirtualDir GetParentDirectory() const override;

-    // Creates a directory that contains all the NCAs in the gamecard
-    VirtualDir ConcatenatedPseudoDirectory();
-
-    std::array<u8, 0x200> GetCertificate() const;
-
 private:
    Loader::ResultStatus AddNCAFromPartition(XCIPartition part);

@@ -133,13 +116,10 @@ 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;

-    u64 update_normal_partition_end;
-
    Core::Crypto::KeyManager keys;
 };
 } // namespace FileSys
@@ -0,0 +1,492 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <locale>
+#include "common/hex_util.h"
+#include "common/microprofile.h"
+#include "common/swap.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/core_timing_util.h"
+#include "core/file_sys/cheat_engine.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/hid.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace FileSys {
+
+constexpr s64 CHEAT_ENGINE_TICKS = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 60);
+constexpr u32 KEYPAD_BITMASK = 0x3FFFFFF;
+
+u64 Cheat::Address() const {
+    u64 out;
+    std::memcpy(&out, raw.data(), sizeof(u64));
+    return Common::swap64(out) & 0xFFFFFFFFFF;
+}
+
+u64 Cheat::ValueWidth(u64 offset) const {
+    return Value(offset, width);
+}
+
+u64 Cheat::Value(u64 offset, u64 width) const {
+    u64 out;
+    std::memcpy(&out, raw.data() + offset, sizeof(u64));
+    out = Common::swap64(out);
+    if (width == 8)
+        return out;
+    return out & ((1ull << (width * CHAR_BIT)) - 1);
+}
+
+u32 Cheat::KeypadValue() const {
+    u32 out;
+    std::memcpy(&out, raw.data(), sizeof(u32));
+    return Common::swap32(out) & 0x0FFFFFFF;
+}
+
+void CheatList::SetMemoryParameters(VAddr main_begin, VAddr heap_begin, VAddr main_end,
+                                    VAddr heap_end, MemoryWriter writer, MemoryReader reader) {
+    this->main_region_begin = main_begin;
+    this->main_region_end = main_end;
+    this->heap_region_begin = heap_begin;
+    this->heap_region_end = heap_end;
+    this->writer = writer;
+    this->reader = reader;
+}
+
+MICROPROFILE_DEFINE(Cheat_Engine, "Add-Ons", "Cheat Engine", MP_RGB(70, 200, 70));
+
+void CheatList::Execute() {
+    MICROPROFILE_SCOPE(Cheat_Engine);
+
+    std::fill(scratch.begin(), scratch.end(), 0);
+    in_standard = false;
+    for (std::size_t i = 0; i < master_list.size(); ++i) {
+        LOG_DEBUG(Common_Filesystem, "Executing block #{:08X} ({})", i, master_list[i].first);
+        current_block = i;
+        ExecuteBlock(master_list[i].second);
+    }
+
+    in_standard = true;
+    for (std::size_t i = 0; i < standard_list.size(); ++i) {
+        LOG_DEBUG(Common_Filesystem, "Executing block #{:08X} ({})", i, standard_list[i].first);
+        current_block = i;
+        ExecuteBlock(standard_list[i].second);
+    }
+}
+
+CheatList::CheatList(const Core::System& system_, ProgramSegment master, ProgramSegment standard)
+    : master_list{std::move(master)}, standard_list{std::move(standard)}, system{&system_} {}
+
+bool CheatList::EvaluateConditional(const Cheat& cheat) const {
+    using ComparisonFunction = bool (*)(u64, u64);
+    constexpr std::array<ComparisonFunction, 6> comparison_functions{
+        [](u64 a, u64 b) { return a > b; },  [](u64 a, u64 b) { return a >= b; },
+        [](u64 a, u64 b) { return a < b; },  [](u64 a, u64 b) { return a <= b; },
+        [](u64 a, u64 b) { return a == b; }, [](u64 a, u64 b) { return a != b; },
+    };
+
+    if (cheat.type == CodeType::ConditionalInput) {
+        const auto applet_resource =
+            system->ServiceManager().GetService<Service::HID::Hid>("hid")->GetAppletResource();
+        if (applet_resource == nullptr) {
+            LOG_WARNING(
+                Common_Filesystem,
+                "Attempted to evaluate input conditional, but applet resource is not initialized!");
+            return false;
+        }
+
+        const auto press_state =
+            applet_resource
+                ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad)
+                .GetAndResetPressState();
+        return ((press_state & cheat.KeypadValue()) & KEYPAD_BITMASK) != 0;
+    }
+
+    ASSERT(cheat.type == CodeType::Conditional);
+
+    const auto offset =
+        cheat.memory_type == MemoryType::MainNSO ? main_region_begin : heap_region_begin;
+    ASSERT(static_cast<u8>(cheat.comparison_op.Value()) < 6);
+    auto* function = comparison_functions[static_cast<u8>(cheat.comparison_op.Value())];
+    const auto addr = cheat.Address() + offset;
+
+    return function(reader(cheat.width, SanitizeAddress(addr)), cheat.ValueWidth(8));
+}
+
+void CheatList::ProcessBlockPairs(const Block& block) {
+    block_pairs.clear();
+
+    u64 scope = 0;
+    std::map<u64, u64> pairs;
+
+    for (std::size_t i = 0; i < block.size(); ++i) {
+        const auto& cheat = block[i];
+
+        switch (cheat.type) {
+        case CodeType::Conditional:
+        case CodeType::ConditionalInput:
+            pairs.insert_or_assign(scope, i);
+            ++scope;
+            break;
+        case CodeType::EndConditional: {
+            --scope;
+            const auto idx = pairs.at(scope);
+            block_pairs.insert_or_assign(idx, i);
+            break;
+        }
+        case CodeType::Loop: {
+            if (cheat.end_of_loop) {
+                --scope;
+                const auto idx = pairs.at(scope);
+                block_pairs.insert_or_assign(idx, i);
+            } else {
+                pairs.insert_or_assign(scope, i);
+                ++scope;
+            }
+            break;
+        }
+        }
+    }
+}
+
+void CheatList::WriteImmediate(const Cheat& cheat) {
+    const auto offset =
+        cheat.memory_type == MemoryType::MainNSO ? main_region_begin : heap_region_begin;
+    const auto& register_3 = scratch.at(cheat.register_3);
+
+    const auto addr = cheat.Address() + offset + register_3;
+    LOG_DEBUG(Common_Filesystem, "writing value={:016X} to addr={:016X}", addr,
+              cheat.Value(8, cheat.width));
+    writer(cheat.width, SanitizeAddress(addr), cheat.ValueWidth(8));
+}
+
+void CheatList::BeginConditional(const Cheat& cheat) {
+    if (EvaluateConditional(cheat)) {
+        return;
+    }
+
+    const auto iter = block_pairs.find(current_index);
+    ASSERT(iter != block_pairs.end());
+    current_index = iter->second - 1;
+}
+
+void CheatList::EndConditional(const Cheat& cheat) {
+    LOG_DEBUG(Common_Filesystem, "Ending conditional block.");
+}
+
+void CheatList::Loop(const Cheat& cheat) {
+    if (cheat.end_of_loop.Value())
+        ASSERT(!cheat.end_of_loop.Value());
+
+    auto& register_3 = scratch.at(cheat.register_3);
+    const auto iter = block_pairs.find(current_index);
+    ASSERT(iter != block_pairs.end());
+    ASSERT(iter->first < iter->second);
+
+    const s32 initial_value = static_cast<s32>(cheat.Value(4, sizeof(s32)));
+    for (s32 i = initial_value; i >= 0; --i) {
+        register_3 = static_cast<u64>(i);
+        for (std::size_t c = iter->first + 1; c < iter->second; ++c) {
+            current_index = c;
+            ExecuteSingleCheat(
+                (in_standard ? standard_list : master_list)[current_block].second[c]);
+        }
+    }
+
+    current_index = iter->second;
+}
+
+void CheatList::LoadImmediate(const Cheat& cheat) {
+    auto& register_3 = scratch.at(cheat.register_3);
+
+    LOG_DEBUG(Common_Filesystem, "setting register={:01X} equal to value={:016X}", cheat.register_3,
+              cheat.Value(4, 8));
+    register_3 = cheat.Value(4, 8);
+}
+
+void CheatList::LoadIndexed(const Cheat& cheat) {
+    const auto offset =
+        cheat.memory_type == MemoryType::MainNSO ? main_region_begin : heap_region_begin;
+    auto& register_3 = scratch.at(cheat.register_3);
+
+    const auto addr = (cheat.load_from_register.Value() ? register_3 : offset) + cheat.Address();
+    LOG_DEBUG(Common_Filesystem, "writing indexed value to register={:01X}, addr={:016X}",
+              cheat.register_3, addr);
+    register_3 = reader(cheat.width, SanitizeAddress(addr));
+}
+
+void CheatList::StoreIndexed(const Cheat& cheat) {
+    const auto& register_3 = scratch.at(cheat.register_3);
+
+    const auto addr =
+        register_3 + (cheat.add_additional_register.Value() ? scratch.at(cheat.register_6) : 0);
+    LOG_DEBUG(Common_Filesystem, "writing value={:016X} to addr={:016X}",
+              cheat.Value(4, cheat.width), addr);
+    writer(cheat.width, SanitizeAddress(addr), cheat.ValueWidth(4));
+}
+
+void CheatList::RegisterArithmetic(const Cheat& cheat) {
+    using ArithmeticFunction = u64 (*)(u64, u64);
+    constexpr std::array<ArithmeticFunction, 5> arithmetic_functions{
+        [](u64 a, u64 b) { return a + b; },  [](u64 a, u64 b) { return a - b; },
+        [](u64 a, u64 b) { return a * b; },  [](u64 a, u64 b) { return a << b; },
+        [](u64 a, u64 b) { return a >> b; },
+    };
+
+    using ArithmeticOverflowCheck = bool (*)(u64, u64);
+    constexpr std::array<ArithmeticOverflowCheck, 5> arithmetic_overflow_checks{
+        [](u64 a, u64 b) { return a > (std::numeric_limits<u64>::max() - b); },       // a + b
+        [](u64 a, u64 b) { return a > (std::numeric_limits<u64>::max() + b); },       // a - b
+        [](u64 a, u64 b) { return a > (std::numeric_limits<u64>::max() / b); },       // a * b
+        [](u64 a, u64 b) { return b >= 64 || (a & ~((1ull << (64 - b)) - 1)) != 0; }, // a << b
+        [](u64 a, u64 b) { return b >= 64 || (a & ((1ull << b) - 1)) != 0; },         // a >> b
+    };
+
+    static_assert(sizeof(arithmetic_functions) == sizeof(arithmetic_overflow_checks),
+                  "Missing or have extra arithmetic overflow checks compared to functions!");
+
+    auto& register_3 = scratch.at(cheat.register_3);
+
+    ASSERT(static_cast<u8>(cheat.arithmetic_op.Value()) < 5);
+    auto* function = arithmetic_functions[static_cast<u8>(cheat.arithmetic_op.Value())];
+    auto* overflow_function =
+        arithmetic_overflow_checks[static_cast<u8>(cheat.arithmetic_op.Value())];
+    LOG_DEBUG(Common_Filesystem, "performing arithmetic with register={:01X}, value={:016X}",
+              cheat.register_3, cheat.ValueWidth(4));
+
+    if (overflow_function(register_3, cheat.ValueWidth(4))) {
+        LOG_WARNING(Common_Filesystem,
+                    "overflow will occur when performing arithmetic operation={:02X} with operands "
+                    "a={:016X}, b={:016X}!",
+                    static_cast<u8>(cheat.arithmetic_op.Value()), register_3, cheat.ValueWidth(4));
+    }
+
+    register_3 = function(register_3, cheat.ValueWidth(4));
+}
+
+void CheatList::BeginConditionalInput(const Cheat& cheat) {
+    if (EvaluateConditional(cheat))
+        return;
+
+    const auto iter = block_pairs.find(current_index);
+    ASSERT(iter != block_pairs.end());
+    current_index = iter->second - 1;
+}
+
+VAddr CheatList::SanitizeAddress(VAddr in) const {
+    if ((in < main_region_begin || in >= main_region_end) &&
+        (in < heap_region_begin || in >= heap_region_end)) {
+        LOG_ERROR(Common_Filesystem,
+                  "Cheat attempting to access memory at invalid address={:016X}, if this persists, "
+                  "the cheat may be incorrect. However, this may be normal early in execution if "
+                  "the game has not properly set up yet.",
+                  in);
+        return 0; ///< Invalid addresses will hard crash
+    }
+
+    return in;
+}
+
+void CheatList::ExecuteSingleCheat(const Cheat& cheat) {
+    using CheatOperationFunction = void (CheatList::*)(const Cheat&);
+    constexpr std::array<CheatOperationFunction, 9> cheat_operation_functions{
+        &CheatList::WriteImmediate,        &CheatList::BeginConditional,
+        &CheatList::EndConditional,        &CheatList::Loop,
+        &CheatList::LoadImmediate,         &CheatList::LoadIndexed,
+        &CheatList::StoreIndexed,          &CheatList::RegisterArithmetic,
+        &CheatList::BeginConditionalInput,
+    };
+
+    const auto index = static_cast<u8>(cheat.type.Value());
+    ASSERT(index < sizeof(cheat_operation_functions));
+    const auto op = cheat_operation_functions[index];
+    (this->*op)(cheat);
+}
+
+void CheatList::ExecuteBlock(const Block& block) {
+    encountered_loops.clear();
+
+    ProcessBlockPairs(block);
+    for (std::size_t i = 0; i < block.size(); ++i) {
+        current_index = i;
+        ExecuteSingleCheat(block[i]);
+        i = current_index;
+    }
+}
+
+CheatParser::~CheatParser() = default;
+
+CheatList CheatParser::MakeCheatList(const Core::System& system, CheatList::ProgramSegment master,
+                                     CheatList::ProgramSegment standard) const {
+    return {system, std::move(master), std::move(standard)};
+}
+
+TextCheatParser::~TextCheatParser() = default;
+
+CheatList TextCheatParser::Parse(const Core::System& system, const std::vector<u8>& data) const {
+    std::stringstream ss;
+    ss.write(reinterpret_cast<const char*>(data.data()), data.size());
+
+    std::vector<std::string> lines;
+    std::string stream_line;
+    while (std::getline(ss, stream_line)) {
+        // Remove a trailing \r
+        if (!stream_line.empty() && stream_line.back() == '\r')
+            stream_line.pop_back();
+        lines.push_back(std::move(stream_line));
+    }
+
+    CheatList::ProgramSegment master_list;
+    CheatList::ProgramSegment standard_list;
+
+    for (std::size_t i = 0; i < lines.size(); ++i) {
+        auto line = lines[i];
+
+        if (!line.empty() && (line[0] == '[' || line[0] == '{')) {
+            const auto master = line[0] == '{';
+            const auto begin = master ? line.find('{') : line.find('[');
+            const auto end = master ? line.rfind('}') : line.rfind(']');
+
+            ASSERT(begin != std::string::npos && end != std::string::npos);
+
+            const std::string patch_name{line.begin() + begin + 1, line.begin() + end};
+            CheatList::Block block{};
+
+            while (i < lines.size() - 1) {
+                line = lines[++i];
+                if (!line.empty() && (line[0] == '[' || line[0] == '{')) {
+                    --i;
+                    break;
+                }
+
+                if (line.size() < 8)
+                    continue;
+
+                Cheat out{};
+                out.raw = ParseSingleLineCheat(line);
+                block.push_back(out);
+            }
+
+            (master ? master_list : standard_list).emplace_back(patch_name, block);
+        }
+    }
+
+    return MakeCheatList(system, master_list, standard_list);
+}
+
+std::array<u8, 16> TextCheatParser::ParseSingleLineCheat(const std::string& line) const {
+    std::array<u8, 16> out{};
+
+    if (line.size() < 8)
+        return out;
+
+    const auto word1 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data(), 8});
+    std::memcpy(out.data(), word1.data(), sizeof(u32));
+
+    if (line.size() < 17 || line[8] != ' ')
+        return out;
+
+    const auto word2 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data() + 9, 8});
+    std::memcpy(out.data() + sizeof(u32), word2.data(), sizeof(u32));
+
+    if (line.size() < 26 || line[17] != ' ') {
+        // Perform shifting in case value is truncated early.
+        const auto type = static_cast<CodeType>((out[0] & 0xF0) >> 4);
+        if (type == CodeType::Loop || type == CodeType::LoadImmediate ||
+            type == CodeType::StoreIndexed || type == CodeType::RegisterArithmetic) {
+            std::memcpy(out.data() + 8, out.data() + 4, sizeof(u32));
+            std::memset(out.data() + 4, 0, sizeof(u32));
+        }
+
+        return out;
+    }
+
+    const auto word3 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data() + 18, 8});
+    std::memcpy(out.data() + 2 * sizeof(u32), word3.data(), sizeof(u32));
+
+    if (line.size() < 35 || line[26] != ' ') {
+        // Perform shifting in case value is truncated early.
+        const auto type = static_cast<CodeType>((out[0] & 0xF0) >> 4);
+        if (type == CodeType::WriteImmediate || type == CodeType::Conditional) {
+            std::memcpy(out.data() + 12, out.data() + 8, sizeof(u32));
+            std::memset(out.data() + 8, 0, sizeof(u32));
+        }
+
+        return out;
+    }
+
+    const auto word4 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data() + 27, 8});
+    std::memcpy(out.data() + 3 * sizeof(u32), word4.data(), sizeof(u32));
+
+    return out;
+}
+
+namespace {
+u64 MemoryReadImpl(u32 width, VAddr addr) {
+    switch (width) {
+    case 1:
+        return Memory::Read8(addr);
+    case 2:
+        return Memory::Read16(addr);
+    case 4:
+        return Memory::Read32(addr);
+    case 8:
+        return Memory::Read64(addr);
+    default:
+        UNREACHABLE();
+        return 0;
+    }
+}
+
+void MemoryWriteImpl(u32 width, VAddr addr, u64 value) {
+    switch (width) {
+    case 1:
+        Memory::Write8(addr, static_cast<u8>(value));
+        break;
+    case 2:
+        Memory::Write16(addr, static_cast<u16>(value));
+        break;
+    case 4:
+        Memory::Write32(addr, static_cast<u32>(value));
+        break;
+    case 8:
+        Memory::Write64(addr, value);
+        break;
+    default:
+        UNREACHABLE();
+    }
+}
+} // Anonymous namespace
+
+CheatEngine::CheatEngine(Core::System& system, std::vector<CheatList> cheats_,
+                         const std::string& build_id, VAddr code_region_start,
+                         VAddr code_region_end)
+    : cheats{std::move(cheats_)}, core_timing{system.CoreTiming()} {
+    event = core_timing.RegisterEvent(
+        "CheatEngine::FrameCallback::" + build_id,
+        [this](u64 userdata, s64 cycles_late) { FrameCallback(userdata, cycles_late); });
+    core_timing.ScheduleEvent(CHEAT_ENGINE_TICKS, event);
+
+    const auto& vm_manager = system.CurrentProcess()->VMManager();
+    for (auto& list : this->cheats) {
+        list.SetMemoryParameters(code_region_start, vm_manager.GetHeapRegionBaseAddress(),
+                                 code_region_end, vm_manager.GetHeapRegionEndAddress(),
+                                 &MemoryWriteImpl, &MemoryReadImpl);
+    }
+}
+
+CheatEngine::~CheatEngine() {
+    core_timing.UnscheduleEvent(event, 0);
+}
+
+void CheatEngine::FrameCallback(u64 userdata, s64 cycles_late) {
+    for (auto& list : cheats) {
+        list.Execute();
+    }
+
+    core_timing.ScheduleEvent(CHEAT_ENGINE_TICKS - cycles_late, event);
+}
+
+} // namespace FileSys
@@ -0,0 +1,234 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <map>
+#include <set>
+#include <vector>
+#include "common/bit_field.h"
+#include "common/common_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Core::Timing {
+class CoreTiming;
+struct EventType;
+} // namespace Core::Timing
+
+namespace FileSys {
+
+enum class CodeType : u32 {
+    // 0TMR00AA AAAAAAAA YYYYYYYY YYYYYYYY
+    // Writes a T sized value Y to the address A added to the value of register R in memory domain M
+    WriteImmediate = 0,
+
+    // 1TMC00AA AAAAAAAA YYYYYYYY YYYYYYYY
+    // Compares the T sized value Y to the value at address A in memory domain M using the
+    // conditional function C. If success, continues execution. If failure, jumps to the matching
+    // EndConditional statement.
+    Conditional = 1,
+
+    // 20000000
+    // Terminates a Conditional or ConditionalInput block.
+    EndConditional = 2,
+
+    // 300R0000 VVVVVVVV
+    // Starts looping V times, storing the current count in register R.
+    // Loop block is terminated with a matching 310R0000.
+    Loop = 3,
+
+    // 400R0000 VVVVVVVV VVVVVVVV
+    // Sets the value of register R to the value V.
+    LoadImmediate = 4,
+
+    // 5TMRI0AA AAAAAAAA
+    // Sets the value of register R to the value of width T at address A in memory domain M, with
+    // the current value of R added to the address if I == 1.
+    LoadIndexed = 5,
+
+    // 6T0RIFG0 VVVVVVVV VVVVVVVV
+    // Writes the value V of width T to the memory address stored in register R. Adds the value of
+    // register G to the final calculation if F is nonzero. Increments the value of register R by T
+    // after operation if I is nonzero.
+    StoreIndexed = 6,
+
+    // 7T0RA000 VVVVVVVV
+    // Performs the arithmetic operation A on the value in register R and the value V of width T,
+    // storing the result in register R.
+    RegisterArithmetic = 7,
+
+    // 8KKKKKKK
+    // Checks to see if any of the buttons defined by the bitmask K are pressed. If any are,
+    // execution continues. If none are, execution skips to the next EndConditional command.
+    ConditionalInput = 8,
+};
+
+enum class MemoryType : u32 {
+    // Addressed relative to start of main NSO
+    MainNSO = 0,
+
+    // Addressed relative to start of heap
+    Heap = 1,
+};
+
+enum class ArithmeticOp : u32 {
+    Add = 0,
+    Sub = 1,
+    Mult = 2,
+    LShift = 3,
+    RShift = 4,
+};
+
+enum class ComparisonOp : u32 {
+    GreaterThan = 1,
+    GreaterThanEqual = 2,
+    LessThan = 3,
+    LessThanEqual = 4,
+    Equal = 5,
+    Inequal = 6,
+};
+
+union Cheat {
+    std::array<u8, 16> raw;
+
+    BitField<4, 4, CodeType> type;
+    BitField<0, 4, u32> width; // Can be 1, 2, 4, or 8. Measured in bytes.
+    BitField<0, 4, u32> end_of_loop;
+    BitField<12, 4, MemoryType> memory_type;
+    BitField<8, 4, u32> register_3;
+    BitField<8, 4, ComparisonOp> comparison_op;
+    BitField<20, 4, u32> load_from_register;
+    BitField<20, 4, u32> increment_register;
+    BitField<20, 4, ArithmeticOp> arithmetic_op;
+    BitField<16, 4, u32> add_additional_register;
+    BitField<28, 4, u32> register_6;
+
+    u64 Address() const;
+    u64 ValueWidth(u64 offset) const;
+    u64 Value(u64 offset, u64 width) const;
+    u32 KeypadValue() const;
+};
+
+class CheatParser;
+
+// Represents a full collection of cheats for a game. The Execute function should be called every
+// interval that all cheats should be executed. Clients should not directly instantiate this class
+// (hence private constructor), they should instead receive an instance from CheatParser, which
+// guarantees the list is always in an acceptable state.
+class CheatList {
+public:
+    friend class CheatParser;
+
+    using Block = std::vector<Cheat>;
+    using ProgramSegment = std::vector<std::pair<std::string, Block>>;
+
+    // (width in bytes, address, value)
+    using MemoryWriter = void (*)(u32, VAddr, u64);
+    // (width in bytes, address) -> value
+    using MemoryReader = u64 (*)(u32, VAddr);
+
+    void SetMemoryParameters(VAddr main_begin, VAddr heap_begin, VAddr main_end, VAddr heap_end,
+                             MemoryWriter writer, MemoryReader reader);
+
+    void Execute();
+
+private:
+    CheatList(const Core::System& system_, ProgramSegment master, ProgramSegment standard);
+
+    void ProcessBlockPairs(const Block& block);
+    void ExecuteSingleCheat(const Cheat& cheat);
+
+    void ExecuteBlock(const Block& block);
+
+    bool EvaluateConditional(const Cheat& cheat) const;
+
+    // Individual cheat operations
+    void WriteImmediate(const Cheat& cheat);
+    void BeginConditional(const Cheat& cheat);
+    void EndConditional(const Cheat& cheat);
+    void Loop(const Cheat& cheat);
+    void LoadImmediate(const Cheat& cheat);
+    void LoadIndexed(const Cheat& cheat);
+    void StoreIndexed(const Cheat& cheat);
+    void RegisterArithmetic(const Cheat& cheat);
+    void BeginConditionalInput(const Cheat& cheat);
+
+    VAddr SanitizeAddress(VAddr in) const;
+
+    // Master Codes are defined as codes that cannot be disabled and are run prior to all
+    // others.
+    ProgramSegment master_list;
+    // All other codes
+    ProgramSegment standard_list;
+
+    bool in_standard = false;
+
+    // 16 (0x0-0xF) scratch registers that can be used by cheats
+    std::array<u64, 16> scratch{};
+
+    MemoryWriter writer = nullptr;
+    MemoryReader reader = nullptr;
+
+    u64 main_region_begin{};
+    u64 heap_region_begin{};
+    u64 main_region_end{};
+    u64 heap_region_end{};
+
+    u64 current_block{};
+    // The current index of the cheat within the current Block
+    u64 current_index{};
+
+    // The 'stack' of the program. When a conditional or loop statement is encountered, its index is
+    // pushed onto this queue. When a end block is encountered, the condition is checked.
+    std::map<u64, u64> block_pairs;
+
+    std::set<u64> encountered_loops;
+
+    const Core::System* system;
+};
+
+// Intermediary class that parses a text file or other disk format for storing cheats into a
+// CheatList object, that can be used for execution.
+class CheatParser {
+public:
+    virtual ~CheatParser();
+
+    virtual CheatList Parse(const Core::System& system, const std::vector<u8>& data) const = 0;
+
+protected:
+    CheatList MakeCheatList(const Core::System& system_, CheatList::ProgramSegment master,
+                            CheatList::ProgramSegment standard) const;
+};
+
+// CheatParser implementation that parses text files
+class TextCheatParser final : public CheatParser {
+public:
+    ~TextCheatParser() override;
+
+    CheatList Parse(const Core::System& system, const std::vector<u8>& data) const override;
+
+private:
+    std::array<u8, 16> ParseSingleLineCheat(const std::string& line) const;
+};
+
+// Class that encapsulates a CheatList and manages its interaction with memory and CoreTiming
+class CheatEngine final {
+public:
+    CheatEngine(Core::System& system_, std::vector<CheatList> cheats_, const std::string& build_id,
+                VAddr code_region_start, VAddr code_region_end);
+    ~CheatEngine();
+
+private:
+    void FrameCallback(u64 userdata, s64 cycles_late);
+
+    std::vector<CheatList> cheats;
+
+    Core::Timing::EventType* event;
+    Core::Timing::CoreTiming& core_timing;
+};
+
+} // namespace FileSys
@@ -528,14 +528,6 @@ u64 NCA::GetTitleId() const {
    return header.title_id;
 }

-std::array<u8, 16> NCA::GetRightsId() const {
-    return header.rights_id;
-}
-
-u32 NCA::GetSDKVersion() const {
-    return header.sdk_version;
-}
-
 bool NCA::IsUpdate() const {
    return is_update;
 }
@@ -112,8 +112,6 @@ public:

    NCAContentType GetType() const;
    u64 GetTitleId() const;
-    std::array<u8, 0x10> GetRightsId() const;
-    u32 GetSDKVersion() const;
    bool IsUpdate() const;

    VirtualFile GetRomFS() const;
@@ -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[name] = content_offset + entry.offset;
-        sizes[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;
 };

@@ -22,7 +22,6 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 #include "core/loader/nso.h"
-#include "core/memory/cheat_engine.h"
 #include "core/settings.h"

 namespace FileSys {
@@ -64,8 +63,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {

    if (Settings::values.dump_exefs) {
        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
-        const auto dump_dir =
-            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
+        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
        if (dump_dir != nullptr) {
            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
            VfsRawCopyD(exefs, exefs_dir);
@@ -90,8 +88,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    }

    // LayeredExeFS
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
    if (load_dir != nullptr && load_dir->GetSize() > 0) {
        auto patch_dirs = load_dir->GetSubdirectories();
        std::sort(
@@ -177,8 +174,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
    if (Settings::values.dump_nso) {
        LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
                 title_id);
-        const auto dump_dir =
-            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
+        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
        if (dump_dir != nullptr) {
            const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
            const auto file = nso_dir->CreateFile(fmt::format("{}-{}.nso", name, build_id));
@@ -190,13 +186,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st

    LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);

-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
-    if (load_dir == nullptr) {
-        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
-        return nso;
-    }
-
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
    auto patch_dirs = load_dir->GetSubdirectories();
    std::sort(patch_dirs.begin(), patch_dirs.end(),
              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -234,13 +224,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {

    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);

-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
-    if (load_dir == nullptr) {
-        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
-        return false;
-    }
-
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
    auto patch_dirs = load_dir->GetSubdirectories();
    std::sort(patch_dirs.begin(), patch_dirs.end(),
              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -248,10 +232,9 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
    return !CollectPatches(patch_dirs, build_id).empty();
 }

-namespace {
-std::optional<std::vector<Memory::CheatEntry>> ReadCheatFileFromFolder(
-    const Core::System& system, u64 title_id, const std::array<u8, 0x20>& build_id_,
-    const VirtualDir& base_path, bool upper) {
+static std::optional<CheatList> ReadCheatFileFromFolder(const Core::System& system, u64 title_id,
+                                                        const std::array<u8, 0x20>& build_id_,
+                                                        const VirtualDir& base_path, bool upper) {
    const auto build_id_raw = Common::HexToString(build_id_, upper);
    const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
    const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
@@ -269,39 +252,31 @@ std::optional<std::vector<Memory::CheatEntry>> ReadCheatFileFromFolder(
        return std::nullopt;
    }

-    Memory::TextCheatParser parser;
-    return parser.Parse(
-        system, std::string_view(reinterpret_cast<const char* const>(data.data()), data.size()));
+    TextCheatParser parser;
+    return parser.Parse(system, data);
 }

-} // Anonymous namespace
-
-std::vector<Memory::CheatEntry> PatchManager::CreateCheatList(
-    const Core::System& system, const std::array<u8, 32>& build_id_) const {
-    const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
-    if (load_dir == nullptr) {
-        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
-        return {};
-    }
-
+std::vector<CheatList> PatchManager::CreateCheatList(const Core::System& system,
+                                                     const std::array<u8, 32>& build_id_) const {
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
    auto patch_dirs = load_dir->GetSubdirectories();
    std::sort(patch_dirs.begin(), patch_dirs.end(),
              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });

-    std::vector<Memory::CheatEntry> out;
+    std::vector<CheatList> out;
+    out.reserve(patch_dirs.size());
    for (const auto& subdir : patch_dirs) {
        auto cheats_dir = subdir->GetSubdirectory("cheats");
        if (cheats_dir != nullptr) {
            auto res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, true);
            if (res.has_value()) {
-                std::copy(res->begin(), res->end(), std::back_inserter(out));
+                out.push_back(std::move(*res));
                continue;
            }

            res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, false);
-            if (res.has_value()) {
-                std::copy(res->begin(), res->end(), std::back_inserter(out));
-            }
+            if (res.has_value())
+                out.push_back(std::move(*res));
        }
    }

@@ -309,8 +284,7 @@ std::vector<Memory::CheatEntry> PatchManager::CreateCheatList(
 }

 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
    if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
        load_dir == nullptr || load_dir->GetSize() <= 0) {
        return;
@@ -419,8 +393,6 @@ static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {

 std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
    VirtualFile update_raw) const {
-    if (title_id == 0)
-        return {};
    std::map<std::string, std::string, std::less<>> out;
    const auto& installed = Core::System::GetInstance().GetContentProvider();
    const auto& disabled = Settings::values.disabled_addons[title_id];
@@ -451,8 +423,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
    }

    // General Mods (LayeredFS and IPS)
-    const auto mod_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto mod_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
    if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
        for (const auto& mod : mod_dir->GetSubdirectories()) {
            std::string types;
@@ -8,9 +8,9 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
+#include "core/file_sys/cheat_engine.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/vfs.h"
-#include "core/memory/dmnt_cheat_types.h"

 namespace Core {
 class System;
@@ -51,8 +51,8 @@ public:
    bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;

    // Creates a CheatList object with all
-    std::vector<Memory::CheatEntry> CreateCheatList(const Core::System& system,
-                                                    const std::array<u8, 0x20>& build_id) const;
+    std::vector<CheatList> CreateCheatList(const Core::System& system,
+                                           const std::array<u8, 0x20>& build_id) const;

    // Currently tracked RomFS patches:
    // - Game Updates
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.

 #include <algorithm>
-#include <random>
 #include <regex>
 #include <mbedtls/sha256.h>
 #include "common/assert.h"
@@ -49,21 +48,18 @@ static bool FollowsTwoDigitDirFormat(std::string_view name) {
 static bool FollowsNcaIdFormat(std::string_view name) {
    static const std::regex nca_id_regex("[0-9A-F]{32}\\.nca", std::regex_constants::ECMAScript |
                                                                   std::regex_constants::icase);
-    static const std::regex nca_id_cnmt_regex(
-        "[0-9A-F]{32}\\.cnmt.nca", std::regex_constants::ECMAScript | std::regex_constants::icase);
-    return (name.size() == 36 && std::regex_match(name.begin(), name.end(), nca_id_regex)) ||
-           (name.size() == 41 && std::regex_match(name.begin(), name.end(), nca_id_cnmt_regex));
+    return name.size() == 36 && std::regex_match(name.begin(), name.end(), nca_id_regex);
 }

 static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bool second_hex_upper,
-                                            bool within_two_digit, bool cnmt_suffix) {
-    if (!within_two_digit)
-        return fmt::format(cnmt_suffix ? "{}.cnmt.nca" : "/{}.nca",
-                           Common::HexToString(nca_id, second_hex_upper));
+                                            bool within_two_digit) {
+    if (!within_two_digit) {
+        return fmt::format("/{}.nca", Common::HexToString(nca_id, second_hex_upper));
+    }

    Core::Crypto::SHA256Hash hash{};
    mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
-    return fmt::format(cnmt_suffix ? "/000000{:02X}/{}.cnmt.nca" : "/000000{:02X}/{}.nca", hash[0],
+    return fmt::format("/000000{:02X}/{}.nca", hash[0],
                       Common::HexToString(nca_id, second_hex_upper));
 }

@@ -131,156 +127,6 @@ std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
    return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
 }

-PlaceholderCache::PlaceholderCache(VirtualDir dir_) : dir(std::move(dir_)) {}
-
-bool PlaceholderCache::Create(const NcaID& id, u64 size) const {
-    const auto path = GetRelativePathFromNcaID(id, false, true, false);
-
-    if (dir->GetFileRelative(path) != nullptr) {
-        return false;
-    }
-
-    Core::Crypto::SHA256Hash hash{};
-    mbedtls_sha256(id.data(), id.size(), hash.data(), 0);
-    const auto dirname = fmt::format("000000{:02X}", hash[0]);
-
-    const auto dir2 = GetOrCreateDirectoryRelative(dir, dirname);
-
-    if (dir2 == nullptr)
-        return false;
-
-    const auto file = dir2->CreateFile(fmt::format("{}.nca", Common::HexToString(id, false)));
-
-    if (file == nullptr)
-        return false;
-
-    return file->Resize(size);
-}
-
-bool PlaceholderCache::Delete(const NcaID& id) const {
-    const auto path = GetRelativePathFromNcaID(id, false, true, false);
-
-    if (dir->GetFileRelative(path) == nullptr) {
-        return false;
-    }
-
-    Core::Crypto::SHA256Hash hash{};
-    mbedtls_sha256(id.data(), id.size(), hash.data(), 0);
-    const auto dirname = fmt::format("000000{:02X}", hash[0]);
-
-    const auto dir2 = GetOrCreateDirectoryRelative(dir, dirname);
-
-    const auto res = dir2->DeleteFile(fmt::format("{}.nca", Common::HexToString(id, false)));
-
-    return res;
-}
-
-bool PlaceholderCache::Exists(const NcaID& id) const {
-    const auto path = GetRelativePathFromNcaID(id, false, true, false);
-
-    return dir->GetFileRelative(path) != nullptr;
-}
-
-bool PlaceholderCache::Write(const NcaID& id, u64 offset, const std::vector<u8>& data) const {
-    const auto path = GetRelativePathFromNcaID(id, false, true, false);
-    const auto file = dir->GetFileRelative(path);
-
-    if (file == nullptr)
-        return false;
-
-    return file->WriteBytes(data, offset) == data.size();
-}
-
-bool PlaceholderCache::Register(RegisteredCache* cache, const NcaID& placeholder,
-                                const NcaID& install) const {
-    const auto path = GetRelativePathFromNcaID(placeholder, false, true, false);
-    const auto file = dir->GetFileRelative(path);
-
-    if (file == nullptr)
-        return false;
-
-    const auto res = cache->RawInstallNCA(NCA{file}, &VfsRawCopy, false, install);
-
-    if (res != InstallResult::Success)
-        return false;
-
-    return Delete(placeholder);
-}
-
-bool PlaceholderCache::CleanAll() const {
-    return dir->GetParentDirectory()->CleanSubdirectoryRecursive(dir->GetName());
-}
-
-std::optional<std::array<u8, 0x10>> PlaceholderCache::GetRightsID(const NcaID& id) const {
-    const auto path = GetRelativePathFromNcaID(id, false, true, false);
-    const auto file = dir->GetFileRelative(path);
-
-    if (file == nullptr)
-        return std::nullopt;
-
-    NCA nca{file};
-
-    if (nca.GetStatus() != Loader::ResultStatus::Success &&
-        nca.GetStatus() != Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-        return std::nullopt;
-    }
-
-    const auto rights_id = nca.GetRightsId();
-    if (rights_id == NcaID{})
-        return std::nullopt;
-
-    return rights_id;
-}
-
-u64 PlaceholderCache::Size(const NcaID& id) const {
-    const auto path = GetRelativePathFromNcaID(id, false, true, false);
-    const auto file = dir->GetFileRelative(path);
-
-    if (file == nullptr)
-        return 0;
-
-    return file->GetSize();
-}
-
-bool PlaceholderCache::SetSize(const NcaID& id, u64 new_size) const {
-    const auto path = GetRelativePathFromNcaID(id, false, true, false);
-    const auto file = dir->GetFileRelative(path);
-
-    if (file == nullptr)
-        return false;
-
-    return file->Resize(new_size);
-}
-
-std::vector<NcaID> PlaceholderCache::List() const {
-    std::vector<NcaID> out;
-    for (const auto& sdir : dir->GetSubdirectories()) {
-        for (const auto& file : sdir->GetFiles()) {
-            const auto name = file->GetName();
-            if (name.length() == 36 && name[32] == '.' && name[33] == 'n' && name[34] == 'c' &&
-                name[35] == 'a') {
-                out.push_back(Common::HexStringToArray<0x10>(name.substr(0, 32)));
-            }
-        }
-    }
-    return out;
-}
-
-NcaID PlaceholderCache::Generate() {
-    std::random_device device;
-    std::mt19937 gen(device());
-    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-
-    NcaID out{};
-
-    const auto v1 = distribution(gen);
-    const auto v2 = distribution(gen);
-    std::memcpy(out.data(), &v1, sizeof(u64));
-    std::memcpy(out.data() + sizeof(u64), &v2, sizeof(u64));
-
-    return out;
-}
-
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                       std::string_view path) const {
    const auto file = dir->GetFileRelative(path);
@@ -323,18 +169,14 @@ VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,

 VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
    VirtualFile file;
-    // Try all five relevant modes of file storage:
-    // (bit 2 = uppercase/lower, bit 1 = within a two-digit dir, bit 0 = .cnmt suffix)
-    // 000: /000000**/{:032X}.nca
-    // 010: /{:032X}.nca
-    // 100: /000000**/{:032x}.nca
-    // 110: /{:032x}.nca
-    // 111: /{:032x}.cnmt.nca
-    for (u8 i = 0; i < 8; ++i) {
-        if ((i % 2) == 1 && i != 7)
-            continue;
-        const auto path =
-            GetRelativePathFromNcaID(id, (i & 0b100) == 0, (i & 0b010) == 0, (i & 0b001) == 0b001);
+    // Try all four modes of file storage:
+    // (bit 1 = uppercase/lower, bit 0 = within a two-digit dir)
+    // 00: /000000**/{:032X}.nca
+    // 01: /{:032X}.nca
+    // 10: /000000**/{:032x}.nca
+    // 11: /{:032x}.nca
+    for (u8 i = 0; i < 4; ++i) {
+        const auto path = GetRelativePathFromNcaID(id, (i & 0b10) == 0, (i & 0b01) == 0);
        file = OpenFileOrDirectoryConcat(dir, path);
        if (file != nullptr)
            return file;
@@ -630,7 +472,7 @@ InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFuncti
        memcpy(id.data(), hash.data(), 16);
    }

-    std::string path = GetRelativePathFromNcaID(id, false, true, false);
+    std::string path = GetRelativePathFromNcaID(id, false, true);

    if (GetFileAtID(id) != nullptr && !overwrite_if_exists) {
        LOG_WARNING(Loader, "Attempting to overwrite existing NCA. Skipping...");
@@ -25,8 +25,6 @@ enum class NCAContentType : u8;
 enum class TitleType : u8;

 struct ContentRecord;
-struct MetaRecord;
-class RegisteredCache;

 using NcaID = std::array<u8, 0x10>;
 using ContentProviderParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
@@ -91,27 +89,6 @@ protected:
    Core::Crypto::KeyManager keys;
 };

-class PlaceholderCache {
-public:
-    explicit PlaceholderCache(VirtualDir dir);
-
-    bool Create(const NcaID& id, u64 size) const;
-    bool Delete(const NcaID& id) const;
-    bool Exists(const NcaID& id) const;
-    bool Write(const NcaID& id, u64 offset, const std::vector<u8>& data) const;
-    bool Register(RegisteredCache* cache, const NcaID& placeholder, const NcaID& install) const;
-    bool CleanAll() const;
-    std::optional<std::array<u8, 0x10>> GetRightsID(const NcaID& id) const;
-    u64 Size(const NcaID& id) const;
-    bool SetSize(const NcaID& id, u64 new_size) const;
-    std::vector<NcaID> List() const;
-
-    static NcaID Generate();
-
-private:
-    VirtualDir dir;
-};
-
 /*
 * A class that catalogues NCAs in the registered directory structure.
 * Nintendo's registered format follows this structure:
@@ -126,8 +103,6 @@ private:
 * when 4GB splitting can be ignored.)
 */
 class RegisteredCache : public ContentProvider {
-    friend class PlaceholderCache;
-
 public:
    // Parsing function defines the conversion from raw file to NCA. If there are other steps
    // besides creating the NCA from the file (e.g. NAX0 on SD Card), that should go in a custom
@@ -7,7 +7,6 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -35,17 +34,16 @@ 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() {
    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));
 }

-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
-                                          ContentRecordType type) const {
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {
    std::shared_ptr<NCA> res;

    switch (storage) {
@@ -53,17 +51,13 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
        res = Core::System::GetInstance().GetContentProvider().GetEntry(title_id, type);
        break;
    case StorageId::NandSystem:
-        res =
-            Core::System::GetInstance().GetFileSystemController().GetSystemNANDContents()->GetEntry(
-                title_id, type);
+        res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);
        break;
    case StorageId::NandUser:
-        res = Core::System::GetInstance().GetFileSystemController().GetUserNANDContents()->GetEntry(
-            title_id, type);
+        res = Service::FileSystem::GetUserNANDContents()->GetEntry(title_id, type);
        break;
    case StorageId::SdCard:
-        res = Core::System::GetInstance().GetFileSystemController().GetSDMCContents()->GetEntry(
-            title_id, type);
+        res = Service::FileSystem::GetSDMCContents()->GetEntry(title_id, type);
        break;
    default:
        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
@@ -33,8 +33,8 @@ public:
    ~RomFSFactory();

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

 private:
    VirtualFile file;
@@ -15,8 +15,22 @@ namespace FileSys {

 constexpr char SAVE_DATA_SIZE_FILENAME[] = ".yuzu_save_size";

-namespace {
-void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
+std::string SaveDataDescriptor::DebugInfo() const {
+    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}, "
+                       "rank={}, index={}]",
+                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id,
+                       static_cast<u8>(rank), index);
+}
+
+SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {
+    // Delete all temporary storages
+    // On hardware, it is expected that temporary storage be empty at first use.
+    dir->DeleteSubdirectoryRecursive("temp");
+}
+
+SaveDataFactory::~SaveDataFactory() = default;
+
+ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataDescriptor& meta) {
    if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
        if (meta.zero_1 != 0) {
            LOG_WARNING(Service_FS,
@@ -51,51 +65,23 @@ void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
                    "non-zero ({:016X}{:016X})",
                    meta.user_id[1], meta.user_id[0]);
    }
-}
-} // Anonymous namespace

-std::string SaveDataDescriptor::DebugInfo() const {
-    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, "
-                       "save_id={:016X}, "
-                       "rank={}, index={}]",
-                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id,
-                       static_cast<u8>(rank), index);
-}
-
-SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {
-    // Delete all temporary storages
-    // On hardware, it is expected that temporary storage be empty at first use.
-    dir->DeleteSubdirectoryRecursive("temp");
-}
-
-SaveDataFactory::~SaveDataFactory() = default;
-
-ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
-                                              const SaveDataDescriptor& meta) const {
-    PrintSaveDataDescriptorWarnings(meta);
-
-    const auto save_directory =
+    std::string save_directory =
        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);

-    auto out = dir->CreateDirectoryRelative(save_directory);
-
-    // Return an error if the save data doesn't actually exist.
-    if (out == nullptr) {
-        // TODO(DarkLordZach): Find out correct error code.
-        return ResultCode(-1);
-    }
-
-    return MakeResult<VirtualDir>(std::move(out));
-}
-
-ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
-                                            const SaveDataDescriptor& meta) const {
-
-    const auto save_directory =
-        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+    // TODO(DarkLordZach): Try to not create when opening, there are dedicated create save methods.
+    // But, user_ids don't match so this works for now.

    auto out = dir->GetDirectoryRelative(save_directory);

+    if (out == nullptr) {
+        // TODO(bunnei): This is a work-around to always create a save data directory if it does not
+        // already exist. This is a hack, as we do not understand yet how this works on hardware.
+        // Without a save data directory, many games will assert on boot. This should not have any
+        // bad side-effects.
+        out = dir->CreateDirectoryRelative(save_directory);
+    }
+
    // Return an error if the save data doesn't actually exist.
    if (out == nullptr) {
        // TODO(Subv): Find out correct error code.
@@ -127,9 +113,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);

@@ -167,7 +152,7 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
 }

 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
-                                        SaveDataSize new_value) const {
+                                        SaveDataSize new_value) {
    const auto path = GetFullPath(SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
    const auto dir = GetOrCreateDirectoryRelative(this->dir, path);

@@ -64,8 +64,7 @@ public:
    explicit SaveDataFactory(VirtualDir dir);
    ~SaveDataFactory();

-    ResultVal<VirtualDir> Create(SaveDataSpaceId space, const SaveDataDescriptor& meta) const;
-    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataDescriptor& meta) const;
+    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataDescriptor& meta);

    VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;

@@ -74,8 +73,7 @@ public:
                                   u128 user_id, u64 save_id);

    SaveDataSize ReadSaveDataSize(SaveDataType type, u64 title_id, u128 user_id) const;
-    void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
-                           SaveDataSize new_value) const;
+    void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id, SaveDataSize new_value);

 private:
    VirtualDir dir;
@@ -6,7 +6,6 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/xts_archive.h"
-#include "core/settings.h"

 namespace FileSys {

@@ -15,38 +14,16 @@ SDMCFactory::SDMCFactory(VirtualDir dir_)
                                GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/registered"),
                                [](const VirtualFile& file, const NcaID& id) {
                                    return NAX{file, id}.GetDecrypted();
-                                })),
-      placeholder(std::make_unique<PlaceholderCache>(
-          GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/placehld"))) {}
+                                })) {}

 SDMCFactory::~SDMCFactory() = default;

-ResultVal<VirtualDir> SDMCFactory::Open() const {
+ResultVal<VirtualDir> SDMCFactory::Open() {
    return MakeResult<VirtualDir>(dir);
 }

-VirtualDir SDMCFactory::GetSDMCContentDirectory() const {
-    return GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents");
-}
-
 RegisteredCache* SDMCFactory::GetSDMCContents() const {
    return contents.get();
 }

-PlaceholderCache* SDMCFactory::GetSDMCPlaceholder() const {
-    return placeholder.get();
-}
-
-VirtualDir SDMCFactory::GetImageDirectory() const {
-    return GetOrCreateDirectoryRelative(dir, "/Nintendo/Album");
-}
-
-u64 SDMCFactory::GetSDMCFreeSpace() const {
-    return GetSDMCTotalSpace() - dir->GetSize();
-}
-
-u64 SDMCFactory::GetSDMCTotalSpace() const {
-    return static_cast<u64>(Settings::values.sdmc_size);
-}
-
 } // namespace FileSys
@@ -11,7 +11,6 @@
 namespace FileSys {

 class RegisteredCache;
-class PlaceholderCache;

 /// File system interface to the SDCard archive
 class SDMCFactory {
@@ -19,23 +18,13 @@ public:
    explicit SDMCFactory(VirtualDir dir);
    ~SDMCFactory();

-    ResultVal<VirtualDir> Open() const;
-
-    VirtualDir GetSDMCContentDirectory() const;
-
+    ResultVal<VirtualDir> Open();
    RegisteredCache* GetSDMCContents() const;
-    PlaceholderCache* GetSDMCPlaceholder() const;
-
-    VirtualDir GetImageDirectory() const;
-
-    u64 GetSDMCFreeSpace() const;
-    u64 GetSDMCTotalSpace() const;

 private:
    VirtualDir dir;

    std::unique_ptr<RegisteredCache> contents;
-    std::unique_ptr<PlaceholderCache> placeholder;
 };

 } // namespace FileSys
@@ -14,7 +14,6 @@
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/program_metadata.h"
 #include "core/file_sys/submission_package.h"
 #include "core/loader/loader.h"

@@ -79,10 +78,6 @@ Loader::ResultStatus NSP::GetStatus() const {
 }

 Loader::ResultStatus NSP::GetProgramStatus(u64 title_id) const {
-    if (IsExtractedType() && GetExeFS() != nullptr && FileSys::IsDirectoryExeFS(GetExeFS())) {
-        return Loader::ResultStatus::Success;
-    }
-
    const auto iter = program_status.find(title_id);
    if (iter == program_status.end())
        return Loader::ResultStatus::ErrorNSPMissingProgramNCA;
@@ -90,29 +85,12 @@ Loader::ResultStatus NSP::GetProgramStatus(u64 title_id) const {
 }

 u64 NSP::GetFirstTitleID() const {
-    if (IsExtractedType()) {
-        return GetProgramTitleID();
-    }
-
    if (program_status.empty())
        return 0;
    return program_status.begin()->first;
 }

 u64 NSP::GetProgramTitleID() const {
-    if (IsExtractedType()) {
-        if (GetExeFS() == nullptr || !IsDirectoryExeFS(GetExeFS())) {
-            return 0;
-        }
-
-        ProgramMetadata meta;
-        if (meta.Load(GetExeFS()->GetFile("main.npdm")) == Loader::ResultStatus::Success) {
-            return meta.GetTitleID();
-        } else {
-            return 0;
-        }
-    }
-
    const auto out = GetFirstTitleID();
    if ((out & 0x800) == 0)
        return out;
@@ -124,10 +102,6 @@ u64 NSP::GetProgramTitleID() const {
 }

 std::vector<u64> NSP::GetTitleIDs() const {
-    if (IsExtractedType()) {
-        return {GetProgramTitleID()};
-    }
-
    std::vector<u64> out;
    out.reserve(ncas.size());
    for (const auto& kv : ncas)
@@ -248,8 +222,7 @@ void NSP::InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files) {

 void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
    for (const auto& outer_file : files) {
-        if (outer_file->GetName().size() < 9 ||
-            outer_file->GetName().substr(outer_file->GetName().size() - 9) != ".cnmt.nca") {
+        if (outer_file->GetName().substr(outer_file->GetName().size() - 9) != ".cnmt.nca") {
            continue;
        }

@@ -1,79 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string>
-#include <zip.h>
-#include "common/logging/backend.h"
-#include "core/file_sys/vfs.h"
-#include "core/file_sys/vfs_libzip.h"
-#include "core/file_sys/vfs_vector.h"
-
-namespace FileSys {
-
-VirtualDir ExtractZIP(VirtualFile file) {
-    zip_error_t error{};
-
-    const auto data = file->ReadAllBytes();
-    std::unique_ptr<zip_source_t, decltype(&zip_source_close)> src{
-        zip_source_buffer_create(data.data(), data.size(), 0, &error), zip_source_close};
-    if (src == nullptr)
-        return nullptr;
-
-    std::unique_ptr<zip_t, decltype(&zip_close)> zip{zip_open_from_source(src.get(), 0, &error),
-                                                     zip_close};
-    if (zip == nullptr)
-        return nullptr;
-
-    std::shared_ptr<VectorVfsDirectory> out = std::make_shared<VectorVfsDirectory>();
-
-    const auto num_entries = zip_get_num_entries(zip.get(), 0);
-
-    zip_stat_t stat{};
-    zip_stat_init(&stat);
-
-    for (std::size_t i = 0; i < num_entries; ++i) {
-        const auto stat_res = zip_stat_index(zip.get(), i, 0, &stat);
-        if (stat_res == -1)
-            return nullptr;
-
-        const std::string name(stat.name);
-        if (name.empty())
-            continue;
-
-        if (name.back() != '/') {
-            std::unique_ptr<zip_file_t, decltype(&zip_fclose)> file{
-                zip_fopen_index(zip.get(), i, 0), zip_fclose};
-
-            std::vector<u8> buf(stat.size);
-            if (zip_fread(file.get(), buf.data(), buf.size()) != buf.size())
-                return nullptr;
-
-            const auto parts = FileUtil::SplitPathComponents(stat.name);
-            const auto new_file = std::make_shared<VectorVfsFile>(buf, parts.back());
-
-            std::shared_ptr<VectorVfsDirectory> dtrv = out;
-            for (std::size_t j = 0; j < parts.size() - 1; ++j) {
-                if (dtrv == nullptr)
-                    return nullptr;
-                const auto subdir = dtrv->GetSubdirectory(parts[j]);
-                if (subdir == nullptr) {
-                    const auto temp = std::make_shared<VectorVfsDirectory>(
-                        std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, parts[j]);
-                    dtrv->AddDirectory(temp);
-                    dtrv = temp;
-                } else {
-                    dtrv = std::dynamic_pointer_cast<VectorVfsDirectory>(subdir);
-                }
-            }
-
-            if (dtrv == nullptr)
-                return nullptr;
-            dtrv->AddFile(new_file);
-        }
-    }
-
-    return out;
-}
-
-} // namespace FileSys
@@ -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 "core/file_sys/vfs_types.h"
-
-namespace FileSys {
-
-VirtualDir ExtractZIP(VirtualFile zip);
-
-} // namespace FileSys
@@ -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());
@@ -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
@@ -171,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)) {
@@ -18,7 +18,6 @@
 #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"
@@ -89,7 +88,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
 }

 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();
@@ -141,7 +140,6 @@ 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;

@@ -205,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));
 }
@@ -25,7 +25,6 @@ class HandleTable;
 class Process;
 class ResourceLimit;
 class Thread;
-class GlobalScheduler;

 /// Represents a single instance of the kernel.
 class KernelCore {
@@ -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();

@@ -154,11 +140,6 @@ ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
    thread->SetMutexWaitAddress(0);
    thread->SetWaitHandle(0);

-    if (thread->GetProcessorID() >= 0)
-        system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
-    if (holding_thread->GetProcessorID() >= 0)
-        system.CpuCore(holding_thread->GetProcessorID()).PrepareReschedule();
-
    return RESULT_SUCCESS;
 }
 } // namespace Kernel
@@ -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;
@@ -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;
@@ -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,277 +17,56 @@

 namespace Kernel {

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

-void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
-    thread_list.push_back(std::move(thread));
-}
+Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core)
+    : cpu_core{cpu_core}, system{system} {}

-void GlobalScheduler::RemoveThread(const Thread* thread) {
-    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
-                      thread_list.end());
-}
-
-/*
- * UnloadThread selects a core and forces it to unload its current thread's context
- */
-void GlobalScheduler::UnloadThread(s32 core) {
-    Scheduler& sched = system.Scheduler(core);
-    sched.UnloadThread();
-}
-
-/*
- * SelectThread takes care of selecting the new scheduled thread.
- * It does it in 3 steps:
- * - 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.
- * - 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.
- * - 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 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.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);
-}
-
-/*
- * YieldThread takes a thread and moves it to the back of the it's priority list
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
-void 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
-    ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority),
-               "Thread yielding without being in front");
-    scheduled_queue[core_id].yield(priority);
-
-    Thread* winner = scheduled_queue[core_id].front(priority);
-    AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-/*
- * YieldThreadAndBalanceLoad 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.
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
-void 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;
-    }
-
-    AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-/*
- * YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
- * and into the suggested queue. If no thread can be squeduled afterwards in that core,
- * a suggested thread is obtained instead.
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
-void 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;
-        }
-    }
-
-    AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-void GlobalScheduler::Schedule(u32 priority, u32 core, Thread* thread) {
-    ASSERT_MSG(thread->GetProcessorID() == 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() == core, "Thread must be assigned to this core.");
-    scheduled_queue[core].add(thread, priority, false);
-}
-
-void GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner) {
-    if (current_thread == winner) {
-        // TODO(blinkhawk): manage redundant operations, this is not implemented.
-        // as its mostly an optimization.
-        // current_thread->SetRedundantSchedulerOperation();
-    } else {
-        reselection_pending.store(true, std::memory_order_release);
+Scheduler::~Scheduler() {
+    for (auto& thread : thread_list) {
+        thread->Stop();
    }
 }

-GlobalScheduler::~GlobalScheduler() = default;
-
-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 (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);
@@ -306,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();
-
-    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() == 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) {
@@ -385,4 +130,124 @@ void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
    last_context_switch_time = most_recent_switch_ticks;
 }

+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,178 +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) {
-        suggested_queue[core].add(thread, priority);
-    }
-
-    // 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) {
-        suggested_queue[core].remove(thread, priority);
-    }
-
-    // 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) {
-        scheduled_queue[core].remove(thread, priority);
-        scheduled_queue[core].add(thread, priority);
-    }
-
-    // Unschedule a thread.
-    void Unschedule(u32 priority, u32 core, Thread* thread) {
-        scheduled_queue[core].remove(thread, priority);
-    }
-
-    // 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) {
-        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);
-        }
-    }
-
-    /*
-     * UnloadThread selects a core and forces it to unload its current thread's context
-     */
-    void UnloadThread(s32 core);
-
-    /*
-     * SelectThread takes care of selecting the new scheduled thread.
-     * It does it in 3 steps:
-     * - 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.
-     * - 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.
-     * - 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();
-    }
-
-    /*
-     * YieldThread takes a thread and moves it to the back of the it's priority list
-     * This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    void YieldThread(Thread* thread);
-
-    /*
-     * YieldThreadAndBalanceLoad 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.
-     * This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    void YieldThreadAndBalanceLoad(Thread* thread);
-
-    /*
-     * YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
-     * and into the suggested queue. If no thread can be squeduled afterwards in that core,
-     * a suggested thread is obtained instead.
-     * This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    void YieldThreadAndWaitForLoadBalancing(Thread* thread);
-
-    u32 CpuCoresCount() const {
-        return NUM_CPU_CORES;
-    }
-
-    void SetReselectionPending() {
-        reselection_pending.store(true, std::memory_order_release);
-    }
-
-    bool IsReselectionPending() const {
-        return reselection_pending.load();
-    }
-
-private:
-    void AskForReselectionOrMarkRedundant(Thread* current_thread, 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> reselection_pending;
-
-    /// 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, const 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();
-
-    void UnloadThread();
-
-    void SelectThreads();
+    void Reschedule();

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

-    Thread* GetSelectedThread() const;
-
    /// Gets the timestamp for the last context switch in ticks.
    u64 GetLastContextSwitchTicks() const;

-    bool ContextSwitchPending() const {
-        return 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;
    }

 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
     * @param new_thread The thread to switch to
     */
-    void SwitchContext();
+    void SwitchContext(Thread* new_thread);

    /**
     * Called on every context switch to update the internal timestamp
@@ -206,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 context_switch_pending = false;
+    Core::System& system;
+    static std::mutex scheduler_mutex;
 };

 } // namespace Kernel
@@ -516,7 +516,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
    thread->WakeAfterDelay(nano_seconds);
    thread->SetWakeupCallback(DefaultThreadWakeupCallback);

-    system.PrepareReschedule(thread->GetProcessorID());
+    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();

    return RESULT_TIMEOUT;
 }
@@ -534,7 +534,6 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
    }

    thread->CancelWait();
-    system.PrepareReschedule(thread->GetProcessorID());
    return RESULT_SUCCESS;
 }

@@ -578,8 +577,7 @@ static ResultCode ArbitrateUnlock(Core::System& system, VAddr mutex_addr) {
    }

    auto* const current_process = system.Kernel().CurrentProcess();
-    return current_process->GetMutex().Release(mutex_addr,
-                                               system.CurrentScheduler().GetCurrentThread());
+    return current_process->GetMutex().Release(mutex_addr);
 }

 enum class BreakType : u32 {
@@ -1068,8 +1066,6 @@ static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 act
    }

    thread->SetActivity(static_cast<ThreadActivity>(activity));
-
-    system.PrepareReschedule(thread->GetProcessorID());
    return RESULT_SUCCESS;
 }

@@ -1151,7 +1147,7 @@ static ResultCode SetThreadPriority(Core::System& system, Handle handle, u32 pri

    thread->SetPriority(priority);

-    system.PrepareReschedule(thread->GetProcessorID());
+    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
    return RESULT_SUCCESS;
 }

@@ -1507,7 +1503,7 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e
    thread->SetName(
        fmt::format("thread[entry_point={:X}, handle={:X}]", entry_point, *new_thread_handle));

-    system.PrepareReschedule(thread->GetProcessorID());
+    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();

    return RESULT_SUCCESS;
 }
@@ -1529,7 +1525,7 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
    thread->ResumeFromWait();

    if (thread->GetStatus() == ThreadStatus::Ready) {
-        system.PrepareReschedule(thread->GetProcessorID());
+        system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
    }

    return RESULT_SUCCESS;
@@ -1541,7 +1537,7 @@ static void ExitThread(Core::System& system) {

    auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
    current_thread->Stop();
-    system.GlobalScheduler().RemoveThread(current_thread);
+    system.CurrentScheduler().RemoveThread(current_thread);
    system.PrepareReschedule();
 }

@@ -1561,13 +1557,13 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
    if (nanoseconds <= 0) {
        switch (static_cast<SleepType>(nanoseconds)) {
        case SleepType::YieldWithoutLoadBalancing:
-            current_thread->YieldSimple();
+            scheduler.YieldWithoutLoadBalancing(current_thread);
            break;
        case SleepType::YieldWithLoadBalancing:
-            current_thread->YieldAndBalanceLoad();
+            scheduler.YieldWithLoadBalancing(current_thread);
            break;
        case SleepType::YieldAndWaitForLoadBalancing:
-            current_thread->YieldAndWaitForLoadBalancing();
+            scheduler.YieldAndWaitForLoadBalancing(current_thread);
            break;
        default:
            UNREACHABLE_MSG("Unimplemented sleep yield type '{:016X}'!", nanoseconds);
@@ -1576,7 +1572,10 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
        current_thread->Sleep(nanoseconds);
    }

-    system.PrepareReschedule(current_thread->GetProcessorID());
+    // Reschedule all CPU cores
+    for (std::size_t i = 0; i < Core::NUM_CPU_CORES; ++i) {
+        system.CpuCore(i).PrepareReschedule();
+    }
 }

 /// Wait process wide key atomic
@@ -1607,14 +1606,12 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    ASSERT(thread);

-    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
-
-    const auto release_result =
-        current_process->GetMutex().Release(mutex_addr, current_thread.get());
+    const auto release_result = current_process->GetMutex().Release(mutex_addr);
    if (release_result.IsError()) {
        return release_result;
    }

+    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
    current_thread->SetCondVarWaitAddress(condition_variable_addr);
    current_thread->SetMutexWaitAddress(mutex_addr);
    current_thread->SetWaitHandle(thread_handle);
@@ -1625,7 +1622,7 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add

    // Note: Deliberately don't attempt to inherit the lock owner's priority.

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

@@ -1635,17 +1632,24 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
    LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
              condition_variable_addr, target);

+    const auto RetrieveWaitingThreads = [&system](std::size_t core_index,
+                                                  std::vector<SharedPtr<Thread>>& waiting_threads,
+                                                  VAddr condvar_addr) {
+        const auto& scheduler = system.Scheduler(core_index);
+        const auto& thread_list = scheduler.GetThreadList();
+
+        for (const auto& thread : thread_list) {
+            if (thread->GetCondVarWaitAddress() == condvar_addr)
+                waiting_threads.push_back(thread);
+        }
+    };
+
    // Retrieve a list of all threads that are waiting for this condition variable.
    std::vector<SharedPtr<Thread>> waiting_threads;
-    const auto& scheduler = system.GlobalScheduler();
-    const auto& thread_list = scheduler.GetThreadList();
-
-    for (const auto& thread : thread_list) {
-        if (thread->GetCondVarWaitAddress() == condition_variable_addr) {
-            waiting_threads.push_back(thread);
-        }
-    }
-
+    RetrieveWaitingThreads(0, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(1, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(2, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(3, waiting_threads, condition_variable_addr);
    // Sort them by priority, such that the highest priority ones come first.
    std::sort(waiting_threads.begin(), waiting_threads.end(),
              [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
@@ -1700,7 +1704,7 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
            thread->SetLockOwner(nullptr);
            thread->SetMutexWaitAddress(0);
            thread->SetWaitHandle(0);
-            system.PrepareReschedule(thread->GetProcessorID());
+            system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
        } else {
            // Atomically signal that the mutex now has a waiting thread.
            do {
@@ -1724,7 +1728,6 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
            thread->SetStatus(ThreadStatus::WaitMutex);

            owner->AddMutexWaiter(thread);
-            system.PrepareReschedule(thread->GetProcessorID());
        }
    }

@@ -1751,12 +1754,7 @@ static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type,

    const auto arbitration_type = static_cast<AddressArbiter::ArbitrationType>(type);
    auto& address_arbiter = system.Kernel().CurrentProcess()->GetAddressArbiter();
-    const ResultCode result =
-        address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
-    if (result == RESULT_SUCCESS) {
-        system.PrepareReschedule();
-    }
-    return result;
+    return address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
 }

 // Signals to an address (via Address Arbiter)
@@ -2042,10 +2040,7 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,
        return ERR_INVALID_HANDLE;
    }

-    system.PrepareReschedule(thread->GetProcessorID());
    thread->ChangeCore(core, affinity_mask);
-    system.PrepareReschedule(thread->GetProcessorID());
-
    return RESULT_SUCCESS;
 }

@@ -2156,7 +2151,6 @@ static ResultCode SignalEvent(Core::System& system, Handle handle) {
    }

    writable_event->Signal();
-    system.PrepareReschedule();
    return RESULT_SUCCESS;
 }

@@ -45,7 +45,15 @@ void Thread::Stop() {
                                                             callback_handle);
    kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
    callback_handle = 0;
-    SetStatus(ThreadStatus::Dead);
+
+    // Clean up thread from ready queue
+    // This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
+    if (status == ThreadStatus::Ready || status == ThreadStatus::Paused) {
+        scheduler->UnscheduleThread(this, current_priority);
+    }
+
+    status = ThreadStatus::Dead;
+
    WakeupAllWaitingThreads();

    // Clean up any dangling references in objects that this thread was waiting for
@@ -124,11 +132,13 @@ void Thread::ResumeFromWait() {
    wakeup_callback = nullptr;

    if (activity == ThreadActivity::Paused) {
-        SetStatus(ThreadStatus::Paused);
+        status = ThreadStatus::Paused;
        return;
    }

-    SetStatus(ThreadStatus::Ready);
+    status = ThreadStatus::Ready;
+
+    ChangeScheduler();
 }

 void Thread::CancelWait() {
@@ -195,9 +205,9 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
    thread->name = std::move(name);
    thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
    thread->owner_process = &owner_process;
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.AddThread(thread);
    thread->tls_address = thread->owner_process->CreateTLSRegion();
+    thread->scheduler = &system.Scheduler(processor_id);
+    thread->scheduler->AddThread(thread);

    thread->owner_process->RegisterThread(thread.get());

@@ -240,22 +250,6 @@ void Thread::SetStatus(ThreadStatus new_status) {
        return;
    }

-    switch (new_status) {
-    case ThreadStatus::Ready:
-    case ThreadStatus::Running:
-        SetSchedulingStatus(ThreadSchedStatus::Runnable);
-        break;
-    case ThreadStatus::Dormant:
-        SetSchedulingStatus(ThreadSchedStatus::None);
-        break;
-    case ThreadStatus::Dead:
-        SetSchedulingStatus(ThreadSchedStatus::Exited);
-        break;
-    default:
-        SetSchedulingStatus(ThreadSchedStatus::Paused);
-        break;
-    }
-
    if (status == ThreadStatus::Running) {
        last_running_ticks = Core::System::GetInstance().CoreTiming().GetTicks();
    }
@@ -317,7 +311,8 @@ void Thread::UpdatePriority() {
        return;
    }

-    SetCurrentPriority(new_priority);
+    scheduler->SetThreadPriority(this, new_priority);
+    current_priority = new_priority;

    if (!lock_owner) {
        return;
@@ -333,7 +328,47 @@ void Thread::UpdatePriority() {
 }

 void Thread::ChangeCore(u32 core, u64 mask) {
-    SetCoreAndAffinityMask(core, mask);
+    ideal_core = core;
+    affinity_mask = mask;
+    ChangeScheduler();
+}
+
+void Thread::ChangeScheduler() {
+    if (status != ThreadStatus::Ready) {
+        return;
+    }
+
+    auto& system = Core::System::GetInstance();
+    std::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
+
+    if (!new_processor_id) {
+        new_processor_id = processor_id;
+    }
+    if (ideal_core != -1 && system.Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+        new_processor_id = ideal_core;
+    }
+
+    ASSERT(*new_processor_id < 4);
+
+    // Add thread to new core's scheduler
+    auto& next_scheduler = system.Scheduler(*new_processor_id);
+
+    if (*new_processor_id != processor_id) {
+        // Remove thread from previous core's scheduler
+        scheduler->RemoveThread(this);
+        next_scheduler.AddThread(this);
+    }
+
+    processor_id = *new_processor_id;
+
+    // If the thread was ready, unschedule from the previous core and schedule on the new core
+    scheduler->UnscheduleThread(this, current_priority);
+    next_scheduler.ScheduleThread(this, current_priority);
+
+    // Change thread's scheduler
+    scheduler = &next_scheduler;
+
+    system.CpuCore(processor_id).PrepareReschedule();
 }

 bool Thread::AllWaitObjectsReady() const {
@@ -356,7 +391,7 @@ void Thread::SetActivity(ThreadActivity value) {
        if (status == ThreadStatus::Ready) {
            status = ThreadStatus::Paused;
        } else if (status == ThreadStatus::Running) {
-            SetStatus(ThreadStatus::Paused);
+            status = ThreadStatus::Paused;
            Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
        }
    } else if (status == ThreadStatus::Paused) {
@@ -373,171 +408,6 @@ void Thread::Sleep(s64 nanoseconds) {
    WakeAfterDelay(nanoseconds);
 }

-void Thread::YieldSimple() {
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.YieldThread(this);
-}
-
-void Thread::YieldAndBalanceLoad() {
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.YieldThreadAndBalanceLoad(this);
-}
-
-void Thread::YieldAndWaitForLoadBalancing() {
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.YieldThreadAndWaitForLoadBalancing(this);
-}
-
-void Thread::SetSchedulingStatus(ThreadSchedStatus new_status) {
-    const u32 old_flags = scheduling_state;
-    scheduling_state =
-        (scheduling_state & ThreadSchedMasks::HighMask) | static_cast<u32>(new_status);
-    AdjustSchedulingOnStatus(old_flags);
-}
-
-void Thread::SetCurrentPriority(u32 new_priority) {
-    u32 old_priority = std::exchange(current_priority, new_priority);
-    AdjustSchedulingOnPriority(old_priority);
-}
-
-ResultCode Thread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
-    const auto HighestSetCore = [](u64 mask, u32 max_cores) {
-        for (s32 core = max_cores - 1; core >= 0; core--) {
-            if (((mask >> core) & 1) != 0) {
-                return core;
-            }
-        }
-        return -1;
-    };
-
-    const bool use_override = affinity_override_count != 0;
-    // The value -3 is "do not change the ideal core".
-    if (new_core == -3) {
-        new_core = use_override ? ideal_core_override : ideal_core;
-        if ((new_affinity_mask & (1 << new_core)) == 0) {
-            return ERR_INVALID_COMBINATION;
-        }
-    }
-    if (use_override) {
-        ideal_core_override = new_core;
-        affinity_mask_override = new_affinity_mask;
-    } else {
-        const u64 old_affinity_mask = std::exchange(affinity_mask, new_affinity_mask);
-        ideal_core = new_core;
-        if (old_affinity_mask != new_affinity_mask) {
-            const s32 old_core = processor_id;
-            if (processor_id >= 0 && ((affinity_mask >> processor_id) & 1) == 0) {
-                if (ideal_core < 0) {
-                    processor_id = HighestSetCore(affinity_mask, GlobalScheduler::NUM_CPU_CORES);
-                } else {
-                    processor_id = ideal_core;
-                }
-            }
-            AdjustSchedulingOnAffinity(old_affinity_mask, old_core);
-        }
-    }
-    return RESULT_SUCCESS;
-}
-
-void Thread::AdjustSchedulingOnStatus(u32 old_flags) {
-    if (old_flags == scheduling_state) {
-        return;
-    }
-
-    auto& scheduler = kernel.GlobalScheduler();
-    if (static_cast<ThreadSchedStatus>(old_flags & ThreadSchedMasks::LowMask) ==
-        ThreadSchedStatus::Runnable) {
-        // In this case the thread was running, now it's pausing/exitting
-        if (processor_id >= 0) {
-            scheduler.Unschedule(current_priority, processor_id, this);
-        }
-
-        for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-            if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-                scheduler.Unsuggest(current_priority, core, this);
-            }
-        }
-    } else if (GetSchedulingStatus() == ThreadSchedStatus::Runnable) {
-        // The thread is now set to running from being stopped
-        if (processor_id >= 0) {
-            scheduler.Schedule(current_priority, processor_id, this);
-        }
-
-        for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-            if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-                scheduler.Suggest(current_priority, core, this);
-            }
-        }
-    }
-
-    scheduler.SetReselectionPending();
-}
-
-void Thread::AdjustSchedulingOnPriority(u32 old_priority) {
-    if (GetSchedulingStatus() != ThreadSchedStatus::Runnable) {
-        return;
-    }
-    auto& scheduler = Core::System::GetInstance().GlobalScheduler();
-    if (processor_id >= 0) {
-        scheduler.Unschedule(old_priority, processor_id, this);
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-            scheduler.Unsuggest(old_priority, core, this);
-        }
-    }
-
-    // Add thread to the new priority queues.
-    Thread* current_thread = GetCurrentThread();
-
-    if (processor_id >= 0) {
-        if (current_thread == this) {
-            scheduler.SchedulePrepend(current_priority, processor_id, this);
-        } else {
-            scheduler.Schedule(current_priority, processor_id, this);
-        }
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-            scheduler.Suggest(current_priority, core, this);
-        }
-    }
-
-    scheduler.SetReselectionPending();
-}
-
-void Thread::AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core) {
-    auto& scheduler = Core::System::GetInstance().GlobalScheduler();
-    if (GetSchedulingStatus() != ThreadSchedStatus::Runnable ||
-        current_priority >= THREADPRIO_COUNT) {
-        return;
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (((old_affinity_mask >> core) & 1) != 0) {
-            if (core == old_core) {
-                scheduler.Unschedule(current_priority, core, this);
-            } else {
-                scheduler.Unsuggest(current_priority, core, this);
-            }
-        }
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (((affinity_mask >> core) & 1) != 0) {
-            if (core == processor_id) {
-                scheduler.Schedule(current_priority, core, this);
-            } else {
-                scheduler.Suggest(current_priority, core, this);
-            }
-        }
-    }
-
-    scheduler.SetReselectionPending();
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 /**
@@ -75,26 +75,6 @@ enum class ThreadActivity : u32 {
    Paused = 1,
 };

-enum class ThreadSchedStatus : u32 {
-    None = 0,
-    Paused = 1,
-    Runnable = 2,
-    Exited = 3,
-};
-
-enum ThreadSchedFlags : u32 {
-    ProcessPauseFlag = 1 << 4,
-    ThreadPauseFlag = 1 << 5,
-    ProcessDebugPauseFlag = 1 << 6,
-    KernelInitPauseFlag = 1 << 8,
-};
-
-enum ThreadSchedMasks : u32 {
-    LowMask = 0x000f,
-    HighMask = 0xfff0,
-    ForcePauseMask = 0x0070,
-};
-
 class Thread final : public WaitObject {
 public:
    using MutexWaitingThreads = std::vector<SharedPtr<Thread>>;
@@ -298,10 +278,6 @@ public:
        return processor_id;
    }

-    void SetProcessorID(s32 new_core) {
-        processor_id = new_core;
-    }
-
    Process* GetOwnerProcess() {
        return owner_process;
    }
@@ -407,38 +383,11 @@ public:
    /// Sleeps this thread for the given amount of nanoseconds.
    void Sleep(s64 nanoseconds);

-    /// Yields this thread without rebalancing loads.
-    void YieldSimple();
-
-    /// Yields this thread and does a load rebalancing.
-    void YieldAndBalanceLoad();
-
-    /// Yields this thread and if the core is left idle, loads are rebalanced
-    void YieldAndWaitForLoadBalancing();
-
-    ThreadSchedStatus GetSchedulingStatus() const {
-        return static_cast<ThreadSchedStatus>(scheduling_state & ThreadSchedMasks::LowMask);
-    }
-
-    bool IsRunning() const {
-        return is_running;
-    }
-
-    void SetIsRunning(bool value) {
-        is_running = value;
-    }
-
 private:
    explicit Thread(KernelCore& kernel);
    ~Thread() override;

-    void SetSchedulingStatus(ThreadSchedStatus new_status);
-    void SetCurrentPriority(u32 new_priority);
-    ResultCode SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask);
-
-    void AdjustSchedulingOnStatus(u32 old_flags);
-    void AdjustSchedulingOnPriority(u32 old_priority);
-    void AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core);
+    void ChangeScheduler();

    Core::ARM_Interface::ThreadContext context{};

@@ -504,13 +453,6 @@ private:

    ThreadActivity activity = ThreadActivity::Normal;

-    s32 ideal_core_override = -1;
-    u64 affinity_mask_override = 0x1;
-    u32 affinity_override_count = 0;
-
-    u32 scheduling_state = 0;
-    bool is_running = false;
-
    std::string name;
 };

@@ -23,8 +23,6 @@ SharedPtr<TransferMemory> TransferMemory::Create(KernelCore& kernel, VAddr base_
    transfer_memory->owner_permissions = permissions;
    transfer_memory->owner_process = kernel.CurrentProcess();

-    transfer_memory->MapMemory(base_address, size, permissions);
-
    return transfer_memory;
 }

@@ -6,8 +6,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
@@ -50,8 +48,17 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
        if (ShouldWait(thread.get()))
            continue;

-        candidate = thread.get();
-        candidate_priority = thread->GetPriority();
+        // A thread is ready to run if it's either in ThreadStatus::WaitSynch
+        // and the rest of the objects it is waiting on are ready.
+        bool ready_to_run = true;
+        if (thread_status == ThreadStatus::WaitSynch) {
+            ready_to_run = thread->AllWaitObjectsReady();
+        }
+
+        if (ready_to_run) {
+            candidate = thread.get();
+            candidate_priority = thread->GetPriority();
+        }
    }

    return candidate;
@@ -88,7 +95,6 @@ void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
    }
    if (resume) {
        thread->ResumeFromWait();
-        Core::System::GetInstance().PrepareReschedule(thread->GetProcessorID());
    }
 }

@@ -70,7 +70,7 @@ public:

 protected:
    void Get(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
+        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
        ProfileBase profile_base{};
        ProfileData data{};
        if (profile_manager.GetProfileBaseAndData(user_id, profile_base, data)) {
@@ -89,7 +89,7 @@ protected:
    }

    void GetBase(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
+        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
        ProfileBase profile_base{};
        if (profile_manager.GetProfileBase(user_id, profile_base)) {
            IPC::ResponseBuilder rb{ctx, 16};
@@ -263,7 +263,7 @@ private:
 };

 void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
+    LOG_INFO(Service_ACC, "called");
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push<u32>(static_cast<u32>(profile_manager->GetUserCount()));
@@ -272,7 +272,7 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    Common::UUID user_id = rp.PopRaw<Common::UUID>();
-    LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
+    LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());

    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
@@ -280,21 +280,21 @@ void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
 }

 void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
+    LOG_INFO(Service_ACC, "called");
    ctx.WriteBuffer(profile_manager->GetAllUsers());
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }

 void Module::Interface::ListOpenUsers(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
+    LOG_INFO(Service_ACC, "called");
    ctx.WriteBuffer(profile_manager->GetOpenUsers());
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }

 void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
+    LOG_INFO(Service_ACC, "called");
    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(RESULT_SUCCESS);
    rb.PushRaw<Common::UUID>(profile_manager->GetLastOpenedUser());
@@ -31,7 +31,6 @@
 #include "core/hle/service/am/tcap.h"
 #include "core/hle/service/apm/controller.h"
 #include "core/hle/service/apm/interface.h"
-#include "core/hle/service/bcat/backend/backend.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -47,20 +46,15 @@ constexpr ResultCode ERR_NO_DATA_IN_CHANNEL{ErrorModule::AM, 0x2};
 constexpr ResultCode ERR_NO_MESSAGES{ErrorModule::AM, 0x3};
 constexpr ResultCode ERR_SIZE_OUT_OF_BOUNDS{ErrorModule::AM, 0x1F7};

-enum class LaunchParameterKind : u32 {
-    ApplicationSpecific = 1,
-    AccountPreselectedUser = 2,
-};
+constexpr u32 POP_LAUNCH_PARAMETER_MAGIC = 0xC79497CA;

-constexpr u32 LAUNCH_PARAMETER_ACCOUNT_PRESELECTED_USER_MAGIC = 0xC79497CA;
-
-struct LaunchParameterAccountPreselectedUser {
+struct LaunchParameters {
    u32_le magic;
    u32_le is_account_selected;
    u128 current_user;
    INSERT_PADDING_BYTES(0x70);
 };
-static_assert(sizeof(LaunchParameterAccountPreselectedUser) == 0x88);
+static_assert(sizeof(LaunchParameters) == 0x88);

 IWindowController::IWindowController(Core::System& system_)
    : ServiceFramework("IWindowController"), system{system_} {
@@ -238,12 +232,12 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework{"IDebugFunctions"} {

 IDebugFunctions::~IDebugFunctions() = default;

-ISelfController::ISelfController(Core::System& system,
-                                 std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-    : ServiceFramework("ISelfController"), system(system), nvflinger(std::move(nvflinger)) {
+ISelfController::ISelfController(Core::System& system_,
+                                 std::shared_ptr<NVFlinger::NVFlinger> nvflinger_)
+    : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger_)) {
    // clang-format off
    static const FunctionInfo functions[] = {
-        {0, &ISelfController::Exit, "Exit"},
+        {0, nullptr, "Exit"},
        {1, &ISelfController::LockExit, "LockExit"},
        {2, &ISelfController::UnlockExit, "UnlockExit"},
        {3, &ISelfController::EnterFatalSection, "EnterFatalSection"},
@@ -288,7 +282,7 @@ ISelfController::ISelfController(Core::System& system,

    RegisterHandlers(functions);

-    auto& kernel = system.Kernel();
+    auto& kernel = system_.Kernel();
    launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
                                                              "ISelfController:LaunchableEvent");

@@ -304,28 +298,15 @@ ISelfController::ISelfController(Core::System& system,

 ISelfController::~ISelfController() = default;

-void ISelfController::Exit(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called");
-
-    system.Shutdown();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void ISelfController::LockExit(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called");
-
-    system.SetExitLock(true);
+    LOG_WARNING(Service_AM, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }

 void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called");
-
-    system.SetExitLock(false);
+    LOG_WARNING(Service_AM, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
@@ -569,10 +550,6 @@ void AppletMessageQueue::OperationModeChanged() {
    on_operation_mode_changed.writable->Signal();
 }

-void AppletMessageQueue::RequestExit() {
-    PushMessage(AppletMessage::ExitRequested);
-}
-
 ICommonStateGetter::ICommonStateGetter(Core::System& system,
                                       std::shared_ptr<AppletMessageQueue> msg_queue)
    : ServiceFramework("ICommonStateGetter"), system(system), msg_queue(std::move(msg_queue)) {
@@ -847,16 +824,17 @@ private:
    void PopInteractiveOutData(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_AM, "called");

+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+
        const auto storage = applet->GetBroker().PopInteractiveDataToGame();
        if (storage == nullptr) {
            LOG_ERROR(Service_AM,
                      "storage is a nullptr. There is no data in the current interactive channel");
-            IPC::ResponseBuilder rb{ctx, 2};
+
            rb.Push(ERR_NO_DATA_IN_CHANNEL);
            return;
        }

-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IStorage>(std::move(*storage));
    }
@@ -1088,7 +1066,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)

    RegisterHandlers(functions);

-    auto& kernel = system.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    gpu_error_detected_event = Kernel::WritableEvent::CreateEventPair(
        kernel, Kernel::ResetType::Manual, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
 }
@@ -1133,55 +1111,26 @@ void IApplicationFunctions::EndBlockingHomeButton(Kernel::HLERequestContext& ctx
 }

 void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto kind = rp.PopEnum<LaunchParameterKind>();
+    LOG_DEBUG(Service_AM, "called");

-    LOG_DEBUG(Service_AM, "called, kind={:08X}", static_cast<u8>(kind));
+    LaunchParameters params{};

-    if (kind == LaunchParameterKind::ApplicationSpecific && !launch_popped_application_specific) {
-        const auto backend = BCAT::CreateBackendFromSettings(
-            [this](u64 tid) { return system.GetFileSystemController().GetBCATDirectory(tid); });
-        const auto build_id_full = system.GetCurrentProcessBuildID();
-        u64 build_id{};
-        std::memcpy(&build_id, build_id_full.data(), sizeof(u64));
+    params.magic = POP_LAUNCH_PARAMETER_MAGIC;
+    params.is_account_selected = 1;

-        const auto data =
-            backend->GetLaunchParameter({system.CurrentProcess()->GetTitleID(), build_id});
+    Account::ProfileManager profile_manager{};
+    const auto uuid = profile_manager.GetUser(Settings::values.current_user);
+    ASSERT(uuid);
+    params.current_user = uuid->uuid;

-        if (data.has_value()) {
-            IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-            rb.Push(RESULT_SUCCESS);
-            rb.PushIpcInterface<AM::IStorage>(*data);
-            launch_popped_application_specific = true;
-            return;
-        }
-    } else if (kind == LaunchParameterKind::AccountPreselectedUser &&
-               !launch_popped_account_preselect) {
-        LaunchParameterAccountPreselectedUser params{};
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};

-        params.magic = LAUNCH_PARAMETER_ACCOUNT_PRESELECTED_USER_MAGIC;
-        params.is_account_selected = 1;
+    rb.Push(RESULT_SUCCESS);

-        Account::ProfileManager profile_manager{};
-        const auto uuid = profile_manager.GetUser(Settings::values.current_user);
-        ASSERT(uuid);
-        params.current_user = uuid->uuid;
+    std::vector<u8> buffer(sizeof(LaunchParameters));
+    std::memcpy(buffer.data(), &params, buffer.size());

-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-        rb.Push(RESULT_SUCCESS);
-
-        std::vector<u8> buffer(sizeof(LaunchParameterAccountPreselectedUser));
-        std::memcpy(buffer.data(), &params, buffer.size());
-
-        rb.PushIpcInterface<AM::IStorage>(buffer);
-        launch_popped_account_preselect = true;
-        return;
-    }
-
-    LOG_ERROR(Service_AM, "Attempted to load launch parameter but none was found!");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ERR_NO_DATA_IN_CHANNEL);
+    rb.PushIpcInterface<AM::IStorage>(buffer);
 }

 void IApplicationFunctions::CreateApplicationAndRequestToStartForQuest(
@@ -1194,21 +1143,13 @@ void IApplicationFunctions::CreateApplicationAndRequestToStartForQuest(

 void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    u128 user_id = rp.PopRaw<u128>();
-
-    LOG_DEBUG(Service_AM, "called, uid={:016X}{:016X}", user_id[1], user_id[0]);
-
-    FileSys::SaveDataDescriptor descriptor{};
-    descriptor.title_id = system.CurrentProcess()->GetTitleID();
-    descriptor.user_id = user_id;
-    descriptor.type = FileSys::SaveDataType::SaveData;
-    const auto res = system.GetFileSystemController().CreateSaveData(
-        FileSys::SaveDataSpaceId::NandUser, descriptor);
+    u128 uid = rp.PopRaw<u128>(); // What does this do?
+    LOG_WARNING(Service, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);

    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(res.Code());
+    rb.Push(RESULT_SUCCESS);
    rb.Push<u64>(0);
-}
+} // namespace Service::AM

 void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
    // Takes an input u32 Result, no output.
@@ -1320,8 +1261,8 @@ void IApplicationFunctions::ExtendSaveData(Kernel::HLERequestContext& ctx) {
              "new_journal={:016X}",
              static_cast<u8>(type), user_id[1], user_id[0], new_normal_size, new_journal_size);

-    system.GetFileSystemController().WriteSaveDataSize(
-        type, system.CurrentProcess()->GetTitleID(), user_id, {new_normal_size, new_journal_size});
+    const auto title_id = system.CurrentProcess()->GetTitleID();
+    FileSystem::WriteSaveDataSize(type, title_id, user_id, {new_normal_size, new_journal_size});

    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
@@ -1340,8 +1281,8 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_AM, "called with type={:02X}, user_id={:016X}{:016X}", static_cast<u8>(type),
              user_id[1], user_id[0]);

-    const auto size = system.GetFileSystemController().ReadSaveDataSize(
-        type, system.CurrentProcess()->GetTitleID(), user_id);
+    const auto title_id = system.CurrentProcess()->GetTitleID();
+    const auto size = FileSystem::ReadSaveDataSize(type, title_id, user_id);

    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(RESULT_SUCCESS);
@@ -45,7 +45,6 @@ class AppletMessageQueue {
 public:
    enum class AppletMessage : u32 {
        NoMessage = 0,
-        ExitRequested = 4,
        FocusStateChanged = 15,
        OperationModeChanged = 30,
        PerformanceModeChanged = 31,
@@ -60,7 +59,6 @@ public:
    AppletMessage PopMessage();
    std::size_t GetMessageCount() const;
    void OperationModeChanged();
-    void RequestExit();

 private:
    std::queue<AppletMessage> messages;
@@ -125,7 +123,6 @@ public:
    ~ISelfController() override;

 private:
-    void Exit(Kernel::HLERequestContext& ctx);
    void LockExit(Kernel::HLERequestContext& ctx);
    void UnlockExit(Kernel::HLERequestContext& ctx);
    void EnterFatalSection(Kernel::HLERequestContext& ctx);
@@ -147,7 +144,6 @@ private:
    void GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx);
    void GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequestContext& ctx);

-    Core::System& system;
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
    Kernel::EventPair launchable_event;
    Kernel::EventPair accumulated_suspended_tick_changed_event;
@@ -254,8 +250,6 @@ private:
    void EnableApplicationCrashReport(Kernel::HLERequestContext& ctx);
    void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);

-    bool launch_popped_application_specific = false;
-    bool launch_popped_account_preselect = false;
    Kernel::EventPair gpu_error_detected_event;
    Core::System& system;
 };
@@ -9,18 +9,12 @@
 #include "core/hle/service/service.h"

 namespace Service {
-namespace FileSystem {
-class FileSystemController;
-}
-
 namespace NVFlinger {
 class NVFlinger;
 }

 namespace AM {

-class AppletMessageQueue;
-
 class AppletAE final : public ServiceFramework<AppletAE> {
 public:
    explicit AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
@@ -9,18 +9,12 @@
 #include "core/hle/service/service.h"

 namespace Service {
-namespace FileSystem {
-class FileSystemController;
-}
-
 namespace NVFlinger {
 class NVFlinger;
 }

 namespace AM {

-class AppletMessageQueue;
-
 class AppletOE final : public ServiceFramework<AppletOE> {
 public:
    explicit AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,