copyright: Update year and names of many .cpp and .h files

yuzu-copyright: Update year and names of many .cpp and .h files
2021-08-10 13:07:49 -05:00 · 2021-08-10 13:00:50 -05:00
302 changed files with 4336 additions and 5358 deletions
@@ -7,7 +7,7 @@ if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* dis
 fi

 # Default clang-format points to default 3.5 version one
-CLANG_FORMAT=clang-format-12
+CLANG_FORMAT=clang-format-10
 $CLANG_FORMAT --version

 if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then
@@ -28,6 +28,9 @@
 [submodule "mbedtls"]
    path = externals/mbedtls
    url = https://github.com/yuzu-emu/mbedtls
+[submodule "libzip"]
+    path = externals/libzip/libzip
+    url = https://github.com/nih-at/libzip.git
 [submodule "xbyak"]
    path = externals/xbyak
    url = https://github.com/herumi/xbyak.git
@@ -29,10 +29,16 @@ option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")

 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(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)

+if (NOT ENABLE_WEB_SERVICE)
+    set(YUZU_ENABLE_BOXCAT OFF)
+endif()
+
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
@@ -129,7 +135,7 @@ endif()
 # boost asio's concept usage doesn't play nicely with some compilers yet.
 add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
 if (MSVC)
-    add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>)
+    add_compile_options(/std:c++latest)

    # cubeb and boost still make use of deprecated result_of.
    add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
@@ -370,7 +376,7 @@ if (ENABLE_SDL2)
    if (YUZU_USE_BUNDLED_SDL2)
        # Detect toolchain and platform
        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.16")
+            set(SDL2_VER "SDL2-2.0.15-prerelease")
        else()
            message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
        endif()
@@ -390,7 +396,7 @@ if (ENABLE_SDL2)
    elseif (YUZU_USE_EXTERNAL_SDL2)
        message(STATUS "Using SDL2 from externals.")
    else()
-        find_package(SDL2 2.0.16 REQUIRED)
+        find_package(SDL2 2.0.15 REQUIRED)

        # Some installations don't set SDL2_LIBRARIES
        if("${SDL2_LIBRARIES}" STREQUAL "")
@@ -416,6 +422,11 @@ if (CONAN_REQUIRED_LIBS)
    endif()
    include(${CMAKE_BINARY_DIR}/conan.cmake)

+    set(CONAN_LIB_OPTIONS
+        libzip:with_openssl=False
+        libzip:enable_windows_crypto=False
+    )
+
    conan_check(VERSION 1.24.0 REQUIRED)

    # Manually add iconv to fix a dep conflict between qt and sdl2
@@ -507,10 +518,6 @@ set(FFmpeg_COMPONENTS
    avutil
    swscale)

-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    Include(FindPkgConfig REQUIRED)
-    pkg_check_modules(LIBVA libva)
-endif()
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
    # Use system installed FFmpeg
    find_package(FFmpeg QUIET COMPONENTS ${FFmpeg_COMPONENTS})
@@ -533,9 +540,6 @@ endif()

 if (YUZU_USE_BUNDLED_FFMPEG)
    if (NOT WIN32)
-        # TODO(lat9nq): Move this to externals/ffmpeg/CMakeLists.txt (and move externals/ffmpeg to
-        # externals/ffmpeg/ffmpeg)
-
        # Build FFmpeg from externals
        message(STATUS "Using FFmpeg from externals")

@@ -575,23 +579,20 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                CACHE PATH "Paths to FFmpeg libraries" FORCE)
        endforeach()

-        Include(FindPkgConfig REQUIRED)
-        pkg_check_modules(LIBVA libva)
-        pkg_check_modules(CUDA cuda)
-        pkg_check_modules(FFNVCODEC ffnvcodec)
-        pkg_check_modules(VDPAU vdpau)
-
-        set(FFmpeg_HWACCEL_LIBRARIES)
-        set(FFmpeg_HWACCEL_FLAGS)
-        set(FFmpeg_HWACCEL_INCLUDE_DIRS)
-        set(FFmpeg_HWACCEL_LDFLAGS)
+        set(FFmpeg_INCLUDE_DIR
+            "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR}"
+            CACHE PATH "Path to FFmpeg headers" FORCE)

+        if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+            Include(FindPkgConfig REQUIRED)
+            pkg_check_modules(LIBVA libva)
+        endif()
        if(LIBVA_FOUND)
            pkg_check_modules(LIBDRM libdrm REQUIRED)
            find_package(X11 REQUIRED)
            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+            set(FFmpeg_LIBVA_LIBRARIES
                ${LIBDRM_LIBRARIES}
                ${X11_LIBRARIES}
                ${LIBVA-DRM_LIBRARIES}
@@ -601,56 +602,11 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                --enable-hwaccel=h264_vaapi
                --enable-hwaccel=vp9_vaapi
                --enable-libdrm)
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${LIBDRM_INCLUDE_DIRS}
-                ${X11_INCLUDE_DIRS}
-                ${LIBVA-DRM_INCLUDE_DIRS}
-                ${LIBVA-X11_INCLUDE_DIRS}
-                ${LIBVA_INCLUDE_DIRS}
-            )
            message(STATUS "VA-API found")
        else()
            set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
        endif()

-        if (FFNVCODEC_FOUND AND CUDA_FOUND)
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-cuvid
-                --enable-ffnvcodec
-                --enable-nvdec
-                --enable-hwaccel=h264_nvdec
-                --enable-hwaccel=vp9_nvdec
-                --extra-cflags=-I${CUDA_INCLUDE_DIRS}
-            )
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                ${FFNVCODEC_LIBRARIES}
-                ${CUDA_LIBRARIES}
-            )
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${FFNVCODEC_INCLUDE_DIRS}
-                ${CUDA_INCLUDE_DIRS}
-            )
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS
-                ${FFNVCODEC_LDFLAGS}
-                ${CUDA_LDFLAGS}
-            )
-            message(STATUS "ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
-        endif()
-
-        if (VDPAU_FOUND)
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-vdpau
-                --enable-hwaccel=h264_vdpau
-                --enable-hwaccel=vp9_vdpau
-            )
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
-            message(STATUS "vdpau libraries version ${VDPAU_VERSION} found")
-        else()
-            list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
-        endif()
-
        # `configure` parameters builds only exactly what yuzu needs from FFmpeg
        # `--disable-vdpau` is needed to avoid linking issues
        add_custom_command(
@@ -668,6 +624,7 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                    --disable-network
                    --disable-postproc
                    --disable-swresample
+                    --disable-vdpau
                    --enable-decoder=h264
                    --enable-decoder=vp9
                    --cc="${CMAKE_C_COMPILER}"
@@ -696,26 +653,15 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                ${FFmpeg_BUILD_DIR}
        )

-        set(FFmpeg_INCLUDE_DIR
-            "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR};${FFmpeg_HWACCEL_INCLUDE_DIRS}"
-            CACHE PATH "Path to FFmpeg headers" FORCE)
-
-        set(FFmpeg_LDFLAGS
-            "${FFmpeg_HWACCEL_LDFLAGS}"
-            CACHE STRING "FFmpeg linker flags" FORCE)
-
        # ALL makes this custom target build every time
        # but it won't actually build if the DEPENDS parameter is up to date
        add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_BUILD_LIBRARIES} ffmpeg-configure)
        link_libraries(${FFmpeg_LIBVA_LIBRARIES})
-        set(FFmpeg_LIBRARIES ${FFmpeg_BUILD_LIBRARIES} ${FFmpeg_HWACCEL_LIBRARIES}
+        set(FFmpeg_LIBRARIES ${FFmpeg_LIBVA_LIBRARIES} ${FFmpeg_BUILD_LIBRARIES}
            CACHE PATH "Paths to FFmpeg libraries" FORCE)
        unset(FFmpeg_BUILD_LIBRARIES)
-        unset(FFmpeg_HWACCEL_FLAGS)
-        unset(FFmpeg_HWACCEL_INCLUDE_DIRS)
-        unset(FFmpeg_HWACCEL_LDFLAGS)
-        unset(FFmpeg_HWACCEL_LIBRARIES)
+        unset(FFmpeg_LIBVA_LIBRARIES)

        if (FFmpeg_FOUND)
            message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
@@ -724,13 +670,12 @@ if (YUZU_USE_BUNDLED_FFMPEG)
        endif()
    else() # WIN32
        # Use yuzu FFmpeg binaries
-        set(FFmpeg_EXT_NAME "ffmpeg-4.4")
+        set(FFmpeg_EXT_NAME "ffmpeg-4.3.1")
        set(FFmpeg_PATH "${CMAKE_BINARY_DIR}/externals/${FFmpeg_EXT_NAME}")
        download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "")
        set(FFmpeg_FOUND YES)
        set(FFmpeg_INCLUDE_DIR "${FFmpeg_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
        set(FFmpeg_LIBRARY_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg library directory" FORCE)
-        set(FFmpeg_LDFLAGS "" CACHE STRING "FFmpeg linker flags" FORCE)
        set(FFmpeg_DLL_DIR "${FFmpeg_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
        set(FFmpeg_LIBRARIES
            ${FFmpeg_LIBRARY_DIR}/swscale.lib
@@ -756,7 +701,7 @@ if (APPLE)
 elseif (WIN32)
    # WSAPoll and SHGetKnownFolderPath (AppData/Roaming) didn't exist before WinNT 6.x (Vista)
    add_definitions(-D_WIN32_WINNT=0x0600 -DWINVER=0x0600)
-    set(PLATFORM_LIBRARIES winmm ws2_32 iphlpapi)
+    set(PLATFORM_LIBRARIES winmm ws2_32)
    if (MINGW)
        # PSAPI is the Process Status API
        set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version)
@@ -769,7 +714,7 @@ endif()
 # against all the src files. This should be used before making a pull request.
 # =======================================================================

-set(CLANG_FORMAT_POSTFIX "-12")
+set(CLANG_FORMAT_POSTFIX "-10")
 find_program(CLANG_FORMAT
    NAMES clang-format${CLANG_FORMAT_POSTFIX}
          clang-format
@@ -7,9 +7,7 @@ include(DownloadExternals)
 # xbyak
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
    add_library(xbyak INTERFACE)
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/xbyak/xbyak DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    target_include_directories(xbyak SYSTEM INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
+    target_include_directories(xbyak SYSTEM INTERFACE ./xbyak/xbyak)
    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
 endif()

@@ -21,7 +19,6 @@ target_include_directories(catch-single-include INTERFACE catch/single_include)
 if (ARCHITECTURE_x86_64)
    set(DYNARMIC_TESTS OFF)
    set(DYNARMIC_NO_BUNDLED_FMT ON)
-    set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
    add_subdirectory(dynarmic)
 endif()

@@ -93,6 +90,13 @@ endif()
 # Sirit
 add_subdirectory(sirit)

+# libzip
+find_package(libzip 1.5)
+if (NOT libzip_FOUND)
+    message(STATUS "libzip 1.5 or newer not found, falling back to externals")
+    add_subdirectory(libzip EXCLUDE_FROM_ALL)
+endif()
+
 if (ENABLE_WEB_SERVICE)
    find_package(OpenSSL 1.1)
    if (OPENSSL_FOUND)
@@ -0,0 +1,72 @@
+
+find_package(PkgConfig QUIET)
+pkg_check_modules(PC_libzip QUIET libzip)
+
+find_path(libzip_INCLUDE_DIR
+  NAMES zip.h
+  PATHS ${PC_libzip_INCLUDE_DIRS}
+  "$ENV{LIB_DIR}/include"
+  "$ENV{INCLUDE}"
+  /usr/local/include
+  /usr/include
+)
+find_path(libzip_INCLUDE_DIR_ZIPCONF
+  NAMES zipconf.h
+  HINTS ${PC_libzip_INCLUDE_DIRS}
+  "$ENV{LIB_DIR}/include"
+  "$ENV{LIB_DIR}/lib/libzip/include"
+  "$ENV{LIB}/lib/libzip/include"
+  /usr/local/lib/libzip/include
+  /usr/lib/libzip/include
+  /usr/local/include
+  /usr/include
+  "$ENV{INCLUDE}"
+)
+find_library(libzip_LIBRARY
+  NAMES zip
+  PATHS ${PC_libzip_LIBRARY_DIRS}
+  "$ENV{LIB_DIR}/lib" "$ENV{LIB}" /usr/local/lib /usr/lib
+)
+
+if (libzip_INCLUDE_DIR_ZIPCONF)
+  FILE(READ "${libzip_INCLUDE_DIR_ZIPCONF}/zipconf.h" _libzip_VERSION_CONTENTS)
+  if (_libzip_VERSION_CONTENTS)
+    STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" libzip_VERSION "${_libzip_VERSION_CONTENTS}")
+  endif()
+  unset(_libzip_VERSION_CONTENTS)
+endif()
+
+set(libzip_VERSION ${libzip_VERSION} CACHE STRING "Version number of libzip")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(libzip
+  FOUND_VAR libzip_FOUND
+  REQUIRED_VARS
+    libzip_LIBRARY
+    libzip_INCLUDE_DIR
+    libzip_INCLUDE_DIR_ZIPCONF
+    libzip_VERSION
+  VERSION_VAR libzip_VERSION
+)
+
+if(libzip_FOUND)
+  set(libzip_LIBRARIES ${libzip_LIBRARY})
+  set(libzip_INCLUDE_DIRS ${libzip_INCLUDE_DIR})
+  set(libzip_DEFINITIONS ${PC_libzip_CFLAGS_OTHER})
+endif()
+
+if(libzip_FOUND AND NOT TARGET libzip::libzip)
+  add_library(libzip::libzip UNKNOWN IMPORTED)
+  set_target_properties(libzip::libzip PROPERTIES
+    IMPORTED_LOCATION "${libzip_LIBRARY}"
+    INTERFACE_COMPILE_OPTIONS "${PC_libzip_CFLAGS_OTHER}"
+    INTERFACE_INCLUDE_DIRECTORIES "${libzip_INCLUDE_DIR}"
+  )
+endif()
+
+mark_as_advanced(
+    libzip_INCLUDE_DIR
+    libzip_INCLUDE_DIR_ZIPCONF
+    libzip_LIBRARY
+    libzip_VERSION
+)
@@ -0,0 +1,564 @@
+# TODO:
+# create usable libtool .la file
+
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)
+
+LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/libzip")
+
+PROJECT(libzip C)
+
+OPTION(ENABLE_COMMONCRYPTO "Enable use of CommonCrypto" ON)
+OPTION(ENABLE_GNUTLS "Enable use of GnuTLS" ON)
+OPTION(ENABLE_MBEDTLS "Enable use of mbed TLS" ON)
+OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON)
+OPTION(ENABLE_WINDOWS_CRYPTO "Enable use of Windows cryptography libraries" ON)
+
+OPTION(ENABLE_BZIP2 "Enable use of BZip2" OFF)
+OPTION(ENABLE_LZMA "Enable use of LZMA" OFF)
+
+INCLUDE(CheckFunctionExists)
+INCLUDE(CheckIncludeFiles)
+INCLUDE(CheckSymbolExists)
+INCLUDE(CheckTypeSize)
+INCLUDE(CheckCSourceRuns)
+INCLUDE(CheckCSourceCompiles)
+INCLUDE(CheckStructHasMember)
+INCLUDE(TestBigEndian)
+INCLUDE(GNUInstallDirs)
+IF(ENABLE_COMMONCRYPTO)
+  CHECK_INCLUDE_FILES(CommonCrypto/CommonCrypto.h COMMONCRYPTO_FOUND)
+ELSE()
+  SET(COMMONCRYPTO_FOUND FALSE)
+ENDIF()
+IF(ENABLE_GNUTLS)
+  INCLUDE(FindNettle)
+  INCLUDE(FindGnuTLS)
+ELSE()
+  SET(GNUTLS_FOUND FALSE)
+ENDIF()
+IF(ENABLE_MBEDTLS)
+  FIND_PATH(MBEDTLS_INCLUDE_DIR mbedtls/aes.h)
+  FIND_LIBRARY(MBEDTLS_LIBRARIES NAMES mbedcrypto)
+ELSE()
+  SET(MBEDTLS_LIBRARIES FALSE)
+ENDIF()
+IF(ENABLE_OPENSSL)
+  INCLUDE(FindOpenSSL)
+ELSE()
+  SET(OPENSSL_FOUND FALSE)
+ENDIF()
+IF(WIN32)
+  IF(ENABLE_WINDOWS_CRYPTO)
+    SET(WINDOWS_CRYPTO_FOUND TRUE)
+  ENDIF()
+ELSE()
+  SET(WINDOWS_CRYPTO_FOUND FALSE)
+ENDIF()
+
+OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
+OPTION(SHARED_LIB_VERSIONNING "Add SO version in .so build" ON)
+
+SET(PACKAGE "libzip")
+SET(PACKAGE_NAME ${PACKAGE})
+SET(PACKAGE_VERSION_MAJOR "1")
+SET(PACKAGE_VERSION_MINOR "5")
+SET(PACKAGE_VERSION_MICRO "2a")
+#SET(VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}")
+SET(VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_MICRO}")
+SET(PACKAGE_VERSION ${VERSION})
+SET(LIBZIP_VERSION ${PACKAGE_VERSION})
+SET(LIBZIP_VERSION_MAJOR ${PACKAGE_VERSION_MAJOR})
+SET(LIBZIP_VERSION_MINOR ${PACKAGE_VERSION_MINOR})
+SET(LIBZIP_VERSION_MICRO ${PACKAGE_VERSION_MICRO})
+SET(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
+
+SET(ARCHIVE_NAME ${PACKAGE_NAME}-${PACKAGE_VERSION})
+IF(NOT TARGET dist)
+ADD_CUSTOM_TARGET(dist
+  COMMAND git config tar.tar.xz.command "xz -c"
+  COMMAND git archive --prefix=${ARCHIVE_NAME}/ -o ${ARCHIVE_NAME}.tar.gz HEAD
+  COMMAND git archive --prefix=${ARCHIVE_NAME}/ -o ${ARCHIVE_NAME}.tar.xz HEAD
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+  )
+ADD_CUSTOM_TARGET(distcheck
+  COMMAND chmod -R u+w ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest 2>/dev/null || true
+  COMMAND rm -rf ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
+  COMMAND cmake -E tar xf ${ARCHIVE_NAME}.tar.gz
+  COMMAND chmod -R u-w ${ARCHIVE_NAME}
+  COMMAND mkdir ${ARCHIVE_NAME}-build
+  COMMAND mkdir ${ARCHIVE_NAME}-dest
+  COMMAND cd ${ARCHIVE_NAME}-build && cmake -DCMAKE_INSTALL_PREFIX=../${ARCHIVE_NAME}-dest ../${ARCHIVE_NAME}
+  COMMAND cd ${ARCHIVE_NAME}-build && make -j4
+  COMMAND cd ${ARCHIVE_NAME}-build && make test
+  COMMAND cd ${ARCHIVE_NAME}-build && make install
+#  COMMAND cd ${ARCHIVE_NAME}-build && make uninstall
+#  COMMAND if [ `find ${ARCHIVE_NAME}-dest ! -type d | wc -l` -ne 0 ]; then echo leftover files in ${ARCHIVE_NAME}-dest; false; fi
+  COMMAND cd ${ARCHIVE_NAME}-build && make clean
+  COMMAND chmod -R u+w ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
+  COMMAND rm -rf ${ARCHIVE_NAME} ${ARCHIVE_NAME}-build ${ARCHIVE_NAME}-dest
+  COMMAND echo "${ARCHIVE_NAME}.tar.gz is ready for distribution."
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+  )
+ADD_DEPENDENCIES(distcheck dist)
+ENDIF(NOT TARGET dist)
+
+IF(BUILD_SHARED_LIBS)
+  SET(HAVE_SHARED TRUE)
+ELSE()
+  SET(ZIP_STATIC TRUE)
+ENDIF()
+
+# Checks
+
+CHECK_FUNCTION_EXISTS(_chmod HAVE__CHMOD)
+CHECK_FUNCTION_EXISTS(_close HAVE__CLOSE)
+CHECK_FUNCTION_EXISTS(_dup HAVE__DUP)
+CHECK_FUNCTION_EXISTS(_fdopen HAVE__FDOPEN)
+CHECK_FUNCTION_EXISTS(_fileno HAVE__FILENO)
+CHECK_FUNCTION_EXISTS(_open HAVE__OPEN)
+CHECK_FUNCTION_EXISTS(_setmode HAVE__SETMODE)
+CHECK_FUNCTION_EXISTS(_snprintf HAVE__SNPRINTF)
+CHECK_FUNCTION_EXISTS(_strdup HAVE__STRDUP)
+CHECK_FUNCTION_EXISTS(_stricmp HAVE__STRICMP)
+CHECK_FUNCTION_EXISTS(_strtoi64 HAVE__STRTOI64)
+CHECK_FUNCTION_EXISTS(_strtoui64 HAVE__STRTOUI64)
+CHECK_FUNCTION_EXISTS(_unlink HAVE__UNLINK)
+CHECK_FUNCTION_EXISTS(arc4random HAVE_ARC4RANDOM)
+CHECK_FUNCTION_EXISTS(clonefile HAVE_CLONEFILE)
+CHECK_FUNCTION_EXISTS(explicit_bzero HAVE_EXPLICIT_BZERO)
+CHECK_FUNCTION_EXISTS(explicit_memset HAVE_EXPLICIT_MEMSET)
+CHECK_FUNCTION_EXISTS(fileno HAVE_FILENO)
+CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO)
+CHECK_FUNCTION_EXISTS(ftello HAVE_FTELLO)
+CHECK_FUNCTION_EXISTS(getprogname HAVE_GETPROGNAME)
+CHECK_FUNCTION_EXISTS(localtime_r HAVE_LOCALTIME_R)
+CHECK_FUNCTION_EXISTS(open HAVE_OPEN)
+CHECK_FUNCTION_EXISTS(setmode HAVE_SETMODE)
+CHECK_FUNCTION_EXISTS(snprintf HAVE_SNPRINTF)
+CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
+CHECK_FUNCTION_EXISTS(strdup HAVE_STRDUP)
+CHECK_FUNCTION_EXISTS(stricmp HAVE_STRICMP)
+CHECK_FUNCTION_EXISTS(strtoll HAVE_STRTOLL)
+CHECK_FUNCTION_EXISTS(strtoull HAVE_STRTOULL)
+
+CHECK_INCLUDE_FILES("sys/types.h;sys/stat.h;fts.h" HAVE_FTS_H)
+CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H)
+CHECK_INCLUDE_FILES(strings.h HAVE_STRINGS_H)
+CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H)
+
+CHECK_INCLUDE_FILES(inttypes.h HAVE_INTTYPES_H_LIBZIP)
+CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H_LIBZIP)
+CHECK_INCLUDE_FILES(sys/types.h HAVE_SYS_TYPES_H_LIBZIP)
+
+# TODO: fix test
+# this test does not find __progname even when it exists
+#CHECK_SYMBOL_EXISTS(__progname stdlib.h HAVE___PROGNAME)
+
+CHECK_TYPE_SIZE(__int8 __INT8_LIBZIP)
+CHECK_TYPE_SIZE(int8_t INT8_T_LIBZIP)
+CHECK_TYPE_SIZE(uint8_t UINT8_T_LIBZIP)
+CHECK_TYPE_SIZE(__int16 __INT16_LIBZIP)
+CHECK_TYPE_SIZE(int16_t INT16_T_LIBZIP)
+CHECK_TYPE_SIZE(uint16_t UINT16_T_LIBZIP)
+CHECK_TYPE_SIZE(__int32 __INT32_LIBZIP)
+CHECK_TYPE_SIZE(int32_t INT32_T_LIBZIP)
+CHECK_TYPE_SIZE(uint32_t UINT32_T_LIBZIP)
+CHECK_TYPE_SIZE(__int64 __INT64_LIBZIP)
+CHECK_TYPE_SIZE(int64_t INT64_T_LIBZIP)
+CHECK_TYPE_SIZE(uint64_t UINT64_T_LIBZIP)
+CHECK_TYPE_SIZE("short" SHORT_LIBZIP)
+CHECK_TYPE_SIZE("int" INT_LIBZIP)
+CHECK_TYPE_SIZE("long" LONG_LIBZIP)
+CHECK_TYPE_SIZE("long long" LONG_LONG_LIBZIP)
+CHECK_TYPE_SIZE("off_t" SIZEOF_OFF_T)
+CHECK_TYPE_SIZE("size_t" SIZE_T_LIBZIP)
+CHECK_TYPE_SIZE("ssize_t" SSIZE_T_LIBZIP)
+
+CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h>
+#include <linux/fs.h>
+int main(int argc, char *argv[]) { unsigned long x = FICLONERANGE; }" HAVE_FICLONERANGE)
+
+CHECK_C_SOURCE_COMPILES("
+int foo(char * _Nullable bar);
+int main(int argc, char *argv[]) { }" HAVE_NULLABLE)
+
+TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
+
+#FIND_PACKAGE(ZLIB 1.1.2 REQUIRED)
+INCLUDE_DIRECTORIES(../zlib/zlib)
+SET(CMAKE_REQUIRED_INCLUDES ../zlib/zlib)
+
+IF(ENABLE_BZIP2)
+  FIND_PACKAGE(BZip2)
+  IF(BZIP2_FOUND)
+    SET (HAVE_LIBBZ2 1)
+
+    INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR})
+    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${BZIP2_LIBRARIES})
+  ELSE()
+    MESSAGE(WARNING "-- bzip2 library not found; bzip2 support disabled")
+  ENDIF(BZIP2_FOUND)
+ENDIF(ENABLE_BZIP2)
+
+IF(ENABLE_LZMA)
+  FIND_PACKAGE(LibLZMA)
+  IF(LIBLZMA_FOUND)
+    SET (HAVE_LIBLZMA 1)
+
+    INCLUDE_DIRECTORIES(${LIBLZMA_INCLUDE_DIR})
+    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${LIBLZMA_LIBRARY})
+  ELSE()
+    MESSAGE(WARNING "-- lzma library not found; lzma support disabled")
+  ENDIF(LIBLZMA_FOUND)
+ENDIF(ENABLE_LZMA)
+
+
+IF (COMMONCRYPTO_FOUND)
+  SET (HAVE_CRYPTO 1)
+  SET (HAVE_COMMONCRYPTO 1)
+ELSEIF (WINDOWS_CRYPTO_FOUND)
+  SET (HAVE_CRYPTO 1)
+  SET (HAVE_WINDOWS_CRYPTO 1)
+ELSEIF (GNUTLS_FOUND AND NETTLE_FOUND)
+  SET (HAVE_CRYPTO 1)
+  SET (HAVE_GNUTLS 1)
+  INCLUDE_DIRECTORIES(${GNUTLS_INCLUDE_DIR} ${NETTLE_INCLUDE_DIR})
+  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${GNUTLS_LIBRARY} ${NETTLE_LIBRARY})
+ELSEIF (OPENSSL_FOUND)
+  SET (HAVE_CRYPTO 1)
+  SET (HAVE_OPENSSL 1)
+  INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
+  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${OPENSSL_LIBRARIES})
+ELSEIF (MBEDTLS_LIBRARIES)
+  SET (HAVE_CRYPTO 1)
+  SET (HAVE_MBEDTLS 1)
+  INCLUDE_DIRECTORIES(${MBEDTLS_INCLUDE_DIR})
+  SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} ${MBEDTLS_LIBRARIES})
+ENDIF()
+
+IF (NOT HAVE_CRYPTO)
+  MESSAGE(WARNING "-- neither Common Crypto, GnuTLS, mbed TLS, OpenSSL, nor Windows Cryptography found; AES support disabled")
+ENDIF()
+
+IF(MSVC)
+ADD_DEFINITIONS("-D_CRT_SECURE_NO_WARNINGS")
+ADD_DEFINITIONS("-D_CRT_NONSTDC_NO_DEPRECATE")
+ENDIF(MSVC)
+
+if(WIN32)
+  if(HAVE_WINDOWS_CRYPTO)
+    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} bcrypt)
+  endif()
+  if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+    ADD_DEFINITIONS(-DMS_UWP)
+  else(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+    SET (OPTIONAL_LIBRARY ${OPTIONAL_LIBRARY} advapi32)
+  endif(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+endif(WIN32)
+
+ADD_DEFINITIONS("-DHAVE_CONFIG_H")
+
+# rpath handling: use rpath in installed binaries
+IF(NOT CMAKE_SYSTEM_NAME MATCHES Linux)
+	SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+	SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+ENDIF()
+
+# fixed size integral types
+
+IF(HAVE_INTTYPES_H_LIBZIP)
+  SET(LIBZIP_TYPES_INCLUDE "#define __STDC_FORMAT_MACROS 1
+#include <inttypes.h>")
+ELSEIF(HAVE_STDINT_H_LIBZIP)
+  SET(LIBZIP_TYPES_INCLUDE "#include <stdint.h>")
+ELSEIF(HAVE_SYS_TYPES_H_LIBZIP)
+  SET(LIBZIP_TYPES_INCLUDE "#include <sys/types.h>")
+ENDIF()
+
+IF(HAVE_INT8_T_LIBZIP)
+  SET(ZIP_INT8_T int8_t)
+ELSEIF(HAVE___INT8_LIBZIP)
+  SET(ZIP_INT8_T __int8)
+ELSE()
+  SET(ZIP_INT8_T "signed char")
+ENDIF()
+
+IF(HAVE_UINT8_T_LIBZIP)
+  SET(ZIP_UINT8_T uint8_t)
+ELSEIF(HAVE___INT8_LIBZIP)
+  SET(ZIP_UINT8_T "unsigned __int8")
+ELSE()
+  SET(ZIP_UINT8_T "unsigned char")
+ENDIF()
+
+IF(HAVE_INT16_T_LIBZIP)
+  SET(ZIP_INT16_T int16_t)
+ELSEIF(HAVE___INT16_LIBZIP)
+  SET(INT16_T_LIBZIP __int16)
+ELSEIF(SHORT_LIBZIP EQUAL 2)
+  SET(INT16_T_LIBZIP short)
+ENDIF()
+
+IF(HAVE_UINT16_T_LIBZIP)
+  SET(ZIP_UINT16_T uint16_t)
+ELSEIF(HAVE___INT16_LIBZIP)
+  SET(UINT16_T_LIBZIP "unsigned __int16")
+ELSEIF(SHORT_LIBZIP EQUAL 2)
+  SET(UINT16_T_LIBZIP "unsigned short")
+ENDIF()
+
+IF(HAVE_INT32_T_LIBZIP)
+  SET(ZIP_INT32_T int32_t)
+ELSEIF(HAVE___INT32_LIBZIP)
+  SET(ZIP_INT32_T __int32)
+ELSEIF(INT_LIBZIP EQUAL 4)
+  SET(ZIP_INT32_T int)
+ELSEIF(LONG_LIBZIP EQUAL 4)
+  SET(ZIP_INT32_T long)
+ENDIF()
+
+IF(HAVE_UINT32_T_LIBZIP)
+SET(ZIP_UINT32_T uint32_t)
+ELSEIF(HAVE___INT32_LIBZIP)
+SET(ZIP_UINT32_T "unsigned __int32")
+ELSEIF(INT_LIBZIP EQUAL 4)
+SET(ZIP_UINT32_T "unsigned int")
+ELSEIF(LONG_LIBZIP EQUAL 4)
+SET(ZIP_UINT32_T "unsigned long")
+ENDIF()
+
+IF(HAVE_INT64_T_LIBZIP)
+  SET(ZIP_INT64_T int64_t)
+ELSEIF(HAVE___INT64_LIBZIP)
+  SET(ZIP_INT64_T __int64)
+ELSEIF(LONG_LIBZIP EQUAL 8)
+  SET(ZIP_INT64_T long)
+ELSEIF(LONG_LONG_LIBZIP EQUAL 8)
+  SET(ZIP_INT64_T "long long")
+ENDIF()
+
+IF(HAVE_UINT64_T_LIBZIP)
+  SET(ZIP_UINT64_T uint64_t)
+ELSEIF(HAVE___INT64_LIBZIP)
+  SET(ZIP_UINT64_T "unsigned __int64")
+ELSEIF(LONG_LIBZIP EQUAL 8)
+  SET(ZIP_UINT64_T "unsigned long")
+ELSEIF(LONG_LONG_LIBZIP EQUAL 8)
+  SET(ZIP_UINT64_T "unsigned long long")
+ENDIF()
+
+IF(HAVE_NULLABLE)
+  SET(ZIP_NULLABLE_DEFINES)
+ELSE()
+  SET(ZIP_NULLABLE_DEFINES "#define _Nullable
+#define _Nonnull")
+ENDIF()
+
+# write out config file
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libzip/cmake-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/libzip/config.h)
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libzip/cmake-zipconf.h.in ${CMAKE_CURRENT_BINARY_DIR}/libzip/zipconf.h)
+
+# installation
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libzip/zipconf.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+INSTALL(FILES libzip/lib/zip.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+SET(CMAKE_C_VISIBILITY_PRESET hidden)
+
+ADD_LIBRARY(zip
+  libzip/lib/zip_add.c
+  libzip/lib/zip_add_dir.c
+  libzip/lib/zip_add_entry.c
+  libzip/lib/zip_algorithm_deflate.c
+  libzip/lib/zip_buffer.c
+  libzip/lib/zip_close.c
+  libzip/lib/zip_delete.c
+  libzip/lib/zip_dir_add.c
+  libzip/lib/zip_dirent.c
+  libzip/lib/zip_discard.c
+  libzip/lib/zip_entry.c
+  libzip/lib/zip_err_str.c
+  libzip/lib/zip_error.c
+  libzip/lib/zip_error_clear.c
+  libzip/lib/zip_error_get.c
+  libzip/lib/zip_error_get_sys_type.c
+  libzip/lib/zip_error_strerror.c
+  libzip/lib/zip_error_to_str.c
+  libzip/lib/zip_extra_field.c
+  libzip/lib/zip_extra_field_api.c
+  libzip/lib/zip_fclose.c
+  libzip/lib/zip_fdopen.c
+  libzip/lib/zip_file_add.c
+  libzip/lib/zip_file_error_clear.c
+  libzip/lib/zip_file_error_get.c
+  libzip/lib/zip_file_get_comment.c
+  libzip/lib/zip_file_get_external_attributes.c
+  libzip/lib/zip_file_get_offset.c
+  libzip/lib/zip_file_rename.c
+  libzip/lib/zip_file_replace.c
+  libzip/lib/zip_file_set_comment.c
+  libzip/lib/zip_file_set_encryption.c
+  libzip/lib/zip_file_set_external_attributes.c
+  libzip/lib/zip_file_set_mtime.c
+  libzip/lib/zip_file_strerror.c
+  libzip/lib/zip_filerange_crc.c
+  libzip/lib/zip_fopen.c
+  libzip/lib/zip_fopen_encrypted.c
+  libzip/lib/zip_fopen_index.c
+  libzip/lib/zip_fopen_index_encrypted.c
+  libzip/lib/zip_fread.c
+  libzip/lib/zip_fseek.c
+  libzip/lib/zip_ftell.c
+  libzip/lib/zip_get_archive_comment.c
+  libzip/lib/zip_get_archive_flag.c
+  libzip/lib/zip_get_encryption_implementation.c
+  libzip/lib/zip_get_file_comment.c
+  libzip/lib/zip_get_name.c
+  libzip/lib/zip_get_num_entries.c
+  libzip/lib/zip_get_num_files.c
+  libzip/lib/zip_hash.c
+  libzip/lib/zip_io_util.c
+  libzip/lib/zip_libzip_version.c
+  libzip/lib/zip_memdup.c
+  libzip/lib/zip_name_locate.c
+  libzip/lib/zip_new.c
+  libzip/lib/zip_open.c
+  libzip/lib/zip_progress.c
+  libzip/lib/zip_rename.c
+  libzip/lib/zip_replace.c
+  libzip/lib/zip_set_archive_comment.c
+  libzip/lib/zip_set_archive_flag.c
+  libzip/lib/zip_set_default_password.c
+  libzip/lib/zip_set_file_comment.c
+  libzip/lib/zip_set_file_compression.c
+  libzip/lib/zip_set_name.c
+  libzip/lib/zip_source_accept_empty.c
+  libzip/lib/zip_source_begin_write.c
+  libzip/lib/zip_source_begin_write_cloning.c
+  libzip/lib/zip_source_buffer.c
+  libzip/lib/zip_source_call.c
+  libzip/lib/zip_source_close.c
+  libzip/lib/zip_source_commit_write.c
+  libzip/lib/zip_source_compress.c
+  libzip/lib/zip_source_crc.c
+  libzip/lib/zip_source_error.c
+  libzip/lib/zip_source_filep.c
+  libzip/lib/zip_source_free.c
+  libzip/lib/zip_source_function.c
+  libzip/lib/zip_source_get_compression_flags.c
+  libzip/lib/zip_source_is_deleted.c
+  libzip/lib/zip_source_layered.c
+  libzip/lib/zip_source_open.c
+  libzip/lib/zip_source_pkware.c
+  libzip/lib/zip_source_read.c
+  libzip/lib/zip_source_remove.c
+  libzip/lib/zip_source_rollback_write.c
+  libzip/lib/zip_source_seek.c
+  libzip/lib/zip_source_seek_write.c
+  libzip/lib/zip_source_stat.c
+  libzip/lib/zip_source_supports.c
+  libzip/lib/zip_source_tell.c
+  libzip/lib/zip_source_tell_write.c
+  libzip/lib/zip_source_window.c
+  libzip/lib/zip_source_write.c
+  libzip/lib/zip_source_zip.c
+  libzip/lib/zip_source_zip_new.c
+  libzip/lib/zip_stat.c
+  libzip/lib/zip_stat_index.c
+  libzip/lib/zip_stat_init.c
+  libzip/lib/zip_strerror.c
+  libzip/lib/zip_string.c
+  libzip/lib/zip_unchange.c
+  libzip/lib/zip_unchange_all.c
+  libzip/lib/zip_unchange_archive.c
+  libzip/lib/zip_unchange_data.c
+  libzip/lib/zip_utf-8.c
+)
+
+IF(WIN32)
+  target_sources(zip PRIVATE
+    libzip/lib/zip_source_win32handle.c
+    libzip/lib/zip_source_win32utf8.c
+    libzip/lib/zip_source_win32w.c
+  )
+  IF(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore)
+  ELSE()
+    target_sources(zip PRIVATE libzip/lib/zip_source_win32a.c)
+  ENDIF()
+ELSE()
+  target_sources(zip PRIVATE
+    libzip/lib/zip_mkstempm.c
+    libzip/lib/zip_source_file.c
+    libzip/lib/zip_random_unix.c
+  )
+ENDIF()
+
+IF(HAVE_LIBBZ2)
+  target_sources(zip PRIVATE libzip/lib/zip_algorithm_bzip2.c)
+ENDIF()
+
+IF(HAVE_LIBLZMA)
+  target_sources(zip PRIVATE libzip/lib/zip_algorithm_xz.c)
+ENDIF()
+
+IF(HAVE_COMMONCRYPTO)
+  target_sources(zip PRIVATE libzip/lib/zip_crypto_commoncrypto.c)
+ELSEIF(HAVE_WINDOWS_CRYPTO)
+  target_sources(zip PRIVATE libzip/lib/zip_crypto_win.c)
+ELSEIF(HAVE_GNUTLS)
+  target_sources(zip PRIVATE libzip/lib/zip_crypto_gnutls.c)
+ELSEIF(HAVE_OPENSSL)
+  target_sources(zip PRIVATE libzip/lib/zip_crypto_openssl.c)
+ELSEIF(HAVE_MBEDTLS)
+  target_sources(zip PRIVATE libzip/lib/zip_crypto_mbedtls.c)
+ENDIF()
+
+IF(HAVE_CRYPTO)
+  target_sources(zip PRIVATE
+    libzip/lib/zip_winzip_aes.c
+    libzip/lib/zip_source_winzip_aes_decode.c
+    libzip/lib/zip_source_winzip_aes_encode.c
+  )
+ENDIF()
+
+target_include_directories(zip
+PUBLIC
+  libzip/lib
+  ${CMAKE_CURRENT_BINARY_DIR}/libzip
+)
+
+# pkgconfig file
+SET(prefix ${CMAKE_INSTALL_PREFIX})
+SET(exec_prefix \${prefix})
+SET(bindir \${exec_prefix}/${CMAKE_INSTALL_BINDIR})
+SET(libdir \${exec_prefix}/${CMAKE_INSTALL_LIBDIR})
+SET(includedir \${prefix}/${CMAKE_INSTALL_INCLUDEDIR})
+IF(CMAKE_SYSTEM_NAME MATCHES BSD)
+  SET(PKG_CONFIG_RPATH "-Wl,-R\${libdir}")
+ENDIF(CMAKE_SYSTEM_NAME MATCHES BSD)
+get_target_property(LIBS_PRIVATE zip LINK_LIBRARIES)
+foreach(LIB ${LIBS_PRIVATE})
+  if(LIB MATCHES "^/")
+    get_filename_component(LIB ${LIB} NAME_WE)
+    string(REGEX REPLACE "^lib" "" LIB ${LIB})
+  endif()
+  set(LIBS "${LIBS} -l${LIB}")
+endforeach()
+CONFIGURE_FILE(libzip/libzip.pc.in libzip/libzip.pc @ONLY)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libzip.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
+ADD_CUSTOM_TARGET(update_zip_err_str
+  COMMAND sh ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/make_zip_err_str.sh ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip.h ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip_err_str.c
+  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/zip.h ${CMAKE_CURRENT_SOURCE_DIR}/libzip/lib/make_zip_err_str.sh
+)
+
+IF(SHARED_LIB_VERSIONNING)
+SET_TARGET_PROPERTIES(zip PROPERTIES VERSION 5.0 SOVERSION 5)
+ENDIF()
+
+TARGET_LINK_LIBRARIES(zip ${ZLIB_LIBRARIES} ${OPTIONAL_LIBRARY})
+INSTALL(TARGETS zip
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+
@@ -53,8 +53,6 @@ add_library(common STATIC
    div_ceil.h
    dynamic_library.cpp
    dynamic_library.h
-    error.cpp
-    error.h
    fiber.cpp
    fiber.h
    fs/file.cpp
@@ -90,6 +88,7 @@ add_library(common STATIC
    microprofile.cpp
    microprofile.h
    microprofileui.h
+    misc.cpp
    nvidia_flags.cpp
    nvidia_flags.h
    page_table.cpp
@@ -9,48 +9,41 @@
 namespace Common {

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
    auto mod{static_cast<T>(value % size)};
    value -= mod;
    return static_cast<T>(mod == T{0} ? value : value + size);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
    return static_cast<T>((value + ((1ULL << align_log2) - 1)) >> align_log2 << align_log2);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
    return static_cast<T>(value - value % size);
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr bool Is4KBAligned(T value) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool Is4KBAligned(T value) {
    return (value & 0xFFF) == 0;
 }

 template <typename T>
-requires std::is_unsigned_v<T>
-[[nodiscard]] constexpr bool IsWordAligned(T value) {
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool IsWordAligned(T value) {
    return (value & 0b11) == 0;
 }

 template <typename T>
-requires std::is_integral_v<T>
-[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
+requires std::is_integral_v<T>[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
    using U = typename std::make_unsigned_t<T>;
    const U mask = static_cast<U>(alignment - 1);
    return (value & mask) == 0;
 }

 template <typename T, typename U>
-requires std::is_integral_v<T>
-[[nodiscard]] constexpr T DivideUp(T x, U y) {
+requires std::is_integral_v<T>[[nodiscard]] constexpr T DivideUp(T x, U y) {
    return (x + (y - 1)) / y;
 }

@@ -4,8 +4,9 @@

 #pragma once

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

 #if !defined(ARCHITECTURE_x86_64)
 #include <cstdlib> // for exit
@@ -48,6 +49,16 @@ __declspec(dllimport) void __stdcall DebugBreak(void);

 #endif // _MSC_VER ndef

+// Generic function to get last error message.
+// Call directly after the command or use the error num.
+// This function might change the error code.
+// Defined in misc.cpp.
+[[nodiscard]] std::string GetLastErrorMsg();
+
+// Like GetLastErrorMsg(), but passing an explicit error code.
+// Defined in misc.cpp.
+[[nodiscard]] std::string NativeErrorToString(int e);
+
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
    [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \
        using T = std::underlying_type_t<type>;                                                    \
@@ -61,14 +72,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
        using T = std::underlying_type_t<type>;                                                    \
        return static_cast<type>(static_cast<T>(a) ^ static_cast<T>(b));                           \
    }                                                                                              \
-    [[nodiscard]] constexpr type operator<<(type a, type b) noexcept {                             \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) << static_cast<T>(b));                          \
-    }                                                                                              \
-    [[nodiscard]] constexpr type operator>>(type a, type b) noexcept {                             \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) >> static_cast<T>(b));                          \
-    }                                                                                              \
    constexpr type& operator|=(type& a, type b) noexcept {                                         \
        a = a | b;                                                                                 \
        return a;                                                                                  \
@@ -81,14 +84,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
        a = a ^ b;                                                                                 \
        return a;                                                                                  \
    }                                                                                              \
-    constexpr type& operator<<=(type& a, type b) noexcept {                                        \
-        a = a << b;                                                                                \
-        return a;                                                                                  \
-    }                                                                                              \
-    constexpr type& operator>>=(type& a, type b) noexcept {                                        \
-        a = a >> b;                                                                                \
-        return a;                                                                                  \
-    }                                                                                              \
    [[nodiscard]] constexpr type operator~(type key) noexcept {                                    \
        using T = std::underlying_type_t<type>;                                                    \
        return static_cast<type>(~static_cast<T>(key));                                            \
@@ -11,15 +11,15 @@ namespace Common {

 /// Ceiled integer division.
 template <typename N, typename D>
-requires std::is_integral_v<N> && std::is_unsigned_v<D>
-[[nodiscard]] constexpr N DivCeil(N number, D divisor) {
+requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeil(N number,
+                                                                                        D divisor) {
    return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
 }

 /// Ceiled integer division with logarithmic divisor in base 2
 template <typename N, typename D>
-requires std::is_integral_v<N> && std::is_unsigned_v<D>
-[[nodiscard]] constexpr N DivCeilLog2(N value, D alignment_log2) {
+requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeilLog2(
+    N value, D alignment_log2) {
    return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
 }

@@ -1,21 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-namespace Common {
-
-// Generic function to get last error message.
-// Call directly after the command or use the error num.
-// This function might change the error code.
-// Defined in error.cpp.
-[[nodiscard]] std::string GetLastErrorMsg();
-
-// Like GetLastErrorMsg(), but passing an explicit error code.
-// Defined in error.cpp.
-[[nodiscard]] std::string NativeErrorToString(int e);
-
-} // namespace Common
@@ -21,7 +21,6 @@
 #define SCREENSHOTS_DIR "screenshots"
 #define SDMC_DIR "sdmc"
 #define SHADER_DIR "shader"
-#define TAS_DIR "tas"

 // yuzu-specific files

@@ -116,7 +116,6 @@ private:
        GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
        GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
        GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);
-        GenerateYuzuPath(YuzuPath::TASDir, yuzu_path / TAS_DIR);
    }

    ~PathManagerImpl() = default;
@@ -23,7 +23,6 @@ enum class YuzuPath {
    ScreenshotsDir, // Where yuzu screenshots are stored.
    SDMCDir,        // Where the emulated SDMC is stored.
    ShaderDir,      // Where shaders are stored.
-    TASDir,         // Where TAS scripts are stored.
 };

 /**
@@ -235,19 +235,20 @@ public:

 template <typename T>
 concept HasLightCompareType = requires {
-    { std::is_same<typename T::LightCompareType, void>::value } -> std::convertible_to<bool>;
+    { std::is_same<typename T::LightCompareType, void>::value }
+    ->std::convertible_to<bool>;
 };

 namespace impl {

-    template <typename T, typename Default>
-    consteval auto* GetLightCompareType() {
-        if constexpr (HasLightCompareType<T>) {
-            return static_cast<typename T::LightCompareType*>(nullptr);
-        } else {
-            return static_cast<Default*>(nullptr);
-        }
+template <typename T, typename Default>
+consteval auto* GetLightCompareType() {
+    if constexpr (HasLightCompareType<T>) {
+        return static_cast<typename T::LightCompareType*>(nullptr);
+    } else {
+        return static_cast<Default*>(nullptr);
    }
+}

 } // namespace impl

@@ -2,10 +2,13 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <climits>
-#include <exception>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
 #include <thread>
 #include <vector>

@@ -13,174 +16,28 @@
 #include <windows.h> // For OutputDebugStringW
 #endif

+#include "common/assert.h"
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
-#include "common/fs/fs_paths.h"
-#include "common/fs/path_util.h"
 #include "common/literals.h"
-#include "common/thread.h"

 #include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/settings.h"
-#ifdef _WIN32
 #include "common/string_util.h"
-#endif
 #include "common/threadsafe_queue.h"

 namespace Common::Log {

-namespace {
-
-/**
- * Interface for logging backends.
- */
-class Backend {
-public:
-    virtual ~Backend() = default;
-
-    virtual void Write(const Entry& entry) = 0;
-
-    virtual void EnableForStacktrace() = 0;
-
-    virtual void Flush() = 0;
-};
-
-/**
- * Backend that writes to stderr and with color
- */
-class ColorConsoleBackend final : public Backend {
-public:
-    explicit ColorConsoleBackend() = default;
-
-    ~ColorConsoleBackend() override = default;
-
-    void Write(const Entry& entry) override {
-        if (enabled.load(std::memory_order_relaxed)) {
-            PrintColoredMessage(entry);
-        }
-    }
-
-    void Flush() override {
-        // stderr shouldn't be buffered
-    }
-
-    void EnableForStacktrace() override {
-        enabled = true;
-    }
-
-    void SetEnabled(bool enabled_) {
-        enabled = enabled_;
-    }
-
-private:
-    std::atomic_bool enabled{false};
-};
-
-/**
- * Backend that writes to a file passed into the constructor
- */
-class FileBackend final : public Backend {
-public:
-    explicit FileBackend(const std::filesystem::path& filename) {
-        auto old_filename = filename;
-        old_filename += ".old.txt";
-
-        // Existence checks are done within the functions themselves.
-        // We don't particularly care if these succeed or not.
-        static_cast<void>(FS::RemoveFile(old_filename));
-        static_cast<void>(FS::RenameFile(filename, old_filename));
-
-        file = std::make_unique<FS::IOFile>(filename, FS::FileAccessMode::Write,
-                                            FS::FileType::TextFile);
-    }
-
-    ~FileBackend() override = default;
-
-    void Write(const Entry& entry) override {
-        if (!enabled) {
-            return;
-        }
-
-        bytes_written += file->WriteString(FormatLogMessage(entry).append(1, '\n'));
-
-        using namespace Common::Literals;
-        // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
-        const auto write_limit = Settings::values.extended_logging ? 1_GiB : 100_MiB;
-        const bool write_limit_exceeded = bytes_written > write_limit;
-        if (entry.log_level >= Level::Error || write_limit_exceeded) {
-            if (write_limit_exceeded) {
-                // Stop writing after the write limit is exceeded.
-                // Don't close the file so we can print a stacktrace if necessary
-                enabled = false;
-            }
-            file->Flush();
-        }
-    }
-
-    void Flush() override {
-        file->Flush();
-    }
-
-    void EnableForStacktrace() override {
-        enabled = true;
-        bytes_written = 0;
-    }
-
-private:
-    std::unique_ptr<FS::IOFile> file;
-    bool enabled = true;
-    std::size_t bytes_written = 0;
-};
-
-/**
- * Backend that writes to Visual Studio's output window
- */
-class DebuggerBackend final : public Backend {
-public:
-    explicit DebuggerBackend() = default;
-
-    ~DebuggerBackend() override = default;
-
-    void Write(const Entry& entry) override {
-#ifdef _WIN32
-        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
-#endif
-    }
-
-    void Flush() override {}
-
-    void EnableForStacktrace() override {}
-};
-
-bool initialization_in_progress_suppress_logging = true;
-
 /**
 * Static state as a singleton.
 */
 class Impl {
 public:
    static Impl& Instance() {
-        if (!instance) {
-            throw std::runtime_error("Using Logging instance before its initialization");
-        }
-        return *instance;
-    }
-
-    static void Initialize() {
-        if (instance) {
-            LOG_WARNING(Log, "Reinitializing logging backend");
-            return;
-        }
-        using namespace Common::FS;
-        const auto& log_dir = GetYuzuPath(YuzuPath::LogDir);
-        void(CreateDir(log_dir));
-        Filter filter;
-        filter.ParseFilterString(Settings::values.log_filter.GetValue());
-        instance = std::unique_ptr<Impl, decltype(&Deleter)>(new Impl(log_dir / LOG_FILE, filter),
-                                                             Deleter);
-        initialization_in_progress_suppress_logging = false;
+        static Impl backend;
+        return backend;
    }

    Impl(const Impl&) = delete;
@@ -189,54 +46,74 @@ public:
    Impl(Impl&&) = delete;
    Impl& operator=(Impl&&) = delete;

+    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+                   const char* function, std::string message) {
+        message_queue.Push(
+            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message)));
+    }
+
+    void AddBackend(std::unique_ptr<Backend> backend) {
+        std::lock_guard lock{writing_mutex};
+        backends.push_back(std::move(backend));
+    }
+
+    void RemoveBackend(std::string_view backend_name) {
+        std::lock_guard lock{writing_mutex};
+
+        std::erase_if(backends, [&backend_name](const auto& backend) {
+            return backend_name == backend->GetName();
+        });
+    }
+
+    const Filter& GetGlobalFilter() const {
+        return filter;
+    }
+
    void SetGlobalFilter(const Filter& f) {
        filter = f;
    }

-    void SetColorConsoleBackendEnabled(bool enabled) {
-        color_console_backend.SetEnabled(enabled);
-    }
-
-    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string message) {
-        if (!filter.CheckMessage(log_class, log_level))
-            return;
-        const Entry& entry =
-            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message));
-        message_queue.Push(entry);
+    Backend* GetBackend(std::string_view backend_name) {
+        const auto it =
+            std::find_if(backends.begin(), backends.end(),
+                         [&backend_name](const auto& i) { return backend_name == i->GetName(); });
+        if (it == backends.end())
+            return nullptr;
+        return it->get();
    }

 private:
-    Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
-              Common::SetCurrentThreadName("yuzu:Log");
-              Entry entry;
-              const auto write_logs = [this, &entry]() {
-                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-              };
-              while (true) {
-                  entry = message_queue.PopWait();
-                  if (entry.final_entry) {
-                      break;
-                  }
-                  write_logs();
-              }
-              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-              // case where a system is repeatedly spamming logs even on close.
-              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-              while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                  write_logs();
-              }
-          })} {}
+    Impl() {
+        backend_thread = std::thread([&] {
+            Entry entry;
+            auto write_logs = [&](Entry& e) {
+                std::lock_guard lock{writing_mutex};
+                for (const auto& backend : backends) {
+                    backend->Write(e);
+                }
+            };
+            while (true) {
+                entry = message_queue.PopWait();
+                if (entry.final_entry) {
+                    break;
+                }
+                write_logs(entry);
+            }

-    ~Impl() {
-        StopBackendThread();
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+            // case where a system is repeatedly spamming logs even on close.
+            const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
+            int logs_written = 0;
+            while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
+                write_logs(entry);
+            }
+        });
    }

-    void StopBackendThread() {
-        Entry stop_entry{};
-        stop_entry.final_entry = true;
-        message_queue.Push(stop_entry);
+    ~Impl() {
+        Entry entry;
+        entry.final_entry = true;
+        message_queue.Push(entry);
        backend_thread.join();
    }

@@ -258,51 +135,100 @@ private:
        };
    }

-    void ForEachBackend(auto lambda) {
-        lambda(static_cast<Backend&>(debugger_backend));
-        lambda(static_cast<Backend&>(color_console_backend));
-        lambda(static_cast<Backend&>(file_backend));
-    }
-
-    static void Deleter(Impl* ptr) {
-        delete ptr;
-    }
-
-    static inline std::unique_ptr<Impl, decltype(&Deleter)> instance{nullptr, Deleter};
-
-    Filter filter;
-    DebuggerBackend debugger_backend{};
-    ColorConsoleBackend color_console_backend{};
-    FileBackend file_backend;
-
+    std::mutex writing_mutex;
    std::thread backend_thread;
-    MPSCQueue<Entry> message_queue{};
+    std::vector<std::unique_ptr<Backend>> backends;
+    MPSCQueue<Entry> message_queue;
+    Filter filter;
    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
-} // namespace

-void Initialize() {
-    Impl::Initialize();
+ConsoleBackend::~ConsoleBackend() = default;
+
+void ConsoleBackend::Write(const Entry& entry) {
+    PrintMessage(entry);
 }

-void DisableLoggingInTests() {
-    initialization_in_progress_suppress_logging = true;
+ColorConsoleBackend::~ColorConsoleBackend() = default;
+
+void ColorConsoleBackend::Write(const Entry& entry) {
+    PrintColoredMessage(entry);
+}
+
+FileBackend::FileBackend(const std::filesystem::path& filename) {
+    auto old_filename = filename;
+    old_filename += ".old.txt";
+
+    // Existence checks are done within the functions themselves.
+    // We don't particularly care if these succeed or not.
+    FS::RemoveFile(old_filename);
+    void(FS::RenameFile(filename, old_filename));
+
+    file =
+        std::make_unique<FS::IOFile>(filename, FS::FileAccessMode::Write, FS::FileType::TextFile);
+}
+
+FileBackend::~FileBackend() = default;
+
+void FileBackend::Write(const Entry& entry) {
+    if (!file->IsOpen()) {
+        return;
+    }
+
+    using namespace Common::Literals;
+    // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
+    constexpr std::size_t MAX_BYTES_WRITTEN = 100_MiB;
+    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1_GiB;
+
+    const bool write_limit_exceeded =
+        bytes_written > MAX_BYTES_WRITTEN_EXTENDED ||
+        (bytes_written > MAX_BYTES_WRITTEN && !Settings::values.extended_logging);
+
+    // Close the file after the write limit is exceeded.
+    if (write_limit_exceeded) {
+        file->Close();
+        return;
+    }
+
+    bytes_written += file->WriteString(FormatLogMessage(entry).append(1, '\n'));
+    if (entry.log_level >= Level::Error) {
+        file->Flush();
+    }
+}
+
+DebuggerBackend::~DebuggerBackend() = default;
+
+void DebuggerBackend::Write(const Entry& entry) {
+#ifdef _WIN32
+    ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
+#endif
 }

 void SetGlobalFilter(const Filter& filter) {
    Impl::Instance().SetGlobalFilter(filter);
 }

-void SetColorConsoleBackendEnabled(bool enabled) {
-    Impl::Instance().SetColorConsoleBackendEnabled(enabled);
+void AddBackend(std::unique_ptr<Backend> backend) {
+    Impl::Instance().AddBackend(std::move(backend));
+}
+
+void RemoveBackend(std::string_view backend_name) {
+    Impl::Instance().RemoveBackend(backend_name);
+}
+
+Backend* GetBackend(std::string_view backend_name) {
+    return Impl::Instance().GetBackend(backend_name);
 }

 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                       unsigned int line_num, const char* function, const char* format,
                       const fmt::format_args& args) {
-    if (!initialization_in_progress_suppress_logging) {
-        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,
-                                   fmt::vformat(format, args));
-    }
+    auto& instance = Impl::Instance();
+    const auto& filter = instance.GetGlobalFilter();
+    if (!filter.CheckMessage(log_class, log_level))
+        return;
+
+    instance.PushEntry(log_class, log_level, filename, line_num, function,
+                       fmt::vformat(format, args));
 }
 } // namespace Common::Log
@@ -5,21 +5,120 @@
 #pragma once

 #include <filesystem>
+#include <memory>
+#include <string>
+#include <string_view>
 #include "common/logging/filter.h"
+#include "common/logging/log.h"
+
+namespace Common::FS {
+class IOFile;
+}

 namespace Common::Log {

 class Filter;

-/// Initializes the logging system. This should be the first thing called in main.
-void Initialize();
+/**
+ * Interface for logging backends. As loggers can be created and removed at runtime, this can be
+ * used by a frontend for adding a custom logging backend as needed
+ */
+class Backend {
+public:
+    virtual ~Backend() = default;

-void DisableLoggingInTests();
+    virtual void SetFilter(const Filter& new_filter) {
+        filter = new_filter;
+    }
+    virtual const char* GetName() const = 0;
+    virtual void Write(const Entry& entry) = 0;
+
+private:
+    Filter filter;
+};

 /**
- * The global filter will prevent any messages from even being processed if they are filtered.
+ * Backend that writes to stderr without any color commands
+ */
+class ConsoleBackend : public Backend {
+public:
+    ~ConsoleBackend() override;
+
+    static const char* Name() {
+        return "console";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to stderr and with color
+ */
+class ColorConsoleBackend : public Backend {
+public:
+    ~ColorConsoleBackend() override;
+
+    static const char* Name() {
+        return "color_console";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to a file passed into the constructor
+ */
+class FileBackend : public Backend {
+public:
+    explicit FileBackend(const std::filesystem::path& filename);
+    ~FileBackend() override;
+
+    static const char* Name() {
+        return "file";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+
+    void Write(const Entry& entry) override;
+
+private:
+    std::unique_ptr<FS::IOFile> file;
+    std::size_t bytes_written = 0;
+};
+
+/**
+ * Backend that writes to Visual Studio's output window
+ */
+class DebuggerBackend : public Backend {
+public:
+    ~DebuggerBackend() override;
+
+    static const char* Name() {
+        return "debugger";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+void AddBackend(std::unique_ptr<Backend> backend);
+
+void RemoveBackend(std::string_view backend_name);
+
+Backend* GetBackend(std::string_view backend_name);
+
+/**
+ * The global filter will prevent any messages from even being processed if they are filtered. Each
+ * backend can have a filter, but if the level is lower than the global filter, the backend will
+ * never get the message
 */
 void SetGlobalFilter(const Filter& filter);
-
-void SetColorConsoleBackendEnabled(bool enabled);
-} // namespace Common::Log
+} // namespace Common::Log
@@ -111,7 +111,6 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
    SUB(Service, NCM)                                                                              \
    SUB(Service, NFC)                                                                              \
    SUB(Service, NFP)                                                                              \
-    SUB(Service, NGCT)                                                                             \
    SUB(Service, NIFM)                                                                             \
    SUB(Service, NIM)                                                                              \
    SUB(Service, NPNS)                                                                             \
@@ -81,7 +81,6 @@ enum class Class : u8 {
    Service_NCM,       ///< The NCM service
    Service_NFC,       ///< The NFC (Near-field communication) service
    Service_NFP,       ///< The NFP service
-    Service_NGCT,      ///< The NGCT (No Good Content for Terra) service
    Service_NIFM,      ///< The NIFM (Network interface) service
    Service_NIM,       ///< The NIM service
    Service_NPNS,      ///< The NPNS service
@@ -1,140 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2+ or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <deque>
-#include <memory>
-#include <type_traits>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-template <class Traits>
-class LeastRecentlyUsedCache {
-    using ObjectType = typename Traits::ObjectType;
-    using TickType = typename Traits::TickType;
-
-    struct Item {
-        ObjectType obj;
-        TickType tick;
-        Item* next{};
-        Item* prev{};
-    };
-
-public:
-    LeastRecentlyUsedCache() : first_item{}, last_item{} {}
-    ~LeastRecentlyUsedCache() = default;
-
-    size_t Insert(ObjectType obj, TickType tick) {
-        const auto new_id = Build();
-        auto& item = item_pool[new_id];
-        item.obj = obj;
-        item.tick = tick;
-        Attach(item);
-        return new_id;
-    }
-
-    void Touch(size_t id, TickType tick) {
-        auto& item = item_pool[id];
-        if (item.tick >= tick) {
-            return;
-        }
-        item.tick = tick;
-        if (&item == last_item) {
-            return;
-        }
-        Detach(item);
-        Attach(item);
-    }
-
-    void Free(size_t id) {
-        auto& item = item_pool[id];
-        Detach(item);
-        item.prev = nullptr;
-        item.next = nullptr;
-        free_items.push_back(id);
-    }
-
-    template <typename Func>
-    void ForEachItemBelow(TickType tick, Func&& func) {
-        static constexpr bool RETURNS_BOOL =
-            std::is_same_v<std::invoke_result<Func, ObjectType>, bool>;
-        Item* iterator = first_item;
-        while (iterator) {
-            if (static_cast<s64>(tick) - static_cast<s64>(iterator->tick) < 0) {
-                return;
-            }
-            Item* next = iterator->next;
-            if constexpr (RETURNS_BOOL) {
-                if (func(iterator->obj)) {
-                    return;
-                }
-            } else {
-                func(iterator->obj);
-            }
-            iterator = next;
-        }
-    }
-
-private:
-    size_t Build() {
-        if (free_items.empty()) {
-            const size_t item_id = item_pool.size();
-            auto& item = item_pool.emplace_back();
-            item.next = nullptr;
-            item.prev = nullptr;
-            return item_id;
-        }
-        const size_t item_id = free_items.front();
-        free_items.pop_front();
-        auto& item = item_pool[item_id];
-        item.next = nullptr;
-        item.prev = nullptr;
-        return item_id;
-    }
-
-    void Attach(Item& item) {
-        if (!first_item) {
-            first_item = &item;
-        }
-        if (!last_item) {
-            last_item = &item;
-        } else {
-            item.prev = last_item;
-            last_item->next = &item;
-            item.next = nullptr;
-            last_item = &item;
-        }
-    }
-
-    void Detach(Item& item) {
-        if (item.prev) {
-            item.prev->next = item.next;
-        }
-        if (item.next) {
-            item.next->prev = item.prev;
-        }
-        if (&item == first_item) {
-            first_item = item.next;
-            if (first_item) {
-                first_item->prev = nullptr;
-            }
-        }
-        if (&item == last_item) {
-            last_item = item.prev;
-            if (last_item) {
-                last_item->next = nullptr;
-            }
-        }
-    }
-
-    std::deque<Item> item_pool;
-    std::deque<size_t> free_items;
-    Item* first_item{};
-    Item* last_item{};
-};
-
-} // namespace Common
@@ -10,9 +10,7 @@
 #include <cstring>
 #endif

-#include "common/error.h"
-
-namespace Common {
+#include "common/common_funcs.h"

 std::string NativeErrorToString(int e) {
 #ifdef _WIN32
@@ -52,5 +50,3 @@ std::string GetLastErrorMsg() {
    return NativeErrorToString(errno);
 #endif
 }
-
-} // namespace Common
@@ -54,13 +54,15 @@ void LogSettings() {
    log_setting("Renderer_GPUAccuracyLevel", values.gpu_accuracy.GetValue());
    log_setting("Renderer_UseAsynchronousGpuEmulation",
                values.use_asynchronous_gpu_emulation.GetValue());
-    log_setting("Renderer_NvdecEmulation", values.nvdec_emulation.GetValue());
+    log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
    log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
    log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
    log_setting("Renderer_ShaderBackend", values.shader_backend.GetValue());
    log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
+    log_setting("Renderer_UseGarbageCollection", values.use_caches_gc.GetValue());
    log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
    log_setting("Audio_OutputEngine", values.sink_id.GetValue());
+    log_setting("Audio_EnableAudioStretching", values.enable_audio_stretching.GetValue());
    log_setting("Audio_OutputDevice", values.audio_device_id.GetValue());
    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd.GetValue());
    log_path("DataStorage_CacheDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir));
@@ -69,9 +71,8 @@ void LogSettings() {
    log_path("DataStorage_NANDDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir));
    log_path("DataStorage_SDMCDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir));
    log_setting("Debugging_ProgramArgs", values.program_args.GetValue());
-    log_setting("Input_EnableMotion", values.motion_enabled.GetValue());
-    log_setting("Input_EnableVibration", values.vibration_enabled.GetValue());
-    log_setting("Input_EnableRawInput", values.enable_raw_input.GetValue());
+    log_setting("Services_BCATBackend", values.bcat_backend.GetValue());
+    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local.GetValue());
 }

 bool IsConfiguringGlobal() {
@@ -112,6 +113,7 @@ void RestoreGlobalState(bool is_powered_on) {
    }

    // Audio
+    values.enable_audio_stretching.SetGlobal(true);
    values.volume.SetGlobal(true);

    // Core
@@ -135,12 +137,13 @@ void RestoreGlobalState(bool is_powered_on) {
    values.use_disk_shader_cache.SetGlobal(true);
    values.gpu_accuracy.SetGlobal(true);
    values.use_asynchronous_gpu_emulation.SetGlobal(true);
-    values.nvdec_emulation.SetGlobal(true);
+    values.use_nvdec_emulation.SetGlobal(true);
    values.accelerate_astc.SetGlobal(true);
    values.use_vsync.SetGlobal(true);
    values.shader_backend.SetGlobal(true);
    values.use_asynchronous_shaders.SetGlobal(true);
    values.use_fast_gpu_time.SetGlobal(true);
+    values.use_caches_gc.SetGlobal(true);
    values.bg_red.SetGlobal(true);
    values.bg_green.SetGlobal(true);
    values.bg_blue.SetGlobal(true);
@@ -4,7 +4,6 @@

 #pragma once

-#include <algorithm>
 #include <array>
 #include <atomic>
 #include <chrono>
@@ -16,6 +15,7 @@

 #include "common/common_types.h"
 #include "common/settings_input.h"
+#include "input_common/udp/client.h"

 namespace Settings {

@@ -47,12 +47,6 @@ enum class FullscreenMode : u32 {
    Exclusive = 1,
 };

-enum class NvdecEmulation : u32 {
-    Off = 0,
-    CPU = 1,
-    GPU = 2,
-};
-
 /** The BasicSetting class is a simple resource manager. It defines a label and default value
 * alongside the actual value of the setting for simpler and less-error prone use with frontend
 * configurations. Setting a default value and label is required, though subclasses may deviate from
@@ -80,14 +74,14 @@ public:
     */
    explicit BasicSetting(const Type& default_val, const std::string& name)
        : default_value{default_val}, global{default_val}, label{name} {}
-    virtual ~BasicSetting() = default;
+    ~BasicSetting() = default;

    /**
     *  Returns a reference to the setting's value.
     *
     * @returns A reference to the setting
     */
-    [[nodiscard]] virtual const Type& GetValue() const {
+    [[nodiscard]] const Type& GetValue() const {
        return global;
    }

@@ -96,7 +90,7 @@ public:
     *
     * @param value The desired value
     */
-    virtual void SetValue(const Type& value) {
+    void SetValue(const Type& value) {
        Type temp{value};
        std::swap(global, temp);
    }
@@ -126,7 +120,7 @@ public:
     *
     * @returns A reference to the setting
     */
-    virtual const Type& operator=(const Type& value) {
+    const Type& operator=(const Type& value) {
        Type temp{value};
        std::swap(global, temp);
        return global;
@@ -137,7 +131,7 @@ public:
     *
     * @returns A reference to the setting
     */
-    explicit virtual operator const Type&() const {
+    explicit operator const Type&() const {
        return global;
    }

@@ -147,51 +141,6 @@ protected:
    const std::string label{};  ///< The setting's label
 };

-/**
- * BasicRangedSetting class is intended for use with quantifiable settings that need a more
- * restrictive range than implicitly defined by its type. Implements a minimum and maximum that is
- * simply used to sanitize SetValue and the assignment overload.
- */
-template <typename Type>
-class BasicRangedSetting : virtual public BasicSetting<Type> {
-public:
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     */
-    explicit BasicRangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                                const std::string& name)
-        : BasicSetting<Type>{default_val, name}, minimum{min_val}, maximum{max_val} {}
-    virtual ~BasicRangedSetting() = default;
-
-    /**
-     * Like BasicSetting's SetValue, except value is clamped to the range of the setting.
-     *
-     * @param value The desired value
-     */
-    void SetValue(const Type& value) override {
-        this->global = std::clamp(value, minimum, maximum);
-    }
-
-    /**
-     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
-     *
-     * @param value The desired value
-     * @returns A reference to the setting's value
-     */
-    const Type& operator=(const Type& value) override {
-        this->global = std::clamp(value, minimum, maximum);
-        return this->global;
-    }
-
-    const Type minimum; ///< Minimum allowed value of the setting
-    const Type maximum; ///< Maximum allowed value of the setting
-};
-
 /**
 * The Setting class is a slightly more complex version of the BasicSetting class. This adds a
 * custom setting to switch to when a guest application specifically requires it. The effect is that
@@ -203,7 +152,7 @@ public:
 * Like the BasicSetting, this requires setting a default value and label to use.
 */
 template <typename Type>
-class Setting : virtual public BasicSetting<Type> {
+class Setting final : public BasicSetting<Type> {
 public:
    /**
     * Sets a default value, label, and setting value.
@@ -213,7 +162,7 @@ public:
     */
    explicit Setting(const Type& default_val, const std::string& name)
        : BasicSetting<Type>(default_val, name) {}
-    virtual ~Setting() = default;
+    ~Setting() = default;

    /**
     * Tells this setting to represent either the global or custom setting when other member
@@ -242,13 +191,7 @@ public:
     *
     * @returns The required value of the setting
     */
-    [[nodiscard]] virtual const Type& GetValue() const override {
-        if (use_global) {
-            return this->global;
-        }
-        return custom;
-    }
-    [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
+    [[nodiscard]] const Type& GetValue(bool need_global = false) const {
        if (use_global || need_global) {
            return this->global;
        }
@@ -260,7 +203,7 @@ public:
     *
     * @param value The new value
     */
-    void SetValue(const Type& value) override {
+    void SetValue(const Type& value) {
        Type temp{value};
        if (use_global) {
            std::swap(this->global, temp);
@@ -276,7 +219,7 @@ public:
     *
     * @returns A reference to the current setting value
     */
-    const Type& operator=(const Type& value) override {
+    const Type& operator=(const Type& value) {
        Type temp{value};
        if (use_global) {
            std::swap(this->global, temp);
@@ -291,87 +234,18 @@ public:
     *
     * @returns A reference to the current setting value
     */
-    virtual explicit operator const Type&() const override {
+    explicit operator const Type&() const {
        if (use_global) {
            return this->global;
        }
        return custom;
    }

-protected:
+private:
    bool use_global{true}; ///< The setting's global state
    Type custom{};         ///< The custom value of the setting
 };

-/**
- * RangedSetting is a Setting that implements a maximum and minimum value for its setting. Intended
- * for use with quantifiable settings.
- */
-template <typename Type>
-class RangedSetting final : public BasicRangedSetting<Type>, public Setting<Type> {
-public:
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     */
-    explicit RangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                           const std::string& name)
-        : BasicSetting<Type>{default_val, name},
-          BasicRangedSetting<Type>{default_val, min_val, max_val, name}, Setting<Type>{default_val,
-                                                                                       name} {}
-    virtual ~RangedSetting() = default;
-
-    // The following are needed to avoid a MSVC bug
-    // (source: https://stackoverflow.com/questions/469508)
-    [[nodiscard]] const Type& GetValue() const override {
-        return Setting<Type>::GetValue();
-    }
-    [[nodiscard]] const Type& GetValue(bool need_global) const override {
-        return Setting<Type>::GetValue(need_global);
-    }
-    explicit operator const Type&() const override {
-        if (this->use_global) {
-            return this->global;
-        }
-        return this->custom;
-    }
-
-    /**
-     * Like BasicSetting's SetValue, except value is clamped to the range of the setting. Sets the
-     * appropriate value depending on the global state.
-     *
-     * @param value The desired value
-     */
-    void SetValue(const Type& value) override {
-        const Type temp = std::clamp(value, this->minimum, this->maximum);
-        if (this->use_global) {
-            this->global = temp;
-        }
-        this->custom = temp;
-    }
-
-    /**
-     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
-     * Uses the appropriate value depending on the global state.
-     *
-     * @param value The desired value
-     * @returns A reference to the setting's value
-     */
-    const Type& operator=(const Type& value) override {
-        const Type temp = std::clamp(value, this->minimum, this->maximum);
-        if (this->use_global) {
-            this->global = temp;
-            return this->global;
-        }
-        this->custom = temp;
-        return this->custom;
-    }
-};
-
 /**
 * The InputSetting class allows for getting a reference to either the global or custom members.
 * This is required as we cannot easily modify the values of user-defined types within containers
@@ -414,14 +288,14 @@ struct Values {
    BasicSetting<std::string> audio_device_id{"auto", "output_device"};
    BasicSetting<std::string> sink_id{"auto", "output_engine"};
    BasicSetting<bool> audio_muted{false, "audio_muted"};
-    RangedSetting<u8> volume{100, 0, 100, "volume"};
+    Setting<bool> enable_audio_stretching{true, "enable_audio_stretching"};
+    Setting<u8> volume{100, "volume"};

    // Core
    Setting<bool> use_multi_core{true, "use_multi_core"};

    // Cpu
-    RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
-                                            CPUAccuracy::Unsafe, "cpu_accuracy"};
+    Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, "cpu_accuracy"};
    // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
    BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
    BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
@@ -443,8 +317,7 @@ struct Values {
    Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};

    // Renderer
-    RangedSetting<RendererBackend> renderer_backend{
-        RendererBackend::OpenGL, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
+    Setting<RendererBackend> renderer_backend{RendererBackend::OpenGL, "backend"};
    BasicSetting<bool> renderer_debug{false, "debug"};
    BasicSetting<bool> renderer_shader_feedback{false, "shader_feedback"};
    BasicSetting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
@@ -455,30 +328,29 @@ struct Values {
    Setting<u16> resolution_factor{1, "resolution_factor"};
    // *nix platforms may have issues with the borderless windowed fullscreen mode.
    // Default to exclusive fullscreen on these platforms for now.
-    RangedSetting<FullscreenMode> fullscreen_mode{
+    Setting<FullscreenMode> fullscreen_mode{
 #ifdef _WIN32
        FullscreenMode::Borderless,
 #else
        FullscreenMode::Exclusive,
 #endif
-        FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    RangedSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
-    RangedSetting<int> max_anisotropy{0, 0, 4, "max_anisotropy"};
+        "fullscreen_mode"};
+    Setting<int> aspect_ratio{0, "aspect_ratio"};
+    Setting<int> max_anisotropy{0, "max_anisotropy"};
    Setting<bool> use_speed_limit{true, "use_speed_limit"};
-    RangedSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
+    Setting<u16> speed_limit{100, "speed_limit"};
    Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
-    RangedSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
-                                            GPUAccuracy::Extreme, "gpu_accuracy"};
+    Setting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, "gpu_accuracy"};
    Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
-    Setting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
+    Setting<bool> use_nvdec_emulation{true, "use_nvdec_emulation"};
    Setting<bool> accelerate_astc{true, "accelerate_astc"};
    Setting<bool> use_vsync{true, "use_vsync"};
-    BasicRangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
+    BasicSetting<u16> fps_cap{1000, "fps_cap"};
    BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};
-    RangedSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
-                                                ShaderBackend::SPIRV, "shader_backend"};
+    Setting<ShaderBackend> shader_backend{ShaderBackend::GLASM, "shader_backend"};
    Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
    Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
+    Setting<bool> use_caches_gc{false, "use_caches_gc"};

    Setting<u8> bg_red{0, "bg_red"};
    Setting<u8> bg_green{0, "bg_green"};
@@ -492,33 +364,27 @@ struct Values {
    std::chrono::seconds custom_rtc_differential;

    BasicSetting<s32> current_user{0, "current_user"};
-    RangedSetting<s32> language_index{1, 0, 17, "language_index"};
-    RangedSetting<s32> region_index{1, 0, 6, "region_index"};
-    RangedSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"};
-    RangedSetting<s32> sound_index{1, 0, 2, "sound_index"};
+    Setting<s32> language_index{1, "language_index"};
+    Setting<s32> region_index{1, "region_index"};
+    Setting<s32> time_zone_index{0, "time_zone_index"};
+    Setting<s32> sound_index{1, "sound_index"};

    // Controls
    InputSetting<std::array<PlayerInput, 10>> players;

    Setting<bool> use_docked_mode{true, "use_docked_mode"};

-    BasicSetting<bool> enable_raw_input{false, "enable_raw_input"};
-
    Setting<bool> vibration_enabled{true, "vibration_enabled"};
    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};

    Setting<bool> motion_enabled{true, "motion_enabled"};
    BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
                                            "motion_device"};
-    BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
-
-    BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
-    BasicSetting<bool> tas_enable{false, "tas_enable"};
-    BasicSetting<bool> tas_loop{false, "tas_loop"};
-    BasicSetting<bool> tas_swap_controllers{true, "tas_swap_controllers"};
+    BasicSetting<std::string> udp_input_servers{InputCommon::CemuhookUDP::DEFAULT_SRV,
+                                                "udp_input_servers"};

    BasicSetting<bool> mouse_panning{false, "mouse_panning"};
-    BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
+    BasicSetting<u8> mouse_panning_sensitivity{10, "mouse_panning_sensitivity"};
    BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
    std::string mouse_device;
    MouseButtonsRaw mouse_buttons;
@@ -567,8 +433,9 @@ struct Values {
    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
    BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};

-    // Network
-    BasicSetting<std::string> network_interface{std::string(), "network_interface"};
+    // Services
+    BasicSetting<std::string> bcat_backend{"none", "bcat_backend"};
+    BasicSetting<bool> bcat_boxcat_local{false, "bcat_boxcat_local"};

    // WebService
    BasicSetting<bool> enable_telemetry{true, "enable_telemetry"};
@@ -2,9 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <string>
-
-#include "common/error.h"
+#include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "common/thread.h"
 #ifdef __APPLE__
@@ -23,6 +21,8 @@
 #include <unistd.h>
 #endif

+#include <string>
+
 #ifdef __FreeBSD__
 #define cpu_set_t cpuset_t
 #endif
@@ -14,7 +14,7 @@
 #include <utility>

 namespace Common {
-template <typename T, bool with_stop_token = false>
+template <typename T>
 class SPSCQueue {
 public:
    SPSCQueue() {
@@ -46,13 +46,15 @@ public:
        ElementPtr* new_ptr = new ElementPtr();
        write_ptr->next.store(new_ptr, std::memory_order_release);
        write_ptr = new_ptr;
-        ++size;

-        // cv_mutex must be held or else there will be a missed wakeup if the other thread is in the
-        // line before cv.wait
+        const size_t previous_size{size++};
+
+        // Acquire the mutex and then immediately release it as a fence.
        // TODO(bunnei): This can be replaced with C++20 waitable atomics when properly supported.
        // See discussion on https://github.com/yuzu-emu/yuzu/pull/3173 for details.
-        std::lock_guard lock{cv_mutex};
+        if (previous_size == 0) {
+            std::lock_guard lock{cv_mutex};
+        }
        cv.notify_one();
    }

@@ -84,7 +86,7 @@ public:
    void Wait() {
        if (Empty()) {
            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, [this] { return !Empty(); });
+            cv.wait(lock, [this]() { return !Empty(); });
        }
    }

@@ -95,19 +97,6 @@ public:
        return t;
    }

-    T PopWait(std::stop_token stop_token) {
-        if (Empty()) {
-            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, stop_token, [this] { return !Empty(); });
-        }
-        if (stop_token.stop_requested()) {
-            return T{};
-        }
-        T t;
-        Pop(t);
-        return t;
-    }
-
    // not thread-safe
    void Clear() {
        size.store(0);
@@ -136,13 +125,13 @@ private:
    ElementPtr* read_ptr;
    std::atomic_size_t size{0};
    std::mutex cv_mutex;
-    std::conditional_t<with_stop_token, std::condition_variable_any, std::condition_variable> cv;
+    std::condition_variable cv;
 };

 // a simple thread-safe,
 // single reader, multiple writer queue

-template <typename T, bool with_stop_token = false>
+template <typename T>
 class MPSCQueue {
 public:
    [[nodiscard]] std::size_t Size() const {
@@ -179,17 +168,13 @@ public:
        return spsc_queue.PopWait();
    }

-    T PopWait(std::stop_token stop_token) {
-        return spsc_queue.PopWait(stop_token);
-    }
-
    // not thread-safe
    void Clear() {
        spsc_queue.Clear();
    }

 private:
-    SPSCQueue<T, with_stop_token> spsc_queue;
+    SPSCQueue<T> spsc_queue;
    std::mutex write_lock;
 };
 } // namespace Common
@@ -58,13 +58,6 @@ struct UUID {
        uuid = INVALID_UUID;
    }

-    [[nodiscard]] constexpr bool IsInvalid() const {
-        return uuid == INVALID_UUID;
-    }
-    [[nodiscard]] constexpr bool IsValid() const {
-        return !IsInvalid();
-    }
-
    // TODO(ogniK): Properly generate a Nintendo ID
    [[nodiscard]] constexpr u64 GetNintendoID() const {
        return uuid[0];
@@ -667,8 +667,8 @@ template <typename T>

 // linear interpolation via float: 0.0=begin, 1.0=end
 template <typename X>
-[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{})
-    Lerp(const X& begin, const X& end, const float t) {
+[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
+                                                                     const float t) {
    return begin * (1.f - t) + end * t;
 }

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

 #include <bitset>
 #include <initializer_list>
-#include <xbyak/xbyak.h>
+#include <xbyak.h>
 #include "common/assert.h"

 namespace Common::X64 {
@@ -5,7 +5,7 @@
 #pragma once

 #include <type_traits>
-#include <xbyak/xbyak.h>
+#include <xbyak.h>
 #include "common/x64/xbyak_abi.h"

 namespace Common::X64 {
@@ -106,6 +106,8 @@ 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
@@ -261,8 +263,6 @@ add_library(core STATIC
    hle/service/acc/acc_u0.h
    hle/service/acc/acc_u1.cpp
    hle/service/acc/acc_u1.h
-    hle/service/acc/async_context.cpp
-    hle/service/acc/async_context.h
    hle/service/acc/errors.h
    hle/service/acc/profile_manager.cpp
    hle/service/acc/profile_manager.h
@@ -452,8 +452,6 @@ add_library(core STATIC
    hle/service/nfp/nfp.h
    hle/service/nfp/nfp_user.cpp
    hle/service/nfp/nfp_user.h
-    hle/service/ngct/ngct.cpp
-    hle/service/ngct/ngct.h
    hle/service/nifm/nifm.cpp
    hle/service/nifm/nifm.h
    hle/service/nim/nim.cpp
@@ -638,8 +636,6 @@ add_library(core STATIC
    memory.h
    network/network.cpp
    network/network.h
-    network/network_interface.cpp
-    network/network_interface.h
    network/sockets.h
    perf_stats.cpp
    perf_stats.h
@@ -651,6 +647,13 @@ add_library(core STATIC
    tools/freezer.h
 )

+if (YUZU_ENABLE_BOXCAT)
+    target_sources(core PRIVATE
+        hle/service/bcat/backend/boxcat.cpp
+        hle/service/bcat/backend/boxcat.h
+    )
+endif()
+
 if (MSVC)
    target_compile_options(core PRIVATE
        /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
@@ -681,7 +684,12 @@ endif()
 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::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus zip)
+
+if (YUZU_ENABLE_BOXCAT)
+    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
+    target_link_libraries(core PRIVATE httplib nlohmann_json::nlohmann_json)
+endif()

 if (ENABLE_WEB_SERVICE)
    target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
@@ -4,7 +4,6 @@

 #include <array>
 #include <atomic>
-#include <exception>
 #include <memory>
 #include <utility>

@@ -83,14 +82,10 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
    }
 }

-void KProcessDeleter(Kernel::KProcess* process) {
-    process->Destroy();
-}
-
-using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
-
 } // Anonymous namespace

+/*static*/ System System::s_instance;
+
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
                                         const std::string& path) {
    // To account for split 00+01+etc files.
@@ -239,8 +234,8 @@ struct System::Impl {
        }

        telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
-        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
+        auto main_process = Kernel::KProcess::Create(system.Kernel());
+        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
                                            Kernel::KProcess::ProcessType::Userland)
                   .IsSuccess());
        main_process->Open();
@@ -253,7 +248,7 @@ struct System::Impl {
                                             static_cast<u32>(load_result));
        }
        AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process.get());
+        kernel.MakeCurrentProcess(main_process);
        kernel.InitializeCores();

        // Initialize cheat engine
@@ -305,6 +300,10 @@ struct System::Impl {
        is_powered_on = false;
        exit_lock = false;

+        if (gpu_core) {
+            gpu_core->ShutDown();
+        }
+
        services.reset();
        service_manager.reset();
        cheat_engine.reset();
@@ -313,13 +312,11 @@ struct System::Impl {
        time_manager.Shutdown();
        core_timing.Shutdown();
        app_loader.reset();
-        perf_stats.reset();
        gpu_core.reset();
+        perf_stats.reset();
        kernel.Shutdown();
        memory.Reset();
        applet_manager.ClearAll();
-        // TODO: The main process should be freed based on KAutoObject ref counting.
-        main_process.reset();

        LOG_DEBUG(Core, "Shutdown OK");
    }
@@ -378,7 +375,6 @@ struct System::Impl {
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
    std::unique_ptr<Core::DeviceMemory> device_memory;
-    KProcessPtr main_process{nullptr, KProcessDeleter};
    Core::Memory::Memory memory;
    CpuManager cpu_manager;
    std::atomic_bool is_powered_on{};
@@ -429,20 +425,6 @@ struct System::Impl {
 System::System() : impl{std::make_unique<Impl>(*this)} {}
 System::~System() = default;

-System& System::GetInstance() {
-    if (!s_instance) {
-        throw std::runtime_error("Using System instance before its initialization");
-    }
-    return *s_instance;
-}
-
-void System::InitializeGlobalInstance() {
-    if (s_instance) {
-        throw std::runtime_error("Reinitializing Global System instance.");
-    }
-    s_instance = std::unique_ptr<System>(new System);
-}
-
 CpuManager& System::GetCpuManager() {
    return impl->cpu_manager;
 }
@@ -120,9 +120,9 @@ public:
     * Gets the instance of the System singleton class.
     * @returns Reference to the instance of the System singleton class.
     */
-    [[deprecated("Use of the global system instance is deprecated")]] static System& GetInstance();
-
-    static void InitializeGlobalInstance();
+    [[deprecated("Use of the global system instance is deprecated")]] static System& GetInstance() {
+        return s_instance;
+    }

    /// Enumeration representing the return values of the System Initialize and Load process.
    enum class ResultStatus : u32 {
@@ -396,7 +396,7 @@ private:
    struct Impl;
    std::unique_ptr<Impl> impl;

-    inline static std::unique_ptr<System> s_instance{};
+    static System s_instance;
 };

 } // namespace Core
@@ -21,25 +21,34 @@ namespace Core {
 CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;

-void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
-                             std::size_t core) {
-    cpu_manager.RunThread(stop_token, core);
+void CpuManager::ThreadStart(CpuManager& cpu_manager, std::size_t core) {
+    cpu_manager.RunThread(core);
 }

 void CpuManager::Initialize() {
    running_mode = true;
    if (is_multicore) {
        for (std::size_t core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) {
-            core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+            core_data[core].host_thread =
+                std::make_unique<std::thread>(ThreadStart, std::ref(*this), core);
        }
    } else {
-        core_data[0].host_thread = std::jthread(ThreadStart, std::ref(*this), 0);
+        core_data[0].host_thread = std::make_unique<std::thread>(ThreadStart, std::ref(*this), 0);
    }
 }

 void CpuManager::Shutdown() {
    running_mode = false;
    Pause(false);
+    if (is_multicore) {
+        for (auto& data : core_data) {
+            data.host_thread->join();
+            data.host_thread.reset();
+        }
+    } else {
+        core_data[0].host_thread->join();
+        core_data[0].host_thread.reset();
+    }
 }

 std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
@@ -308,7 +317,7 @@ void CpuManager::Pause(bool paused) {
    }
 }

-void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
+void CpuManager::RunThread(std::size_t core) {
    /// Initialization
    system.RegisterCoreThread(core);
    std::string name;
@@ -352,10 +361,6 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
            return;
        }

-        if (stop_token.stop_requested()) {
-            break;
-        }
-
        auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
        data.is_running = true;
        Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
@@ -78,9 +78,9 @@ private:
    void SingleCoreRunSuspendThread();
    void SingleCorePause(bool paused);

-    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
+    static void ThreadStart(CpuManager& cpu_manager, std::size_t core);

-    void RunThread(std::stop_token stop_token, std::size_t core);
+    void RunThread(std::size_t core);

    struct CoreData {
        std::shared_ptr<Common::Fiber> host_context;
@@ -89,7 +89,7 @@ private:
        std::atomic<bool> is_running;
        std::atomic<bool> is_paused;
        std::atomic<bool> initialized;
-        std::jthread host_thread;
+        std::unique_ptr<std::thread> host_thread;
    };

    std::atomic<bool> running_mode{};
@@ -5,7 +5,6 @@
 #pragma once

 #include <array>
-#include <string>
 #include <vector>

 #include "common/common_funcs.h"
@@ -273,10 +273,6 @@ VirtualFile VfsDirectory::GetFile(std::string_view name) const {
    return iter == files.end() ? nullptr : *iter;
 }

-FileTimeStampRaw VfsDirectory::GetFileTimeStamp([[maybe_unused]] std::string_view path) const {
-    return {};
-}
-
 VirtualDir VfsDirectory::GetSubdirectory(std::string_view name) const {
    const auto& subs = GetSubdirectories();
    const auto iter = std::find_if(subs.begin(), subs.end(),
@@ -199,9 +199,6 @@ public:
    // file with name.
    virtual VirtualFile GetFile(std::string_view name) const;

-    // Returns a struct containing the file's timestamp.
-    virtual FileTimeStampRaw GetFileTimeStamp(std::string_view path) const;
-
    // Returns a vector containing all of the subdirectories in this directory.
    virtual std::vector<VirtualDir> GetSubdirectories() const = 0;
    // Returns the directory with name matching name. Returns nullptr if directory dosen't have a
@@ -0,0 +1,88 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <string>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
+#include <zip.h>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#include "common/fs/path_util.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 = static_cast<std::size_t>(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)> file2{
+                zip_fopen_index(zip.get(), i, 0), zip_fclose};
+
+            std::vector<u8> buf(stat.size);
+            if (zip_fread(file2.get(), buf.data(), buf.size()) != s64(buf.size()))
+                return nullptr;
+
+            const auto parts = Common::FS::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
@@ -0,0 +1,13 @@
+// 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
@@ -13,13 +13,6 @@
 #include "common/logging/log.h"
 #include "core/file_sys/vfs_real.h"

-// For FileTimeStampRaw
-#include <sys/stat.h>
-
-#ifdef _MSC_VER
-#define stat _stat64
-#endif
-
 namespace FileSys {

 namespace FS = Common::FS;
@@ -399,28 +392,6 @@ std::vector<VirtualFile> RealVfsDirectory::GetFiles() const {
    return IterateEntries<RealVfsFile, VfsFile>();
 }

-FileTimeStampRaw RealVfsDirectory::GetFileTimeStamp(std::string_view path_) const {
-    const auto full_path = FS::SanitizePath(path + '/' + std::string(path_));
-    const auto fs_path = std::filesystem::path{FS::ToU8String(full_path)};
-    struct stat file_status;
-
-#ifdef _WIN32
-    const auto stat_result = _wstat64(fs_path.c_str(), &file_status);
-#else
-    const auto stat_result = stat(fs_path.c_str(), &file_status);
-#endif
-
-    if (stat_result != 0) {
-        return {};
-    }
-
-    return {
-        .created{static_cast<u64>(file_status.st_ctime)},
-        .accessed{static_cast<u64>(file_status.st_atime)},
-        .modified{static_cast<u64>(file_status.st_mtime)},
-    };
-}
-
 std::vector<VirtualDir> RealVfsDirectory::GetSubdirectories() const {
    return IterateEntries<RealVfsDirectory, VfsDirectory>();
 }
@@ -86,7 +86,6 @@ public:
    VirtualDir CreateDirectoryRelative(std::string_view relative_path) override;
    bool DeleteSubdirectoryRecursive(std::string_view name) override;
    std::vector<VirtualFile> GetFiles() const override;
-    FileTimeStampRaw GetFileTimeStamp(std::string_view path) const override;
    std::vector<VirtualDir> GetSubdirectories() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
@@ -6,8 +6,6 @@

 #include <memory>

-#include "common/common_types.h"
-
 namespace FileSys {

 class VfsDirectory;
@@ -20,11 +18,4 @@ using VirtualDir = std::shared_ptr<VfsDirectory>;
 using VirtualFile = std::shared_ptr<VfsFile>;
 using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;

-struct FileTimeStampRaw {
-    u64 created{};
-    u64 accessed{};
-    u64 modified{};
-    u64 padding{};
-};
-
 } // namespace FileSys
@@ -13,8 +13,7 @@ ProfileSelectApplet::~ProfileSelectApplet() = default;
 void DefaultProfileSelectApplet::SelectProfile(
    std::function<void(std::optional<Common::UUID>)> callback) const {
    Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user.GetValue())
-                 .value_or(Common::UUID{Common::INVALID_UUID}));
+    callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::UUID{}));
    LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }

@@ -28,20 +28,13 @@ constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 12.1.0-1.0";

 // Atmosphere version constants.

-constexpr u8 ATMOSPHERE_RELEASE_VERSION_MAJOR = 1;
-constexpr u8 ATMOSPHERE_RELEASE_VERSION_MINOR = 0;
-constexpr u8 ATMOSPHERE_RELEASE_VERSION_MICRO = 0;
-
-constexpr u32 AtmosphereTargetFirmwareWithRevision(u8 major, u8 minor, u8 micro, u8 rev) {
-    return u32{major} << 24 | u32{minor} << 16 | u32{micro} << 8 | u32{rev};
-}
-
-constexpr u32 AtmosphereTargetFirmware(u8 major, u8 minor, u8 micro) {
-    return AtmosphereTargetFirmwareWithRevision(major, minor, micro, 0);
-}
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MAJOR = 0;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MINOR = 19;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MICRO = 5;

 constexpr u32 GetTargetFirmware() {
-    return AtmosphereTargetFirmware(HOS_VERSION_MAJOR, HOS_VERSION_MINOR, HOS_VERSION_MICRO);
+    return u32{HOS_VERSION_MAJOR} << 24 | u32{HOS_VERSION_MINOR} << 16 |
+           u32{HOS_VERSION_MICRO} << 8 | 0U;
 }

 } // namespace HLE::ApiVersion
@@ -22,10 +22,12 @@ class KThread;

 template <typename T>
 concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T & t) {
-    { t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
+    { t.GetAffinityMask() }
+    ->Common::ConvertibleTo<u64>;
    {t.SetAffinityMask(0)};

-    { t.GetAffinity(0) } -> std::same_as<bool>;
+    { t.GetAffinity(0) }
+    ->std::same_as<bool>;
    {t.SetAffinity(0, false)};
    {t.SetAll()};
 };
@@ -36,20 +38,25 @@ concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T & t) {
    {(typename T::QueueEntry()).Initialize()};
    {(typename T::QueueEntry()).SetPrev(std::addressof(t))};
    {(typename T::QueueEntry()).SetNext(std::addressof(t))};
-    { (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
-    { (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
-    { t.GetPriorityQueueEntry(0) } -> std::same_as<typename T::QueueEntry&>;
+    { (typename T::QueueEntry()).GetNext() }
+    ->std::same_as<T*>;
+    { (typename T::QueueEntry()).GetPrev() }
+    ->std::same_as<T*>;
+    { t.GetPriorityQueueEntry(0) }
+    ->std::same_as<typename T::QueueEntry&>;

    {t.GetAffinityMask()};
-    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() } -> KPriorityQueueAffinityMask;
+    { std::remove_cvref_t<decltype(t.GetAffinityMask())>() }
+    ->KPriorityQueueAffinityMask;

-    { t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
-    { t.GetPriority() } -> Common::ConvertibleTo<s32>;
+    { t.GetActiveCore() }
+    ->Common::ConvertibleTo<s32>;
+    { t.GetPriority() }
+    ->Common::ConvertibleTo<s32>;
 };

 template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>
-requires KPriorityQueueMember<Member>
-class KPriorityQueue {
+requires KPriorityQueueMember<Member> class KPriorityQueue {
 public:
    using AffinityMaskType = std::remove_cv_t<
        std::remove_reference_t<decltype(std::declval<Member>().GetAffinityMask())>>;
@@ -197,7 +197,7 @@ private:

 class [[nodiscard]] KScopedSchedulerLock : KScopedLock<GlobalSchedulerContext::LockType> {
 public:
-    explicit KScopedSchedulerLock(KernelCore& kernel);
+    explicit KScopedSchedulerLock(KernelCore & kernel);
    ~KScopedSchedulerLock();
 };

@@ -13,18 +13,19 @@ namespace Kernel {

 template <typename T>
 concept KLockable = !std::is_reference_v<T> && requires(T & t) {
-    { t.Lock() } -> std::same_as<void>;
-    { t.Unlock() } -> std::same_as<void>;
+    { t.Lock() }
+    ->std::same_as<void>;
+    { t.Unlock() }
+    ->std::same_as<void>;
 };

 template <typename T>
-requires KLockable<T>
-class [[nodiscard]] KScopedLock {
+requires KLockable<T> class [[nodiscard]] KScopedLock {
 public:
-    explicit KScopedLock(T* l) : lock_ptr(l) {
+    explicit KScopedLock(T * l) : lock_ptr(l) {
        this->lock_ptr->Lock();
    }
-    explicit KScopedLock(T& l) : KScopedLock(std::addressof(l)) {}
+    explicit KScopedLock(T & l) : KScopedLock(std::addressof(l)) {}

    ~KScopedLock() {
        this->lock_ptr->Unlock();
@@ -33,7 +34,7 @@ public:
    KScopedLock(const KScopedLock&) = delete;
    KScopedLock& operator=(const KScopedLock&) = delete;

-    KScopedLock(KScopedLock&&) = delete;
+    KScopedLock(KScopedLock &&) = delete;
    KScopedLock& operator=(KScopedLock&&) = delete;

 private:
@@ -17,7 +17,7 @@ namespace Kernel {

 class [[nodiscard]] KScopedSchedulerLockAndSleep {
 public:
-    explicit KScopedSchedulerLockAndSleep(KernelCore& kernel_, KThread* t, s64 timeout)
+    explicit KScopedSchedulerLockAndSleep(KernelCore & kernel_, KThread * t, s64 timeout)
        : kernel(kernel_), thread(t), timeout_tick(timeout) {
        // Lock the scheduler.
        kernel.GlobalSchedulerContext().scheduler_lock.Lock();
@@ -267,23 +267,20 @@ struct KernelCore::Impl {
        }
    }

-    static inline thread_local u32 host_thread_id = UINT32_MAX;
-
-    /// Gets the host thread ID for the caller, allocating a new one if this is the first time
-    u32 GetHostThreadId(std::size_t core_id) {
-        if (host_thread_id == UINT32_MAX) {
-            // The first four slots are reserved for CPU core threads
-            ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
-            host_thread_id = static_cast<u32>(core_id);
+    /// Creates a new host thread ID, should only be called by GetHostThreadId
+    u32 AllocateHostThreadId(std::optional<std::size_t> core_id) {
+        if (core_id) {
+            // The first for slots are reserved for CPU core threads
+            ASSERT(*core_id < Core::Hardware::NUM_CPU_CORES);
+            return static_cast<u32>(*core_id);
+        } else {
+            return next_host_thread_id++;
        }
-        return host_thread_id;
    }

    /// Gets the host thread ID for the caller, allocating a new one if this is the first time
-    u32 GetHostThreadId() {
-        if (host_thread_id == UINT32_MAX) {
-            host_thread_id = next_host_thread_id++;
-        }
+    u32 GetHostThreadId(std::optional<std::size_t> core_id = std::nullopt) {
+        const thread_local auto host_thread_id{AllocateHostThreadId(core_id)};
        return host_thread_id;
    }

@@ -5,7 +5,6 @@
 #pragma once

 #include <array>
-#include <functional>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -1078,8 +1078,8 @@ static ResultCode GetThreadContext(Core::System& system, VAddr out_context, Hand
            for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) {
                if (thread.GetPointerUnsafe() == kernel.Scheduler(i).GetCurrentThread()) {
                    current = true;
-                    break;
                }
+                break;
            }

            // If the thread is current, retry until it isn't.
@@ -23,7 +23,6 @@
 #include "core/hle/service/acc/acc_su.h"
 #include "core/hle/service/acc/acc_u0.h"
 #include "core/hle/service/acc/acc_u1.h"
-#include "core/hle/service/acc/async_context.h"
 #include "core/hle/service/acc/errors.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/glue/arp.h"
@@ -455,6 +454,22 @@ public:
        : IProfileCommon{system_, "IProfileEditor", true, user_id_, profile_manager_} {}
 };

+class IAsyncContext final : public ServiceFramework<IAsyncContext> {
+public:
+    explicit IAsyncContext(Core::System& system_) : ServiceFramework{system_, "IAsyncContext"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetSystemEvent"},
+            {1, nullptr, "Cancel"},
+            {2, nullptr, "HasDone"},
+            {3, nullptr, "GetResult"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
 class ISessionObject final : public ServiceFramework<ISessionObject> {
 public:
    explicit ISessionObject(Core::System& system_, Common::UUID)
@@ -489,44 +504,16 @@ public:
    }
 };

-class EnsureTokenIdCacheAsyncInterface final : public IAsyncContext {
-public:
-    explicit EnsureTokenIdCacheAsyncInterface(Core::System& system_) : IAsyncContext{system_} {
-        MarkComplete();
-    }
-    ~EnsureTokenIdCacheAsyncInterface() = default;
-
-    void LoadIdTokenCache(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-protected:
-    bool IsComplete() const override {
-        return true;
-    }
-
-    void Cancel() override {}
-
-    ResultCode GetResult() const override {
-        return ResultSuccess;
-    }
-};
-
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
    explicit IManagerForApplication(Core::System& system_, Common::UUID user_id_)
-        : ServiceFramework{system_, "IManagerForApplication"},
-          ensure_token_id{std::make_shared<EnsureTokenIdCacheAsyncInterface>(system)},
-          user_id{user_id_} {
+        : ServiceFramework{system_, "IManagerForApplication"}, user_id{user_id_} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
            {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
-            {2, &IManagerForApplication::EnsureIdTokenCacheAsync, "EnsureIdTokenCacheAsync"},
-            {3, &IManagerForApplication::LoadIdTokenCache, "LoadIdTokenCache"},
+            {2, nullptr, "EnsureIdTokenCacheAsync"},
+            {3, nullptr, "LoadIdTokenCache"},
            {130, &IManagerForApplication::GetNintendoAccountUserResourceCacheForApplication, "GetNintendoAccountUserResourceCacheForApplication"},
            {150, nullptr, "CreateAuthorizationRequest"},
            {160, &IManagerForApplication::StoreOpenContext, "StoreOpenContext"},
@@ -553,20 +540,6 @@ private:
        rb.PushRaw<u64>(user_id.GetNintendoID());
    }

-    void EnsureIdTokenCacheAsync(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface(ensure_token_id);
-    }
-
-    void LoadIdTokenCache(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-        ensure_token_id->LoadIdTokenCache(ctx);
-    }
-
    void GetNintendoAccountUserResourceCacheForApplication(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_ACC, "(STUBBED) called");

@@ -589,7 +562,6 @@ private:
        rb.Push(ResultSuccess);
    }

-    std::shared_ptr<EnsureTokenIdCacheAsyncInterface> ensure_token_id{};
    Common::UUID user_id{Common::INVALID_UUID};
 };

@@ -929,7 +901,8 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
    }

    const auto user_list = profile_manager->GetAllUsers();
-    if (std::ranges::all_of(user_list, [](const auto& user) { return user.IsInvalid(); })) {
+    if (std::all_of(user_list.begin(), user_list.end(),
+                    [](const auto& user) { return user.uuid == Common::INVALID_UUID; })) {
        rb.Push(ResultUnknown); // TODO(ogniK): Find the correct error code
        rb.PushRaw<u128>(Common::INVALID_UUID);
        return;
@@ -1,68 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/acc/async_context.h"
-
-namespace Service::Account {
-IAsyncContext::IAsyncContext(Core::System& system_)
-    : ServiceFramework{system_, "IAsyncContext"}, compeletion_event{system_.Kernel()} {
-
-    Kernel::KAutoObject::Create(std::addressof(compeletion_event));
-    compeletion_event.Initialize("IAsyncContext:CompletionEvent");
-
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, &IAsyncContext::GetSystemEvent, "GetSystemEvent"},
-        {1, &IAsyncContext::Cancel, "Cancel"},
-        {2, &IAsyncContext::HasDone, "HasDone"},
-        {3, &IAsyncContext::GetResult, "GetResult"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-void IAsyncContext::GetSystemEvent(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(compeletion_event.GetReadableEvent());
-}
-
-void IAsyncContext::Cancel(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
-
-    Cancel();
-    MarkComplete();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void IAsyncContext::HasDone(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
-
-    is_complete.store(IsComplete());
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(is_complete.load());
-}
-
-void IAsyncContext::GetResult(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(GetResult());
-}
-
-void IAsyncContext::MarkComplete() {
-    is_complete.store(true);
-    compeletion_event.GetWritableEvent().Signal();
-}
-
-} // namespace Service::Account
@@ -1,37 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <atomic>
-#include "core/hle/kernel/k_event.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Account {
-
-class IAsyncContext : public ServiceFramework<IAsyncContext> {
-public:
-    explicit IAsyncContext(Core::System& system_);
-
-    void GetSystemEvent(Kernel::HLERequestContext& ctx);
-    void Cancel(Kernel::HLERequestContext& ctx);
-    void HasDone(Kernel::HLERequestContext& ctx);
-    void GetResult(Kernel::HLERequestContext& ctx);
-
-protected:
-    virtual bool IsComplete() const = 0;
-    virtual void Cancel() = 0;
-    virtual ResultCode GetResult() const = 0;
-
-    void MarkComplete();
-
-    std::atomic<bool> is_complete{false};
-    Kernel::KEvent compeletion_event;
-};
-
-} // namespace Service::Account
@@ -208,10 +208,9 @@ bool ProfileManager::UserExists(UUID uuid) const {
 }

 bool ProfileManager::UserExistsIndex(std::size_t index) const {
-    if (index >= MAX_USERS) {
+    if (index >= MAX_USERS)
        return false;
-    }
-    return profiles[index].user_uuid.IsValid();
+    return profiles[index].user_uuid.uuid != Common::INVALID_UUID;
 }

 /// Opens a specific user
@@ -305,7 +304,7 @@ bool ProfileManager::RemoveUser(UUID uuid) {

 bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
    const auto index = GetUserIndex(uuid);
-    if (!index || profile_new.user_uuid.IsInvalid()) {
+    if (!index || profile_new.user_uuid == UUID(Common::INVALID_UUID)) {
        return false;
    }

@@ -347,7 +346,7 @@ void ProfileManager::ParseUserSaveFile() {
    }

    for (const auto& user : data.users) {
-        if (user.uuid.IsInvalid()) {
+        if (user.uuid == UUID(Common::INVALID_UUID)) {
            continue;
        }

@@ -275,14 +275,12 @@ ISelfController::ISelfController(Core::System& system_, NVFlinger::NVFlinger& nv
        {18, nullptr, "SetRequiresCaptureButtonShortPressedMessage"},
        {19, &ISelfController::SetAlbumImageOrientation, "SetAlbumImageOrientation"},
        {20, nullptr, "SetDesirableKeyboardLayout"},
-        {21, nullptr, "GetScreenShotProgramId"},
        {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
        {41, nullptr, "IsSystemBufferSharingEnabled"},
        {42, nullptr, "GetSystemSharedLayerHandle"},
        {43, nullptr, "GetSystemSharedBufferHandle"},
        {44, &ISelfController::CreateManagedDisplaySeparableLayer, "CreateManagedDisplaySeparableLayer"},
        {45, nullptr, "SetManagedDisplayLayerSeparationMode"},
-        {46, nullptr, "SetRecordingLayerCompositionEnabled"},
        {50, &ISelfController::SetHandlesRequestToDisplay, "SetHandlesRequestToDisplay"},
        {51, nullptr, "ApproveToDisplay"},
        {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
@@ -304,7 +302,6 @@ ISelfController::ISelfController(Core::System& system_, NVFlinger::NVFlinger& nv
        {100, &ISelfController::SetAlbumImageTakenNotificationEnabled, "SetAlbumImageTakenNotificationEnabled"},
        {110, nullptr, "SetApplicationAlbumUserData"},
        {120, nullptr, "SaveCurrentScreenshot"},
-        {130, nullptr, "SetRecordVolumeMuted"},
        {1000, nullptr, "GetDebugStorageChannel"},
    };
    // clang-format on
@@ -686,7 +683,6 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_,
        {91, nullptr, "GetCurrentPerformanceConfiguration"},
        {100, nullptr, "SetHandlingHomeButtonShortPressedEnabled"},
        {110, nullptr, "OpenMyGpuErrorHandler"},
-        {120, nullptr, "GetAppletLaunchedHistory"},
        {200, nullptr, "GetOperationModeSystemInfo"},
        {300, nullptr, "GetSettingsPlatformRegion"},
        {400, nullptr, "ActivateMigrationService"},
@@ -1274,8 +1270,7 @@ void ILibraryAppletCreator::CreateHandleStorage(Kernel::HLERequestContext& ctx)
 IApplicationFunctions::IApplicationFunctions(Core::System& system_)
    : ServiceFramework{system_, "IApplicationFunctions"}, gpu_error_detected_event{system.Kernel()},
      friend_invitation_storage_channel_event{system.Kernel()},
-      notification_storage_channel_event{system.Kernel()}, health_warning_disappeared_system_event{
-                                                               system.Kernel()} {
+      health_warning_disappeared_system_event{system.Kernel()} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
@@ -1327,7 +1322,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
        {131, nullptr, "SetDelayTimeToAbortOnGpuError"},
        {140, &IApplicationFunctions::GetFriendInvitationStorageChannelEvent, "GetFriendInvitationStorageChannelEvent"},
        {141, &IApplicationFunctions::TryPopFromFriendInvitationStorageChannel, "TryPopFromFriendInvitationStorageChannel"},
-        {150, &IApplicationFunctions::GetNotificationStorageChannelEvent, "GetNotificationStorageChannelEvent"},
+        {150, nullptr, "GetNotificationStorageChannelEvent"},
        {151, nullptr, "TryPopFromNotificationStorageChannel"},
        {160, &IApplicationFunctions::GetHealthWarningDisappearedSystemEvent, "GetHealthWarningDisappearedSystemEvent"},
        {170, nullptr, "SetHdcpAuthenticationActivated"},
@@ -1345,14 +1340,11 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)

    Kernel::KAutoObject::Create(std::addressof(gpu_error_detected_event));
    Kernel::KAutoObject::Create(std::addressof(friend_invitation_storage_channel_event));
-    Kernel::KAutoObject::Create(std::addressof(notification_storage_channel_event));
    Kernel::KAutoObject::Create(std::addressof(health_warning_disappeared_system_event));

    gpu_error_detected_event.Initialize("IApplicationFunctions:GpuErrorDetectedSystemEvent");
    friend_invitation_storage_channel_event.Initialize(
        "IApplicationFunctions:FriendInvitationStorageChannelEvent");
-    notification_storage_channel_event.Initialize(
-        "IApplicationFunctions:NotificationStorageChannelEvent");
    health_warning_disappeared_system_event.Initialize(
        "IApplicationFunctions:HealthWarningDisappearedSystemEvent");
 }
@@ -1770,14 +1762,6 @@ void IApplicationFunctions::TryPopFromFriendInvitationStorageChannel(
    rb.Push(ERR_NO_DATA_IN_CHANNEL);
 }

-void IApplicationFunctions::GetNotificationStorageChannelEvent(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(notification_storage_channel_event.GetReadableEvent());
-}
-
 void IApplicationFunctions::GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_AM, "called");

@@ -295,7 +295,6 @@ private:
    void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);
    void GetFriendInvitationStorageChannelEvent(Kernel::HLERequestContext& ctx);
    void TryPopFromFriendInvitationStorageChannel(Kernel::HLERequestContext& ctx);
-    void GetNotificationStorageChannelEvent(Kernel::HLERequestContext& ctx);
    void GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx);

    bool launch_popped_application_specific = false;
@@ -303,7 +302,6 @@ private:
    s32 previous_program_index{-1};
    Kernel::KEvent gpu_error_detected_event;
    Kernel::KEvent friend_invitation_storage_channel_event;
-    Kernel::KEvent notification_storage_channel_event;
    Kernel::KEvent health_warning_disappeared_system_event;
 };

@@ -16,30 +16,6 @@

 namespace Service::AM::Applets {

-struct ErrorCode {
-    u32 error_category{};
-    u32 error_number{};
-
-    static constexpr ErrorCode FromU64(u64 error_code) {
-        return {
-            .error_category{static_cast<u32>(error_code >> 32)},
-            .error_number{static_cast<u32>(error_code & 0xFFFFFFFF)},
-        };
-    }
-
-    static constexpr ErrorCode FromResultCode(ResultCode result) {
-        return {
-            .error_category{2000 + static_cast<u32>(result.module.Value())},
-            .error_number{result.description.Value()},
-        };
-    }
-
-    constexpr ResultCode ToResultCode() const {
-        return ResultCode{static_cast<ErrorModule>(error_category - 2000), error_number};
-    }
-};
-static_assert(sizeof(ErrorCode) == 0x8, "ErrorCode has incorrect size.");
-
 #pragma pack(push, 4)
 struct ShowError {
    u8 mode;
@@ -100,7 +76,12 @@ void CopyArgumentData(const std::vector<u8>& data, T& variable) {
 }

 ResultCode Decode64BitError(u64 error) {
-    return ErrorCode::FromU64(error).ToResultCode();
+    const auto description = (error >> 32) & 0x1FFF;
+    auto module = error & 0x3FF;
+    if (module >= 2000)
+        module -= 2000;
+    module &= 0x1FF;
+    return {static_cast<ErrorModule>(module), static_cast<u32>(description)};
 }

 } // Anonymous namespace
@@ -60,7 +60,7 @@ void ProfileSelect::Execute() {
 void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
    UserSelectionOutput output{};

-    if (uuid.has_value() && uuid->IsValid()) {
+    if (uuid.has_value() && uuid->uuid != Common::INVALID_UUID) {
        output.result = 0;
        output.uuid_selected = uuid->uuid;
    } else {
@@ -41,14 +41,6 @@ AudCtl::AudCtl(Core::System& system_) : ServiceFramework{system_, "audctl"} {
        {27, nullptr, "SetVolumeMappingTableForDev"},
        {28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
        {29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
-        {30, nullptr, "Unknown30"},
-        {31, nullptr, "Unknown31"},
-        {32, nullptr, "Unknown32"},
-        {33, nullptr, "Unknown33"},
-        {34, nullptr, "Unknown34"},
-        {10000, nullptr, "Unknown10000"},
-        {10001, nullptr, "Unknown10001"},
-        {10002, nullptr, "Unknown10002"},
    };
    // clang-format on

@@ -3,65 +3,38 @@
 // Refer to the license.txt file included.

 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/k_event.h"
 #include "core/hle/service/audio/audin_u.h"

 namespace Service::Audio {

-IAudioIn::IAudioIn(Core::System& system_)
-    : ServiceFramework{system_, "IAudioIn"}, buffer_event{system_.Kernel()} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetAudioInState"},
-        {1, &IAudioIn::Start, "Start"},
-        {2, nullptr, "Stop"},
-        {3, nullptr, "AppendAudioInBuffer"},
-        {4, &IAudioIn::RegisterBufferEvent, "RegisterBufferEvent"},
-        {5, nullptr, "GetReleasedAudioInBuffer"},
-        {6, nullptr, "ContainsAudioInBuffer"},
-        {7, nullptr, "AppendUacInBuffer"},
-        {8, &IAudioIn::AppendAudioInBufferAuto, "AppendAudioInBufferAuto"},
-        {9, nullptr, "GetReleasedAudioInBuffersAuto"},
-        {10, nullptr, "AppendUacInBufferAuto"},
-        {11, nullptr, "GetAudioInBufferCount"},
-        {12, nullptr, "SetDeviceGain"},
-        {13, nullptr, "GetDeviceGain"},
-        {14, nullptr, "FlushAudioInBuffers"},
-    };
-    // clang-format on
+class IAudioIn final : public ServiceFramework<IAudioIn> {
+public:
+    explicit IAudioIn(Core::System& system_) : ServiceFramework{system_, "IAudioIn"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetAudioInState"},
+            {1, nullptr, "Start"},
+            {2, nullptr, "Stop"},
+            {3, nullptr, "AppendAudioInBuffer"},
+            {4, nullptr, "RegisterBufferEvent"},
+            {5, nullptr, "GetReleasedAudioInBuffer"},
+            {6, nullptr, "ContainsAudioInBuffer"},
+            {7, nullptr, "AppendUacInBuffer"},
+            {8, nullptr, "AppendAudioInBufferAuto"},
+            {9, nullptr, "GetReleasedAudioInBuffersAuto"},
+            {10, nullptr, "AppendUacInBufferAuto"},
+            {11, nullptr, "GetAudioInBufferCount"},
+            {12, nullptr, "SetDeviceGain"},
+            {13, nullptr, "GetDeviceGain"},
+            {14, nullptr, "FlushAudioInBuffers"},
+        };
+        // clang-format on

-    RegisterHandlers(functions);
-
-    Kernel::KAutoObject::Create(std::addressof(buffer_event));
-    buffer_event.Initialize("IAudioIn:BufferEvent");
-}
-
-IAudioIn::~IAudioIn() = default;
-
-void IAudioIn::Start(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_Audio, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void IAudioIn::RegisterBufferEvent(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_Audio, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(buffer_event.GetReadableEvent());
-}
-
-void IAudioIn::AppendAudioInBufferAuto(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_Audio, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
+        RegisterHandlers(functions);
+    }
+};

 AudInU::AudInU(Core::System& system_) : ServiceFramework{system_, "audin:u"} {
    // clang-format off
@@ -4,7 +4,6 @@

 #pragma once

-#include "core/hle/kernel/k_event.h"
 #include "core/hle/service/service.h"

 namespace Core {
@@ -17,19 +16,6 @@ class HLERequestContext;

 namespace Service::Audio {

-class IAudioIn final : public ServiceFramework<IAudioIn> {
-public:
-    explicit IAudioIn(Core::System& system_);
-    ~IAudioIn() override;
-
-private:
-    void Start(Kernel::HLERequestContext& ctx);
-    void RegisterBufferEvent(Kernel::HLERequestContext& ctx);
-    void AppendAudioInBufferAuto(Kernel::HLERequestContext& ctx);
-
-    Kernel::KEvent buffer_event;
-};
-
 class AudInU final : public ServiceFramework<AudInU> {
 public:
    explicit AudInU(Core::System& system_);
@@ -187,8 +187,7 @@ public:
            {10, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
            {11, &IAudioDevice::QueryAudioDeviceInputEvent, "QueryAudioDeviceInputEvent"},
            {12, &IAudioDevice::QueryAudioDeviceOutputEvent, "QueryAudioDeviceOutputEvent"},
-            {13, nullptr, "GetActiveAudioOutputDeviceName"},
-            {14, nullptr, "ListAudioOutputDeviceName"},
+            {13, nullptr, "GetAudioSystemMasterVolumeSetting"},
        };
        RegisterHandlers(functions);
    }
@@ -0,0 +1,548 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <fmt/ostream.h>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#ifndef __clang__
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+#endif
+#include <httplib.h>
+#include <mbedtls/sha256.h>
+#include <nlohmann/json.hpp>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/hex_util.h"
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "core/core.h"
+#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_libzip.h"
+#include "core/file_sys/vfs_vector.h"
+#include "core/frontend/applets/error.h"
+#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/bcat/backend/boxcat.h"
+
+namespace Service::BCAT {
+namespace {
+
+// Prevents conflicts with windows macro called CreateFile
+FileSys::VirtualFile VfsCreateFileWrap(FileSys::VirtualDir dir, std::string_view name) {
+    return dir->CreateFile(name);
+}
+
+// Prevents conflicts with windows macro called DeleteFile
+bool VfsDeleteFileWrap(FileSys::VirtualDir dir, std::string_view name) {
+    return dir->DeleteFile(name);
+}
+
+constexpr ResultCode ERROR_GENERAL_BCAT_FAILURE{ErrorModule::BCAT, 1};
+
+constexpr char BOXCAT_HOSTNAME[] = "api.yuzu-emu.org";
+
+// Formatted using fmt with arg[0] = hex title id
+constexpr char BOXCAT_PATHNAME_DATA[] = "/game-assets/{:016X}/boxcat";
+constexpr char BOXCAT_PATHNAME_LAUNCHPARAM[] = "/game-assets/{:016X}/launchparam";
+
+constexpr char BOXCAT_PATHNAME_EVENTS[] = "/game-assets/boxcat/events";
+
+constexpr char BOXCAT_API_VERSION[] = "1";
+constexpr char BOXCAT_CLIENT_TYPE[] = "yuzu";
+
+// HTTP status codes for Boxcat
+enum class ResponseStatus {
+    Ok = 200,               ///< Operation completed successfully.
+    BadClientVersion = 301, ///< The Boxcat-Client-Version doesn't match the server.
+    NoUpdate = 304,         ///< The digest provided would match the new data, no need to update.
+    NoMatchTitleId = 404,   ///< The title ID provided doesn't have a boxcat implementation.
+    NoMatchBuildId = 406,   ///< The build ID provided is blacklisted (potentially because of format
+                            ///< issues or whatnot) and has no data.
+};
+
+enum class DownloadResult {
+    Success = 0,
+    NoResponse,
+    GeneralWebError,
+    NoMatchTitleId,
+    NoMatchBuildId,
+    InvalidContentType,
+    GeneralFSError,
+    BadClientVersion,
+};
+
+constexpr std::array<const char*, 8> DOWNLOAD_RESULT_LOG_MESSAGES{
+    "Success",
+    "There was no response from the server.",
+    "There was a general web error code returned from the server.",
+    "The title ID of the current game doesn't have a boxcat implementation. If you believe an "
+    "implementation should be added, contact yuzu support.",
+    "The build ID of the current version of the game is marked as incompatible with the current "
+    "BCAT distribution. Try upgrading or downgrading your game version or contacting yuzu support.",
+    "The content type of the web response was invalid.",
+    "There was a general filesystem error while saving the zip file.",
+    "The server is either too new or too old to serve the request. Try using the latest version of "
+    "an official release of yuzu.",
+};
+
+std::ostream& operator<<(std::ostream& os, DownloadResult result) {
+    return os << DOWNLOAD_RESULT_LOG_MESSAGES.at(static_cast<std::size_t>(result));
+}
+
+constexpr u32 PORT = 443;
+constexpr u32 TIMEOUT_SECONDS = 30;
+[[maybe_unused]] constexpr u64 VFS_COPY_BLOCK_SIZE = 1ULL << 24; // 4MB
+
+std::filesystem::path GetBINFilePath(u64 title_id) {
+    return Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir) / "bcat" /
+           fmt::format("{:016X}/launchparam.bin", title_id);
+}
+
+std::filesystem::path GetZIPFilePath(u64 title_id) {
+    return Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir) / "bcat" /
+           fmt::format("{:016X}/data.zip", title_id);
+}
+
+// If the error is something the user should know about (build ID mismatch, bad client version),
+// display an error.
+void HandleDownloadDisplayResult(const AM::Applets::AppletManager& applet_manager,
+                                 DownloadResult res) {
+    if (res == DownloadResult::Success || res == DownloadResult::NoResponse ||
+        res == DownloadResult::GeneralWebError || res == DownloadResult::GeneralFSError ||
+        res == DownloadResult::NoMatchTitleId || res == DownloadResult::InvalidContentType) {
+        return;
+    }
+
+    const auto& frontend{applet_manager.GetAppletFrontendSet()};
+    frontend.error->ShowCustomErrorText(
+        ResultUnknown, "There was an error while attempting to use Boxcat.",
+        DOWNLOAD_RESULT_LOG_MESSAGES[static_cast<std::size_t>(res)], [] {});
+}
+
+bool VfsRawCopyProgress(FileSys::VirtualFile src, FileSys::VirtualFile dest,
+                        std::string_view dir_name, ProgressServiceBackend& progress,
+                        std::size_t block_size = 0x1000) {
+    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
+        return false;
+    if (!dest->Resize(src->GetSize()))
+        return false;
+
+    progress.StartDownloadingFile(dir_name, src->GetName(), src->GetSize());
+
+    std::vector<u8> temp(std::min(block_size, src->GetSize()));
+    for (std::size_t i = 0; i < src->GetSize(); i += block_size) {
+        const auto read = std::min(block_size, src->GetSize() - i);
+
+        if (src->Read(temp.data(), read, i) != read) {
+            return false;
+        }
+
+        if (dest->Write(temp.data(), read, i) != read) {
+            return false;
+        }
+
+        progress.UpdateFileProgress(i);
+    }
+
+    progress.FinishDownloadingFile();
+
+    return true;
+}
+
+bool VfsRawCopyDProgressSingle(FileSys::VirtualDir src, FileSys::VirtualDir dest,
+                               ProgressServiceBackend& progress, std::size_t block_size = 0x1000) {
+    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
+        return false;
+
+    for (const auto& file : src->GetFiles()) {
+        const auto out_file = VfsCreateFileWrap(dest, file->GetName());
+        if (!VfsRawCopyProgress(file, out_file, src->GetName(), progress, block_size)) {
+            return false;
+        }
+    }
+    progress.CommitDirectory(src->GetName());
+
+    return true;
+}
+
+bool VfsRawCopyDProgress(FileSys::VirtualDir src, FileSys::VirtualDir dest,
+                         ProgressServiceBackend& progress, std::size_t block_size = 0x1000) {
+    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
+        return false;
+
+    for (const auto& dir : src->GetSubdirectories()) {
+        const auto out = dest->CreateSubdirectory(dir->GetName());
+        if (!VfsRawCopyDProgressSingle(dir, out, progress, block_size)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+} // Anonymous namespace
+
+class Boxcat::Client {
+public:
+    Client(std::filesystem::path path_, u64 title_id_, u64 build_id_)
+        : path(std::move(path_)), title_id(title_id_), build_id(build_id_) {}
+
+    DownloadResult DownloadDataZip() {
+        return DownloadInternal(fmt::format(BOXCAT_PATHNAME_DATA, title_id), TIMEOUT_SECONDS,
+                                "application/zip");
+    }
+
+    DownloadResult DownloadLaunchParam() {
+        return DownloadInternal(fmt::format(BOXCAT_PATHNAME_LAUNCHPARAM, title_id),
+                                TIMEOUT_SECONDS / 3, "application/octet-stream");
+    }
+
+private:
+    DownloadResult DownloadInternal(const std::string& resolved_path, u32 timeout_seconds,
+                                    const std::string& content_type_name) {
+        if (client == nullptr) {
+            client = std::make_unique<httplib::SSLClient>(BOXCAT_HOSTNAME, PORT);
+            client->set_connection_timeout(timeout_seconds);
+            client->set_read_timeout(timeout_seconds);
+            client->set_write_timeout(timeout_seconds);
+        }
+
+        httplib::Headers headers{
+            {std::string("Game-Assets-API-Version"), std::string(BOXCAT_API_VERSION)},
+            {std::string("Boxcat-Client-Type"), std::string(BOXCAT_CLIENT_TYPE)},
+            {std::string("Game-Build-Id"), fmt::format("{:016X}", build_id)},
+        };
+
+        if (Common::FS::Exists(path)) {
+            Common::FS::IOFile file{path, Common::FS::FileAccessMode::Read,
+                                    Common::FS::FileType::BinaryFile};
+            if (file.IsOpen()) {
+                std::vector<u8> bytes(file.GetSize());
+                void(file.Read(bytes));
+                const auto digest = DigestFile(bytes);
+                headers.insert({std::string("If-None-Match"), Common::HexToString(digest, false)});
+            }
+        }
+
+        const auto response = client->Get(resolved_path.c_str(), headers);
+        if (response == nullptr)
+            return DownloadResult::NoResponse;
+
+        if (response->status == static_cast<int>(ResponseStatus::NoUpdate))
+            return DownloadResult::Success;
+        if (response->status == static_cast<int>(ResponseStatus::BadClientVersion))
+            return DownloadResult::BadClientVersion;
+        if (response->status == static_cast<int>(ResponseStatus::NoMatchTitleId))
+            return DownloadResult::NoMatchTitleId;
+        if (response->status == static_cast<int>(ResponseStatus::NoMatchBuildId))
+            return DownloadResult::NoMatchBuildId;
+        if (response->status != static_cast<int>(ResponseStatus::Ok))
+            return DownloadResult::GeneralWebError;
+
+        const auto content_type = response->headers.find("content-type");
+        if (content_type == response->headers.end() ||
+            content_type->second.find(content_type_name) == std::string::npos) {
+            return DownloadResult::InvalidContentType;
+        }
+
+        if (!Common::FS::CreateDirs(path)) {
+            return DownloadResult::GeneralFSError;
+        }
+
+        Common::FS::IOFile file{path, Common::FS::FileAccessMode::Append,
+                                Common::FS::FileType::BinaryFile};
+        if (!file.IsOpen()) {
+            return DownloadResult::GeneralFSError;
+        }
+
+        if (!file.SetSize(response->body.size())) {
+            return DownloadResult::GeneralFSError;
+        }
+
+        if (file.Write(response->body) != response->body.size()) {
+            return DownloadResult::GeneralFSError;
+        }
+
+        return DownloadResult::Success;
+    }
+
+    using Digest = std::array<u8, 0x20>;
+    static Digest DigestFile(std::vector<u8> bytes) {
+        Digest out{};
+        mbedtls_sha256_ret(bytes.data(), bytes.size(), out.data(), 0);
+        return out;
+    }
+
+    std::unique_ptr<httplib::SSLClient> client;
+    std::filesystem::path path;
+    u64 title_id;
+    u64 build_id;
+};
+
+Boxcat::Boxcat(AM::Applets::AppletManager& applet_manager_, DirectoryGetter getter)
+    : Backend(std::move(getter)), applet_manager{applet_manager_} {}
+
+Boxcat::~Boxcat() = default;
+
+void SynchronizeInternal(AM::Applets::AppletManager& applet_manager, DirectoryGetter dir_getter,
+                         TitleIDVersion title, ProgressServiceBackend& progress,
+                         std::optional<std::string> dir_name = {}) {
+    progress.SetNeedHLELock(true);
+
+    if (Settings::values.bcat_boxcat_local) {
+        LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping download.");
+        const auto dir = dir_getter(title.title_id);
+        if (dir)
+            progress.SetTotalSize(dir->GetSize());
+        progress.FinishDownload(ResultSuccess);
+        return;
+    }
+
+    const auto zip_path = GetZIPFilePath(title.title_id);
+    Boxcat::Client client{zip_path, title.title_id, title.build_id};
+
+    progress.StartConnecting();
+
+    const auto res = client.DownloadDataZip();
+    if (res != DownloadResult::Success) {
+        LOG_ERROR(Service_BCAT, "Boxcat synchronization failed with error '{}'!", res);
+
+        if (res == DownloadResult::NoMatchBuildId || res == DownloadResult::NoMatchTitleId) {
+            Common::FS::RemoveFile(zip_path);
+        }
+
+        HandleDownloadDisplayResult(applet_manager, res);
+        progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
+        return;
+    }
+
+    progress.StartProcessingDataList();
+
+    Common::FS::IOFile zip{zip_path, Common::FS::FileAccessMode::Read,
+                           Common::FS::FileType::BinaryFile};
+    const auto size = zip.GetSize();
+    std::vector<u8> bytes(size);
+    if (!zip.IsOpen() || size == 0 || zip.Read(bytes) != bytes.size()) {
+        LOG_ERROR(Service_BCAT, "Boxcat failed to read ZIP file at path '{}'!",
+                  Common::FS::PathToUTF8String(zip_path));
+        progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
+        return;
+    }
+
+    const auto extracted = FileSys::ExtractZIP(std::make_shared<FileSys::VectorVfsFile>(bytes));
+    if (extracted == nullptr) {
+        LOG_ERROR(Service_BCAT, "Boxcat failed to extract ZIP file!");
+        progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
+        return;
+    }
+
+    if (dir_name == std::nullopt) {
+        progress.SetTotalSize(extracted->GetSize());
+
+        const auto target_dir = dir_getter(title.title_id);
+        if (target_dir == nullptr || !VfsRawCopyDProgress(extracted, target_dir, progress)) {
+            LOG_ERROR(Service_BCAT, "Boxcat failed to copy extracted ZIP to target directory!");
+            progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
+            return;
+        }
+    } else {
+        const auto target_dir = dir_getter(title.title_id);
+        if (target_dir == nullptr) {
+            LOG_ERROR(Service_BCAT, "Boxcat failed to get directory for title ID!");
+            progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
+            return;
+        }
+
+        const auto target_sub = target_dir->GetSubdirectory(*dir_name);
+        const auto source_sub = extracted->GetSubdirectory(*dir_name);
+
+        progress.SetTotalSize(source_sub->GetSize());
+
+        std::vector<std::string> filenames;
+        {
+            const auto files = target_sub->GetFiles();
+            std::transform(files.begin(), files.end(), std::back_inserter(filenames),
+                           [](const auto& vfile) { return vfile->GetName(); });
+        }
+
+        for (const auto& filename : filenames) {
+            VfsDeleteFileWrap(target_sub, filename);
+        }
+
+        if (target_sub == nullptr || source_sub == nullptr ||
+            !VfsRawCopyDProgressSingle(source_sub, target_sub, progress)) {
+            LOG_ERROR(Service_BCAT, "Boxcat failed to copy extracted ZIP to target directory!");
+            progress.FinishDownload(ERROR_GENERAL_BCAT_FAILURE);
+            return;
+        }
+    }
+
+    progress.FinishDownload(ResultSuccess);
+}
+
+bool Boxcat::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) {
+    is_syncing.exchange(true);
+
+    std::thread([this, title, &progress] {
+        SynchronizeInternal(applet_manager, dir_getter, title, progress);
+    }).detach();
+
+    return true;
+}
+
+bool Boxcat::SynchronizeDirectory(TitleIDVersion title, std::string name,
+                                  ProgressServiceBackend& progress) {
+    is_syncing.exchange(true);
+
+    std::thread([this, title, name, &progress] {
+        SynchronizeInternal(applet_manager, dir_getter, title, progress, name);
+    }).detach();
+
+    return true;
+}
+
+bool Boxcat::Clear(u64 title_id) {
+    if (Settings::values.bcat_boxcat_local) {
+        LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping clear.");
+        return true;
+    }
+
+    const auto dir = dir_getter(title_id);
+
+    std::vector<std::string> dirnames;
+
+    for (const auto& subdir : dir->GetSubdirectories())
+        dirnames.push_back(subdir->GetName());
+
+    for (const auto& subdir : dirnames) {
+        if (!dir->DeleteSubdirectoryRecursive(subdir))
+            return false;
+    }
+
+    return true;
+}
+
+void Boxcat::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
+    LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id,
+              Common::HexToString(passphrase));
+}
+
+std::optional<std::vector<u8>> Boxcat::GetLaunchParameter(TitleIDVersion title) {
+    const auto bin_file_path = GetBINFilePath(title.title_id);
+
+    if (Settings::values.bcat_boxcat_local) {
+        LOG_INFO(Service_BCAT, "Boxcat using local data by override, skipping download.");
+    } else {
+        Client launch_client{bin_file_path, title.title_id, title.build_id};
+
+        const auto res = launch_client.DownloadLaunchParam();
+        if (res != DownloadResult::Success) {
+            LOG_ERROR(Service_BCAT, "Boxcat synchronization failed with error '{}'!", res);
+
+            if (res == DownloadResult::NoMatchBuildId || res == DownloadResult::NoMatchTitleId) {
+                Common::FS::RemoveFile(bin_file_path);
+            }
+
+            HandleDownloadDisplayResult(applet_manager, res);
+            return std::nullopt;
+        }
+    }
+
+    Common::FS::IOFile bin{bin_file_path, Common::FS::FileAccessMode::Read,
+                           Common::FS::FileType::BinaryFile};
+    const auto size = bin.GetSize();
+    std::vector<u8> bytes(size);
+    if (!bin.IsOpen() || size == 0 || bin.Read(bytes) != bytes.size()) {
+        LOG_ERROR(Service_BCAT, "Boxcat failed to read launch parameter binary at path '{}'!",
+                  Common::FS::PathToUTF8String(bin_file_path));
+        return std::nullopt;
+    }
+
+    return bytes;
+}
+
+Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
+                                       std::map<std::string, EventStatus>& games) {
+    httplib::SSLClient client{BOXCAT_HOSTNAME, static_cast<int>(PORT)};
+    client.set_connection_timeout(static_cast<int>(TIMEOUT_SECONDS));
+    client.set_read_timeout(static_cast<int>(TIMEOUT_SECONDS));
+    client.set_write_timeout(static_cast<int>(TIMEOUT_SECONDS));
+
+    httplib::Headers headers{
+        {std::string("Game-Assets-API-Version"), std::string(BOXCAT_API_VERSION)},
+        {std::string("Boxcat-Client-Type"), std::string(BOXCAT_CLIENT_TYPE)},
+    };
+
+    if (!client.is_valid()) {
+        LOG_ERROR(Service_BCAT, "Client is invalid, going offline!");
+        return StatusResult::Offline;
+    }
+
+    if (!client.is_socket_open()) {
+        LOG_ERROR(Service_BCAT, "Failed to open socket, going offline!");
+        return StatusResult::Offline;
+    }
+
+    const auto response = client.Get(BOXCAT_PATHNAME_EVENTS, headers);
+    if (response == nullptr)
+        return StatusResult::Offline;
+
+    if (response->status == static_cast<int>(ResponseStatus::BadClientVersion))
+        return StatusResult::BadClientVersion;
+
+    try {
+        nlohmann::json json = nlohmann::json::parse(response->body);
+
+        if (!json["online"].get<bool>())
+            return StatusResult::Offline;
+
+        if (json["global"].is_null())
+            global = std::nullopt;
+        else
+            global = json["global"].get<std::string>();
+
+        if (json["games"].is_array()) {
+            for (const auto& object : json["games"]) {
+                if (object.is_object() && object.find("name") != object.end()) {
+                    EventStatus detail{};
+                    if (object["header"].is_string()) {
+                        detail.header = object["header"].get<std::string>();
+                    } else {
+                        detail.header = std::nullopt;
+                    }
+
+                    if (object["footer"].is_string()) {
+                        detail.footer = object["footer"].get<std::string>();
+                    } else {
+                        detail.footer = std::nullopt;
+                    }
+
+                    if (object["events"].is_array()) {
+                        for (const auto& event : object["events"]) {
+                            if (!event.is_string())
+                                continue;
+                            detail.events.push_back(event.get<std::string>());
+                        }
+                    }
+
+                    games.insert_or_assign(object["name"], std::move(detail));
+                }
+            }
+        }
+
+        return StatusResult::Success;
+    } catch (const nlohmann::json::parse_error& error) {
+        LOG_ERROR(Service_BCAT, "{}", error.what());
+        return StatusResult::ParseError;
+    }
+}
+
+} // namespace Service::BCAT
@@ -0,0 +1,64 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include <map>
+#include <optional>
+#include "core/hle/service/bcat/backend/backend.h"
+
+namespace Service::AM::Applets {
+class AppletManager;
+}
+
+namespace Service::BCAT {
+
+struct EventStatus {
+    std::optional<std::string> header;
+    std::optional<std::string> footer;
+    std::vector<std::string> events;
+};
+
+/// Boxcat is yuzu's custom backend implementation of Nintendo's BCAT service. It is free to use and
+/// doesn't require a switch or nintendo account. The content is controlled by the yuzu team.
+class Boxcat final : public Backend {
+    friend void SynchronizeInternal(AM::Applets::AppletManager& applet_manager,
+                                    DirectoryGetter dir_getter, TitleIDVersion title,
+                                    ProgressServiceBackend& progress,
+                                    std::optional<std::string> dir_name);
+
+public:
+    explicit Boxcat(AM::Applets::AppletManager& applet_manager_, DirectoryGetter getter);
+    ~Boxcat() override;
+
+    bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) override;
+    bool SynchronizeDirectory(TitleIDVersion title, std::string name,
+                              ProgressServiceBackend& progress) override;
+
+    bool Clear(u64 title_id) override;
+
+    void SetPassphrase(u64 title_id, const Passphrase& passphrase) override;
+
+    std::optional<std::vector<u8>> GetLaunchParameter(TitleIDVersion title) override;
+
+    enum class StatusResult {
+        Success,
+        Offline,
+        ParseError,
+        BadClientVersion,
+    };
+
+    static StatusResult GetStatus(std::optional<std::string>& global,
+                                  std::map<std::string, EventStatus>& games);
+
+private:
+    std::atomic_bool is_syncing{false};
+
+    class Client;
+    std::unique_ptr<Client> client;
+    AM::Applets::AppletManager& applet_manager;
+};
+
+} // namespace Service::BCAT
@@ -4,6 +4,7 @@

 #include <cctype>
 #include <mbedtls/md5.h>
+#include "backend/boxcat.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
@@ -577,6 +578,12 @@ void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(

 std::unique_ptr<Backend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
                                                   DirectoryGetter getter) {
+#ifdef YUZU_ENABLE_BOXCAT
+    if (Settings::values.bcat_backend.GetValue() == "boxcat") {
+        return std::make_unique<Boxcat>(system.GetAppletManager(), std::move(getter));
+    }
+#endif
+
    return std::make_unique<NullBackend>(std::move(getter));
 }

@@ -175,10 +175,6 @@ public:
            {143, nullptr, "GetAudioControlInputState"},
            {144, nullptr, "AcquireAudioConnectionStateChangedEvent"},
            {145, nullptr, "GetConnectedAudioDevice"},
-            {146, nullptr, "CloseAudioControlInput"},
-            {147, nullptr, "RegisterAudioControlNotification"},
-            {148, nullptr, "SendAudioControlPassthroughCommand"},
-            {149, nullptr, "SendAudioControlSetAbsoluteVolumeCommand"},
            {256, nullptr, "IsManufacturingMode"},
            {257, nullptr, "EmulateBluetoothCrash"},
            {258, nullptr, "GetBleChannelMap"},
@@ -15,7 +15,6 @@ CAPS_SS::CAPS_SS(Core::System& system_) : ServiceFramework{system_, "caps:ss"} {
        {204, nullptr, "SaveEditedScreenShotEx0"},
        {206, nullptr, "Unknown206"},
        {208, nullptr, "SaveScreenShotOfMovieEx1"},
-        {1000, nullptr, "Unknown1000"},
    };
    // clang-format on

@@ -55,8 +55,6 @@ public:
            {36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
            {37, nullptr, "OwnTicket2"},
            {38, nullptr, "OwnTicket3"},
-            {39, nullptr, "DeleteAllInactivePersonalizedTicket"},
-            {40, nullptr, "DeletePrepurchaseRecordByNintendoAccountId"},
            {501, nullptr, "Unknown501"},
            {502, nullptr, "Unknown502"},
            {503, nullptr, "GetTitleKey"},
@@ -90,15 +88,11 @@ public:
            {1503, nullptr, "Unknown1503"},
            {1504, nullptr, "Unknown1504"},
            {1505, nullptr, "Unknown1505"},
-            {1506, nullptr, "Unknown1506"},
            {2000, nullptr, "Unknown2000"},
            {2001, nullptr, "Unknown2001"},
-            {2002, nullptr, "Unknown2002"},
-            {2003, nullptr, "Unknown2003"},
            {2100, nullptr, "Unknown2100"},
            {2501, nullptr, "Unknown2501"},
            {2502, nullptr, "Unknown2502"},
-            {2601, nullptr, "Unknown2601"},
            {3001, nullptr, "Unknown3001"},
            {3002, nullptr, "Unknown3002"},
        };
@@ -97,24 +97,14 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons

 ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_) const {
    std::string path(Common::FS::SanitizePath(path_));
-
-    // NOTE: This is inaccurate behavior. CreateDirectory is not recursive.
-    // CreateDirectory should return PathNotFound if the parent directory does not exist.
-    // This is here temporarily in order to have UMM "work" in the meantime.
-    // TODO (Morph): Remove this when a hardware test verifies the correct behavior.
-    const auto components = Common::FS::SplitPathComponents(path);
-    std::string relative_path;
-    for (const auto& component : components) {
-        // Skip empty path components
-        if (component.empty()) {
-            continue;
-        }
-        relative_path = Common::FS::SanitizePath(relative_path + '/' + component);
-        auto new_dir = backing->CreateSubdirectory(relative_path);
-        if (new_dir == nullptr) {
-            // TODO(DarkLordZach): Find a better error code for this
-            return ResultUnknown;
-        }
+    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
+    if (dir == nullptr || Common::FS::GetFilename(Common::FS::GetParentPath(path)).empty()) {
+        dir = backing;
+    }
+    auto new_dir = dir->CreateSubdirectory(Common::FS::GetFilename(path));
+    if (new_dir == nullptr) {
+        // TODO(DarkLordZach): Find a better error code for this
+        return ResultUnknown;
    }
    return ResultSuccess;
 }
@@ -261,18 +251,6 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
    return FileSys::ERROR_PATH_NOT_FOUND;
 }

-ResultVal<FileSys::FileTimeStampRaw> VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
-    const std::string& path) const {
-    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
-    if (dir == nullptr) {
-        return FileSys::ERROR_PATH_NOT_FOUND;
-    }
-    if (GetEntryType(path).Failed()) {
-        return FileSys::ERROR_PATH_NOT_FOUND;
-    }
-    return MakeResult(dir->GetFileTimeStamp(Common::FS::GetFilename(path)));
-}
-
 FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}

 FileSystemController::~FileSystemController() = default;
@@ -240,12 +240,6 @@ public:
     */
    ResultVal<FileSys::EntryType> GetEntryType(const std::string& path) const;

-    /**
-     * Get the timestamp of the specified path
-     * @return The timestamp of the specified path or error code
-     */
-    ResultVal<FileSys::FileTimeStampRaw> GetFileTimeStampRaw(const std::string& path) const;
-
 private:
    FileSys::VirtualDir backing;
 };
@@ -326,7 +326,7 @@ public:
            {11, &IFileSystem::GetFreeSpaceSize, "GetFreeSpaceSize"},
            {12, &IFileSystem::GetTotalSpaceSize, "GetTotalSpaceSize"},
            {13, &IFileSystem::CleanDirectoryRecursively, "CleanDirectoryRecursively"},
-            {14, &IFileSystem::GetFileTimeStampRaw, "GetFileTimeStampRaw"},
+            {14, nullptr, "GetFileTimeStampRaw"},
            {15, nullptr, "QueryEntry"},
        };
        RegisterHandlers(functions);
@@ -501,24 +501,6 @@ public:
        rb.Push(size.get_total_size());
    }

-    void GetFileTimeStampRaw(Kernel::HLERequestContext& ctx) {
-        const auto file_buffer = ctx.ReadBuffer();
-        const std::string name = Common::StringFromBuffer(file_buffer);
-
-        LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name);
-
-        auto result = backend.GetFileTimeStampRaw(name);
-        if (result.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 10};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(*result);
-    }
-
 private:
    VfsDirectoryServiceWrapper backend;
    SizeGetter size;
@@ -507,7 +507,6 @@ private:
        LarkNesRight = 18,
        Lucia = 19,
        Verification = 20,
-        Lagon = 21,
    };

    struct NPadEntry {
@@ -15,20 +15,6 @@
 namespace Service::HID {
 class Controller_Touchscreen final : public ControllerBase {
 public:
-    enum class TouchScreenModeForNx : u8 {
-        UseSystemSetting,
-        Finger,
-        Heat2,
-    };
-
-    struct TouchScreenConfigurationForNx {
-        TouchScreenModeForNx mode;
-        INSERT_PADDING_BYTES_NOINIT(0x7);
-        INSERT_PADDING_BYTES_NOINIT(0xF); // Reserved
-    };
-    static_assert(sizeof(TouchScreenConfigurationForNx) == 0x17,
-                  "TouchScreenConfigurationForNx is an invalid size");
-
    explicit Controller_Touchscreen(Core::System& system_);
    ~Controller_Touchscreen() override;

@@ -239,12 +239,6 @@ Hid::Hid(Core::System& system_)
        {81, &Hid::ResetGyroscopeZeroDriftMode, "ResetGyroscopeZeroDriftMode"},
        {82, &Hid::IsSixAxisSensorAtRest, "IsSixAxisSensorAtRest"},
        {83, &Hid::IsFirmwareUpdateAvailableForSixAxisSensor, "IsFirmwareUpdateAvailableForSixAxisSensor"},
-        {84, nullptr, "EnableSixAxisSensorUnalteredPassthrough"},
-        {85, nullptr, "IsSixAxisSensorUnalteredPassthroughEnabled"},
-        {86, nullptr, "StoreSixAxisSensorCalibrationParameter"},
-        {87, nullptr, "LoadSixAxisSensorCalibrationParameter"},
-        {88, nullptr, "GetSixAxisSensorIcInformation"},
-        {89, nullptr, "ResetIsSixAxisSensorDeviceNewlyAssigned"},
        {91, &Hid::ActivateGesture, "ActivateGesture"},
        {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
        {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
@@ -337,7 +331,7 @@ Hid::Hid(Core::System& system_)
        {529, nullptr, "SetDisallowedPalmaConnection"},
        {1000, &Hid::SetNpadCommunicationMode, "SetNpadCommunicationMode"},
        {1001, &Hid::GetNpadCommunicationMode, "GetNpadCommunicationMode"},
-        {1002, &Hid::SetTouchScreenConfiguration, "SetTouchScreenConfiguration"},
+        {1002, nullptr, "SetTouchScreenConfiguration"},
        {1003, nullptr, "IsFirmwareUpdateNeededForNotification"},
        {2000, nullptr, "ActivateDigitizer"},
    };
@@ -1637,18 +1631,6 @@ void Hid::GetNpadCommunicationMode(Kernel::HLERequestContext& ctx) {
                    .GetNpadCommunicationMode());
 }

-void Hid::SetTouchScreenConfiguration(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto touchscreen_mode{rp.PopRaw<Controller_Touchscreen::TouchScreenConfigurationForNx>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, touchscreen_mode={}, applet_resource_user_id={}",
-                touchscreen_mode.mode, applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 class HidDbg final : public ServiceFramework<HidDbg> {
 public:
    explicit HidDbg(Core::System& system_) : ServiceFramework{system_, "hid:dbg"} {
@@ -1662,9 +1644,6 @@ public:
            {12, nullptr, "UnsetTouchScreenAutoPilotState"},
            {13, nullptr, "GetTouchScreenConfiguration"},
            {14, nullptr, "ProcessTouchScreenAutoTune"},
-            {15, nullptr, "ForceStopTouchScreenManagement"},
-            {16, nullptr, "ForceRestartTouchScreenManagement"},
-            {17, nullptr, "IsTouchScreenManaged"},
            {20, nullptr, "DeactivateMouse"},
            {21, nullptr, "SetMouseAutoPilotState"},
            {22, nullptr, "UnsetMouseAutoPilotState"},
@@ -159,7 +159,6 @@ private:
    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
    void SetNpadCommunicationMode(Kernel::HLERequestContext& ctx);
    void GetNpadCommunicationMode(Kernel::HLERequestContext& ctx);
-    void SetTouchScreenConfiguration(Kernel::HLERequestContext& ctx);

    enum class VibrationDeviceType : u32 {
        Unknown = 0,
@@ -1,59 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included
-
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/ngct/ngct.h"
-#include "core/hle/service/service.h"
-
-namespace Service::NGCT {
-
-class IService final : public ServiceFramework<IService> {
-public:
-    explicit IService(Core::System& system_) : ServiceFramework{system_, "ngct:u"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IService::Match, "Match"},
-            {1, &IService::Filter, "Filter"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void Match(Kernel::HLERequestContext& ctx) {
-        const auto buffer = ctx.ReadBuffer();
-        const auto text = Common::StringFromFixedZeroTerminatedBuffer(
-            reinterpret_cast<const char*>(buffer.data()), buffer.size());
-
-        LOG_WARNING(Service_NGCT, "(STUBBED) called, text={}", text);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        // Return false since we don't censor anything
-        rb.Push(false);
-    }
-
-    void Filter(Kernel::HLERequestContext& ctx) {
-        const auto buffer = ctx.ReadBuffer();
-        const auto text = Common::StringFromFixedZeroTerminatedBuffer(
-            reinterpret_cast<const char*>(buffer.data()), buffer.size());
-
-        LOG_WARNING(Service_NGCT, "(STUBBED) called, text={}", text);
-
-        // Return the same string since we don't censor anything
-        ctx.WriteBuffer(buffer);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-};
-
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<IService>(system)->InstallAsService(system.ServiceManager());
-}
-
-} // namespace Service::NGCT
@@ -1,20 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included
-
-#pragma once
-
-namespace Core {
-class System;
-}
-
-namespace Service::SM {
-class ServiceManager;
-}
-
-namespace Service::NGCT {
-
-/// Registers all NGCT services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
-
-} // namespace Service::NGCT
@@ -11,7 +11,6 @@
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/service.h"
 #include "core/network/network.h"
-#include "core/network/network_interface.h"

 namespace Service::NIFM {

@@ -180,10 +179,10 @@ private:
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);

-        if (Network::GetHostIPv4Address().has_value()) {
-            rb.PushEnum(RequestState::Connected);
-        } else {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
            rb.PushEnum(RequestState::NotSubmitted);
+        } else {
+            rb.PushEnum(RequestState::Connected);
        }
    }

@@ -277,45 +276,37 @@ private:
    void GetCurrentNetworkProfile(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");

-        const auto net_iface = Network::GetSelectedNetworkInterface();
-
-        const SfNetworkProfileData network_profile_data = [&net_iface] {
-            if (!net_iface) {
-                return SfNetworkProfileData{};
-            }
-
-            return SfNetworkProfileData{
-                .ip_setting_data{
-                    .ip_address_setting{
-                        .is_automatic{true},
-                        .current_address{Network::TranslateIPv4(net_iface->ip_address)},
-                        .subnet_mask{Network::TranslateIPv4(net_iface->subnet_mask)},
-                        .gateway{Network::TranslateIPv4(net_iface->gateway)},
-                    },
-                    .dns_setting{
-                        .is_automatic{true},
-                        .primary_dns{1, 1, 1, 1},
-                        .secondary_dns{1, 0, 0, 1},
-                    },
-                    .proxy_setting{
-                        .enabled{false},
-                        .port{},
-                        .proxy_server{},
-                        .automatic_auth_enabled{},
-                        .user{},
-                        .password{},
-                    },
-                    .mtu{1500},
+        const SfNetworkProfileData network_profile_data{
+            .ip_setting_data{
+                .ip_address_setting{
+                    .is_automatic{true},
+                    .current_address{192, 168, 1, 100},
+                    .subnet_mask{255, 255, 255, 0},
+                    .gateway{192, 168, 1, 1},
                },
-                .uuid{0xdeadbeef, 0xdeadbeef},
-                .network_name{"yuzu Network"},
-                .wireless_setting_data{
-                    .ssid_length{12},
-                    .ssid{"yuzu Network"},
-                    .passphrase{"yuzupassword"},
+                .dns_setting{
+                    .is_automatic{true},
+                    .primary_dns{1, 1, 1, 1},
+                    .secondary_dns{1, 0, 0, 1},
                },
-            };
-        }();
+                .proxy_setting{
+                    .enabled{false},
+                    .port{},
+                    .proxy_server{},
+                    .automatic_auth_enabled{},
+                    .user{},
+                    .password{},
+                },
+                .mtu{1500},
+            },
+            .uuid{0xdeadbeef, 0xdeadbeef},
+            .network_name{"yuzu Network"},
+            .wireless_setting_data{
+                .ssid_length{12},
+                .ssid{"yuzu Network"},
+                .passphrase{"yuzupassword"},
+            },
+        };

        ctx.WriteBuffer(network_profile_data);

@@ -331,15 +322,12 @@ private:
    void GetCurrentIpAddress(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");

-        auto ipv4 = Network::GetHostIPv4Address();
-        if (!ipv4) {
-            LOG_ERROR(Service_NIFM, "Couldn't get host IPv4 address, defaulting to 0.0.0.0");
-            ipv4.emplace(Network::IPv4Address{0, 0, 0, 0});
-        }
+        const auto [ipv4, error] = Network::GetHostIPv4Address();
+        UNIMPLEMENTED_IF(error != Network::Errno::SUCCESS);

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.PushRaw(*ipv4);
+        rb.PushRaw(ipv4);
    }
    void CreateTemporaryNetworkProfile(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_NIFM, "called");
@@ -360,33 +348,25 @@ private:
        LOG_WARNING(Service_NIFM, "(STUBBED) called");

        struct IpConfigInfo {
-            IpAddressSetting ip_address_setting{};
-            DnsSetting dns_setting{};
+            IpAddressSetting ip_address_setting;
+            DnsSetting dns_setting;
        };
        static_assert(sizeof(IpConfigInfo) == sizeof(IpAddressSetting) + sizeof(DnsSetting),
                      "IpConfigInfo has incorrect size.");

-        const auto net_iface = Network::GetSelectedNetworkInterface();
-
-        const IpConfigInfo ip_config_info = [&net_iface] {
-            if (!net_iface) {
-                return IpConfigInfo{};
-            }
-
-            return IpConfigInfo{
-                .ip_address_setting{
-                    .is_automatic{true},
-                    .current_address{Network::TranslateIPv4(net_iface->ip_address)},
-                    .subnet_mask{Network::TranslateIPv4(net_iface->subnet_mask)},
-                    .gateway{Network::TranslateIPv4(net_iface->gateway)},
-                },
-                .dns_setting{
-                    .is_automatic{true},
-                    .primary_dns{1, 1, 1, 1},
-                    .secondary_dns{1, 0, 0, 1},
-                },
-            };
-        }();
+        const IpConfigInfo ip_config_info{
+            .ip_address_setting{
+                .is_automatic{true},
+                .current_address{192, 168, 1, 100},
+                .subnet_mask{255, 255, 255, 0},
+                .gateway{192, 168, 1, 1},
+            },
+            .dns_setting{
+                .is_automatic{true},
+                .primary_dns{1, 1, 1, 1},
+                .secondary_dns{1, 0, 0, 1},
+            },
+        };

        IPC::ResponseBuilder rb{ctx, 2 + (sizeof(IpConfigInfo) + 3) / sizeof(u32)};
        rb.Push(ResultSuccess);
@@ -404,10 +384,10 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        if (Network::GetHostIPv4Address().has_value()) {
-            rb.Push<u8>(1);
-        } else {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
            rb.Push<u8>(0);
+        } else {
+            rb.Push<u8>(1);
        }
    }
    void IsAnyInternetRequestAccepted(Kernel::HLERequestContext& ctx) {
@@ -415,10 +395,10 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        if (Network::GetHostIPv4Address().has_value()) {
-            rb.Push<u8>(1);
-        } else {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
            rb.Push<u8>(0);
+        } else {
+            rb.Push<u8>(1);
        }
    }
 };
@@ -31,7 +31,6 @@ public:
            {24, nullptr, "DestroyTokenWithApplicationId"},
            {25, nullptr, "QueryIsTokenValid"},
            {26, nullptr, "ListenToMyApplicationId"},
-            {27, nullptr, "DestroyTokenAll"},
            {31, nullptr, "UploadTokenToBaaS"},
            {32, nullptr, "DestroyTokenForBaaS"},
            {33, nullptr, "CreateTokenForBaaS"},
@@ -42,14 +42,15 @@ void nvdisp_disp0::OnClose(DeviceFD fd) {}
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,
                        u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform,
                        const Common::Rectangle<int>& crop_rect) {
-    const VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
+    VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
    LOG_TRACE(Service,
              "Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
              addr, offset, width, height, stride, format);

-    const auto pixel_format = static_cast<Tegra::FramebufferConfig::PixelFormat>(format);
-    const Tegra::FramebufferConfig framebuffer{addr,   offset,       width,     height,
-                                               stride, pixel_format, transform, crop_rect};
+    using PixelFormat = Tegra::FramebufferConfig::PixelFormat;
+    const Tegra::FramebufferConfig framebuffer{
+        addr,      offset,   width, height, stride, static_cast<PixelFormat>(format),
+        transform, crop_rect};

    system.GetPerfStats().EndSystemFrame();
    system.GPU().SwapBuffers(&framebuffer);
@@ -9,20 +9,17 @@
 #include "core/core.h"
 #include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"

 namespace Service::NVFlinger {

-BufferQueue::BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_,
-                         KernelHelpers::ServiceContext& service_context_)
-    : id(id_), layer_id(layer_id_), service_context{service_context_} {
-    buffer_wait_event = service_context.CreateEvent("BufferQueue:WaitEvent");
+BufferQueue::BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_)
+    : id(id_), layer_id(layer_id_), buffer_wait_event{kernel} {
+    Kernel::KAutoObject::Create(std::addressof(buffer_wait_event));
+    buffer_wait_event.Initialize("BufferQueue:WaitEvent");
 }

-BufferQueue::~BufferQueue() {
-    service_context.CloseEvent(buffer_wait_event);
-}
+BufferQueue::~BufferQueue() = default;

 void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer) {
    ASSERT(slot < buffer_slots);
@@ -44,7 +41,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
        .multi_fence = {},
    };

-    buffer_wait_event->GetWritableEvent().Signal();
+    buffer_wait_event.GetWritableEvent().Signal();
 }

 std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::DequeueBuffer(u32 width,
@@ -122,7 +119,7 @@ void BufferQueue::CancelBuffer(u32 slot, const Service::Nvidia::MultiFence& mult
    }
    free_buffers_condition.notify_one();

-    buffer_wait_event->GetWritableEvent().Signal();
+    buffer_wait_event.GetWritableEvent().Signal();
 }

 std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::AcquireBuffer() {
@@ -157,7 +154,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
    }
    free_buffers_condition.notify_one();

-    buffer_wait_event->GetWritableEvent().Signal();
+    buffer_wait_event.GetWritableEvent().Signal();
 }

 void BufferQueue::Connect() {
@@ -172,7 +169,7 @@ void BufferQueue::Disconnect() {
        std::unique_lock lock{queue_sequence_mutex};
        queue_sequence.clear();
    }
-    buffer_wait_event->GetWritableEvent().Signal();
+    buffer_wait_event.GetWritableEvent().Signal();
    is_connect = false;
    free_buffers_condition.notify_one();
 }
@@ -192,11 +189,11 @@ u32 BufferQueue::Query(QueryType type) {
 }

 Kernel::KWritableEvent& BufferQueue::GetWritableBufferWaitEvent() {
-    return buffer_wait_event->GetWritableEvent();
+    return buffer_wait_event.GetWritableEvent();
 }

 Kernel::KReadableEvent& BufferQueue::GetBufferWaitEvent() {
-    return buffer_wait_event->GetReadableEvent();
+    return buffer_wait_event.GetReadableEvent();
 }

 } // namespace Service::NVFlinger
@@ -24,10 +24,6 @@ class KReadableEvent;
 class KWritableEvent;
 } // namespace Kernel

-namespace Service::KernelHelpers {
-class ServiceContext;
-} // namespace Service::KernelHelpers
-
 namespace Service::NVFlinger {

 constexpr u32 buffer_slots = 0x40;
@@ -42,9 +38,7 @@ struct IGBPBuffer {
    u32_le index;
    INSERT_PADDING_WORDS(3);
    u32_le gpu_buffer_id;
-    INSERT_PADDING_WORDS(6);
-    u32_le external_format;
-    INSERT_PADDING_WORDS(10);
+    INSERT_PADDING_WORDS(17);
    u32_le nvmap_handle;
    u32_le offset;
    INSERT_PADDING_WORDS(60);
@@ -60,8 +54,7 @@ public:
        NativeWindowFormat = 2,
    };

-    explicit BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_,
-                         KernelHelpers::ServiceContext& service_context_);
+    explicit BufferQueue(Kernel::KernelCore& kernel, u32 id_, u64 layer_id_);
    ~BufferQueue();

    enum class BufferTransformFlags : u32 {
@@ -137,14 +130,12 @@ private:
    std::list<u32> free_buffers;
    std::array<Buffer, buffer_slots> buffers;
    std::list<u32> queue_sequence;
-    Kernel::KEvent* buffer_wait_event{};
+    Kernel::KEvent buffer_wait_event;

    std::mutex free_buffers_mutex;
    std::condition_variable free_buffers_condition;

    std::mutex queue_sequence_mutex;
-
-    KernelHelpers::ServiceContext& service_context;
 };

 } // namespace Service::NVFlinger
@@ -61,13 +61,12 @@ void NVFlinger::SplitVSync() {
    }
 }

-NVFlinger::NVFlinger(Core::System& system_)
-    : system(system_), service_context(system_, "nvflinger") {
-    displays.emplace_back(0, "Default", service_context, system);
-    displays.emplace_back(1, "External", service_context, system);
-    displays.emplace_back(2, "Edid", service_context, system);
-    displays.emplace_back(3, "Internal", service_context, system);
-    displays.emplace_back(4, "Null", service_context, system);
+NVFlinger::NVFlinger(Core::System& system_) : system(system_) {
+    displays.emplace_back(0, "Default", system);
+    displays.emplace_back(1, "External", system);
+    displays.emplace_back(2, "Edid", system);
+    displays.emplace_back(3, "Internal", system);
+    displays.emplace_back(4, "Null", system);
    guard = std::make_shared<std::mutex>();

    // Schedule the screen composition events
@@ -147,7 +146,7 @@ std::optional<u64> NVFlinger::CreateLayer(u64 display_id) {
 void NVFlinger::CreateLayerAtId(VI::Display& display, u64 layer_id) {
    const u32 buffer_queue_id = next_buffer_queue_id++;
    buffer_queues.emplace_back(
-        std::make_unique<BufferQueue>(system.Kernel(), buffer_queue_id, layer_id, service_context));
+        std::make_unique<BufferQueue>(system.Kernel(), buffer_queue_id, layer_id));
    display.CreateLayer(layer_id, *buffer_queues.back());
 }

@@ -298,7 +297,7 @@ void NVFlinger::Compose() {
        auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>("/dev/nvdisp_disp0");
        ASSERT(nvdisp);

-        nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.external_format,
+        nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
                     igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride,
                     buffer->get().transform, buffer->get().crop_rect);

@@ -15,7 +15,6 @@
 #include <vector>

 #include "common/common_types.h"
-#include "core/hle/service/kernel_helpers.h"

 namespace Common {
 class Event;
@@ -136,8 +135,6 @@ private:
    std::unique_ptr<std::thread> vsync_thread;
    std::unique_ptr<Common::Event> wait_event;
    std::atomic<bool> is_running{};
-
-    KernelHelpers::ServiceContext service_context;
 };

 } // namespace Service::NVFlinger
@@ -46,7 +46,6 @@
 #include "core/hle/service/ncm/ncm.h"
 #include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/nfp/nfp.h"
-#include "core/hle/service/ngct/ngct.h"
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/nim/nim.h"
 #include "core/hle/service/npns/npns.h"
@@ -272,7 +271,6 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
    NCM::InstallInterfaces(*sm, system);
    NFC::InstallInterfaces(*sm, system);
    NFP::InstallInterfaces(*sm, system);
-    NGCT::InstallInterfaces(*sm, system);
    NIFM::InstallInterfaces(*sm, system);
    NIM::InstallInterfaces(*sm, system);
    NPNS::InstallInterfaces(*sm, system);
@@ -415,18 +415,6 @@ void BSD::Write(Kernel::HLERequestContext& ctx) {
                     });
 }

-void BSD::Read(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const s32 fd = rp.Pop<s32>();
-
-    LOG_WARNING(Service, "(STUBBED) called. fd={} len={}", fd, ctx.GetWriteBufferSize());
-
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.Push<u32>(0); // ret
-    rb.Push<u32>(0); // bsd errno
-}
-
 void BSD::Close(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();
@@ -867,7 +855,7 @@ BSD::BSD(Core::System& system_, const char* name) : ServiceFramework{system_, na
        {22, &BSD::Shutdown, "Shutdown"},
        {23, nullptr, "ShutdownAllSockets"},
        {24, &BSD::Write, "Write"},
-        {25, &BSD::Read, "Read"},
+        {25, nullptr, "Read"},
        {26, &BSD::Close, "Close"},
        {27, nullptr, "DuplicateSocket"},
        {28, nullptr, "GetResourceStatistics"},
@@ -135,7 +135,6 @@ private:
    void Send(Kernel::HLERequestContext& ctx);
    void SendTo(Kernel::HLERequestContext& ctx);
    void Write(Kernel::HLERequestContext& ctx);
-    void Read(Kernel::HLERequestContext& ctx);
    void Close(Kernel::HLERequestContext& ctx);
    void EventFd(Kernel::HLERequestContext& ctx);

@@ -97,7 +97,7 @@ public:
            {3, nullptr, "GetAlternateInterface"},
            {4, nullptr, "GetCurrentFrame"},
            {5, nullptr, "CtrlXferAsync"},
-            {6, nullptr, "GetCtrlXferCompletionEvent"},
+            {6, nullptr, "Unknown6"},
            {7, nullptr, "GetCtrlXferReport"},
            {8, nullptr, "ResetDevice"},
            {9, nullptr, "OpenUsbEp"},
@@ -183,8 +183,8 @@ public:
            {4, nullptr, "GetHostPdcFirmwareRevision"},
            {5, nullptr, "GetHostPdcManufactureId"},
            {6, nullptr, "GetHostPdcDeviceId"},
-            {7, nullptr, "EnableCradleRecovery"},
-            {8, nullptr, "DisableCradleRecovery"},
+            {7, nullptr, "AwakeCradle"},
+            {8, nullptr, "SleepCradle"},
        };
        // clang-format on

@@ -12,21 +12,18 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_writable_event.h"
-#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/vi/display/vi_display.h"
 #include "core/hle/service/vi/layer/vi_layer.h"

 namespace Service::VI {

-Display::Display(u64 id, std::string name_, KernelHelpers::ServiceContext& service_context_,
-                 Core::System& system_)
-    : display_id{id}, name{std::move(name_)}, service_context{service_context_} {
-    vsync_event = service_context.CreateEvent(fmt::format("Display VSync Event {}", id));
+Display::Display(u64 id, std::string name_, Core::System& system)
+    : display_id{id}, name{std::move(name_)}, vsync_event{system.Kernel()} {
+    Kernel::KAutoObject::Create(std::addressof(vsync_event));
+    vsync_event.Initialize(fmt::format("Display VSync Event {}", id));
 }

-Display::~Display() {
-    service_context.CloseEvent(vsync_event);
-}
+Display::~Display() = default;

 Layer& Display::GetLayer(std::size_t index) {
    return *layers.at(index);
@@ -37,11 +34,11 @@ const Layer& Display::GetLayer(std::size_t index) const {
 }

 Kernel::KReadableEvent& Display::GetVSyncEvent() {
-    return vsync_event->GetReadableEvent();
+    return vsync_event.GetReadableEvent();
 }

 void Display::SignalVSyncEvent() {
-    vsync_event->GetWritableEvent().Signal();
+    vsync_event.GetWritableEvent().Signal();
 }

 void Display::CreateLayer(u64 layer_id, NVFlinger::BufferQueue& buffer_queue) {
@@ -18,9 +18,6 @@ class KEvent;
 namespace Service::NVFlinger {
 class BufferQueue;
 }
-namespace Service::KernelHelpers {
-class ServiceContext;
-} // namespace Service::KernelHelpers

 namespace Service::VI {

@@ -34,13 +31,10 @@ class Display {
 public:
    /// Constructs a display with a given unique ID and name.
    ///
-    /// @param id The unique ID for this display.
-    /// @param service_context_ The ServiceContext for the owning service.
+    /// @param id   The unique ID for this display.
    /// @param name_ The name for this display.
-    /// @param system_ The global system instance.
    ///
-    Display(u64 id, std::string name_, KernelHelpers::ServiceContext& service_context_,
-            Core::System& system_);
+    Display(u64 id, std::string name_, Core::System& system);
    ~Display();

    /// Gets the unique ID assigned to this display.
@@ -104,10 +98,9 @@ public:
 private:
    u64 display_id;
    std::string name;
-    KernelHelpers::ServiceContext& service_context;

    std::vector<std::shared_ptr<Layer>> layers;
-    Kernel::KEvent* vsync_event{};
+    Kernel::KEvent vsync_event;
 };

 } // namespace Service::VI
@@ -831,7 +831,6 @@ public:
            {6010, nullptr, "GetLayerPresentationAllFencesExpiredEvent"},
            {6011, nullptr, "EnableLayerAutoClearTransitionBuffer"},
            {6012, nullptr, "DisableLayerAutoClearTransitionBuffer"},
-            {6013, nullptr, "SetLayerOpacity"},
            {7000, nullptr, "SetContentVisibility"},
            {8000, nullptr, "SetConductorLayer"},
            {8001, nullptr, "SetTimestampTracking"},
@@ -1159,7 +1158,7 @@ private:

        const auto layer_id = nv_flinger.CreateLayer(display_id);
        if (!layer_id) {
-            LOG_ERROR(Service_VI, "Layer not found! display_id={}", display_id);
+            LOG_ERROR(Service_VI, "Layer not found! layer_id={}", *layer_id);
            IPC::ResponseBuilder rb{ctx, 2};
            rb.Push(ERR_NOT_FOUND);
            return;
@@ -4,6 +4,8 @@

 #include <algorithm>
 #include <cstring>
+#include <optional>
+#include <utility>

 #include "common/assert.h"
 #include "common/atomic_ops.h"
@@ -12,10 +14,12 @@
 #include "common/page_table.h"
 #include "common/settings.h"
 #include "common/swap.h"
+#include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/physical_memory.h"
 #include "core/memory.h"
 #include "video_core/gpu.h"

@@ -58,7 +62,17 @@ struct Memory::Impl {
        }
    }

-    [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(VAddr vaddr) const {
+    bool IsValidVirtualAddress(const Kernel::KProcess& process, const VAddr vaddr) const {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        const auto [pointer, type] = page_table.pointers[vaddr >> PAGE_BITS].PointerType();
+        return pointer != nullptr || type == Common::PageType::RasterizerCachedMemory;
+    }
+
+    bool IsValidVirtualAddress(VAddr vaddr) const {
+        return IsValidVirtualAddress(*system.CurrentProcess(), vaddr);
+    }
+
+    u8* GetPointerFromRasterizerCachedMemory(VAddr vaddr) const {
        const PAddr paddr{current_page_table->backing_addr[vaddr >> PAGE_BITS]};

        if (!paddr) {
@@ -68,6 +82,18 @@ struct Memory::Impl {
        return system.DeviceMemory().GetPointer(paddr) + vaddr;
    }

+    u8* GetPointer(const VAddr vaddr) const {
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            return pointer + vaddr;
+        }
+        const auto type = Common::PageTable::PageInfo::ExtractType(raw_pointer);
+        if (type == Common::PageType::RasterizerCachedMemory) {
+            return GetPointerFromRasterizerCachedMemory(vaddr);
+        }
+        return nullptr;
+    }
+
    u8 Read8(const VAddr addr) {
        return Read<u8>(addr);
    }
@@ -153,7 +179,7 @@ struct Memory::Impl {
        std::string string;
        string.reserve(max_length);
        for (std::size_t i = 0; i < max_length; ++i) {
-            const char c = Read<s8>(vaddr);
+            const char c = Read8(vaddr);
            if (c == '\0') {
                break;
            }
@@ -164,14 +190,15 @@ struct Memory::Impl {
        return string;
    }

-    void WalkBlock(const Kernel::KProcess& process, const VAddr addr, const std::size_t size,
-                   auto on_unmapped, auto on_memory, auto on_rasterizer, auto increment) {
+    void ReadBlock(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
+                   const std::size_t size) {
        const auto& page_table = process.PageTable().PageTableImpl();
-        std::size_t remaining_size = size;
-        std::size_t page_index = addr >> PAGE_BITS;
-        std::size_t page_offset = addr & PAGE_MASK;

-        while (remaining_size) {
+        std::size_t remaining_size = size;
+        std::size_t page_index = src_addr >> PAGE_BITS;
+        std::size_t page_offset = src_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
            const std::size_t copy_amount =
                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
@@ -179,18 +206,22 @@ struct Memory::Impl {
            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
            switch (type) {
            case Common::PageType::Unmapped: {
-                on_unmapped(copy_amount, current_vaddr);
+                LOG_ERROR(HW_Memory,
+                          "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                          current_vaddr, src_addr, size);
+                std::memset(dest_buffer, 0, copy_amount);
                break;
            }
            case Common::PageType::Memory: {
                DEBUG_ASSERT(pointer);
-                u8* mem_ptr = pointer + page_offset + (page_index << PAGE_BITS);
-                on_memory(copy_amount, mem_ptr);
+                const u8* const src_ptr = pointer + page_offset + (page_index << PAGE_BITS);
+                std::memcpy(dest_buffer, src_ptr, copy_amount);
                break;
            }
            case Common::PageType::RasterizerCachedMemory: {
-                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
-                on_rasterizer(current_vaddr, copy_amount, host_ptr);
+                const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
+                system.GPU().FlushRegion(current_vaddr, copy_amount);
+                std::memcpy(dest_buffer, host_ptr, copy_amount);
                break;
            }
            default:
@@ -199,122 +230,248 @@ struct Memory::Impl {

            page_index++;
            page_offset = 0;
-            increment(copy_amount);
+            dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
            remaining_size -= copy_amount;
        }
    }

-    template <bool UNSAFE>
-    void ReadBlockImpl(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
-                       const std::size_t size) {
-        WalkBlock(
-            process, src_addr, size,
-            [src_addr, size, &dest_buffer](const std::size_t copy_amount,
-                                           const VAddr current_vaddr) {
+    void ReadBlockUnsafe(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
+                         const std::size_t size) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+
+        std::size_t remaining_size = size;
+        std::size_t page_index = src_addr >> PAGE_BITS;
+        std::size_t page_offset = src_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                          current_vaddr, src_addr, size);
                std::memset(dest_buffer, 0, copy_amount);
-            },
-            [&dest_buffer](const std::size_t copy_amount, const u8* const src_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                const u8* const src_ptr = pointer + page_offset + (page_index << PAGE_BITS);
                std::memcpy(dest_buffer, src_ptr, copy_amount);
-            },
-            [&system = system, &dest_buffer](const VAddr current_vaddr,
-                                             const std::size_t copy_amount,
-                                             const u8* const host_ptr) {
-                if constexpr (!UNSAFE) {
-                    system.GPU().FlushRegion(current_vaddr, copy_amount);
-                }
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
                std::memcpy(dest_buffer, host_ptr, copy_amount);
-            },
-            [&dest_buffer](const std::size_t copy_amount) {
-                dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
-            });
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
+            remaining_size -= copy_amount;
+        }
    }

    void ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-        ReadBlockImpl<false>(*system.CurrentProcess(), src_addr, dest_buffer, size);
+        ReadBlock(*system.CurrentProcess(), src_addr, dest_buffer, size);
    }

    void ReadBlockUnsafe(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-        ReadBlockImpl<true>(*system.CurrentProcess(), src_addr, dest_buffer, size);
+        ReadBlockUnsafe(*system.CurrentProcess(), src_addr, dest_buffer, size);
    }

-    template <bool UNSAFE>
-    void WriteBlockImpl(const Kernel::KProcess& process, const VAddr dest_addr,
-                        const void* src_buffer, const std::size_t size) {
-        WalkBlock(
-            process, dest_addr, size,
-            [dest_addr, size](const std::size_t copy_amount, const VAddr current_vaddr) {
+    void WriteBlock(const Kernel::KProcess& process, const VAddr dest_addr, const void* src_buffer,
+                    const std::size_t size) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = dest_addr >> PAGE_BITS;
+        std::size_t page_offset = dest_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                          current_vaddr, dest_addr, size);
-            },
-            [&src_buffer](const std::size_t copy_amount, u8* const dest_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                u8* const dest_ptr = pointer + page_offset + (page_index << PAGE_BITS);
                std::memcpy(dest_ptr, src_buffer, copy_amount);
-            },
-            [&system = system, &src_buffer](const VAddr current_vaddr,
-                                            const std::size_t copy_amount, u8* const host_ptr) {
-                if constexpr (!UNSAFE) {
-                    system.GPU().InvalidateRegion(current_vaddr, copy_amount);
-                }
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
+                system.GPU().InvalidateRegion(current_vaddr, copy_amount);
                std::memcpy(host_ptr, src_buffer, copy_amount);
-            },
-            [&src_buffer](const std::size_t copy_amount) {
-                src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
-            });
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
+            remaining_size -= copy_amount;
+        }
+    }
+
+    void WriteBlockUnsafe(const Kernel::KProcess& process, const VAddr dest_addr,
+                          const void* src_buffer, const std::size_t size) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = dest_addr >> PAGE_BITS;
+        std::size_t page_offset = dest_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
+                LOG_ERROR(HW_Memory,
+                          "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                          current_vaddr, dest_addr, size);
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                u8* const dest_ptr = pointer + page_offset + (page_index << PAGE_BITS);
+                std::memcpy(dest_ptr, src_buffer, copy_amount);
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
+                std::memcpy(host_ptr, src_buffer, copy_amount);
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
+            remaining_size -= copy_amount;
+        }
    }

    void WriteBlock(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-        WriteBlockImpl<false>(*system.CurrentProcess(), dest_addr, src_buffer, size);
+        WriteBlock(*system.CurrentProcess(), dest_addr, src_buffer, size);
    }

    void WriteBlockUnsafe(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-        WriteBlockImpl<true>(*system.CurrentProcess(), dest_addr, src_buffer, size);
+        WriteBlockUnsafe(*system.CurrentProcess(), dest_addr, src_buffer, size);
    }

    void ZeroBlock(const Kernel::KProcess& process, const VAddr dest_addr, const std::size_t size) {
-        WalkBlock(
-            process, dest_addr, size,
-            [dest_addr, size](const std::size_t copy_amount, const VAddr current_vaddr) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = dest_addr >> PAGE_BITS;
+        std::size_t page_offset = dest_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped ZeroBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                          current_vaddr, dest_addr, size);
-            },
-            [](const std::size_t copy_amount, u8* const dest_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                u8* const dest_ptr = pointer + page_offset + (page_index << PAGE_BITS);
                std::memset(dest_ptr, 0, copy_amount);
-            },
-            [&system = system](const VAddr current_vaddr, const std::size_t copy_amount,
-                               u8* const host_ptr) {
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
                system.GPU().InvalidateRegion(current_vaddr, copy_amount);
                std::memset(host_ptr, 0, copy_amount);
-            },
-            [](const std::size_t copy_amount) {});
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            remaining_size -= copy_amount;
+        }
+    }
+
+    void ZeroBlock(const VAddr dest_addr, const std::size_t size) {
+        ZeroBlock(*system.CurrentProcess(), dest_addr, size);
    }

    void CopyBlock(const Kernel::KProcess& process, VAddr dest_addr, VAddr src_addr,
                   const std::size_t size) {
-        WalkBlock(
-            process, dest_addr, size,
-            [this, &process, &dest_addr, &src_addr, size](const std::size_t copy_amount,
-                                                          const VAddr current_vaddr) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = src_addr >> PAGE_BITS;
+        std::size_t page_offset = src_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped CopyBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                          current_vaddr, src_addr, size);
                ZeroBlock(process, dest_addr, copy_amount);
-            },
-            [this, &process, &dest_addr](const std::size_t copy_amount, const u8* const src_ptr) {
-                WriteBlockImpl<false>(process, dest_addr, src_ptr, copy_amount);
-            },
-            [this, &system = system, &process, &dest_addr](
-                const VAddr current_vaddr, const std::size_t copy_amount, u8* const host_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                const u8* src_ptr = pointer + page_offset + (page_index << PAGE_BITS);
+                WriteBlock(process, dest_addr, src_ptr, copy_amount);
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
                system.GPU().FlushRegion(current_vaddr, copy_amount);
-                WriteBlockImpl<false>(process, dest_addr, host_ptr, copy_amount);
-            },
-            [&dest_addr, &src_addr](const std::size_t copy_amount) {
-                dest_addr += static_cast<VAddr>(copy_amount);
-                src_addr += static_cast<VAddr>(copy_amount);
-            });
+                WriteBlock(process, dest_addr, host_ptr, copy_amount);
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            dest_addr += static_cast<VAddr>(copy_amount);
+            src_addr += static_cast<VAddr>(copy_amount);
+            remaining_size -= copy_amount;
+        }
+    }
+
+    void CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size) {
+        return CopyBlock(*system.CurrentProcess(), dest_addr, src_addr, size);
    }

    void RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
@@ -357,7 +514,7 @@ struct Memory::Impl {
            } else {
                // Switch page type to uncached if now uncached
                switch (page_type) {
-                case Common::PageType::Unmapped: // NOLINT(bugprone-branch-clone)
+                case Common::PageType::Unmapped:
                    // It is not necessary for a process to have this region mapped into its address
                    // space, for example, a system module need not have a VRAM mapping.
                    break;
@@ -440,44 +597,6 @@ struct Memory::Impl {
        }
    }

-    [[nodiscard]] u8* GetPointerImpl(VAddr vaddr, auto on_unmapped, auto on_rasterizer) const {
-        // AARCH64 masks the upper 16 bit of all memory accesses
-        vaddr &= 0xffffffffffffLL;
-
-        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
-            on_unmapped();
-            return nullptr;
-        }
-
-        // Avoid adding any extra logic to this fast-path block
-        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
-        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
-            return &pointer[vaddr];
-        }
-        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
-        case Common::PageType::Unmapped:
-            on_unmapped();
-            return nullptr;
-        case Common::PageType::Memory:
-            ASSERT_MSG(false, "Mapped memory page without a pointer @ 0x{:016X}", vaddr);
-            return nullptr;
-        case Common::PageType::RasterizerCachedMemory: {
-            u8* const host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
-            on_rasterizer();
-            return host_ptr;
-        }
-        default:
-            UNREACHABLE();
-        }
-        return nullptr;
-    }
-
-    [[nodiscard]] u8* GetPointer(const VAddr vaddr) const {
-        return GetPointerImpl(
-            vaddr, [vaddr]() { LOG_ERROR(HW_Memory, "Unmapped GetPointer @ 0x{:016X}", vaddr); },
-            []() {});
-    }
-
    /**
     * Reads a particular data type out of memory at the given virtual address.
     *
@@ -491,17 +610,39 @@ struct Memory::Impl {
     */
    template <typename T>
    T Read(VAddr vaddr) {
-        T result = 0;
-        const u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr]() {
-                LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, vaddr);
-            },
-            [&system = system, vaddr]() { system.GPU().FlushRegion(vaddr, sizeof(T)); });
-        if (ptr) {
-            std::memcpy(&result, ptr, sizeof(T));
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
+            return 0;
        }
-        return result;
+
+        // Avoid adding any extra logic to this fast-path block
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (const u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            T value;
+            std::memcpy(&value, &pointer[vaddr], sizeof(T));
+            return value;
+        }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
+            return 0;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().FlushRegion(vaddr, sizeof(T));
+            T value;
+            std::memcpy(&value, host_ptr, sizeof(T));
+            return value;
+        }
+        default:
+            UNREACHABLE();
+        }
+        return {};
    }

    /**
@@ -515,46 +656,110 @@ struct Memory::Impl {
     */
    template <typename T>
    void Write(VAddr vaddr, const T data) {
-        u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr, data]() {
-                LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X} = 0x{:016X}", sizeof(T) * 8,
-                          vaddr, static_cast<u64>(data));
-            },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
-        if (ptr) {
-            std::memcpy(ptr, &data, sizeof(T));
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return;
+        }
+
+        // Avoid adding any extra logic to this fast-path block
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            std::memcpy(&pointer[vaddr], &data, sizeof(T));
+            return;
+        }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            u8* const host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().InvalidateRegion(vaddr, sizeof(T));
+            std::memcpy(host_ptr, &data, sizeof(T));
+            break;
+        }
+        default:
+            UNREACHABLE();
        }
    }

    template <typename T>
    bool WriteExclusive(VAddr vaddr, const T data, const T expected) {
-        u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr, data]() {
-                LOG_ERROR(HW_Memory, "Unmapped WriteExclusive{} @ 0x{:016X} = 0x{:016X}",
-                          sizeof(T) * 8, vaddr, static_cast<u64>(data));
-            },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
-        if (ptr) {
-            const auto volatile_pointer = reinterpret_cast<volatile T*>(ptr);
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return true;
+        }
+
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            // NOTE: Avoid adding any extra logic to this fast-path block
+            const auto volatile_pointer = reinterpret_cast<volatile T*>(&pointer[vaddr]);
            return Common::AtomicCompareAndSwap(volatile_pointer, data, expected);
        }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return true;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            u8* host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().InvalidateRegion(vaddr, sizeof(T));
+            auto* pointer = reinterpret_cast<volatile T*>(&host_ptr);
+            return Common::AtomicCompareAndSwap(pointer, data, expected);
+        }
+        default:
+            UNREACHABLE();
+        }
        return true;
    }

    bool WriteExclusive128(VAddr vaddr, const u128 data, const u128 expected) {
-        u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr, data]() {
-                LOG_ERROR(HW_Memory, "Unmapped WriteExclusive128 @ 0x{:016X} = 0x{:016X}{:016X}",
-                          vaddr, static_cast<u64>(data[1]), static_cast<u64>(data[0]));
-            },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(u128)); });
-        if (ptr) {
-            const auto volatile_pointer = reinterpret_cast<volatile u64*>(ptr);
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data[0]), vaddr);
+            return true;
+        }
+
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            // NOTE: Avoid adding any extra logic to this fast-path block
+            const auto volatile_pointer = reinterpret_cast<volatile u64*>(&pointer[vaddr]);
            return Common::AtomicCompareAndSwap(volatile_pointer, data, expected);
        }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}{:016X}", sizeof(data) * 8,
+                      static_cast<u64>(data[1]), static_cast<u64>(data[0]), vaddr);
+            return true;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            u8* host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().InvalidateRegion(vaddr, sizeof(u128));
+            auto* pointer = reinterpret_cast<volatile u64*>(&host_ptr);
+            return Common::AtomicCompareAndSwap(pointer, data, expected);
+        }
+        default:
+            UNREACHABLE();
+        }
        return true;
    }

@@ -584,11 +789,12 @@ void Memory::UnmapRegion(Common::PageTable& page_table, VAddr base, u64 size) {
    impl->UnmapRegion(page_table, base, size);
 }

+bool Memory::IsValidVirtualAddress(const Kernel::KProcess& process, const VAddr vaddr) const {
+    return impl->IsValidVirtualAddress(process, vaddr);
+}
+
 bool Memory::IsValidVirtualAddress(const VAddr vaddr) const {
-    const Kernel::KProcess& process = *system.CurrentProcess();
-    const auto& page_table = process.PageTable().PageTableImpl();
-    const auto [pointer, type] = page_table.pointers[vaddr >> PAGE_BITS].PointerType();
-    return pointer != nullptr || type == Common::PageType::RasterizerCachedMemory;
+    return impl->IsValidVirtualAddress(vaddr);
 }

 u8* Memory::GetPointer(VAddr vaddr) {
@@ -657,38 +863,64 @@ std::string Memory::ReadCString(VAddr vaddr, std::size_t max_length) {

 void Memory::ReadBlock(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
                       const std::size_t size) {
-    impl->ReadBlockImpl<false>(process, src_addr, dest_buffer, size);
+    impl->ReadBlock(process, src_addr, dest_buffer, size);
 }

 void Memory::ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
    impl->ReadBlock(src_addr, dest_buffer, size);
 }

+void Memory::ReadBlockUnsafe(const Kernel::KProcess& process, const VAddr src_addr,
+                             void* dest_buffer, const std::size_t size) {
+    impl->ReadBlockUnsafe(process, src_addr, dest_buffer, size);
+}
+
 void Memory::ReadBlockUnsafe(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
    impl->ReadBlockUnsafe(src_addr, dest_buffer, size);
 }

 void Memory::WriteBlock(const Kernel::KProcess& process, VAddr dest_addr, const void* src_buffer,
                        std::size_t size) {
-    impl->WriteBlockImpl<false>(process, dest_addr, src_buffer, size);
+    impl->WriteBlock(process, dest_addr, src_buffer, size);
 }

 void Memory::WriteBlock(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
    impl->WriteBlock(dest_addr, src_buffer, size);
 }

+void Memory::WriteBlockUnsafe(const Kernel::KProcess& process, VAddr dest_addr,
+                              const void* src_buffer, std::size_t size) {
+    impl->WriteBlockUnsafe(process, dest_addr, src_buffer, size);
+}
+
 void Memory::WriteBlockUnsafe(const VAddr dest_addr, const void* src_buffer,
                              const std::size_t size) {
    impl->WriteBlockUnsafe(dest_addr, src_buffer, size);
 }

+void Memory::ZeroBlock(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
+    impl->ZeroBlock(process, dest_addr, size);
+}
+
+void Memory::ZeroBlock(VAddr dest_addr, std::size_t size) {
+    impl->ZeroBlock(dest_addr, size);
+}
+
 void Memory::CopyBlock(const Kernel::KProcess& process, VAddr dest_addr, VAddr src_addr,
                       const std::size_t size) {
    impl->CopyBlock(process, dest_addr, src_addr, size);
 }

+void Memory::CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size) {
+    impl->CopyBlock(dest_addr, src_addr, size);
+}
+
 void Memory::RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
    impl->RasterizerMarkRegionCached(vaddr, size, cached);
 }

+bool IsKernelVirtualAddress(const VAddr vaddr) {
+    return KERNEL_REGION_VADDR <= vaddr && vaddr < KERNEL_REGION_END;
+}
+
 } // namespace Core::Memory
@@ -39,6 +39,11 @@ enum : VAddr {

    /// Application stack
    DEFAULT_STACK_SIZE = 0x100000,
+
+    /// Kernel Virtual Address Range
+    KERNEL_REGION_VADDR = 0xFFFFFF8000000000,
+    KERNEL_REGION_SIZE = 0x7FFFE00000,
+    KERNEL_REGION_END = KERNEL_REGION_VADDR + KERNEL_REGION_SIZE,
 };

 /// Central class that handles all memory operations and state.
@@ -51,7 +56,7 @@ public:
    Memory& operator=(const Memory&) = delete;

    Memory(Memory&&) = default;
-    Memory& operator=(Memory&&) = delete;
+    Memory& operator=(Memory&&) = default;

    /**
     * Resets the state of the Memory system.
@@ -85,6 +90,17 @@ public:
     */
    void UnmapRegion(Common::PageTable& page_table, VAddr base, u64 size);

+    /**
+     * Checks whether or not the supplied address is a valid virtual
+     * address for the given process.
+     *
+     * @param process The emulated process to check the address against.
+     * @param vaddr   The virtual address to check the validity of.
+     *
+     * @returns True if the given virtual address is valid, false otherwise.
+     */
+    bool IsValidVirtualAddress(const Kernel::KProcess& process, VAddr vaddr) const;
+
    /**
     * Checks whether or not the supplied address is a valid virtual
     * address for the current process.
@@ -93,7 +109,7 @@ public:
     *
     * @returns True if the given virtual address is valid, false otherwise.
     */
-    [[nodiscard]] bool IsValidVirtualAddress(VAddr vaddr) const;
+    bool IsValidVirtualAddress(VAddr vaddr) const;

    /**
     * Gets a pointer to the given address.
@@ -118,7 +134,7 @@ public:
     * @returns The pointer to the given address, if the address is valid.
     *          If the address is not valid, nullptr will be returned.
     */
-    [[nodiscard]] const u8* GetPointer(VAddr vaddr) const;
+    const u8* GetPointer(VAddr vaddr) const;

    template <typename T>
    const T* GetPointer(VAddr vaddr) const {
@@ -311,6 +327,27 @@ public:
    void ReadBlock(const Kernel::KProcess& process, VAddr src_addr, void* dest_buffer,
                   std::size_t size);

+    /**
+     * Reads a contiguous block of bytes from a specified process' address space.
+     * This unsafe version does not trigger GPU flushing.
+     *
+     * @param process     The process to read the data from.
+     * @param src_addr    The virtual address to begin reading from.
+     * @param dest_buffer The buffer to place the read bytes into.
+     * @param size        The amount of data to read, in bytes.
+     *
+     * @note If a size of 0 is specified, then this function reads nothing and
+     *       no attempts to access memory are made at all.
+     *
+     * @pre dest_buffer must be at least size bytes in length, otherwise a
+     *      buffer overrun will occur.
+     *
+     * @post The range [dest_buffer, size) contains the read bytes from the
+     *       process' address space.
+     */
+    void ReadBlockUnsafe(const Kernel::KProcess& process, VAddr src_addr, void* dest_buffer,
+                         std::size_t size);
+
    /**
     * Reads a contiguous block of bytes from the current process' address space.
     *
@@ -371,6 +408,26 @@ public:
    void WriteBlock(const Kernel::KProcess& process, VAddr dest_addr, const void* src_buffer,
                    std::size_t size);

+    /**
+     * Writes a range of bytes into a given process' address space at the specified
+     * virtual address.
+     * This unsafe version does not invalidate GPU Memory.
+     *
+     * @param process    The process to write data into the address space of.
+     * @param dest_addr  The destination virtual address to begin writing the data at.
+     * @param src_buffer The data to write into the process' address space.
+     * @param size       The size of the data to write, in bytes.
+     *
+     * @post The address range [dest_addr, size) in the process' address space
+     *       contains the data that was within src_buffer.
+     *
+     * @post If an attempt is made to write into an unmapped region of memory, the writes
+     *       will be ignored and an error will be logged.
+     *
+     */
+    void WriteBlockUnsafe(const Kernel::KProcess& process, VAddr dest_addr, const void* src_buffer,
+                          std::size_t size);
+
    /**
     * Writes a range of bytes into the current process' address space at the specified
     * virtual address.
@@ -410,6 +467,29 @@ public:
     */
    void WriteBlockUnsafe(VAddr dest_addr, const void* src_buffer, std::size_t size);

+    /**
+     * Fills the specified address range within a process' address space with zeroes.
+     *
+     * @param process   The process that will have a portion of its memory zeroed out.
+     * @param dest_addr The starting virtual address of the range to zero out.
+     * @param size      The size of the address range to zero out, in bytes.
+     *
+     * @post The range [dest_addr, size) within the process' address space is
+     *       filled with zeroes.
+     */
+    void ZeroBlock(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size);
+
+    /**
+     * Fills the specified address range within the current process' address space with zeroes.
+     *
+     * @param dest_addr The starting virtual address of the range to zero out.
+     * @param size      The size of the address range to zero out, in bytes.
+     *
+     * @post The range [dest_addr, size) within the current process' address space is
+     *       filled with zeroes.
+     */
+    void ZeroBlock(VAddr dest_addr, std::size_t size);
+
    /**
     * Copies data within a process' address space to another location within the
     * same address space.
@@ -425,6 +505,19 @@ public:
    void CopyBlock(const Kernel::KProcess& process, VAddr dest_addr, VAddr src_addr,
                   std::size_t size);

+    /**
+     * Copies data within the current process' address space to another location within the
+     * same address space.
+     *
+     * @param dest_addr The destination virtual address to begin copying the data into.
+     * @param src_addr  The source virtual address to begin copying the data from.
+     * @param size      The size of the data to copy, in bytes.
+     *
+     * @post The range [dest_addr, size) within the current process' address space
+     *       contains the same data within the range [src_addr, size).
+     */
+    void CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size);
+
    /**
     * Marks each page within the specified address range as cached or uncached.
     *
@@ -442,4 +535,7 @@ private:
    std::unique_ptr<Impl> impl;
 };

+/// Determines if the given VAddr is a kernel address
+bool IsKernelVirtualAddress(VAddr vaddr);
+
 } // namespace Core::Memory
@@ -7,14 +7,12 @@
 #include <limits>
 #include <utility>
 #include <vector>
-
-#include "common/error.h"
+#include "common/common_funcs.h"

 #ifdef _WIN32
+#define _WINSOCK_DEPRECATED_NO_WARNINGS // gethostname
 #include <winsock2.h>
-#include <ws2tcpip.h>
 #elif YUZU_UNIX
-#include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
@@ -29,9 +27,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "common/settings.h"
 #include "core/network/network.h"
-#include "core/network/network_interface.h"
 #include "core/network/sockets.h"

 namespace Network {
@@ -51,6 +47,11 @@ void Finalize() {
    WSACleanup();
 }

+constexpr IPv4Address TranslateIPv4(in_addr addr) {
+    auto& bytes = addr.S_un.S_un_b;
+    return IPv4Address{bytes.s_b1, bytes.s_b2, bytes.s_b3, bytes.s_b4};
+}
+
 sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
    sockaddr_in result;

@@ -137,6 +138,12 @@ void Initialize() {}

 void Finalize() {}

+constexpr IPv4Address TranslateIPv4(in_addr addr) {
+    const u32 bytes = addr.s_addr;
+    return IPv4Address{static_cast<u8>(bytes), static_cast<u8>(bytes >> 8),
+                       static_cast<u8>(bytes >> 16), static_cast<u8>(bytes >> 24)};
+}
+
 sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
    sockaddr_in result;

@@ -175,7 +182,7 @@ linger MakeLinger(bool enable, u32 linger_value) {
 }

 bool EnableNonBlock(int fd, bool enable) {
-    int flags = fcntl(fd, F_GETFL);
+    int flags = fcntl(fd, F_GETFD);
    if (flags == -1) {
        return false;
    }
@@ -184,7 +191,7 @@ bool EnableNonBlock(int fd, bool enable) {
    } else {
        flags &= ~O_NONBLOCK;
    }
-    return fcntl(fd, F_SETFL, flags) == 0;
+    return fcntl(fd, F_SETFD, flags) == 0;
 }

 Errno TranslateNativeError(int e) {
@@ -220,12 +227,8 @@ Errno GetAndLogLastError() {
 #else
    int e = errno;
 #endif
-    const Errno err = TranslateNativeError(e);
-    if (err == Errno::AGAIN) {
-        return err;
-    }
-    LOG_ERROR(Network, "Socket operation error: {}", Common::NativeErrorToString(e));
-    return err;
+    LOG_ERROR(Network, "Socket operation error: {}", NativeErrorToString(e));
+    return TranslateNativeError(e);
 }

 int TranslateDomain(Domain domain) {
@@ -350,29 +353,27 @@ NetworkInstance::~NetworkInstance() {
    Finalize();
 }

-std::optional<IPv4Address> GetHostIPv4Address() {
-    const std::string& selected_network_interface = Settings::values.network_interface.GetValue();
-    const auto network_interfaces = Network::GetAvailableNetworkInterfaces();
-    if (network_interfaces.size() == 0) {
-        LOG_ERROR(Network, "GetAvailableNetworkInterfaces returned no interfaces");
-        return {};
+std::pair<IPv4Address, Errno> GetHostIPv4Address() {
+    std::array<char, 256> name{};
+    if (gethostname(name.data(), static_cast<int>(name.size()) - 1) == SOCKET_ERROR) {
+        return {IPv4Address{}, GetAndLogLastError()};
    }

-    const auto res =
-        std::ranges::find_if(network_interfaces, [&selected_network_interface](const auto& iface) {
-            return iface.name == selected_network_interface;
-        });
-
-    if (res != network_interfaces.end()) {
-        char ip_addr[16] = {};
-        ASSERT(inet_ntop(AF_INET, &res->ip_address, ip_addr, sizeof(ip_addr)) != nullptr);
-        LOG_INFO(Network, "IP address: {}", ip_addr);
-
-        return TranslateIPv4(res->ip_address);
-    } else {
-        LOG_ERROR(Network, "Couldn't find selected interface \"{}\"", selected_network_interface);
-        return {};
+    hostent* const ent = gethostbyname(name.data());
+    if (!ent) {
+        return {IPv4Address{}, GetAndLogLastError()};
    }
+    if (ent->h_addr_list == nullptr) {
+        UNIMPLEMENTED_MSG("No addr provided in hostent->h_addr_list");
+        return {IPv4Address{}, Errno::SUCCESS};
+    }
+    if (ent->h_length != sizeof(in_addr)) {
+        UNIMPLEMENTED_MSG("Unexpected size={} in hostent->h_length", ent->h_length);
+    }
+
+    in_addr addr;
+    std::memcpy(&addr, ent->h_addr_list[0], sizeof(addr));
+    return {TranslateIPv4(addr), Errno::SUCCESS};
 }

 std::pair<s32, Errno> Poll(std::vector<PollFD>& pollfds, s32 timeout) {
@@ -5,18 +5,11 @@
 #pragma once

 #include <array>
-#include <optional>
 #include <utility>

 #include "common/common_funcs.h"
 #include "common/common_types.h"

-#ifdef _WIN32
-#include <winsock2.h>
-#elif YUZU_UNIX
-#include <netinet/in.h>
-#endif
-
 namespace Network {

 class Socket;
@@ -99,21 +92,8 @@ public:
    ~NetworkInstance();
 };

-#ifdef _WIN32
-constexpr IPv4Address TranslateIPv4(in_addr addr) {
-    auto& bytes = addr.S_un.S_un_b;
-    return IPv4Address{bytes.s_b1, bytes.s_b2, bytes.s_b3, bytes.s_b4};
-}
-#elif YUZU_UNIX
-constexpr IPv4Address TranslateIPv4(in_addr addr) {
-    const u32 bytes = addr.s_addr;
-    return IPv4Address{static_cast<u8>(bytes), static_cast<u8>(bytes >> 8),
-                       static_cast<u8>(bytes >> 16), static_cast<u8>(bytes >> 24)};
-}
-#endif
-
 /// @brief Returns host's IPv4 address
-/// @return human ordered IPv4 address (e.g. 192.168.0.1) as an array
-std::optional<IPv4Address> GetHostIPv4Address();
+/// @return Pair of an array of human ordered IPv4 address (e.g. 192.168.0.1) and an error code
+std::pair<IPv4Address, Errno> GetHostIPv4Address();

 } // namespace Network
@@ -1,210 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <fstream>
-#include <sstream>
-#include <vector>
-
-#include "common/bit_cast.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "common/string_util.h"
-#include "core/network/network_interface.h"
-
-#ifdef _WIN32
-#include <iphlpapi.h>
-#else
-#include <cerrno>
-#include <ifaddrs.h>
-#include <net/if.h>
-#endif
-
-namespace Network {
-
-#ifdef _WIN32
-
-std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
-    std::vector<IP_ADAPTER_ADDRESSES> adapter_addresses;
-    DWORD ret = ERROR_BUFFER_OVERFLOW;
-    DWORD buf_size = 0;
-
-    // retry up to 5 times
-    for (int i = 0; i < 5 && ret == ERROR_BUFFER_OVERFLOW; i++) {
-        ret = GetAdaptersAddresses(
-            AF_INET, GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_GATEWAYS,
-            nullptr, adapter_addresses.data(), &buf_size);
-
-        if (ret != ERROR_BUFFER_OVERFLOW) {
-            break;
-        }
-
-        adapter_addresses.resize((buf_size / sizeof(IP_ADAPTER_ADDRESSES)) + 1);
-    }
-
-    if (ret != NO_ERROR) {
-        LOG_ERROR(Network, "Failed to get network interfaces with GetAdaptersAddresses");
-        return {};
-    }
-
-    std::vector<NetworkInterface> result;
-
-    for (auto current_address = adapter_addresses.data(); current_address != nullptr;
-         current_address = current_address->Next) {
-        if (current_address->FirstUnicastAddress == nullptr ||
-            current_address->FirstUnicastAddress->Address.lpSockaddr == nullptr) {
-            continue;
-        }
-
-        if (current_address->OperStatus != IfOperStatusUp) {
-            continue;
-        }
-
-        const auto ip_addr = Common::BitCast<struct sockaddr_in>(
-                                 *current_address->FirstUnicastAddress->Address.lpSockaddr)
-                                 .sin_addr;
-
-        ULONG mask = 0;
-        if (ConvertLengthToIpv4Mask(current_address->FirstUnicastAddress->OnLinkPrefixLength,
-                                    &mask) != NO_ERROR) {
-            LOG_ERROR(Network, "Failed to convert IPv4 prefix length to subnet mask");
-            continue;
-        }
-
-        struct in_addr gateway = {.S_un{.S_addr{0}}};
-        if (current_address->FirstGatewayAddress != nullptr &&
-            current_address->FirstGatewayAddress->Address.lpSockaddr != nullptr) {
-            gateway = Common::BitCast<struct sockaddr_in>(
-                          *current_address->FirstGatewayAddress->Address.lpSockaddr)
-                          .sin_addr;
-        }
-
-        result.emplace_back(NetworkInterface{
-            .name{Common::UTF16ToUTF8(std::wstring{current_address->FriendlyName})},
-            .ip_address{ip_addr},
-            .subnet_mask = in_addr{.S_un{.S_addr{mask}}},
-            .gateway = gateway});
-    }
-
-    return result;
-}
-
-#else
-
-std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
-    struct ifaddrs* ifaddr = nullptr;
-
-    if (getifaddrs(&ifaddr) != 0) {
-        LOG_ERROR(Network, "Failed to get network interfaces with getifaddrs: {}",
-                  std::strerror(errno));
-        return {};
-    }
-
-    std::vector<NetworkInterface> result;
-
-    for (auto ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
-        if (ifa->ifa_addr == nullptr || ifa->ifa_netmask == nullptr) {
-            continue;
-        }
-
-        if (ifa->ifa_addr->sa_family != AF_INET) {
-            continue;
-        }
-
-        if ((ifa->ifa_flags & IFF_UP) == 0 || (ifa->ifa_flags & IFF_LOOPBACK) != 0) {
-            continue;
-        }
-
-        u32 gateway{};
-
-        std::ifstream file{"/proc/net/route"};
-        if (!file.is_open()) {
-            LOG_ERROR(Network, "Failed to open \"/proc/net/route\"");
-
-            result.emplace_back(NetworkInterface{
-                .name{ifa->ifa_name},
-                .ip_address{Common::BitCast<struct sockaddr_in>(*ifa->ifa_addr).sin_addr},
-                .subnet_mask{Common::BitCast<struct sockaddr_in>(*ifa->ifa_netmask).sin_addr},
-                .gateway{in_addr{.s_addr = gateway}}});
-            continue;
-        }
-
-        // ignore header
-        file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
-
-        bool gateway_found = false;
-
-        for (std::string line; std::getline(file, line);) {
-            std::istringstream iss{line};
-
-            std::string iface_name;
-            iss >> iface_name;
-            if (iface_name != ifa->ifa_name) {
-                continue;
-            }
-
-            iss >> std::hex;
-
-            u32 dest{};
-            iss >> dest;
-            if (dest != 0) {
-                // not the default route
-                continue;
-            }
-
-            iss >> gateway;
-
-            u16 flags{};
-            iss >> flags;
-
-            // flag RTF_GATEWAY (defined in <linux/route.h>)
-            if ((flags & 0x2) == 0) {
-                continue;
-            }
-
-            gateway_found = true;
-            break;
-        }
-
-        if (!gateway_found) {
-            gateway = 0;
-        }
-
-        result.emplace_back(NetworkInterface{
-            .name{ifa->ifa_name},
-            .ip_address{Common::BitCast<struct sockaddr_in>(*ifa->ifa_addr).sin_addr},
-            .subnet_mask{Common::BitCast<struct sockaddr_in>(*ifa->ifa_netmask).sin_addr},
-            .gateway{in_addr{.s_addr = gateway}}});
-    }
-
-    freeifaddrs(ifaddr);
-
-    return result;
-}
-
-#endif
-
-std::optional<NetworkInterface> GetSelectedNetworkInterface() {
-    const auto& selected_network_interface = Settings::values.network_interface.GetValue();
-    const auto network_interfaces = Network::GetAvailableNetworkInterfaces();
-    if (network_interfaces.size() == 0) {
-        LOG_ERROR(Network, "GetAvailableNetworkInterfaces returned no interfaces");
-        return std::nullopt;
-    }
-
-    const auto res =
-        std::ranges::find_if(network_interfaces, [&selected_network_interface](const auto& iface) {
-            return iface.name == selected_network_interface;
-        });
-
-    if (res == network_interfaces.end()) {
-        LOG_ERROR(Network, "Couldn't find selected interface \"{}\"", selected_network_interface);
-        return std::nullopt;
-    }
-
-    return *res;
-}
-
-} // namespace Network
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Moonlacer	f510f95b71	copyright: Update year and names of many .cpp and .h files	2021-08-10 13:07:49 -05:00
Moonlacer	128bdd127b	yuzu-copyright: Update year and names of many .cpp and .h files	2021-08-10 13:00:50 -05:00