Merge pull request #104 from shadps4-emu/modules3

More modules work
2024-04-01 08:45:03 +03:00 · 2024-04-01 08:45:03 +03:00 · 0d49214da3
parent 0719e9c46f 06d6ad09ea
commit 0d49214da3
22 changed files with 13708 additions and 1 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -98,12 +98,28 @@ set(AUDIO_CORE src/audio_core/sdl_audio.cpp
 )
 set(LIBRARIES src/core/libraries/library_common.h
              src/core/libraries/error_codes.h
+              src/core/libraries/libkernel.cpp
+              src/core/libraries/libkernel.h
              src/core/libraries/libscecommondialog.cpp
              src/core/libraries/libscecommondialog.h
              src/core/libraries/libscegnmdriver.cpp
              src/core/libraries/libscegnmdriver.h
+              src/core/libraries/libscehttp.cpp
+              src/core/libraries/libscehttp.h
              src/core/libraries/libscemsgdialog.cpp
              src/core/libraries/libscemsgdialog.h
+              src/core/libraries/libscenet.cpp
+              src/core/libraries/libscenet.h
+              src/core/libraries/libscenetctl.cpp
+              src/core/libraries/libscenetctl.h
+              src/core/libraries/libsceposix.cpp
+              src/core/libraries/libsceposix.h
+              src/core/libraries/libscesavedata.cpp
+              src/core/libraries/libscesavedata.h
+              src/core/libraries/libscessl.cpp
+              src/core/libraries/libscessl.h
+              src/core/libraries/libscesysmodule.cpp
+              src/core/libraries/libscesysmodule.h
              src/core/libraries/libscesystemservice.cpp
              src/core/libraries/libscesystemservice.h
              src/core/libraries/libsceuserservice.cpp
--- a/src/common/logging/filter.cpp
+++ b/src/common/logging/filter.cpp
@ -88,10 +88,17 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
    SUB(Lib, CommonDlg)                                                                            \
    SUB(Lib, MsgDlg)                                                                               \
    SUB(Lib, AudioOut)                                                                             \
+    SUB(Lib, Net)                                                                                  \
+    SUB(Lib, NetCtl)                                                                               \
+    SUB(Lib, SaveData)                                                                             \
+    SUB(Lib, Http)                                                                                 \
+    SUB(Lib, Ssl)                                                                                  \
+    SUB(Lib, SysModule)                                                                            \
    CLS(Frontend)                                                                                  \
    CLS(Render)                                                                                    \
    SUB(Render, Vulkan)                                                                            \
    CLS(Input)                                                                                     \
+    CLS(Tty)                                                                                       \
    CLS(Loader)

 // GetClassName is a macro defined by Windows.h, grrr...
--- a/src/common/logging/types.h
+++ b/src/common/logging/types.h
@ -55,11 +55,18 @@ enum class Class : u8 {
    Lib_CommonDlg,     ///< The LibSceCommonDialog implementation.
    Lib_MsgDlg,        ///< The LibSceMsgDialog implementation.
    Lib_AudioOut,      ///< The LibSceAudioOut implementation.
+    Lib_Net,           ///< The LibSceNet implementation.
+    Lib_NetCtl,        ///< The LibSecNetCtl implementation.
+    Lib_SaveData,      ///< The LibSceSaveData implementation.
+    Lib_Ssl,           ///< The LibSceSsl implementation.
+    Lib_Http,          ///< The LibSceHttp implementation.
+    Lib_SysModule,     ///< The LibSceSysModule implementation
    Frontend,          ///< Emulator UI
    Render,            ///< Video Core
    Render_Vulkan,     ///< Vulkan backend
    Loader,            ///< ROM loader
    Input,             ///< Input emulation
+    Tty,               ///< Debug output from emu
    Count              ///< Total number of logging classes
 };

--- a/src/core/hle/libraries/libkernel/file_system.cpp
+++ b/src/core/hle/libraries/libkernel/file_system.cpp
@ -13,6 +13,8 @@ namespace Core::Libraries::LibKernel {

 int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) {
    LOG_INFO(Kernel_Fs, "path = {} flags = {:#x} mode = {:#x}", path, flags, mode);
+    ASSERT_MSG(flags == 0, "flags!=0 not supported yet");
+    ASSERT_MSG(mode == 0, "mode!=0 not supported yet");
    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();

@ -39,6 +41,21 @@ int PS4_SYSV_ABI posix_open(const char* path, int flags, /* SceKernelMode*/ u16
    return result;
 }

+int PS4_SYSV_ABI sceKernelClose(int d) {
+    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
+    auto* file = h->GetFile(d);
+    if (file == nullptr) {
+        return SCE_KERNEL_ERROR_EBADF;
+    }
+    if (!file->is_directory) {
+        file->f.Close();
+    }
+    file->is_opened = false;
+    LOG_INFO(Kernel_Fs, "Closing {}", file->m_guest_name);
+    h->DeleteHandle(d);
+    return SCE_OK;
+}
+
 size_t PS4_SYSV_ABI _readv(int d, const SceKernelIovec* iov, int iovcnt) {
    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
    auto* file = h->GetFile(d);
@ -51,7 +68,7 @@ size_t PS4_SYSV_ABI _readv(int d, const SceKernelIovec* iov, int iovcnt) {
    return total_read;
 }

-s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence) {
+s64 PS4_SYSV_ABI sceKernelLseek(int d, s64 offset, int whence) {
    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
    auto* file = h->GetFile(d);

@ -74,11 +91,35 @@ s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence) {
    return pos;
 }

+s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence) {
+    return sceKernelLseek(d, offset, whence);
+}
+
+s64 PS4_SYSV_ABI sceKernelRead(int d, void* buf, size_t nbytes) {
+    if (buf == nullptr) {
+        return SCE_KERNEL_ERROR_EFAULT;
+    }
+
+    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
+    auto* file = h->GetFile(d);
+    if (file == nullptr) {
+        return SCE_KERNEL_ERROR_EBADF;
+    }
+    file->m_mutex.lock();
+    u32 bytes_read = file->f.ReadRaw<u8>(buf, static_cast<u32>(nbytes));
+    file->m_mutex.unlock();
+    return bytes_read;
+}
+
 void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym) {
    LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
    LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, posix_open);
+    LIB_FUNCTION("UK2Tl2DWUns", "libkernel", 1, "libkernel", 1, 1, sceKernelClose);
+
    LIB_FUNCTION("+WRlkKjZvag", "libkernel", 1, "libkernel", 1, 1, _readv);
    LIB_FUNCTION("Oy6IpwgtYOk", "libkernel", 1, "libkernel", 1, 1, lseek);
+    LIB_FUNCTION("oib76F-12fk", "libkernel", 1, "libkernel", 1, 1, sceKernelLseek);
+    LIB_FUNCTION("Cg4srZ6TKbU", "libkernel", 1, "libkernel", 1, 1, sceKernelRead);

    // openOrbis (to check if it is valid out of OpenOrbis
    LIB_FUNCTION("6c3rCVE-fTU", "libkernel", 1, "libkernel", 1, 1,
--- a/src/core/hle/libraries/libkernel/thread_management.cpp
+++ b/src/core/hle/libraries/libkernel/thread_management.cpp
@ -57,6 +57,19 @@ int PS4_SYSV_ABI scePthreadAttrInit(ScePthreadAttr* attr) {
    }
 }

+int PS4_SYSV_ABI scePthreadAttrDestroy(ScePthreadAttr* attr) {
+
+    int result = pthread_attr_destroy(&(*attr)->pth_attr);
+
+    delete *attr;
+    *attr = nullptr;
+
+    if (result == 0) {
+        return SCE_OK;
+    }
+    return SCE_KERNEL_ERROR_EINVAL;
+}
+
 int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate) {
    if (attr == nullptr || *attr == nullptr) {
        return SCE_KERNEL_ERROR_EINVAL;
@ -157,6 +170,16 @@ int PS4_SYSV_ABI scePthreadAttrSetaffinity(ScePthreadAttr* pattr,
    return SCE_OK;
 }

+int PS4_SYSV_ABI scePthreadAttrGetaffinity(const ScePthreadAttr* pattr,
+                                           /* SceKernelCpumask*/ u64* mask) {
+    if (pattr == nullptr || *pattr == nullptr) {
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+
+    *mask = (*pattr)->affinity;
+
+    return SCE_OK;
+}
 int PS4_SYSV_ABI scePthreadSetaffinity(ScePthread thread, const /*SceKernelCpumask*/ u64 mask) {
    LOG_INFO(Kernel_Pthread, "called");

@ -479,8 +502,12 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) {
    LIB_FUNCTION("eXbUSpEaTsA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetinheritsched);
    LIB_FUNCTION("DzES9hQF4f4", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedparam);
    LIB_FUNCTION("nsYoNRywwNg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrInit);
+    LIB_FUNCTION("62KCwEMmzcM", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrDestroy);
+
    LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf);
    LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity);
+    LIB_FUNCTION("8+s5BzZjxSg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetaffinity);
+
    LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity);
    LIB_FUNCTION("6UgtwV+0zb4", "libkernel", 1, "libkernel", 1, 1, scePthreadCreate);
    // mutex calls
--- a/src/core/hle/libraries/libs.cpp
+++ b/src/core/hle/libraries/libs.cpp
@ -8,9 +8,17 @@
 #include "core/hle/libraries/libpad/pad.h"
 #include "core/hle/libraries/libs.h"
 #include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h"
+#include "src/core/libraries/libkernel.h"
 #include "src/core/libraries/libsceaudioout.h"
 #include "src/core/libraries/libscecommondialog.h"
+#include "src/core/libraries/libscehttp.h"
 #include "src/core/libraries/libscemsgdialog.h"
+#include "src/core/libraries/libscenet.h"
+#include "src/core/libraries/libscenetctl.h"
+#include "src/core/libraries/libsceposix.h"
+#include "src/core/libraries/libscesavedata.h"
+#include "src/core/libraries/libscessl.h"
+#include "src/core/libraries/libscesysmodule.h"
 #include "src/core/libraries/libscesystemservice.h"
 #include "src/core/libraries/libsceuserservice.h"

@ -31,6 +39,14 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
    Libraries::CommonDialog::RegisterlibSceCommonDialog(sym);
    Libraries::MsgDialog::RegisterlibSceMsgDialog(sym);
    Libraries::AudioOut::RegisterlibSceAudioOut(sym);
+    Libraries::Http::RegisterlibSceHttp(sym);
+    Libraries::Net::RegisterlibSceNet(sym);
+    Libraries::NetCtl::RegisterlibSceNetCtl(sym);
+    Libraries::SaveData::RegisterlibSceSaveData(sym);
+    Libraries::Ssl::RegisterlibSceSsl(sym);
+    Libraries::SysModule::RegisterlibSceSysmodule(sym);
+    Libraries::Kernel::Registerlibkernel(sym);
+    Libraries::Posix::Registerlibsceposix(sym);
 }

 } // namespace OldLibraries
--- a/src/core/libraries/libkernel.cpp
+++ b/src/core/libraries/libkernel.cpp
--- a/src/core/libraries/libkernel.h
+++ b/src/core/libraries/libkernel.h
--- a/src/core/libraries/libscehttp.cpp
+++ b/src/core/libraries/libscehttp.cpp
@ -0,0 +1,720 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "common/logging/log.h"
+#include "error_codes.h"
+#include "libscehttp.h"
+
+namespace Libraries::Http {
+
+int PS4_SYSV_ABI sceHttpAbortRequest() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAbortRequestForce() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAbortWaitRequest() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAddCookie() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAddQuery() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAddRequestHeader() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAddRequestHeaderRaw() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAuthCacheExport() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAuthCacheFlush() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpAuthCacheImport() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCacheRedirectedConnectionEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCookieExport() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCookieFlush() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCookieImport() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateConnection() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateConnectionWithURL() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateEpoll() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateRequest() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateRequest2() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateRequestWithURL() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateRequestWithURL2() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpCreateTemplate() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgEnableProfile() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgGetConnectionStat() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgGetRequestStat() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgSetPrintf() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgShowConnectionStat() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgShowMemoryPoolStat() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgShowRequestStat() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDbgShowStat() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDeleteConnection() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDeleteRequest() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDeleteTemplate() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpDestroyEpoll() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetAcceptEncodingGZIPEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetAllResponseHeaders() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetAuthEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetAutoRedirect() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetConnectionStat() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetCookie() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetCookieEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetCookieStats() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetEpoll() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetEpollId() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetLastErrno() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetMemoryPoolStats() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetNonblock() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetRegisteredCtxIds() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetResponseContentLength() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpGetStatusCode() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpInit(int libnetMemId, int libsslCtxId, std::size_t poolSize) {
+    LOG_ERROR(Lib_Http, "(DUMMY) called libnetMemId = {} libsslCtxId = {} poolSize = {}",
+              libnetMemId, libsslCtxId, poolSize);
+    // return a value >1
+    static int id = 0;
+    return ++id;
+}
+
+int PS4_SYSV_ABI sceHttpParseResponseHeader() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpParseStatusLine() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpReadData() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpRedirectCacheFlush() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpRemoveRequestHeader() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpRequestGetAllHeaders() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsDisableOption() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsDisableOptionPrivate() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsEnableOption() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsEnableOptionPrivate() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSendRequest() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetAcceptEncodingGZIPEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetAuthEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetAuthInfoCallback() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetAutoRedirect() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetChunkedTransferEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetConnectTimeOut() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetCookieEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetCookieMaxNum() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetCookieMaxNumPerDomain() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetCookieMaxSize() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetCookieRecvCallback() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetCookieSendCallback() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetCookieTotalMaxSize() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetDefaultAcceptEncodingGZIPEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetDelayBuildRequestEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetEpoll() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetEpollId() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetHttp09Enabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetInflateGZIPEnabled() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetNonblock() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetPolicyOption() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetPriorityOption() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetProxy() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetRecvBlockSize() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetRecvTimeOut() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetRedirectCallback() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetRequestContentLength() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetRequestStatusCallback() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetResolveRetry() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetResolveTimeOut() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetResponseHeaderMaxSize() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetSendTimeOut() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpSetSocketCreationCallback() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsFreeCaList() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsGetCaList() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsGetSslError() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsLoadCert() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsSetMinSslVersion() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsSetSslCallback() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsSetSslVersion() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpsUnloadCert() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpTerm() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpTryGetNonblock() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpTrySetNonblock() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUnsetEpoll() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUriBuild() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUriCopy() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUriEscape() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUriMerge() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUriParse() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUriSweepPath() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpUriUnescape() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceHttpWaitRequest() {
+    LOG_ERROR(Lib_Http, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceHttp(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("hvG6GfBMXg8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAbortRequest);
+    LIB_FUNCTION("JKl06ZIAl6A", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAbortRequestForce);
+    LIB_FUNCTION("sWQiqKvYTVA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAbortWaitRequest);
+    LIB_FUNCTION("mNan6QSnpeY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddCookie);
+    LIB_FUNCTION("JM58a21mtrQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddQuery);
+    LIB_FUNCTION("EY28T2bkN7k", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddRequestHeader);
+    LIB_FUNCTION("lGAjftanhFs", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddRequestHeaderRaw);
+    LIB_FUNCTION("Y1DCjN-s2BA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAuthCacheExport);
+    LIB_FUNCTION("zzB0StvRab4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAuthCacheFlush);
+    LIB_FUNCTION("wF0KcxK20BE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAuthCacheImport);
+    LIB_FUNCTION("A7n9nNg7NBg", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpCacheRedirectedConnectionEnabled);
+    LIB_FUNCTION("nOkViL17ZOo", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCookieExport);
+    LIB_FUNCTION("seCvUt91WHY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCookieFlush);
+    LIB_FUNCTION("pFnXDxo3aog", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCookieImport);
+    LIB_FUNCTION("Kiwv9r4IZCc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateConnection);
+    LIB_FUNCTION("qgxDBjorUxs", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpCreateConnectionWithURL);
+    LIB_FUNCTION("6381dWF+xsQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateEpoll);
+    LIB_FUNCTION("tsGVru3hCe8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequest);
+    LIB_FUNCTION("rGNm+FjIXKk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequest2);
+    LIB_FUNCTION("Aeu5wVKkF9w", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequestWithURL);
+    LIB_FUNCTION("Cnp77podkCU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequestWithURL2);
+    LIB_FUNCTION("0gYjPTR-6cY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateTemplate);
+    LIB_FUNCTION("Lffcxao-QMM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgEnableProfile);
+    LIB_FUNCTION("6gyx-I0Oob4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgGetConnectionStat);
+    LIB_FUNCTION("fzzBpJjm9Kw", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgGetRequestStat);
+    LIB_FUNCTION("VmqSnjZ5mE4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgSetPrintf);
+    LIB_FUNCTION("KJtUHtp6y0U", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowConnectionStat);
+    LIB_FUNCTION("oEuPssSYskA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowMemoryPoolStat);
+    LIB_FUNCTION("L2gM3qptqHs", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowRequestStat);
+    LIB_FUNCTION("pxBsD-X9eH0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowStat);
+    LIB_FUNCTION("P6A3ytpsiYc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDeleteConnection);
+    LIB_FUNCTION("qe7oZ+v4PWA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDeleteRequest);
+    LIB_FUNCTION("4I8vEpuEhZ8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDeleteTemplate);
+    LIB_FUNCTION("wYhXVfS2Et4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDestroyEpoll);
+    LIB_FUNCTION("1rpZqxdMRwQ", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpGetAcceptEncodingGZIPEnabled);
+    LIB_FUNCTION("aCYPMSUIaP8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetAllResponseHeaders);
+    LIB_FUNCTION("9m8EcOGzcIQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetAuthEnabled);
+    LIB_FUNCTION("mmLexUbtnfY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetAutoRedirect);
+    LIB_FUNCTION("L-DwVoHXLtU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetConnectionStat);
+    LIB_FUNCTION("+G+UsJpeXPc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetCookie);
+    LIB_FUNCTION("iSZjWw1TGiA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetCookieEnabled);
+    LIB_FUNCTION("xkymWiGdMiI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetCookieStats);
+    LIB_FUNCTION("7j9VcwnrZo4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetEpoll);
+    LIB_FUNCTION("IQOP6McWJcY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetEpollId);
+    LIB_FUNCTION("0onIrKx9NIE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetLastErrno);
+    LIB_FUNCTION("16sMmVuOvgU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetMemoryPoolStats);
+    LIB_FUNCTION("Wq4RNB3snSQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetNonblock);
+    LIB_FUNCTION("hkcfqAl+82w", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetRegisteredCtxIds);
+    LIB_FUNCTION("yuO2H2Uvnos", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpGetResponseContentLength);
+    LIB_FUNCTION("0a2TBNfE3BU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetStatusCode);
+    LIB_FUNCTION("A9cVMUtEp4Y", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpInit);
+    LIB_FUNCTION("hPTXo3bICzI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpParseResponseHeader);
+    LIB_FUNCTION("Qq8SfuJJJqE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpParseStatusLine);
+    LIB_FUNCTION("P5pdoykPYTk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpReadData);
+    LIB_FUNCTION("u05NnI+P+KY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpRedirectCacheFlush);
+    LIB_FUNCTION("zNGh-zoQTD0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpRemoveRequestHeader);
+    LIB_FUNCTION("4fgkfVeVsGU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpRequestGetAllHeaders);
+    LIB_FUNCTION("mSQCxzWTwVI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsDisableOption);
+    LIB_FUNCTION("zJYi5br6ZiQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsDisableOptionPrivate);
+    LIB_FUNCTION("f42K37mm5RM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsEnableOption);
+    LIB_FUNCTION("I4+4hKttt1w", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsEnableOptionPrivate);
+    LIB_FUNCTION("1e2BNwI-XzE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSendRequest);
+    LIB_FUNCTION("HRX1iyDoKR8", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetAcceptEncodingGZIPEnabled);
+    LIB_FUNCTION("qFg2SuyTJJY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetAuthEnabled);
+    LIB_FUNCTION("jf4TB2nUO40", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetAuthInfoCallback);
+    LIB_FUNCTION("T-mGo9f3Pu4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetAutoRedirect);
+    LIB_FUNCTION("PDxS48xGQLs", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetChunkedTransferEnabled);
+    LIB_FUNCTION("0S9tTH0uqTU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetConnectTimeOut);
+    LIB_FUNCTION("XNUoD2B9a6A", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieEnabled);
+    LIB_FUNCTION("pM--+kIeW-8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieMaxNum);
+    LIB_FUNCTION("Kp6juCJUJGQ", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetCookieMaxNumPerDomain);
+    LIB_FUNCTION("7Y4364GBras", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieMaxSize);
+    LIB_FUNCTION("Kh6bS2HQKbo", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieRecvCallback);
+    LIB_FUNCTION("GnVDzYfy-KI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieSendCallback);
+    LIB_FUNCTION("pHc3bxUzivU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieTotalMaxSize);
+    LIB_FUNCTION("8kzIXsRy1bY", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetDefaultAcceptEncodingGZIPEnabled);
+    LIB_FUNCTION("22buO-UufJY", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetDelayBuildRequestEnabled);
+    LIB_FUNCTION("-xm7kZQNpHI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetEpoll);
+    LIB_FUNCTION("LG1YW1Uhkgo", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetEpollId);
+    LIB_FUNCTION("pk0AuomQM1o", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetHttp09Enabled);
+    LIB_FUNCTION("i9mhafzkEi8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetInflateGZIPEnabled);
+    LIB_FUNCTION("s2-NPIvz+iA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetNonblock);
+    LIB_FUNCTION("gZ9TpeFQ7Gk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetPolicyOption);
+    LIB_FUNCTION("2NeZnMEP3-0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetPriorityOption);
+    LIB_FUNCTION("i+quCZCL+D8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetProxy);
+    LIB_FUNCTION("mMcB2XIDoV4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetRecvBlockSize);
+    LIB_FUNCTION("yigr4V0-HTM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetRecvTimeOut);
+    LIB_FUNCTION("h9wmFZX4i-4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetRedirectCallback);
+    LIB_FUNCTION("PTiFIUxCpJc", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetRequestContentLength);
+    LIB_FUNCTION("vO4B-42ef-k", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetRequestStatusCallback);
+    LIB_FUNCTION("K1d1LqZRQHQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetResolveRetry);
+    LIB_FUNCTION("Tc-hAYDKtQc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetResolveTimeOut);
+    LIB_FUNCTION("a4VsZ4oqn68", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetResponseHeaderMaxSize);
+    LIB_FUNCTION("xegFfZKBVlw", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetSendTimeOut);
+    LIB_FUNCTION("POJ0azHZX3w", "libSceHttp", 1, "libSceHttp", 1, 1,
+                 sceHttpSetSocketCreationCallback);
+    LIB_FUNCTION("7WcNoAI9Zcw", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsFreeCaList);
+    LIB_FUNCTION("gcUjwU3fa0M", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsGetCaList);
+    LIB_FUNCTION("JBN6N-EY+3M", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsGetSslError);
+    LIB_FUNCTION("DK+GoXCNT04", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsLoadCert);
+    LIB_FUNCTION("jUjp+yqMNdQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsSetMinSslVersion);
+    LIB_FUNCTION("htyBOoWeS58", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsSetSslCallback);
+    LIB_FUNCTION("U5ExQGyyx9s", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsSetSslVersion);
+    LIB_FUNCTION("zXqcE0fizz0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsUnloadCert);
+    LIB_FUNCTION("Ik-KpLTlf7Q", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpTerm);
+    LIB_FUNCTION("V-noPEjSB8c", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpTryGetNonblock);
+    LIB_FUNCTION("fmOs6MzCRqk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpTrySetNonblock);
+    LIB_FUNCTION("59tL1AQBb8U", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUnsetEpoll);
+    LIB_FUNCTION("5LZA+KPISVA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriBuild);
+    LIB_FUNCTION("CR-l-yI-o7o", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriCopy);
+    LIB_FUNCTION("YuOW3dDAKYc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriEscape);
+    LIB_FUNCTION("3lgQ5Qk42ok", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriMerge);
+    LIB_FUNCTION("IWalAn-guFs", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriParse);
+    LIB_FUNCTION("mUU363n4yc0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriSweepPath);
+    LIB_FUNCTION("thTS+57zoLM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriUnescape);
+    LIB_FUNCTION("qISjDHrxONc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpWaitRequest);
+};
+
+} // namespace Libraries::Http
--- a/src/core/libraries/libscehttp.h
+++ b/src/core/libraries/libscehttp.h
@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+
+namespace Libraries::Http {
+
+int PS4_SYSV_ABI sceHttpAbortRequest();
+int PS4_SYSV_ABI sceHttpAbortRequestForce();
+int PS4_SYSV_ABI sceHttpAbortWaitRequest();
+int PS4_SYSV_ABI sceHttpAddCookie();
+int PS4_SYSV_ABI sceHttpAddQuery();
+int PS4_SYSV_ABI sceHttpAddRequestHeader();
+int PS4_SYSV_ABI sceHttpAddRequestHeaderRaw();
+int PS4_SYSV_ABI sceHttpAuthCacheExport();
+int PS4_SYSV_ABI sceHttpAuthCacheFlush();
+int PS4_SYSV_ABI sceHttpAuthCacheImport();
+int PS4_SYSV_ABI sceHttpCacheRedirectedConnectionEnabled();
+int PS4_SYSV_ABI sceHttpCookieExport();
+int PS4_SYSV_ABI sceHttpCookieFlush();
+int PS4_SYSV_ABI sceHttpCookieImport();
+int PS4_SYSV_ABI sceHttpCreateConnection();
+int PS4_SYSV_ABI sceHttpCreateConnectionWithURL();
+int PS4_SYSV_ABI sceHttpCreateEpoll();
+int PS4_SYSV_ABI sceHttpCreateRequest();
+int PS4_SYSV_ABI sceHttpCreateRequest2();
+int PS4_SYSV_ABI sceHttpCreateRequestWithURL();
+int PS4_SYSV_ABI sceHttpCreateRequestWithURL2();
+int PS4_SYSV_ABI sceHttpCreateTemplate();
+int PS4_SYSV_ABI sceHttpDbgEnableProfile();
+int PS4_SYSV_ABI sceHttpDbgGetConnectionStat();
+int PS4_SYSV_ABI sceHttpDbgGetRequestStat();
+int PS4_SYSV_ABI sceHttpDbgSetPrintf();
+int PS4_SYSV_ABI sceHttpDbgShowConnectionStat();
+int PS4_SYSV_ABI sceHttpDbgShowMemoryPoolStat();
+int PS4_SYSV_ABI sceHttpDbgShowRequestStat();
+int PS4_SYSV_ABI sceHttpDbgShowStat();
+int PS4_SYSV_ABI sceHttpDeleteConnection();
+int PS4_SYSV_ABI sceHttpDeleteRequest();
+int PS4_SYSV_ABI sceHttpDeleteTemplate();
+int PS4_SYSV_ABI sceHttpDestroyEpoll();
+int PS4_SYSV_ABI sceHttpGetAcceptEncodingGZIPEnabled();
+int PS4_SYSV_ABI sceHttpGetAllResponseHeaders();
+int PS4_SYSV_ABI sceHttpGetAuthEnabled();
+int PS4_SYSV_ABI sceHttpGetAutoRedirect();
+int PS4_SYSV_ABI sceHttpGetConnectionStat();
+int PS4_SYSV_ABI sceHttpGetCookie();
+int PS4_SYSV_ABI sceHttpGetCookieEnabled();
+int PS4_SYSV_ABI sceHttpGetCookieStats();
+int PS4_SYSV_ABI sceHttpGetEpoll();
+int PS4_SYSV_ABI sceHttpGetEpollId();
+int PS4_SYSV_ABI sceHttpGetLastErrno();
+int PS4_SYSV_ABI sceHttpGetMemoryPoolStats();
+int PS4_SYSV_ABI sceHttpGetNonblock();
+int PS4_SYSV_ABI sceHttpGetRegisteredCtxIds();
+int PS4_SYSV_ABI sceHttpGetResponseContentLength();
+int PS4_SYSV_ABI sceHttpGetStatusCode();
+int PS4_SYSV_ABI sceHttpInit(int libnetMemId, int libsslCtxId, std::size_t poolSize);
+int PS4_SYSV_ABI sceHttpParseResponseHeader();
+int PS4_SYSV_ABI sceHttpParseStatusLine();
+int PS4_SYSV_ABI sceHttpReadData();
+int PS4_SYSV_ABI sceHttpRedirectCacheFlush();
+int PS4_SYSV_ABI sceHttpRemoveRequestHeader();
+int PS4_SYSV_ABI sceHttpRequestGetAllHeaders();
+int PS4_SYSV_ABI sceHttpsDisableOption();
+int PS4_SYSV_ABI sceHttpsDisableOptionPrivate();
+int PS4_SYSV_ABI sceHttpsEnableOption();
+int PS4_SYSV_ABI sceHttpsEnableOptionPrivate();
+int PS4_SYSV_ABI sceHttpSendRequest();
+int PS4_SYSV_ABI sceHttpSetAcceptEncodingGZIPEnabled();
+int PS4_SYSV_ABI sceHttpSetAuthEnabled();
+int PS4_SYSV_ABI sceHttpSetAuthInfoCallback();
+int PS4_SYSV_ABI sceHttpSetAutoRedirect();
+int PS4_SYSV_ABI sceHttpSetChunkedTransferEnabled();
+int PS4_SYSV_ABI sceHttpSetConnectTimeOut();
+int PS4_SYSV_ABI sceHttpSetCookieEnabled();
+int PS4_SYSV_ABI sceHttpSetCookieMaxNum();
+int PS4_SYSV_ABI sceHttpSetCookieMaxNumPerDomain();
+int PS4_SYSV_ABI sceHttpSetCookieMaxSize();
+int PS4_SYSV_ABI sceHttpSetCookieRecvCallback();
+int PS4_SYSV_ABI sceHttpSetCookieSendCallback();
+int PS4_SYSV_ABI sceHttpSetCookieTotalMaxSize();
+int PS4_SYSV_ABI sceHttpSetDefaultAcceptEncodingGZIPEnabled();
+int PS4_SYSV_ABI sceHttpSetDelayBuildRequestEnabled();
+int PS4_SYSV_ABI sceHttpSetEpoll();
+int PS4_SYSV_ABI sceHttpSetEpollId();
+int PS4_SYSV_ABI sceHttpSetHttp09Enabled();
+int PS4_SYSV_ABI sceHttpSetInflateGZIPEnabled();
+int PS4_SYSV_ABI sceHttpSetNonblock();
+int PS4_SYSV_ABI sceHttpSetPolicyOption();
+int PS4_SYSV_ABI sceHttpSetPriorityOption();
+int PS4_SYSV_ABI sceHttpSetProxy();
+int PS4_SYSV_ABI sceHttpSetRecvBlockSize();
+int PS4_SYSV_ABI sceHttpSetRecvTimeOut();
+int PS4_SYSV_ABI sceHttpSetRedirectCallback();
+int PS4_SYSV_ABI sceHttpSetRequestContentLength();
+int PS4_SYSV_ABI sceHttpSetRequestStatusCallback();
+int PS4_SYSV_ABI sceHttpSetResolveRetry();
+int PS4_SYSV_ABI sceHttpSetResolveTimeOut();
+int PS4_SYSV_ABI sceHttpSetResponseHeaderMaxSize();
+int PS4_SYSV_ABI sceHttpSetSendTimeOut();
+int PS4_SYSV_ABI sceHttpSetSocketCreationCallback();
+int PS4_SYSV_ABI sceHttpsFreeCaList();
+int PS4_SYSV_ABI sceHttpsGetCaList();
+int PS4_SYSV_ABI sceHttpsGetSslError();
+int PS4_SYSV_ABI sceHttpsLoadCert();
+int PS4_SYSV_ABI sceHttpsSetMinSslVersion();
+int PS4_SYSV_ABI sceHttpsSetSslCallback();
+int PS4_SYSV_ABI sceHttpsSetSslVersion();
+int PS4_SYSV_ABI sceHttpsUnloadCert();
+int PS4_SYSV_ABI sceHttpTerm();
+int PS4_SYSV_ABI sceHttpTryGetNonblock();
+int PS4_SYSV_ABI sceHttpTrySetNonblock();
+int PS4_SYSV_ABI sceHttpUnsetEpoll();
+int PS4_SYSV_ABI sceHttpUriBuild();
+int PS4_SYSV_ABI sceHttpUriCopy();
+int PS4_SYSV_ABI sceHttpUriEscape();
+int PS4_SYSV_ABI sceHttpUriMerge();
+int PS4_SYSV_ABI sceHttpUriParse();
+int PS4_SYSV_ABI sceHttpUriSweepPath();
+int PS4_SYSV_ABI sceHttpUriUnescape();
+int PS4_SYSV_ABI sceHttpWaitRequest();
+
+void RegisterlibSceHttp(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Http
--- a/src/core/libraries/libscenet.cpp
+++ b/src/core/libraries/libscenet.cpp
--- a/src/core/libraries/libscenet.h
+++ b/src/core/libraries/libscenet.h
@ -0,0 +1,231 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+
+namespace Libraries::Net {
+
+int PS4_SYSV_ABI in6addr_any();
+int PS4_SYSV_ABI in6addr_loopback();
+int PS4_SYSV_ABI sce_net_dummy();
+int PS4_SYSV_ABI sce_net_in6addr_any();
+int PS4_SYSV_ABI sce_net_in6addr_linklocal_allnodes();
+int PS4_SYSV_ABI sce_net_in6addr_linklocal_allrouters();
+int PS4_SYSV_ABI sce_net_in6addr_loopback();
+int PS4_SYSV_ABI sce_net_in6addr_nodelocal_allnodes();
+int PS4_SYSV_ABI sceNetAccept();
+int PS4_SYSV_ABI sceNetAddrConfig6GetInfo();
+int PS4_SYSV_ABI sceNetAddrConfig6Start();
+int PS4_SYSV_ABI sceNetAddrConfig6Stop();
+int PS4_SYSV_ABI sceNetAllocateAllRouteInfo();
+int PS4_SYSV_ABI sceNetBandwidthControlGetDataTraffic();
+int PS4_SYSV_ABI sceNetBandwidthControlGetDefaultParam();
+int PS4_SYSV_ABI sceNetBandwidthControlGetIfParam();
+int PS4_SYSV_ABI sceNetBandwidthControlGetPolicy();
+int PS4_SYSV_ABI sceNetBandwidthControlSetDefaultParam();
+int PS4_SYSV_ABI sceNetBandwidthControlSetIfParam();
+int PS4_SYSV_ABI sceNetBandwidthControlSetPolicy();
+int PS4_SYSV_ABI sceNetBind();
+int PS4_SYSV_ABI sceNetClearDnsCache();
+int PS4_SYSV_ABI sceNetConfigAddArp();
+int PS4_SYSV_ABI sceNetConfigAddArpWithInterface();
+int PS4_SYSV_ABI sceNetConfigAddIfaddr();
+int PS4_SYSV_ABI sceNetConfigAddMRoute();
+int PS4_SYSV_ABI sceNetConfigAddRoute();
+int PS4_SYSV_ABI sceNetConfigAddRoute6();
+int PS4_SYSV_ABI sceNetConfigAddRouteWithInterface();
+int PS4_SYSV_ABI sceNetConfigCleanUpAllInterfaces();
+int PS4_SYSV_ABI sceNetConfigDelArp();
+int PS4_SYSV_ABI sceNetConfigDelArpWithInterface();
+int PS4_SYSV_ABI sceNetConfigDelDefaultRoute();
+int PS4_SYSV_ABI sceNetConfigDelDefaultRoute6();
+int PS4_SYSV_ABI sceNetConfigDelIfaddr();
+int PS4_SYSV_ABI sceNetConfigDelIfaddr6();
+int PS4_SYSV_ABI sceNetConfigDelMRoute();
+int PS4_SYSV_ABI sceNetConfigDelRoute();
+int PS4_SYSV_ABI sceNetConfigDelRoute6();
+int PS4_SYSV_ABI sceNetConfigDownInterface();
+int PS4_SYSV_ABI sceNetConfigEtherGetLinkMode();
+int PS4_SYSV_ABI sceNetConfigEtherPostPlugInOutEvent();
+int PS4_SYSV_ABI sceNetConfigEtherSetLinkMode();
+int PS4_SYSV_ABI sceNetConfigFlushRoute();
+int PS4_SYSV_ABI sceNetConfigGetDefaultRoute();
+int PS4_SYSV_ABI sceNetConfigGetDefaultRoute6();
+int PS4_SYSV_ABI sceNetConfigGetIfaddr();
+int PS4_SYSV_ABI sceNetConfigGetIfaddr6();
+int PS4_SYSV_ABI sceNetConfigRoutingShowRoutingConfig();
+int PS4_SYSV_ABI sceNetConfigRoutingShowtCtlVar();
+int PS4_SYSV_ABI sceNetConfigRoutingStart();
+int PS4_SYSV_ABI sceNetConfigRoutingStop();
+int PS4_SYSV_ABI sceNetConfigSetDefaultRoute();
+int PS4_SYSV_ABI sceNetConfigSetDefaultRoute6();
+int PS4_SYSV_ABI sceNetConfigSetDefaultScope();
+int PS4_SYSV_ABI sceNetConfigSetIfaddr();
+int PS4_SYSV_ABI sceNetConfigSetIfaddr6();
+int PS4_SYSV_ABI sceNetConfigSetIfaddr6WithFlags();
+int PS4_SYSV_ABI sceNetConfigSetIfFlags();
+int PS4_SYSV_ABI sceNetConfigSetIfLinkLocalAddr6();
+int PS4_SYSV_ABI sceNetConfigSetIfmtu();
+int PS4_SYSV_ABI sceNetConfigUnsetIfFlags();
+int PS4_SYSV_ABI sceNetConfigUpInterface();
+int PS4_SYSV_ABI sceNetConfigUpInterfaceWithFlags();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocClearWakeOnWlan();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocCreate();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocGetWakeOnWlanInfo();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocJoin();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocLeave();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuClearWakeOnWlan();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuGetWakeOnWlanInfo();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuSetWakeOnWlan();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocScanJoin();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocSetExtInfoElement();
+int PS4_SYSV_ABI sceNetConfigWlanAdhocSetWakeOnWlan();
+int PS4_SYSV_ABI sceNetConfigWlanApStart();
+int PS4_SYSV_ABI sceNetConfigWlanApStop();
+int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanQuery();
+int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStart();
+int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStop();
+int PS4_SYSV_ABI sceNetConfigWlanDiagGetDeviceInfo();
+int PS4_SYSV_ABI sceNetConfigWlanDiagSetAntenna();
+int PS4_SYSV_ABI sceNetConfigWlanDiagSetTxFixedRate();
+int PS4_SYSV_ABI sceNetConfigWlanGetDeviceConfig();
+int PS4_SYSV_ABI sceNetConfigWlanInfraGetRssiInfo();
+int PS4_SYSV_ABI sceNetConfigWlanInfraLeave();
+int PS4_SYSV_ABI sceNetConfigWlanInfraScanJoin();
+int PS4_SYSV_ABI sceNetConfigWlanScan();
+int PS4_SYSV_ABI sceNetConfigWlanSetDeviceConfig();
+int PS4_SYSV_ABI sceNetConnect();
+int PS4_SYSV_ABI sceNetControl();
+int PS4_SYSV_ABI sceNetDhcpdStart();
+int PS4_SYSV_ABI sceNetDhcpdStop();
+int PS4_SYSV_ABI sceNetDhcpGetAutoipInfo();
+int PS4_SYSV_ABI sceNetDhcpGetInfo();
+int PS4_SYSV_ABI sceNetDhcpGetInfoEx();
+int PS4_SYSV_ABI sceNetDhcpStart();
+int PS4_SYSV_ABI sceNetDhcpStop();
+int PS4_SYSV_ABI sceNetDumpAbort();
+int PS4_SYSV_ABI sceNetDumpCreate();
+int PS4_SYSV_ABI sceNetDumpDestroy();
+int PS4_SYSV_ABI sceNetDumpRead();
+int PS4_SYSV_ABI sceNetDuplicateIpStart();
+int PS4_SYSV_ABI sceNetDuplicateIpStop();
+int PS4_SYSV_ABI sceNetEpollAbort();
+int PS4_SYSV_ABI sceNetEpollControl();
+int PS4_SYSV_ABI sceNetEpollCreate();
+int PS4_SYSV_ABI sceNetEpollDestroy();
+int PS4_SYSV_ABI sceNetEpollWait();
+int PS4_SYSV_ABI sceNetErrnoLoc();
+int PS4_SYSV_ABI sceNetEtherNtostr();
+int PS4_SYSV_ABI sceNetEtherStrton();
+int PS4_SYSV_ABI sceNetEventCallbackCreate();
+int PS4_SYSV_ABI sceNetEventCallbackDestroy();
+int PS4_SYSV_ABI sceNetEventCallbackGetError();
+int PS4_SYSV_ABI sceNetEventCallbackWaitCB();
+int PS4_SYSV_ABI sceNetFreeAllRouteInfo();
+int PS4_SYSV_ABI sceNetGetArpInfo();
+int PS4_SYSV_ABI sceNetGetDns6Info();
+int PS4_SYSV_ABI sceNetGetDnsInfo();
+int PS4_SYSV_ABI sceNetGetIfList();
+int PS4_SYSV_ABI sceNetGetIfListOnce();
+int PS4_SYSV_ABI sceNetGetIfName();
+int PS4_SYSV_ABI sceNetGetIfnameNumList();
+int PS4_SYSV_ABI sceNetGetMacAddress();
+int PS4_SYSV_ABI sceNetGetMemoryPoolStats();
+int PS4_SYSV_ABI sceNetGetNameToIndex();
+int PS4_SYSV_ABI sceNetGetpeername();
+int PS4_SYSV_ABI sceNetGetRandom();
+int PS4_SYSV_ABI sceNetGetRouteInfo();
+int PS4_SYSV_ABI sceNetGetSockInfo();
+int PS4_SYSV_ABI sceNetGetSockInfo6();
+int PS4_SYSV_ABI sceNetGetsockname();
+int PS4_SYSV_ABI sceNetGetsockopt();
+int PS4_SYSV_ABI sceNetGetStatisticsInfo();
+int PS4_SYSV_ABI sceNetGetStatisticsInfoInternal();
+int PS4_SYSV_ABI sceNetGetSystemTime();
+int PS4_SYSV_ABI sceNetHtonl();
+int PS4_SYSV_ABI sceNetHtonll();
+int PS4_SYSV_ABI sceNetHtons();
+int PS4_SYSV_ABI sceNetInetNtop();
+int PS4_SYSV_ABI sceNetInetNtopWithScopeId();
+int PS4_SYSV_ABI sceNetInetPton();
+int PS4_SYSV_ABI sceNetInetPtonEx();
+int PS4_SYSV_ABI sceNetInetPtonWithScopeId();
+int PS4_SYSV_ABI sceNetInfoDumpStart();
+int PS4_SYSV_ABI sceNetInfoDumpStop();
+int PS4_SYSV_ABI sceNetInit();
+int PS4_SYSV_ABI sceNetInitParam();
+int PS4_SYSV_ABI sceNetIoctl();
+int PS4_SYSV_ABI sceNetListen();
+int PS4_SYSV_ABI sceNetMemoryAllocate();
+int PS4_SYSV_ABI sceNetMemoryFree();
+int PS4_SYSV_ABI sceNetNtohl();
+int PS4_SYSV_ABI sceNetNtohll();
+int PS4_SYSV_ABI sceNetNtohs();
+int PS4_SYSV_ABI sceNetPoolCreate(const char* name, int size, int flags);
+int PS4_SYSV_ABI sceNetPoolDestroy();
+int PS4_SYSV_ABI sceNetPppoeStart();
+int PS4_SYSV_ABI sceNetPppoeStop();
+int PS4_SYSV_ABI sceNetRecv();
+int PS4_SYSV_ABI sceNetRecvfrom();
+int PS4_SYSV_ABI sceNetRecvmsg();
+int PS4_SYSV_ABI sceNetResolverAbort();
+int PS4_SYSV_ABI sceNetResolverConnect();
+int PS4_SYSV_ABI sceNetResolverConnectAbort();
+int PS4_SYSV_ABI sceNetResolverConnectCreate();
+int PS4_SYSV_ABI sceNetResolverConnectDestroy();
+int PS4_SYSV_ABI sceNetResolverCreate();
+int PS4_SYSV_ABI sceNetResolverDestroy();
+int PS4_SYSV_ABI sceNetResolverGetError();
+int PS4_SYSV_ABI sceNetResolverStartAton();
+int PS4_SYSV_ABI sceNetResolverStartAton6();
+int PS4_SYSV_ABI sceNetResolverStartNtoa();
+int PS4_SYSV_ABI sceNetResolverStartNtoa6();
+int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecords();
+int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecordsEx();
+int PS4_SYSV_ABI sceNetSend();
+int PS4_SYSV_ABI sceNetSendmsg();
+int PS4_SYSV_ABI sceNetSendto();
+int PS4_SYSV_ABI sceNetSetDns6Info();
+int PS4_SYSV_ABI sceNetSetDns6InfoToKernel();
+int PS4_SYSV_ABI sceNetSetDnsInfo();
+int PS4_SYSV_ABI sceNetSetDnsInfoToKernel();
+int PS4_SYSV_ABI sceNetSetsockopt();
+int PS4_SYSV_ABI sceNetShowIfconfig();
+int PS4_SYSV_ABI sceNetShowIfconfigForBuffer();
+int PS4_SYSV_ABI sceNetShowIfconfigWithMemory();
+int PS4_SYSV_ABI sceNetShowNetstat();
+int PS4_SYSV_ABI sceNetShowNetstatEx();
+int PS4_SYSV_ABI sceNetShowNetstatExForBuffer();
+int PS4_SYSV_ABI sceNetShowNetstatForBuffer();
+int PS4_SYSV_ABI sceNetShowNetstatWithMemory();
+int PS4_SYSV_ABI sceNetShowPolicy();
+int PS4_SYSV_ABI sceNetShowPolicyWithMemory();
+int PS4_SYSV_ABI sceNetShowRoute();
+int PS4_SYSV_ABI sceNetShowRoute6();
+int PS4_SYSV_ABI sceNetShowRoute6ForBuffer();
+int PS4_SYSV_ABI sceNetShowRoute6WithMemory();
+int PS4_SYSV_ABI sceNetShowRouteForBuffer();
+int PS4_SYSV_ABI sceNetShowRouteWithMemory();
+int PS4_SYSV_ABI sceNetShutdown();
+int PS4_SYSV_ABI sceNetSocket();
+int PS4_SYSV_ABI sceNetSocketAbort();
+int PS4_SYSV_ABI sceNetSocketClose();
+int PS4_SYSV_ABI sceNetSyncCreate();
+int PS4_SYSV_ABI sceNetSyncDestroy();
+int PS4_SYSV_ABI sceNetSyncGet();
+int PS4_SYSV_ABI sceNetSyncSignal();
+int PS4_SYSV_ABI sceNetSyncWait();
+int PS4_SYSV_ABI sceNetSysctl();
+int PS4_SYSV_ABI sceNetTerm();
+int PS4_SYSV_ABI sceNetThreadCreate();
+int PS4_SYSV_ABI sceNetThreadExit();
+int PS4_SYSV_ABI sceNetThreadJoin();
+int PS4_SYSV_ABI sceNetUsleep();
+int PS4_SYSV_ABI Func_0E707A589F751C68();
+int PS4_SYSV_ABI sceNetEmulationGet();
+int PS4_SYSV_ABI sceNetEmulationSet();
+
+void RegisterlibSceNet(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Net
--- a/src/core/libraries/libscenetctl.cpp
+++ b/src/core/libraries/libscenetctl.cpp
@ -0,0 +1,636 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "common/logging/log.h"
+#include "error_codes.h"
+#include "libscenetctl.h"
+
+namespace Libraries::NetCtl {
+
+int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweClearEventIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweFinishInternetConnectionTestIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweGetInfoIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweRegisterCallbackIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweSetInternetConnectionTestResultIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestBandwidthTestIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetBweUnregisterCallbackIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetInfoV6() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetResultV6() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetStateV6() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlCheckCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlCheckCallbackForLibIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlClearEventForLibIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlClearEventIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlConnectConfIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlConnectIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlConnectWithRetryIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlDisableBandwidthManagementIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlDisconnectIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlEnableBandwidthManagementIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetBandwidthInfoIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetEtherLinkMode() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetIfStat() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetInfo() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetInfoIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetInfoV6IpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetNatInfo() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetNatInfoIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetResult() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetResultIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetResultV6IpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidForSsidListScanIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetScanInfoByBssidIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidListScanIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidScanIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetState() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetState2IpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetStateIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetStateV6IpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlGetWifiType() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlInit() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlIsBandwidthManagementEnabledIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlRegisterCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackForLibIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6IpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlScanIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlSetErrorNotificationEnabledIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlSetStunWithPaddingFlagIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlTerm() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlUnregisterCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForLibIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6IpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlUnsetStunWithPaddingFlagIpcInt() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_D8DCB6973537A3DC() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlClearEventForNpToolkit() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackForNpToolkit() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForNpToolkit() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApCheckCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApClearEvent() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApGetConnectInfo() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApGetInfo() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApGetResult() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApGetState() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApInit() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRegisterCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApStop() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApTerm() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApUnregisterCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApAppInitWpaKey() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApAppInitWpaKeyForQa() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApAppStartWithRetry() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApAppStartWithRetryPid() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRestart() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpCheckCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpClearEvent() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpGetInfo() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpGetResult() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpGetState() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpRegisterCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpStart() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpStartConf() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpStartWithRetry() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpStop() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceNetCtlApRpUnregisterCallback() {
+    LOG_ERROR(Lib_NetCtl, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceNetCtl(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("XtClSOC1xcU", "libSceNetBwe", 1, "libSceNetCtl", 1, 1,
+                 sceNetBweCheckCallbackIpcInt);
+    LIB_FUNCTION("YALqoY4aeY0", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, sceNetBweClearEventIpcInt);
+    LIB_FUNCTION("ouyROWhGUbM", "libSceNetBwe", 1, "libSceNetCtl", 1, 1,
+                 sceNetBweFinishInternetConnectionTestIpcInt);
+    LIB_FUNCTION("G4vltQ0Vs+0", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, sceNetBweGetInfoIpcInt);
+    LIB_FUNCTION("GqETL5+INhU", "libSceNetBwe", 1, "libSceNetCtl", 1, 1,
+                 sceNetBweRegisterCallbackIpcInt);
+    LIB_FUNCTION("mEUt-phGd5E", "libSceNetBwe", 1, "libSceNetCtl", 1, 1,
+                 sceNetBweSetInternetConnectionTestResultIpcInt);
+    LIB_FUNCTION("pQLJV5SEAqk", "libSceNetBwe", 1, "libSceNetCtl", 1, 1,
+                 sceNetBweStartInternetConnectionTestBandwidthTestIpcInt);
+    LIB_FUNCTION("c+aYh130SV0", "libSceNetBwe", 1, "libSceNetCtl", 1, 1,
+                 sceNetBweStartInternetConnectionTestIpcInt);
+    LIB_FUNCTION("0lViPaTB-R8", "libSceNetBwe", 1, "libSceNetCtl", 1, 1,
+                 sceNetBweUnregisterCallbackIpcInt);
+    LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoV6);
+    LIB_FUNCTION("H5yARg37U5g", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResultV6);
+    LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateV6);
+    LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlRegisterCallbackV6);
+    LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnregisterCallbackV6);
+    LIB_FUNCTION("iQw3iQPhvUQ", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlCheckCallback);
+    LIB_FUNCTION("UF6H6+kjyQs", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlCheckCallbackForLibIpcInt);
+    LIB_FUNCTION("vv6g8zoanL4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlClearEventForLibIpcInt);
+    LIB_FUNCTION("8OJ86vFucfo", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlClearEventIpcInt);
+    LIB_FUNCTION("HCD46HVTyQg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlConnectConfIpcInt);
+    LIB_FUNCTION("ID+Gq3Ddzbg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlConnectIpcInt);
+    LIB_FUNCTION("aPpic8K75YA", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlConnectWithRetryIpcInt);
+    LIB_FUNCTION("9y4IcsJdTCc", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlDisableBandwidthManagementIpcInt);
+    LIB_FUNCTION("qOefcpoSs0k", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlDisconnectIpcInt);
+    LIB_FUNCTION("x9bSmRSE+hc", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlEnableBandwidthManagementIpcInt);
+    LIB_FUNCTION("eCUIlA2t5CE", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetBandwidthInfoIpcInt);
+    LIB_FUNCTION("2EfjPXVPk3s", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetEtherLinkMode);
+    LIB_FUNCTION("teuK4QnJTGg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetIfStat);
+    LIB_FUNCTION("obuxdTiwkF8", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfo);
+    LIB_FUNCTION("xstcTqAhTys", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoIpcInt);
+    LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoV6);
+    LIB_FUNCTION("arAQRFlwqaA", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoV6IpcInt);
+    LIB_FUNCTION("JO4yuTuMoKI", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetNatInfo);
+    LIB_FUNCTION("x+cnsAxKSHo", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetNatInfoIpcInt);
+    LIB_FUNCTION("hhTsdv99azU", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetNetEvConfigInfoIpcInt);
+    LIB_FUNCTION("0cBgduPRR+M", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResult);
+    LIB_FUNCTION("NEtnusbZyAs", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResultIpcInt);
+    LIB_FUNCTION("H5yARg37U5g", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResultV6);
+    LIB_FUNCTION("vdsTa93atXY", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetResultV6IpcInt);
+    LIB_FUNCTION("wP0Ab2maR1Y", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetScanInfoBssidForSsidListScanIpcInt);
+    LIB_FUNCTION("Wn-+887Lt2s", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetScanInfoBssidIpcInt);
+    LIB_FUNCTION("FEdkOG1VbQo", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetScanInfoByBssidIpcInt);
+    LIB_FUNCTION("irV8voIAHDw", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetScanInfoForSsidListScanIpcInt);
+    LIB_FUNCTION("L97eAHI0xxs", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlGetScanInfoForSsidScanIpcInt);
+    LIB_FUNCTION("uBPlr0lbuiI", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetState);
+    LIB_FUNCTION("JXlI9EZVjf4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetState2IpcInt);
+    LIB_FUNCTION("gvnJPMkSoAY", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateIpcInt);
+    LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateV6);
+    LIB_FUNCTION("O8Fk4w5MWss", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateV6IpcInt);
+    LIB_FUNCTION("BXW9b3R1Nw4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetWifiType);
+    LIB_FUNCTION("gky0+oaNM4k", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlInit);
+    LIB_FUNCTION("YtAnCkTR0K4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlIsBandwidthManagementEnabledIpcInt);
+    LIB_FUNCTION("UJ+Z7Q+4ck0", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlRegisterCallback);
+    LIB_FUNCTION("WRvDk2syatE", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlRegisterCallbackForLibIpcInt);
+    LIB_FUNCTION("rqkh2kXvLSw", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlRegisterCallbackIpcInt);
+    LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlRegisterCallbackV6);
+    LIB_FUNCTION("ipqlpcIqRsQ", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlRegisterCallbackV6IpcInt);
+    LIB_FUNCTION("reIsHryCDx4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlScanIpcInt);
+    LIB_FUNCTION("LJYiiIS4HB0", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlSetErrorNotificationEnabledIpcInt);
+    LIB_FUNCTION("DjuqqqV08Nk", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlSetStunWithPaddingFlagIpcInt);
+    LIB_FUNCTION("Z4wwCFiBELQ", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlTerm);
+    LIB_FUNCTION("Rqm2OnZMCz0", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnregisterCallback);
+    LIB_FUNCTION("urWaUWkEGZg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnregisterCallbackForLibIpcInt);
+    LIB_FUNCTION("by9cbB7JGJE", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnregisterCallbackIpcInt);
+    LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnregisterCallbackV6);
+    LIB_FUNCTION("Hjxpy28aID8", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnregisterCallbackV6IpcInt);
+    LIB_FUNCTION("1HSvkN9oxO4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnsetStunWithPaddingFlagIpcInt);
+    LIB_FUNCTION("2Ny2lzU3o9w", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, Func_D8DCB6973537A3DC);
+    LIB_FUNCTION("u5oqtlIP+Fw", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlCheckCallbackForNpToolkit);
+    LIB_FUNCTION("saYB0b2ZWtI", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlClearEventForNpToolkit);
+    LIB_FUNCTION("wIsKy+TfeLs", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlRegisterCallbackForNpToolkit);
+    LIB_FUNCTION("2oUqKR5odGc", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlUnregisterCallbackForNpToolkit);
+    LIB_FUNCTION("19Ec7WkMFfQ", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApCheckCallback);
+    LIB_FUNCTION("meFMaDpdsVI", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApClearEvent);
+    LIB_FUNCTION("hfkLVdXmfnU", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApGetConnectInfo);
+    LIB_FUNCTION("LXADzTIzM9I", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApGetInfo);
+    LIB_FUNCTION("4jkLJc954+Q", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApGetResult);
+    LIB_FUNCTION("AKZOzsb9whc", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApGetState);
+    LIB_FUNCTION("FdN+edNRtiw", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApInit);
+    LIB_FUNCTION("pmjobSVHuY0", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRegisterCallback);
+    LIB_FUNCTION("r-pOyN6AhsM", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApStop);
+    LIB_FUNCTION("cv5Y2efOTeg", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApTerm);
+    LIB_FUNCTION("NpTcFtaQ-0E", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApUnregisterCallback);
+    LIB_FUNCTION("R-4a9Yh4tG8", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApAppInitWpaKey);
+    LIB_FUNCTION("5oLJoOVBbGU", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApAppInitWpaKeyForQa);
+    LIB_FUNCTION("YtTwZ3pa4aQ", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApAppStartWithRetry);
+    LIB_FUNCTION("sgWeDrEt24U", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApAppStartWithRetryPid);
+    LIB_FUNCTION("amqSGH8l--s", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRestart);
+    LIB_FUNCTION("DufQZgH5ISc", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpCheckCallback);
+    LIB_FUNCTION("qhZbOi+2qLY", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpClearEvent);
+    LIB_FUNCTION("VQl16Q+qXeY", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpGetInfo);
+    LIB_FUNCTION("3pxwYqHzGcw", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpGetResult);
+    LIB_FUNCTION("LEn8FGztKWc", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpGetState);
+    LIB_FUNCTION("ofGsK+xoAaM", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpRegisterCallback);
+    LIB_FUNCTION("mjFgpqNavHg", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpStart);
+    LIB_FUNCTION("HMvaHoZWsn8", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpStartConf);
+    LIB_FUNCTION("9Dxg7XSlr2s", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpStartWithRetry);
+    LIB_FUNCTION("6uvAl4RlEyk", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, sceNetCtlApRpStop);
+    LIB_FUNCTION("8eyH37Ns8tk", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1,
+                 sceNetCtlApRpUnregisterCallback);
+};
+
+} // namespace Libraries::NetCtl
--- a/src/core/libraries/libscenetctl.h
+++ b/src/core/libraries/libscenetctl.h
@ -0,0 +1,105 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+
+namespace Libraries::NetCtl {
+
+int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt();
+int PS4_SYSV_ABI sceNetBweClearEventIpcInt();
+int PS4_SYSV_ABI sceNetBweFinishInternetConnectionTestIpcInt();
+int PS4_SYSV_ABI sceNetBweGetInfoIpcInt();
+int PS4_SYSV_ABI sceNetBweRegisterCallbackIpcInt();
+int PS4_SYSV_ABI sceNetBweSetInternetConnectionTestResultIpcInt();
+int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestBandwidthTestIpcInt();
+int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestIpcInt();
+int PS4_SYSV_ABI sceNetBweUnregisterCallbackIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetInfoV6();
+int PS4_SYSV_ABI sceNetCtlGetResultV6();
+int PS4_SYSV_ABI sceNetCtlGetStateV6();
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6();
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6();
+int PS4_SYSV_ABI sceNetCtlCheckCallback();
+int PS4_SYSV_ABI sceNetCtlCheckCallbackForLibIpcInt();
+int PS4_SYSV_ABI sceNetCtlClearEventForLibIpcInt();
+int PS4_SYSV_ABI sceNetCtlClearEventIpcInt();
+int PS4_SYSV_ABI sceNetCtlConnectConfIpcInt();
+int PS4_SYSV_ABI sceNetCtlConnectIpcInt();
+int PS4_SYSV_ABI sceNetCtlConnectWithRetryIpcInt();
+int PS4_SYSV_ABI sceNetCtlDisableBandwidthManagementIpcInt();
+int PS4_SYSV_ABI sceNetCtlDisconnectIpcInt();
+int PS4_SYSV_ABI sceNetCtlEnableBandwidthManagementIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetBandwidthInfoIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetEtherLinkMode();
+int PS4_SYSV_ABI sceNetCtlGetIfStat();
+int PS4_SYSV_ABI sceNetCtlGetInfo();
+int PS4_SYSV_ABI sceNetCtlGetInfoIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetInfoV6IpcInt();
+int PS4_SYSV_ABI sceNetCtlGetNatInfo();
+int PS4_SYSV_ABI sceNetCtlGetNatInfoIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetResult();
+int PS4_SYSV_ABI sceNetCtlGetResultIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetResultV6IpcInt();
+int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidForSsidListScanIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetScanInfoByBssidIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidListScanIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidScanIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetState();
+int PS4_SYSV_ABI sceNetCtlGetState2IpcInt();
+int PS4_SYSV_ABI sceNetCtlGetStateIpcInt();
+int PS4_SYSV_ABI sceNetCtlGetStateV6IpcInt();
+int PS4_SYSV_ABI sceNetCtlGetWifiType();
+int PS4_SYSV_ABI sceNetCtlInit();
+int PS4_SYSV_ABI sceNetCtlIsBandwidthManagementEnabledIpcInt();
+int PS4_SYSV_ABI sceNetCtlRegisterCallback();
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackForLibIpcInt();
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackIpcInt();
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6IpcInt();
+int PS4_SYSV_ABI sceNetCtlScanIpcInt();
+int PS4_SYSV_ABI sceNetCtlSetErrorNotificationEnabledIpcInt();
+int PS4_SYSV_ABI sceNetCtlSetStunWithPaddingFlagIpcInt();
+int PS4_SYSV_ABI sceNetCtlTerm();
+int PS4_SYSV_ABI sceNetCtlUnregisterCallback();
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForLibIpcInt();
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackIpcInt();
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6IpcInt();
+int PS4_SYSV_ABI sceNetCtlUnsetStunWithPaddingFlagIpcInt();
+int PS4_SYSV_ABI Func_D8DCB6973537A3DC();
+int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit();
+int PS4_SYSV_ABI sceNetCtlClearEventForNpToolkit();
+int PS4_SYSV_ABI sceNetCtlRegisterCallbackForNpToolkit();
+int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForNpToolkit();
+int PS4_SYSV_ABI sceNetCtlApCheckCallback();
+int PS4_SYSV_ABI sceNetCtlApClearEvent();
+int PS4_SYSV_ABI sceNetCtlApGetConnectInfo();
+int PS4_SYSV_ABI sceNetCtlApGetInfo();
+int PS4_SYSV_ABI sceNetCtlApGetResult();
+int PS4_SYSV_ABI sceNetCtlApGetState();
+int PS4_SYSV_ABI sceNetCtlApInit();
+int PS4_SYSV_ABI sceNetCtlApRegisterCallback();
+int PS4_SYSV_ABI sceNetCtlApStop();
+int PS4_SYSV_ABI sceNetCtlApTerm();
+int PS4_SYSV_ABI sceNetCtlApUnregisterCallback();
+int PS4_SYSV_ABI sceNetCtlApAppInitWpaKey();
+int PS4_SYSV_ABI sceNetCtlApAppInitWpaKeyForQa();
+int PS4_SYSV_ABI sceNetCtlApAppStartWithRetry();
+int PS4_SYSV_ABI sceNetCtlApAppStartWithRetryPid();
+int PS4_SYSV_ABI sceNetCtlApRestart();
+int PS4_SYSV_ABI sceNetCtlApRpCheckCallback();
+int PS4_SYSV_ABI sceNetCtlApRpClearEvent();
+int PS4_SYSV_ABI sceNetCtlApRpGetInfo();
+int PS4_SYSV_ABI sceNetCtlApRpGetResult();
+int PS4_SYSV_ABI sceNetCtlApRpGetState();
+int PS4_SYSV_ABI sceNetCtlApRpRegisterCallback();
+int PS4_SYSV_ABI sceNetCtlApRpStart();
+int PS4_SYSV_ABI sceNetCtlApRpStartConf();
+int PS4_SYSV_ABI sceNetCtlApRpStartWithRetry();
+int PS4_SYSV_ABI sceNetCtlApRpStop();
+int PS4_SYSV_ABI sceNetCtlApRpUnregisterCallback();
+
+void RegisterlibSceNetCtl(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::NetCtl
--- a/src/core/libraries/libsceposix.cpp
+++ b/src/core/libraries/libsceposix.cpp
@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "common/logging/log.h"
+#include "error_codes.h"
+#include "libsceposix.h"
+
+namespace Libraries::Posix {
+
+void Registerlibsceposix(Core::Loader::SymbolsResolver* sym) {}
+
+} // namespace Libraries::Posix
--- a/src/core/libraries/libsceposix.h
+++ b/src/core/libraries/libsceposix.h
@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+
+namespace Libraries::Posix {
+void Registerlibsceposix(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Posix
--- a/src/core/libraries/libscesavedata.cpp
+++ b/src/core/libraries/libscesavedata.cpp
@ -0,0 +1,653 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "common/logging/log.h"
+#include "error_codes.h"
+#include "libscesavedata.h"
+
+namespace Libraries::SaveData {
+
+int PS4_SYSV_ABI sceSaveDataAbort() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataBackup() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataBindPsnAccount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataBindPsnAccountForSystemBackup() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataChangeDatabase() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataChangeInternal() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckBackupData() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckBackupDataForCdlg() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckBackupDataInternal() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckCloudData() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckIpmiIfSize() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckSaveDataBroken() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersion() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersionLatest() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataClearProgress() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCopy5() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataCreateUploadData() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDebug() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDebugCleanMount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDebugCompiledSdkVersion() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDebugCreateSaveDataRoot() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDebugGetThreadId() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDebugRemoveSaveDataRoot() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDebugTarget() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDelete() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDelete5() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDeleteAllUser() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDeleteCloudData() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDeleteUser() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDirNameSearch() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDirNameSearchInternal() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataDownload() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetAllSize() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetAppLaunchedUser() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetAutoUploadConditions() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetAutoUploadRequestInfo() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetAutoUploadSetting() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetBoundPsnAccountCount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetClientThreadPriority() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetCloudQuotaInfo() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetDataBaseFilePath() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetEventInfo() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetEventResult() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetFormat() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetMountedSaveDataCount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetMountInfo() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetParam() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetProgress() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetSaveDataCount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetSaveDataRootDir() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetSaveDataRootPath() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetSaveDataRootUsbPath() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetSavePoint() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataGetUpdatedDataCount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataInitialize() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataInitialize2() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataInitialize3() {
+    LOG_ERROR(Lib_SaveData, "(DUMMY) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataInitializeForCdlg() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataIsDeletingUsbDb() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataIsMounted() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataLoadIcon() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataMount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataMount2() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataMount5() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataMountInternal() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataMountSys() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataPromote5() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataRebuildDatabase() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataRegisterEventCallback() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataRestoreBackupData() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataRestoreBackupDataForCdlg() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataRestoreLoadSaveDataMemory() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSaveIcon() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetAutoUploadSetting() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetEventInfo() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetParam() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetSaveDataLibraryUser() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataShutdownStart() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSupportedFakeBrokenStatus() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSyncCloudList() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataTerminate() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataTransferringMount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataUmount() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataUmountSys() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataUmountWithBackup() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataUnregisterEventCallback() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSaveDataUpload() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_02E4C4D201716422() {
+    LOG_ERROR(Lib_SaveData, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceSaveData(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("dQ2GohUHXzk", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataAbort);
+    LIB_FUNCTION("z1JA8-iJt3k", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataBackup);
+    LIB_FUNCTION("kLJQ3XioYiU", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataBindPsnAccount);
+    LIB_FUNCTION("hHHCPRqA3+g", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataBindPsnAccountForSystemBackup);
+    LIB_FUNCTION("ykwIZfVD08s", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataChangeDatabase);
+    LIB_FUNCTION("G0hFeOdRCUs", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataChangeInternal);
+    LIB_FUNCTION("RQOqDbk3bSU", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckBackupData);
+    LIB_FUNCTION("rYvLW1z2poM", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckBackupDataForCdlg);
+    LIB_FUNCTION("v1TrX+3ZB10", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckBackupDataInternal);
+    LIB_FUNCTION("-eczr5e4dsI", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckCloudData);
+    LIB_FUNCTION("4OPOZxfVkHA", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckIpmiIfSize);
+    LIB_FUNCTION("1i0rfc+mfa8", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckSaveDataBroken);
+    LIB_FUNCTION("p6A1adyQi3E", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckSaveDataVersion);
+    LIB_FUNCTION("S49B+I96kpk", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCheckSaveDataVersionLatest);
+    LIB_FUNCTION("Wz-4JZfeO9g", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataClearProgress);
+    LIB_FUNCTION("YbCO38BOOl4", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataCopy5);
+    LIB_FUNCTION("kbIIP9aXK9A", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataCreateUploadData);
+    LIB_FUNCTION("gW6G4HxBBXA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDebug);
+    LIB_FUNCTION("bYCnxLexU7M", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDebugCleanMount);
+    LIB_FUNCTION("hVDqYB8+jkk", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDebugCompiledSdkVersion);
+    LIB_FUNCTION("K9gXXlrVLNI", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDebugCreateSaveDataRoot);
+    LIB_FUNCTION("5yHFvMwZX2o", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDebugGetThreadId);
+    LIB_FUNCTION("UGTldPVEdB4", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDebugRemoveSaveDataRoot);
+    LIB_FUNCTION("AYBQmnRplrg", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDebugTarget);
+    LIB_FUNCTION("S1GkePI17zQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDelete);
+    LIB_FUNCTION("SQWusLoK8Pw", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDelete5);
+    LIB_FUNCTION("pJrlpCgR8h4", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDeleteAllUser);
+    LIB_FUNCTION("fU43mJUgKcM", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDeleteCloudData);
+    LIB_FUNCTION("uZqc4JpFdeY", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDeleteUser);
+    LIB_FUNCTION("dyIhnXq-0SM", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDirNameSearch);
+    LIB_FUNCTION("xJ5NFWC3m+k", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataDirNameSearchInternal);
+    LIB_FUNCTION("h1nP9EYv3uc", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDownload);
+    LIB_FUNCTION("A1ThglSGUwA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataGetAllSize);
+    LIB_FUNCTION("KuXcrMAQIMQ", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetAppLaunchedUser);
+    LIB_FUNCTION("itZ46iH14Vs", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetAutoUploadConditions);
+    LIB_FUNCTION("PL20kjAXZZ4", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetAutoUploadRequestInfo);
+    LIB_FUNCTION("G12foE0S77E", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetAutoUploadSetting);
+    LIB_FUNCTION("PzDtD6eBXIM", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetBoundPsnAccountCount);
+    LIB_FUNCTION("tu0SDPl+h88", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetClientThreadPriority);
+    LIB_FUNCTION("6lZYZqQPfkY", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetCloudQuotaInfo);
+    LIB_FUNCTION("CWlBd2Ay1M4", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetDataBaseFilePath);
+    LIB_FUNCTION("eBSSNIG6hMk", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetEventInfo);
+    LIB_FUNCTION("j8xKtiFj0SY", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetEventResult);
+    LIB_FUNCTION("UMpxor4AlKQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataGetFormat);
+    LIB_FUNCTION("pc4guaUPVqA", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetMountedSaveDataCount);
+    LIB_FUNCTION("65VH0Qaaz6s", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetMountInfo);
+    LIB_FUNCTION("XgvSuIdnMlw", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataGetParam);
+    LIB_FUNCTION("ANmSWUiyyGQ", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetProgress);
+    LIB_FUNCTION("SN7rTPHS+Cg", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetSaveDataCount);
+    LIB_FUNCTION("7Bt5pBC-Aco", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetSaveDataMemory);
+    LIB_FUNCTION("QwOO7vegnV8", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetSaveDataMemory2);
+    LIB_FUNCTION("+bRDRotfj0Y", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetSaveDataRootDir);
+    LIB_FUNCTION("3luF0xq0DkQ", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetSaveDataRootPath);
+    LIB_FUNCTION("DwAvlQGvf1o", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetSaveDataRootUsbPath);
+    LIB_FUNCTION("kb24-4DLyNo", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetSavePoint);
+    LIB_FUNCTION("OYmnApJ9q+U", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataGetUpdatedDataCount);
+    LIB_FUNCTION("ZkZhskCPXFw", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataInitialize);
+    LIB_FUNCTION("l1NmDeDpNGU", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataInitialize2);
+    LIB_FUNCTION("TywrFKCoLGY", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataInitialize3);
+    LIB_FUNCTION("g9uwUI3BlQ8", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataInitializeForCdlg);
+    LIB_FUNCTION("voAQW45oKuo", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataIsDeletingUsbDb);
+    LIB_FUNCTION("ieP6jP138Qo", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataIsMounted);
+    LIB_FUNCTION("cGjO3wM3V28", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataLoadIcon);
+    LIB_FUNCTION("32HQAQdwM2o", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMount);
+    LIB_FUNCTION("0z45PIH+SNI", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMount2);
+    LIB_FUNCTION("xz0YMi6BfNk", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMount5);
+    LIB_FUNCTION("msCER7Iibm8", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataMountInternal);
+    LIB_FUNCTION("-XYmdxjOqyA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMountSys);
+    LIB_FUNCTION("uNu7j3pL2mQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataPromote5);
+    LIB_FUNCTION("SgIY-XYA2Xg", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataRebuildDatabase);
+    LIB_FUNCTION("hsKd5c21sQc", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataRegisterEventCallback);
+    LIB_FUNCTION("lU9YRFsgwSU", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataRestoreBackupData);
+    LIB_FUNCTION("HuToUt1GQ8w", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataRestoreBackupDataForCdlg);
+    LIB_FUNCTION("aoZKKNjlq3Y", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataRestoreLoadSaveDataMemory);
+    LIB_FUNCTION("c88Yy54Mx0w", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataSaveIcon);
+    LIB_FUNCTION("0VFHv-Fa4w8", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSetAutoUploadSetting);
+    LIB_FUNCTION("52pL2GKkdjA", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSetEventInfo);
+    LIB_FUNCTION("85zul--eGXs", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataSetParam);
+    LIB_FUNCTION("v3vg2+cooYw", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSetSaveDataLibraryUser);
+    LIB_FUNCTION("h3YURzXGSVQ", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSetSaveDataMemory);
+    LIB_FUNCTION("cduy9v4YmT4", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSetSaveDataMemory2);
+    LIB_FUNCTION("v7AAAMo0Lz4", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSetupSaveDataMemory);
+    LIB_FUNCTION("oQySEUfgXRA", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSetupSaveDataMemory2);
+    LIB_FUNCTION("zMgXM79jRhw", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataShutdownStart);
+    LIB_FUNCTION("+orZm32HB1s", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSupportedFakeBrokenStatus);
+    LIB_FUNCTION("LMSQUTxmGVg", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSyncCloudList);
+    LIB_FUNCTION("wiT9jeC7xPw", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataSyncSaveDataMemory);
+    LIB_FUNCTION("yKDy8S5yLA0", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataTerminate);
+    LIB_FUNCTION("WAzWTZm1H+I", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataTransferringMount);
+    LIB_FUNCTION("BMR4F-Uek3E", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataUmount);
+    LIB_FUNCTION("2-8NWLS8QSA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataUmountSys);
+    LIB_FUNCTION("VwadwBBBJ80", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataUmountWithBackup);
+    LIB_FUNCTION("v-AK1AxQhS0", "libSceSaveData", 1, "libSceSaveData", 1, 1,
+                 sceSaveDataUnregisterEventCallback);
+    LIB_FUNCTION("COwz3WBj+5s", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataUpload);
+    LIB_FUNCTION("AuTE0gFxZCI", "libSceSaveData", 1, "libSceSaveData", 1, 1, Func_02E4C4D201716422);
+};
+
+} // namespace Libraries::SaveData
--- a/src/core/libraries/libscesavedata.h
+++ b/src/core/libraries/libscesavedata.h
@ -0,0 +1,107 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+
+namespace Libraries::SaveData {
+
+int PS4_SYSV_ABI sceSaveDataAbort();
+int PS4_SYSV_ABI sceSaveDataBackup();
+int PS4_SYSV_ABI sceSaveDataBindPsnAccount();
+int PS4_SYSV_ABI sceSaveDataBindPsnAccountForSystemBackup();
+int PS4_SYSV_ABI sceSaveDataChangeDatabase();
+int PS4_SYSV_ABI sceSaveDataChangeInternal();
+int PS4_SYSV_ABI sceSaveDataCheckBackupData();
+int PS4_SYSV_ABI sceSaveDataCheckBackupDataForCdlg();
+int PS4_SYSV_ABI sceSaveDataCheckBackupDataInternal();
+int PS4_SYSV_ABI sceSaveDataCheckCloudData();
+int PS4_SYSV_ABI sceSaveDataCheckIpmiIfSize();
+int PS4_SYSV_ABI sceSaveDataCheckSaveDataBroken();
+int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersion();
+int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersionLatest();
+int PS4_SYSV_ABI sceSaveDataClearProgress();
+int PS4_SYSV_ABI sceSaveDataCopy5();
+int PS4_SYSV_ABI sceSaveDataCreateUploadData();
+int PS4_SYSV_ABI sceSaveDataDebug();
+int PS4_SYSV_ABI sceSaveDataDebugCleanMount();
+int PS4_SYSV_ABI sceSaveDataDebugCompiledSdkVersion();
+int PS4_SYSV_ABI sceSaveDataDebugCreateSaveDataRoot();
+int PS4_SYSV_ABI sceSaveDataDebugGetThreadId();
+int PS4_SYSV_ABI sceSaveDataDebugRemoveSaveDataRoot();
+int PS4_SYSV_ABI sceSaveDataDebugTarget();
+int PS4_SYSV_ABI sceSaveDataDelete();
+int PS4_SYSV_ABI sceSaveDataDelete5();
+int PS4_SYSV_ABI sceSaveDataDeleteAllUser();
+int PS4_SYSV_ABI sceSaveDataDeleteCloudData();
+int PS4_SYSV_ABI sceSaveDataDeleteUser();
+int PS4_SYSV_ABI sceSaveDataDirNameSearch();
+int PS4_SYSV_ABI sceSaveDataDirNameSearchInternal();
+int PS4_SYSV_ABI sceSaveDataDownload();
+int PS4_SYSV_ABI sceSaveDataGetAllSize();
+int PS4_SYSV_ABI sceSaveDataGetAppLaunchedUser();
+int PS4_SYSV_ABI sceSaveDataGetAutoUploadConditions();
+int PS4_SYSV_ABI sceSaveDataGetAutoUploadRequestInfo();
+int PS4_SYSV_ABI sceSaveDataGetAutoUploadSetting();
+int PS4_SYSV_ABI sceSaveDataGetBoundPsnAccountCount();
+int PS4_SYSV_ABI sceSaveDataGetClientThreadPriority();
+int PS4_SYSV_ABI sceSaveDataGetCloudQuotaInfo();
+int PS4_SYSV_ABI sceSaveDataGetDataBaseFilePath();
+int PS4_SYSV_ABI sceSaveDataGetEventInfo();
+int PS4_SYSV_ABI sceSaveDataGetEventResult();
+int PS4_SYSV_ABI sceSaveDataGetFormat();
+int PS4_SYSV_ABI sceSaveDataGetMountedSaveDataCount();
+int PS4_SYSV_ABI sceSaveDataGetMountInfo();
+int PS4_SYSV_ABI sceSaveDataGetParam();
+int PS4_SYSV_ABI sceSaveDataGetProgress();
+int PS4_SYSV_ABI sceSaveDataGetSaveDataCount();
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory();
+int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2();
+int PS4_SYSV_ABI sceSaveDataGetSaveDataRootDir();
+int PS4_SYSV_ABI sceSaveDataGetSaveDataRootPath();
+int PS4_SYSV_ABI sceSaveDataGetSaveDataRootUsbPath();
+int PS4_SYSV_ABI sceSaveDataGetSavePoint();
+int PS4_SYSV_ABI sceSaveDataGetUpdatedDataCount();
+int PS4_SYSV_ABI sceSaveDataInitialize();
+int PS4_SYSV_ABI sceSaveDataInitialize2();
+int PS4_SYSV_ABI sceSaveDataInitialize3();
+int PS4_SYSV_ABI sceSaveDataInitializeForCdlg();
+int PS4_SYSV_ABI sceSaveDataIsDeletingUsbDb();
+int PS4_SYSV_ABI sceSaveDataIsMounted();
+int PS4_SYSV_ABI sceSaveDataLoadIcon();
+int PS4_SYSV_ABI sceSaveDataMount();
+int PS4_SYSV_ABI sceSaveDataMount2();
+int PS4_SYSV_ABI sceSaveDataMount5();
+int PS4_SYSV_ABI sceSaveDataMountInternal();
+int PS4_SYSV_ABI sceSaveDataMountSys();
+int PS4_SYSV_ABI sceSaveDataPromote5();
+int PS4_SYSV_ABI sceSaveDataRebuildDatabase();
+int PS4_SYSV_ABI sceSaveDataRegisterEventCallback();
+int PS4_SYSV_ABI sceSaveDataRestoreBackupData();
+int PS4_SYSV_ABI sceSaveDataRestoreBackupDataForCdlg();
+int PS4_SYSV_ABI sceSaveDataRestoreLoadSaveDataMemory();
+int PS4_SYSV_ABI sceSaveDataSaveIcon();
+int PS4_SYSV_ABI sceSaveDataSetAutoUploadSetting();
+int PS4_SYSV_ABI sceSaveDataSetEventInfo();
+int PS4_SYSV_ABI sceSaveDataSetParam();
+int PS4_SYSV_ABI sceSaveDataSetSaveDataLibraryUser();
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory();
+int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2();
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory();
+int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2();
+int PS4_SYSV_ABI sceSaveDataShutdownStart();
+int PS4_SYSV_ABI sceSaveDataSupportedFakeBrokenStatus();
+int PS4_SYSV_ABI sceSaveDataSyncCloudList();
+int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory();
+int PS4_SYSV_ABI sceSaveDataTerminate();
+int PS4_SYSV_ABI sceSaveDataTransferringMount();
+int PS4_SYSV_ABI sceSaveDataUmount();
+int PS4_SYSV_ABI sceSaveDataUmountSys();
+int PS4_SYSV_ABI sceSaveDataUmountWithBackup();
+int PS4_SYSV_ABI sceSaveDataUnregisterEventCallback();
+int PS4_SYSV_ABI sceSaveDataUpload();
+int PS4_SYSV_ABI Func_02E4C4D201716422();
+
+void RegisterlibSceSaveData(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::SaveData
--- a/src/core/libraries/libscessl.cpp
+++ b/src/core/libraries/libscessl.cpp
--- a/src/core/libraries/libscessl.h
+++ b/src/core/libraries/libscessl.h
@ -0,0 +1,220 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+
+namespace Libraries::Ssl {
+
+int PS4_SYSV_ABI CA_MGMT_allocCertDistinguishedName();
+int PS4_SYSV_ABI CA_MGMT_certDistinguishedNameCompare();
+int PS4_SYSV_ABI CA_MGMT_convertKeyBlobToPKCS8Key();
+int PS4_SYSV_ABI CA_MGMT_convertKeyDER();
+int PS4_SYSV_ABI CA_MGMT_convertKeyPEM();
+int PS4_SYSV_ABI CA_MGMT_convertPKCS8KeyToKeyBlob();
+int PS4_SYSV_ABI CA_MGMT_convertProtectedPKCS8KeyToKeyBlob();
+int PS4_SYSV_ABI CA_MGMT_decodeCertificate();
+int PS4_SYSV_ABI CA_MGMT_enumAltName();
+int PS4_SYSV_ABI CA_MGMT_enumCrl();
+int PS4_SYSV_ABI CA_MGMT_extractAllCertDistinguishedName();
+int PS4_SYSV_ABI CA_MGMT_extractBasicConstraint();
+int PS4_SYSV_ABI CA_MGMT_extractCertASN1Name();
+int PS4_SYSV_ABI CA_MGMT_extractCertTimes();
+int PS4_SYSV_ABI CA_MGMT_extractKeyBlobEx();
+int PS4_SYSV_ABI CA_MGMT_extractKeyBlobTypeEx();
+int PS4_SYSV_ABI CA_MGMT_extractPublicKeyInfo();
+int PS4_SYSV_ABI CA_MGMT_extractSerialNum();
+int PS4_SYSV_ABI CA_MGMT_extractSignature();
+int PS4_SYSV_ABI CA_MGMT_free();
+int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedName();
+int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedNameOnStack();
+int PS4_SYSV_ABI CA_MGMT_freeCertificate();
+int PS4_SYSV_ABI CA_MGMT_freeKeyBlob();
+int PS4_SYSV_ABI CA_MGMT_freeSearchDetails();
+int PS4_SYSV_ABI CA_MGMT_getCertSignAlgoType();
+int PS4_SYSV_ABI CA_MGMT_keyBlobToDER();
+int PS4_SYSV_ABI CA_MGMT_keyBlobToPEM();
+int PS4_SYSV_ABI CA_MGMT_makeKeyBlobEx();
+int PS4_SYSV_ABI CA_MGMT_rawVerifyOID();
+int PS4_SYSV_ABI CA_MGMT_reorderChain();
+int PS4_SYSV_ABI CA_MGMT_returnCertificatePrints();
+int PS4_SYSV_ABI CA_MGMT_verifyCertWithKeyBlob();
+int PS4_SYSV_ABI CA_MGMT_verifySignature();
+int PS4_SYSV_ABI CERT_checkCertificateIssuer();
+int PS4_SYSV_ABI CERT_checkCertificateIssuer2();
+int PS4_SYSV_ABI CERT_checkCertificateIssuerSerialNumber();
+int PS4_SYSV_ABI CERT_CompSubjectAltNames();
+int PS4_SYSV_ABI CERT_CompSubjectAltNames2();
+int PS4_SYSV_ABI CERT_CompSubjectAltNamesExact();
+int PS4_SYSV_ABI CERT_CompSubjectCommonName();
+int PS4_SYSV_ABI CERT_CompSubjectCommonName2();
+int PS4_SYSV_ABI CERT_ComputeBufferHash();
+int PS4_SYSV_ABI CERT_decryptRSASignature();
+int PS4_SYSV_ABI CERT_decryptRSASignatureBuffer();
+int PS4_SYSV_ABI CERT_enumerateAltName();
+int PS4_SYSV_ABI CERT_enumerateAltName2();
+int PS4_SYSV_ABI CERT_enumerateCRL();
+int PS4_SYSV_ABI CERT_enumerateCRL2();
+int PS4_SYSV_ABI CERT_enumerateCRLAux();
+int PS4_SYSV_ABI CERT_extractAllDistinguishedNames();
+int PS4_SYSV_ABI CERT_extractDistinguishedNames();
+int PS4_SYSV_ABI CERT_extractDistinguishedNames2();
+int PS4_SYSV_ABI CERT_extractDistinguishedNamesFromName();
+int PS4_SYSV_ABI CERT_extractRSAKey();
+int PS4_SYSV_ABI CERT_extractSerialNum();
+int PS4_SYSV_ABI CERT_extractSerialNum2();
+int PS4_SYSV_ABI CERT_extractValidityTime();
+int PS4_SYSV_ABI CERT_extractValidityTime2();
+int PS4_SYSV_ABI CERT_getCertExtension();
+int PS4_SYSV_ABI CERT_getCertificateExtensions();
+int PS4_SYSV_ABI CERT_getCertificateExtensions2();
+int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber();
+int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber2();
+int PS4_SYSV_ABI CERT_getCertificateKeyUsage();
+int PS4_SYSV_ABI CERT_getCertificateKeyUsage2();
+int PS4_SYSV_ABI CERT_getCertificateSubject();
+int PS4_SYSV_ABI CERT_getCertificateSubject2();
+int PS4_SYSV_ABI CERT_getCertSignAlgoType();
+int PS4_SYSV_ABI CERT_GetCertTime();
+int PS4_SYSV_ABI CERT_getNumberOfChild();
+int PS4_SYSV_ABI CERT_getRSASignatureAlgo();
+int PS4_SYSV_ABI CERT_getSignatureItem();
+int PS4_SYSV_ABI CERT_getSubjectCommonName();
+int PS4_SYSV_ABI CERT_getSubjectCommonName2();
+int PS4_SYSV_ABI CERT_isRootCertificate();
+int PS4_SYSV_ABI CERT_isRootCertificate2();
+int PS4_SYSV_ABI CERT_rawVerifyOID();
+int PS4_SYSV_ABI CERT_rawVerifyOID2();
+int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfo();
+int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfoCert();
+int PS4_SYSV_ABI CERT_STORE_addCertAuthority();
+int PS4_SYSV_ABI CERT_STORE_addIdentity();
+int PS4_SYSV_ABI CERT_STORE_addIdentityNakedKey();
+int PS4_SYSV_ABI CERT_STORE_addIdentityPSK();
+int PS4_SYSV_ABI CERT_STORE_addIdentityWithCertificateChain();
+int PS4_SYSV_ABI CERT_STORE_addTrustPoint();
+int PS4_SYSV_ABI CERT_STORE_createStore();
+int PS4_SYSV_ABI CERT_STORE_findCertBySubject();
+int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeFirst();
+int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeNext();
+int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainFirst();
+int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainNext();
+int PS4_SYSV_ABI CERT_STORE_findPskByIdentity();
+int PS4_SYSV_ABI CERT_STORE_releaseStore();
+int PS4_SYSV_ABI CERT_STORE_traversePskListHead();
+int PS4_SYSV_ABI CERT_STORE_traversePskListNext();
+int PS4_SYSV_ABI CERT_validateCertificate();
+int PS4_SYSV_ABI CERT_validateCertificateWithConf();
+int PS4_SYSV_ABI CERT_VerifyCertificatePolicies();
+int PS4_SYSV_ABI CERT_VerifyCertificatePolicies2();
+int PS4_SYSV_ABI CERT_verifySignature();
+int PS4_SYSV_ABI CERT_VerifyValidityTime();
+int PS4_SYSV_ABI CERT_VerifyValidityTime2();
+int PS4_SYSV_ABI CERT_VerifyValidityTimeWithConf();
+int PS4_SYSV_ABI CRYPTO_initAsymmetricKey();
+int PS4_SYSV_ABI CRYPTO_uninitAsymmetricKey();
+int PS4_SYSV_ABI GC_createInstanceIDs();
+int PS4_SYSV_ABI getCertSigAlgo();
+int PS4_SYSV_ABI MOCANA_freeMocana();
+int PS4_SYSV_ABI MOCANA_initMocana();
+int PS4_SYSV_ABI RSA_verifySignature();
+int PS4_SYSV_ABI sceSslCheckRecvPending();
+int PS4_SYSV_ABI sceSslClose();
+int PS4_SYSV_ABI sceSslConnect();
+int PS4_SYSV_ABI sceSslCreateSslConnection();
+int PS4_SYSV_ABI sceSslDeleteSslConnection();
+int PS4_SYSV_ABI sceSslDisableOption();
+int PS4_SYSV_ABI sceSslDisableOptionInternal();
+int PS4_SYSV_ABI sceSslDisableOptionInternalInsecure();
+int PS4_SYSV_ABI sceSslEnableOption();
+int PS4_SYSV_ABI sceSslEnableOptionInternal();
+int PS4_SYSV_ABI sceSslFreeCaCerts();
+int PS4_SYSV_ABI sceSslFreeCaList();
+int PS4_SYSV_ABI sceSslFreeSslCertName();
+int PS4_SYSV_ABI sceSslGetCaCerts();
+int PS4_SYSV_ABI sceSslGetCaList();
+int PS4_SYSV_ABI sceSslGetIssuerName();
+int PS4_SYSV_ABI sceSslGetMemoryPoolStats();
+int PS4_SYSV_ABI sceSslGetNameEntryCount();
+int PS4_SYSV_ABI sceSslGetNameEntryInfo();
+int PS4_SYSV_ABI sceSslGetNanoSSLModuleId();
+int PS4_SYSV_ABI sceSslGetNotAfter();
+int PS4_SYSV_ABI sceSslGetNotBefore();
+int PS4_SYSV_ABI sceSslGetSerialNumber();
+int PS4_SYSV_ABI sceSslGetSslError();
+int PS4_SYSV_ABI sceSslGetSubjectName();
+int PS4_SYSV_ABI sceSslInit(std::size_t poolSize);
+int PS4_SYSV_ABI sceSslLoadCert();
+int PS4_SYSV_ABI sceSslLoadRootCACert();
+int PS4_SYSV_ABI sceSslRecv();
+int PS4_SYSV_ABI sceSslReuseConnection();
+int PS4_SYSV_ABI sceSslSend();
+int PS4_SYSV_ABI sceSslSetMinSslVersion();
+int PS4_SYSV_ABI sceSslSetSslVersion();
+int PS4_SYSV_ABI sceSslSetVerifyCallback();
+int PS4_SYSV_ABI sceSslShowMemoryStat();
+int PS4_SYSV_ABI sceSslTerm();
+int PS4_SYSV_ABI sceSslUnloadCert();
+int PS4_SYSV_ABI SSL_acceptConnection();
+int PS4_SYSV_ABI SSL_acceptConnectionCommon();
+int PS4_SYSV_ABI SSL_assignCertificateStore();
+int PS4_SYSV_ABI SSL_ASYNC_acceptConnection();
+int PS4_SYSV_ABI SSL_ASYNC_closeConnection();
+int PS4_SYSV_ABI SSL_ASYNC_connect();
+int PS4_SYSV_ABI SSL_ASYNC_connectCommon();
+int PS4_SYSV_ABI SSL_ASYNC_getRecvBuffer();
+int PS4_SYSV_ABI SSL_ASYNC_getSendBuffer();
+int PS4_SYSV_ABI SSL_ASYNC_init();
+int PS4_SYSV_ABI SSL_ASYNC_initServer();
+int PS4_SYSV_ABI SSL_ASYNC_recvMessage();
+int PS4_SYSV_ABI SSL_ASYNC_recvMessage2();
+int PS4_SYSV_ABI SSL_ASYNC_sendMessage();
+int PS4_SYSV_ABI SSL_ASYNC_sendMessagePending();
+int PS4_SYSV_ABI SSL_ASYNC_start();
+int PS4_SYSV_ABI SSL_closeConnection();
+int PS4_SYSV_ABI SSL_connect();
+int PS4_SYSV_ABI SSL_connectWithCfgParam();
+int PS4_SYSV_ABI SSL_enableCiphers();
+int PS4_SYSV_ABI SSL_findConnectionInstance();
+int PS4_SYSV_ABI SSL_getCipherInfo();
+int PS4_SYSV_ABI SSL_getClientRandom();
+int PS4_SYSV_ABI SSL_getClientSessionInfo();
+int PS4_SYSV_ABI SSL_getCookie();
+int PS4_SYSV_ABI SSL_getNextSessionId();
+int PS4_SYSV_ABI SSL_getServerRandom();
+int PS4_SYSV_ABI SSL_getSessionCache();
+int PS4_SYSV_ABI SSL_getSessionFlags();
+int PS4_SYSV_ABI SSL_getSessionInfo();
+int PS4_SYSV_ABI SSL_getSessionStatus();
+int PS4_SYSV_ABI SSL_getSocketId();
+int PS4_SYSV_ABI SSL_getSSLTLSVersion();
+int PS4_SYSV_ABI SSL_init();
+int PS4_SYSV_ABI SSL_initiateRehandshake();
+int PS4_SYSV_ABI SSL_initServerCert();
+int PS4_SYSV_ABI SSL_ioctl();
+int PS4_SYSV_ABI SSL_isSessionSSL();
+int PS4_SYSV_ABI SSL_lockSessionCacheMutex();
+int PS4_SYSV_ABI SSL_lookupAlert();
+int PS4_SYSV_ABI SSL_negotiateConnection();
+int PS4_SYSV_ABI SSL_recv();
+int PS4_SYSV_ABI SSL_recvPending();
+int PS4_SYSV_ABI SSL_releaseTables();
+int PS4_SYSV_ABI SSL_retrieveServerNameList();
+int PS4_SYSV_ABI SSL_rngFun();
+int PS4_SYSV_ABI SSL_send();
+int PS4_SYSV_ABI SSL_sendAlert();
+int PS4_SYSV_ABI SSL_sendPending();
+int PS4_SYSV_ABI SSL_setCookie();
+int PS4_SYSV_ABI SSL_setServerCert();
+int PS4_SYSV_ABI SSL_setServerNameList();
+int PS4_SYSV_ABI SSL_setSessionFlags();
+int PS4_SYSV_ABI SSL_shutdown();
+int PS4_SYSV_ABI SSL_sslSettings();
+int PS4_SYSV_ABI SSL_validateCertParam();
+int PS4_SYSV_ABI VLONG_freeVlongQueue();
+int PS4_SYSV_ABI Func_22E76E60BC0587D7();
+int PS4_SYSV_ABI Func_28F8791A771D39C7();
+
+void RegisterlibSceSsl(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Ssl
--- a/src/core/libraries/libscesysmodule.cpp
+++ b/src/core/libraries/libscesysmodule.cpp
@ -0,0 +1,130 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#define MAGIC_ENUM_RANGE_MIN 0
+#define MAGIC_ENUM_RANGE_MAX 300
+#include <magic_enum.hpp>
+#include "common/logging/log.h"
+#include "error_codes.h"
+#include "libscesysmodule.h"
+
+namespace Libraries::SysModule {
+
+int PS4_SYSV_ABI sceSysmoduleGetModuleHandleInternal() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleGetModuleInfoForUnwind() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleIsCalledFromSysModule() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleIsCameraPreloaded() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleIsLoaded() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleLoadModule(OrbisSysModule id) {
+    auto color_name = magic_enum::enum_name(id);
+    LOG_ERROR(Lib_SysModule, "(DUMMY) called module = {}", magic_enum::enum_name(id));
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleLoadModuleByNameInternal() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleLoadModuleInternal() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleLoadModuleInternalWithArg() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleMapLibcForLibkernel() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmodulePreloadModuleForLibkernel() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleUnloadModule() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleUnloadModuleByNameInternal() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternal() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternalWithArg() {
+    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceSysmodule(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("D8cuU4d72xM", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleGetModuleHandleInternal);
+    LIB_FUNCTION("4fU5yvOkVG4", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleGetModuleInfoForUnwind);
+    LIB_FUNCTION("ctfO7dQ7geg", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleIsCalledFromSysModule);
+    LIB_FUNCTION("no6T3EfiS3E", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleIsCameraPreloaded);
+    LIB_FUNCTION("fMP5NHUOaMk", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleIsLoaded);
+    LIB_FUNCTION("ynFKQ5bfGks", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleIsLoadedInternal);
+    LIB_FUNCTION("g8cM39EUZ6o", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleLoadModule);
+    LIB_FUNCTION("CU8m+Qs+HN4", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleLoadModuleByNameInternal);
+    LIB_FUNCTION("39iV5E1HoCk", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleLoadModuleInternal);
+    LIB_FUNCTION("hHrGoGoNf+s", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleLoadModuleInternalWithArg);
+    LIB_FUNCTION("lZ6RvVl0vo0", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleMapLibcForLibkernel);
+    LIB_FUNCTION("DOO+zuW1lrE", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmodulePreloadModuleForLibkernel);
+    LIB_FUNCTION("eR2bZFAAU0Q", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleUnloadModule);
+    LIB_FUNCTION("vpTHmA6Knvg", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleUnloadModuleByNameInternal);
+    LIB_FUNCTION("vXZhrtJxkGc", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleUnloadModuleInternal);
+    LIB_FUNCTION("aKa6YfBKZs4", "libSceSysmodule", 1, "libSceSysmodule", 1, 1,
+                 sceSysmoduleUnloadModuleInternalWithArg);
+};
+
+} // namespace Libraries::SysModule
--- a/src/core/libraries/libscesysmodule.h
+++ b/src/core/libraries/libscesysmodule.h
@ -0,0 +1,164 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+
+namespace Libraries::SysModule {
+
+enum class OrbisSysModule : u16 {
+    ORBIS_SYSMODULE_INVALID = 0x0000,
+    ORBIS_SYSMODULE_FIBER = 0x0006,            // libSceFiber.sprx
+    ORBIS_SYSMODULE_ULT = 0x0007,              // libSceUlt.sprx
+    ORBIS_SYSMODULE_NGS2 = 0x000B,             // libSceNgs2.sprx
+    ORBIS_SYSMODULE_XML = 0x0017,              // libSceXml.sprx
+    ORBIS_SYSMODULE_NP_UTILITY = 0x0019,       // libSceNpUtility.sprx
+    ORBIS_SYSMODULE_VOICE = 0x001A,            // libSceVoice.sprx
+    ORBIS_SYSMODULE_VOICEQOS = 0x001B,         // libSceVoiceQos.sprx
+    ORBIS_SYSMODULE_NP_MATCHING2 = 0x001C,     // libSceNpMatching2.sprx
+    ORBIS_SYSMODULE_NP_SCORE_RANKING = 0x001E, // libSceNpScoreRanking.sprx
+    ORBIS_SYSMODULE_RUDP = 0x0021,             // libSceRudp.sprx
+    ORBIS_SYSMODULE_NP_TUS = 0x002C,           // libSceNpTus.sprx
+    ORBIS_SYSMODULE_FACE = 0x0038,
+    ORBIS_SYSMODULE_SMART = 0x0039,
+    ORBIS_SYSMODULE_JSON = 0x0080,
+    ORBIS_SYSMODULE_GAME_LIVE_STREAMING = 0x0081, // libSceGameLiveStreaming.sprx
+    ORBIS_SYSMODULE_COMPANION_UTIL = 0x0082,      // libSceCompanionUtil.sprx
+    ORBIS_SYSMODULE_PLAYGO = 0x0083,              // libScePlayGo.sprx
+    ORBIS_SYSMODULE_FONT = 0x0084,                // libSceFont.sprx
+    ORBIS_SYSMODULE_VIDEO_RECORDING = 0x0085,     // libSceVideoRecording.sprx
+    ORBIS_SYSMODULE_S3DCONVERSION = 0x0086,
+    ORBIS_SYSMODULE_AUDIODEC = 0x0088,    // libSceAudiodec.sprx
+    ORBIS_SYSMODULE_JPEG_DEC = 0x008A,    // libSceJpegDec.sprx
+    ORBIS_SYSMODULE_JPEG_ENC = 0x008B,    // libSceJpegEnc.sprx
+    ORBIS_SYSMODULE_PNG_DEC = 0x008C,     // libScePngDec.sprx
+    ORBIS_SYSMODULE_PNG_ENC = 0x008D,     // libScePngEnc.sprx
+    ORBIS_SYSMODULE_VIDEODEC = 0x008E,    // libSceVideodec.sprx
+    ORBIS_SYSMODULE_MOVE = 0x008F,        // libSceMove.sprx
+    ORBIS_SYSMODULE_PAD_TRACKER = 0x0091, // libScePadTracker.sprx
+    ORBIS_SYSMODULE_DEPTH = 0x0092,       // libSceDepth.sprx
+    ORBIS_SYSMODULE_HAND = 0x0093,
+    ORBIS_SYSMODULE_LIBIME = 0x0095,          // libSceIme.sprx
+    ORBIS_SYSMODULE_IME_DIALOG = 0x0096,      // libSceImeDialog.sprx
+    ORBIS_SYSMODULE_NP_PARTY = 0x0097,        // libSceNpParty.sprx
+    ORBIS_SYSMODULE_FONT_FT = 0x0098,         // libSceFontFt.sprx
+    ORBIS_SYSMODULE_FREETYPE_OT = 0x0099,     // libSceFreeTypeOt.sprx
+    ORBIS_SYSMODULE_FREETYPE_OL = 0x009A,     // libSceFreeTypeOl.sprx
+    ORBIS_SYSMODULE_FREETYPE_OPT_OL = 0x009B, // libSceFreeTypeOptOl.sprx
+    ORBIS_SYSMODULE_SCREEN_SHOT = 0x009C,     // libSceScreenShot.sprx
+    ORBIS_SYSMODULE_NP_AUTH = 0x009D,         // libSceNpAuth.sprx
+    ORBIS_SYSMODULE_SULPHA = 0x009F,
+    ORBIS_SYSMODULE_SAVE_DATA_DIALOG = 0x00A0,  // libSceSaveDataDialog.sprx
+    ORBIS_SYSMODULE_INVITATION_DIALOG = 0x00A2, // libSceInvitationDialog.sprx
+    ORBIS_SYSMODULE_DEBUG_KEYBOARD = 0x00A3,
+    ORBIS_SYSMODULE_MESSAGE_DIALOG = 0x00A4,          // libSceMsgDialog.sprx
+    ORBIS_SYSMODULE_AV_PLAYER = 0x00A5,               // libSceAvPlayer.sprx
+    ORBIS_SYSMODULE_CONTENT_EXPORT = 0x00A6,          // libSceContentExport.sprx
+    ORBIS_SYSMODULE_AUDIO_3D = 0x00A7,                // libSceAudio3d.sprx
+    ORBIS_SYSMODULE_NP_COMMERCE = 0x00A8,             // libSceNpCommerce.sprx
+    ORBIS_SYSMODULE_MOUSE = 0x00A9,                   // libSceMouse.sprx
+    ORBIS_SYSMODULE_COMPANION_HTTPD = 0x00AA,         // libSceCompanionHttpd.sprx
+    ORBIS_SYSMODULE_WEB_BROWSER_DIALOG = 0x00AB,      // libSceWebBrowserDialog.sprx
+    ORBIS_SYSMODULE_ERROR_DIALOG = 0x00AC,            // libSceErrorDialog.sprx
+    ORBIS_SYSMODULE_NP_TROPHY = 0x00AD,               // libSceNpTrophy.sprx
+    ORBIS_SYSMODULE_VIDEO_CORE_IF = 0x00AE,           // libSceVideoCoreInterface.sprx
+    ORBIS_SYSMODULE_VIDEO_CORE_SERVER_IF = 0x00AF,    // libSceVideoCoreServerInterface.sprx
+    ORBIS_SYSMODULE_NP_SNS_FACEBOOK = 0x00B0,         // libSceNpSnsFacebookDialog.sprx
+    ORBIS_SYSMODULE_MOVE_TRACKER = 0x00B1,            // libSceMoveTracker.sprx
+    ORBIS_SYSMODULE_NP_PROFILE_DIALOG = 0x00B2,       // libSceNpProfileDialog.sprx
+    ORBIS_SYSMODULE_NP_FRIEND_LIST_DIALOG = 0x00B3,   // libSceNpFriendListDialog.sprx
+    ORBIS_SYSMODULE_APP_CONTENT = 0x00B4,             // libSceAppContent.sprx
+    ORBIS_SYSMODULE_NP_SIGNALING = 0x00B5,            // libSceNpSignaling.sprx
+    ORBIS_SYSMODULE_REMOTE_PLAY = 0x00B6,             // libSceRemoteplay.sprx
+    ORBIS_SYSMODULE_USBD = 0x00B7,                    // libSceUsbd.sprx
+    ORBIS_SYSMODULE_GAME_CUSTOM_DATA_DIALOG = 0x00B8, // libSceGameCustomDataDialog.sprx
+    ORBIS_SYSMODULE_NP_EULA_DIALOG = 0x00B9,          // libSceNpEulaDialog.sprx
+    ORBIS_SYSMODULE_RANDOM = 0x00BA,                  // libSceRandom.sprx
+    ORBIS_SYSMODULE_RESERVED2 = 0x00BB,
+    ORBIS_SYSMODULE_M4AAC_ENC = 0x00BC,                  // libSceM4aacEnc.sprx
+    ORBIS_SYSMODULE_AUDIODEC_CPU = 0x00BD,               // libSceAudiodecCpu.sprx
+    ORBIS_SYSMODULE_AUDIODEC_CPU_DDP = 0x00BE,           // libSceAudiodecCpuDdp.sprx
+    ORBIS_SYSMODULE_AUDIODEC_CPU_M4AAC = 0x00C0,         // libSceAudiodecCpuM4aac.sprx
+    ORBIS_SYSMODULE_BEMP2_SYS = 0x00C1,                  // libSceBemp2sys.sprx
+    ORBIS_SYSMODULE_BEISOBMF = 0x00C2,                   // libSceBeisobmf.sprx
+    ORBIS_SYSMODULE_PLAY_READY = 0x00C3,                 // libScePlayReady.sprx
+    ORBIS_SYSMODULE_VIDEO_NATIVE_EXT_ESSENTIAL = 0x00C4, // libSceVideoNativeExtEssential.sprx
+    ORBIS_SYSMODULE_ZLIB = 0x00C5,                       // libSceZlib.sprx
+    ORBIS_SYSMODULE_DTCP_IP = 0x00C6,                    // libSceDtcpIp.sprx
+    ORBIS_SYSMODULE_CONTENT_SEARCH = 0x00C7,             // libSceContentSearch.sprx
+    ORBIS_SYSMODULE_SHARE_UTILITY = 0x00C8,              // libSceShareUtility.sprx
+    ORBIS_SYSMODULE_AUDIODEC_CPU_DTS_HD_LBR = 0x00C9,    // libSceAudiodecCpuDtsHdLbr.sprx
+    ORBIS_SYSMODULE_DECI4H = 0x00CA,
+    ORBIS_SYSMODULE_HEAD_TRACKER = 0x00CB,
+    ORBIS_SYSMODULE_GAME_UPDATE = 0x00CC,         // libSceGameUpdate.sprx
+    ORBIS_SYSMODULE_AUTO_MOUNTER_CLIENT = 0x00CD, // libSceAutoMounterClient.sprx
+    ORBIS_SYSMODULE_SYSTEM_GESTURE = 0x00CE,      // libSceSystemGesture.sprx
+    ORBIS_SYSMODULE_VIDEODEC2 = 0x00CF,
+    ORBIS_SYSMODULE_VDECWRAP = 0x00D0,           // libSceVdecwrap.sprx
+    ORBIS_SYSMODULE_AT9_ENC = 0x00D1,            // libSceAt9Enc.sprx
+    ORBIS_SYSMODULE_CONVERT_KEYCODE = 0x00D2,    // libSceConvertKeycode.sprx
+    ORBIS_SYSMODULE_SHARE_PLAY = 0x00D3,         // libSceSharePlay.sprx
+    ORBIS_SYSMODULE_HMD = 0x00D4,                // libSceHmd.sprx
+    ORBIS_SYSMODULE_USB_STORAGE = 0x00D5,        // libSceUsbStorage.sprx
+    ORBIS_SYSMODULE_USB_STORAGE_DIALOG = 0x00D6, // libSceUsbStorageDialog.sprx
+    ORBIS_SYSMODULE_DISC_MAP = 0x00D7,           // libSceDiscMap.sprx
+    ORBIS_SYSMODULE_FACE_TRACKER = 0x00D8,
+    ORBIS_SYSMODULE_HAND_TRACKER = 0x00D9,
+    ORBIS_SYSMODULE_NP_SNS_YOUTUBE_DIALOG = 0x00DA,     // libSceNpSnsYouTubeDialog.sprx
+    ORBIS_SYSMODULE_PROFILE_CACHE_EXTERNAL = 0x00DC,    // libSceProfileCacheExternal.sprx
+    ORBIS_SYSMODULE_MUSIC_PLAYER_SERVICE = 0x00DD,      // libSceMusicPlayerService.sprx
+    ORBIS_SYSMODULE_SP_SYS_CALL_WRAPPER = 0x00DE,       // libSceSpSysCallWrapper.sprx
+    ORBIS_SYSMODULE_PS2_EMU_MENU_DIALOG = 0x00DF,       // libScePs2EmuMenuDialog.sprx
+    ORBIS_SYSMODULE_NP_SNS_DIALYMOTION_DIALOG = 0x00E0, // libSceNpSnsDailyMotionDialog.sprx
+    ORBIS_SYSMODULE_AUDIODEC_CPU_HEVAG = 0x00E1,        // libSceAudiodecCpuHevag.sprx
+    ORBIS_SYSMODULE_LOGIN_DIALOG = 0x00E2,              // libSceLoginDialog.sprx
+    ORBIS_SYSMODULE_LOGIN_SERVICE = 0x00E3,             // libSceLoginService.sprx
+    ORBIS_SYSMODULE_SIGNIN_DIALOG = 0x00E4,             // libSceSigninDialog.sprx
+    ORBIS_SYSMODULE_VDECSW = 0x00E5,                    // libSceVdecsw.sprx
+    ORBIS_SYSMODULE_CUSTOM_MUSIC_CORE = 0x00E6,         // libSceCustomMusicCore.sprx
+    ORBIS_SYSMODULE_JSON2 = 0x00E7,                     // libSceJson2.sprx
+    ORBIS_SYSMODULE_AUDIO_LATENCY_ESTIMATION = 0x00E8,
+    ORBIS_SYSMODULE_WK_FONT_CONFIG = 0x00E9, // libSceWkFontConfig.sprx
+    ORBIS_SYSMODULE_RESERVED27 = 0x00EA,
+    ORBIS_SYSMODULE_HMD_SETUP_DIALOG = 0x00EB, // libSceHmdSetupDialog.sprx
+    ORBIS_SYSMODULE_RESERVED28 = 0x00EC,
+    ORBIS_SYSMODULE_VR_TRACKER = 0x00ED,        // libSceVrTracker.sprx
+    ORBIS_SYSMODULE_CONTENT_DELETE = 0x00EE,    // libSceContentDelete.sprx
+    ORBIS_SYSMODULE_IME_BACKEND = 0x00EF,       // libSceImeBackend.sprx
+    ORBIS_SYSMODULE_NET_CTL_AP_DIALOG = 0x00F0, // libSceNetCtlApDialog.sprx
+    ORBIS_SYSMODULE_PLAYGO_DIALOG = 0x00F1,     // libScePlayGoDialog.sprx
+    ORBIS_SYSMODULE_SOCIAL_SCREEN = 0x00F2,     // libSceSocialScreen.sprx
+    ORBIS_SYSMODULE_EDIT_MP4 = 0x00F3,          // libSceEditMp4.sprx
+    ORBIS_SYSMODULE_PSM_KIT_SYSTEM = 0x00F5,    // libScePsmKitSystem.sprx
+    ORBIS_SYSMODULE_TEXT_TO_SPEECH = 0x00F6,    // libSceTextToSpeech.sprx
+    ORBIS_SYSMODULE_NP_TOOLKIT = 0x00F7,
+    ORBIS_SYSMODULE_CUSTOM_MUSIC_SERVICE = 0x00F8,      // libSceCustomMusicService.sprx
+    ORBIS_SYSMODULE_CL_SYS_CALL_WRAPPER = 0x00F9,       // libSceClSysCallWrapper.sprx
+    ORBIS_SYSMODULE_SYSTEM_LOGGER = 0x00FA,             // libSceSystemLogger.sprx
+    ORBIS_SYSMODULE_BLUETOOTH_HID = 0x00FB,             // libSceBluetoothHid.sprx
+    ORBIS_SYSMODULE_VIDEO_DECODER_ARBITRATION = 0x00FC, // libSceVideoDecoderArbitration.sprx
+    ORBIS_SYSMODULE_VR_SERVICE_DIALOG = 0x00FD,         // libSceVrServiceDialog.sprx
+    ORBIS_SYSMODULE_JOB_MANAGER = 0x00FE,
+    ORBIS_SYSMODULE_KEYBOARD = 0x0106,
+};
+
+int PS4_SYSV_ABI sceSysmoduleGetModuleHandleInternal();
+int PS4_SYSV_ABI sceSysmoduleGetModuleInfoForUnwind();
+int PS4_SYSV_ABI sceSysmoduleIsCalledFromSysModule();
+int PS4_SYSV_ABI sceSysmoduleIsCameraPreloaded();
+int PS4_SYSV_ABI sceSysmoduleIsLoaded();
+int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal();
+int PS4_SYSV_ABI sceSysmoduleLoadModule(OrbisSysModule id);
+int PS4_SYSV_ABI sceSysmoduleLoadModuleByNameInternal();
+int PS4_SYSV_ABI sceSysmoduleLoadModuleInternal();
+int PS4_SYSV_ABI sceSysmoduleLoadModuleInternalWithArg();
+int PS4_SYSV_ABI sceSysmoduleMapLibcForLibkernel();
+int PS4_SYSV_ABI sceSysmodulePreloadModuleForLibkernel();
+int PS4_SYSV_ABI sceSysmoduleUnloadModule();
+int PS4_SYSV_ABI sceSysmoduleUnloadModuleByNameInternal();
+int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternal();
+int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternalWithArg();
+
+void RegisterlibSceSysmodule(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::SysModule