diff --git a/rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp b/rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp
index 1afa85a9cc..e798df5f48 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp
@@ -1,9 +1,213 @@
-#include "stdafx.h"
+#include "stdafx.h"
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceNpCommon.h"
+
 extern psv_log_base sceNpBasic;
 
+enum SceNpBasicFriendListEventType : s32
+{
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_ADDED = 3,
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_DELETED = 4
+};
+
+typedef vm::psv::ptr<void(SceNpBasicFriendListEventType eventType, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<void> userdata)> SceNpBasicFriendListEventHandler;
+
+enum SceNpBasicFriendOnlineStatusEventType : s32
+{
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_UPDATED = 3
+};
+
+enum SceNpBasicFriendOnlineStatus : s32
+{
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_UNKNOWN = 0,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_OFFLINE = 1,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_STANDBY = 2,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_OUT_OF_CONTEXT = 3,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_IN_CONTEXT = 4
+};
+
+typedef vm::psv::ptr<void(SceNpBasicFriendOnlineStatusEventType eventType, vm::psv::ptr<const SceNpId> friendId, SceNpBasicFriendOnlineStatus status, vm::psv::ptr<void> userdata)> SceNpBasicFriendOnlineStatusEventHandler;
+
+enum SceNpBasicBlockListEventType : s32
+{
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_ADDED = 3,
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_DELETED = 4
+};
+
+typedef vm::psv::ptr<void(SceNpBasicBlockListEventType eventType, vm::psv::ptr<const SceNpId> playerId, vm::psv::ptr<void> userdata)> SceNpBasicBlockListEventHandler;
+
+enum SceNpBasicFriendGamePresenceEventType : s32
+{
+	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_UPDATED = 3
+};
+
+enum SceNpBasicInGamePresenceType
+{
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_UNKNOWN = -1,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_NONE = 0,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_DEFAULT = 1,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_JOINABLE = 2,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_MAX = 3
+};
+
+struct SceNpBasicInGamePresence
+{
+	u32 sdkVersion;
+	SceNpBasicInGamePresenceType type;
+	char status[192];
+	u8 data[128];
+	u32 dataSize;
+};
+
+struct SceNpBasicGamePresence
+{
+	u32 size;
+	char title[128];
+	SceNpBasicInGamePresence inGamePresence;
+};
+
+typedef vm::psv::ptr<void(SceNpBasicFriendGamePresenceEventType eventtype, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<const SceNpBasicGamePresence> presence, vm::psv::ptr<void> userdata)> SceNpBasicFriendGamePresenceEventHandler;
+
+struct SceNpBasicInGameDataMessage
+{
+	u8 data[128];
+	u32 dataSize;
+};
+
+typedef vm::psv::ptr<void(vm::psv::ptr<const SceNpId> from, vm::psv::ptr<const SceNpBasicInGameDataMessage> message, vm::psv::ptr<void> userdata)> SceNpBasicInGameDataMessageEventHandler;
+
+struct SceNpBasicEventHandlers
+{
+	u32 sdkVersion;
+	SceNpBasicFriendListEventHandler friendListEventHandler;
+	SceNpBasicFriendOnlineStatusEventHandler friendOnlineStatusEventHandler;
+	SceNpBasicBlockListEventHandler blockListEventHandler;
+	SceNpBasicFriendGamePresenceEventHandler friendGamePresenceEventHandler;
+	SceNpBasicInGameDataMessageEventHandler inGameDataMessageEventHandler;
+};
+
+struct SceNpBasicPlaySessionLogDescription
+{
+	char text[512];
+};
+
+struct SceNpBasicPlaySessionLog
+{
+	u64 date;
+	SceNpId withWhom;
+	SceNpCommunicationId commId;
+	char title[128];
+	SceNpBasicPlaySessionLogDescription description;
+};
+
+enum SceNpBasicPlaySessionLogType : s32
+{
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_INVALID = -1,
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_ALL = 0,
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_BY_NP_COMM_ID = 1,
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_MAX = 2
+};
+
+s32 sceNpBasicInit(vm::psv::ptr<void> opt)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicTerm(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicRegisterHandler(vm::psv::ptr<const SceNpBasicEventHandlers> handlers, vm::psv::ptr<const SceNpCommunicationId> context, vm::psv::ptr<void> userdata)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicUnregisterHandler(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicCheckCallback()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetFriendOnlineStatus(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicFriendOnlineStatus> status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetGamePresenceOfFriend(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicGamePresence> presence)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetFriendListEntryCount(vm::psv::ptr<u32> count)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetBlockListEntryCount(vm::psv::ptr<u32> count)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicCheckIfPlayerIsBlocked(vm::psv::ptr<const SceNpId> player, vm::psv::ptr<u8> playerIsBlocked)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicSetInGamePresence(vm::psv::ptr<const SceNpBasicInGamePresence> presence)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicUnsetInGamePresence()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicSendInGameDataMessage(vm::psv::ptr<const SceNpId> to, vm::psv::ptr<const SceNpBasicInGameDataMessage> message)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicRecordPlaySessionLog(vm::psv::ptr<const SceNpId> withWhom, vm::psv::ptr<const SceNpBasicPlaySessionLogDescription> description)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::psv::ptr<u32> size)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::psv::ptr<SceNpBasicPlaySessionLog> log)
+{
+	throw __FUNCTION__;
+}
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpBasic, #name, name)
 
 psv_log_base sceNpBasic("SceNpBasic", []()
@@ -12,22 +216,22 @@ psv_log_base sceNpBasic("SceNpBasic", []()
 	sceNpBasic.on_unload = nullptr;
 	sceNpBasic.on_stop = nullptr;
 
-	//REG_FUNC(0xEFB91A99, sceNpBasicInit);
-	//REG_FUNC(0x389BCB3B, sceNpBasicTerm);
-	//REG_FUNC(0x26E6E048, sceNpBasicRegisterHandler);
-	//REG_FUNC(0x050AE072, sceNpBasicUnregisterHandler);
-	//REG_FUNC(0x20146AEC, sceNpBasicCheckCallback);
-	//REG_FUNC(0x5183A4B5, sceNpBasicGetFriendOnlineStatus);
-	//REG_FUNC(0xEF8A91BC, sceNpBasicGetGamePresenceOfFriend);
-	//REG_FUNC(0xDF41F308, sceNpBasicGetFriendListEntryCount);
-	//REG_FUNC(0xFF07E787, sceNpBasicGetFriendListEntries);
-	//REG_FUNC(0x407E1E6F, sceNpBasicGetBlockListEntryCount);
-	//REG_FUNC(0x1211AE8E, sceNpBasicGetBlockListEntries);
-	//REG_FUNC(0xF51545D8, sceNpBasicCheckIfPlayerIsBlocked);
-	//REG_FUNC(0x51D75562, sceNpBasicSetInGamePresence);
-	//REG_FUNC(0xD20C2370, sceNpBasicUnsetInGamePresence);
-	//REG_FUNC(0x7A5020A5, sceNpBasicSendInGameDataMessage);
-	//REG_FUNC(0x3B0A7F47, sceNpBasicRecordPlaySessionLog);
-	//REG_FUNC(0xFB0F7FDF, sceNpBasicGetPlaySessionLogSize);
-	//REG_FUNC(0x364531A8, sceNpBasicGetPlaySessionLog);
+	REG_FUNC(0xEFB91A99, sceNpBasicInit);
+	REG_FUNC(0x389BCB3B, sceNpBasicTerm);
+	REG_FUNC(0x26E6E048, sceNpBasicRegisterHandler);
+	REG_FUNC(0x050AE072, sceNpBasicUnregisterHandler);
+	REG_FUNC(0x20146AEC, sceNpBasicCheckCallback);
+	REG_FUNC(0x5183A4B5, sceNpBasicGetFriendOnlineStatus);
+	REG_FUNC(0xEF8A91BC, sceNpBasicGetGamePresenceOfFriend);
+	REG_FUNC(0xDF41F308, sceNpBasicGetFriendListEntryCount);
+	REG_FUNC(0xFF07E787, sceNpBasicGetFriendListEntries);
+	REG_FUNC(0x407E1E6F, sceNpBasicGetBlockListEntryCount);
+	REG_FUNC(0x1211AE8E, sceNpBasicGetBlockListEntries);
+	REG_FUNC(0xF51545D8, sceNpBasicCheckIfPlayerIsBlocked);
+	REG_FUNC(0x51D75562, sceNpBasicSetInGamePresence);
+	REG_FUNC(0xD20C2370, sceNpBasicUnsetInGamePresence);
+	REG_FUNC(0x7A5020A5, sceNpBasicSendInGameDataMessage);
+	REG_FUNC(0x3B0A7F47, sceNpBasicRecordPlaySessionLog);
+	REG_FUNC(0xFB0F7FDF, sceNpBasicGetPlaySessionLogSize);
+	REG_FUNC(0x364531A8, sceNpBasicGetPlaySessionLog);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp b/rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp
index 4422bee950..095de28b17 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp
@@ -2,7 +2,62 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceNpCommon;
+#include "sceNpCommon.h"
+
+s32 sceNpAuthInit()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthCreateStartRequest(vm::psv::ptr<const SceNpAuthRequestParameter> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthDestroyRequest(SceNpAuthRequestId id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthAbortRequest(SceNpAuthRequestId id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthGetTicket(SceNpAuthRequestId id, vm::psv::ptr<void> buf, u32 len)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthGetTicketParam(vm::psv::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::psv::ptr<SceNpTicketParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthGetEntitlementIdList(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthGetEntitlementById(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<const char> entId, vm::psv::ptr<SceNpEntitlement> ent)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpCmpNpId(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpCmpNpIdInOrder(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2, vm::psv::ptr<s32> order)
+{
+	throw __FUNCTION__;
+}
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpCommon, #name, name)
 
@@ -12,15 +67,15 @@ psv_log_base sceNpCommon("SceNpCommon", []()
 	sceNpCommon.on_unload = nullptr;
 	sceNpCommon.on_stop = nullptr;
 
-	//REG_FUNC(0x441D8B4E, sceNpAuthInit);
-	//REG_FUNC(0x6093B689, sceNpAuthTerm);
-	//REG_FUNC(0xED42079F, sceNpAuthCreateStartRequest);
-	//REG_FUNC(0x14FC18AF, sceNpAuthDestroyRequest);
-	//REG_FUNC(0xE2582575, sceNpAuthAbortRequest);
-	//REG_FUNC(0x59608D1C, sceNpAuthGetTicket);
-	//REG_FUNC(0xC1E23E01, sceNpAuthGetTicketParam);
-	//REG_FUNC(0x3377CD37, sceNpAuthGetEntitlementIdList);
-	//REG_FUNC(0xF93842F0, sceNpAuthGetEntitlementById);
-	//REG_FUNC(0xFB8D82E5, sceNpCmpNpId);
-	//REG_FUNC(0x6BC8150A, sceNpCmpNpIdInOrder);
+	REG_FUNC(0x441D8B4E, sceNpAuthInit);
+	REG_FUNC(0x6093B689, sceNpAuthTerm);
+	REG_FUNC(0xED42079F, sceNpAuthCreateStartRequest);
+	REG_FUNC(0x14FC18AF, sceNpAuthDestroyRequest);
+	REG_FUNC(0xE2582575, sceNpAuthAbortRequest);
+	REG_FUNC(0x59608D1C, sceNpAuthGetTicket);
+	REG_FUNC(0xC1E23E01, sceNpAuthGetTicketParam);
+	REG_FUNC(0x3377CD37, sceNpAuthGetEntitlementIdList);
+	REG_FUNC(0xF93842F0, sceNpAuthGetEntitlementById);
+	REG_FUNC(0xFB8D82E5, sceNpCmpNpId);
+	REG_FUNC(0x6BC8150A, sceNpCmpNpIdInOrder);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceNpCommon.h b/rpcs3/Emu/ARMv7/Modules/sceNpCommon.h
new file mode 100644
index 0000000000..2a40b7aee3
--- /dev/null
+++ b/rpcs3/Emu/ARMv7/Modules/sceNpCommon.h
@@ -0,0 +1,154 @@
+#pragma once
+
+enum SceNpServiceState : s32
+{
+	SCE_NP_SERVICE_STATE_UNKNOWN = 0,
+	SCE_NP_SERVICE_STATE_SIGNED_OUT,
+	SCE_NP_SERVICE_STATE_SIGNED_IN,
+	SCE_NP_SERVICE_STATE_ONLINE
+};
+
+struct SceNpCommunicationId
+{
+	char data[9];
+	char term;
+	u8 num;
+	char dummy;
+};
+
+struct SceNpCommunicationPassphrase
+{
+	u8 data[128];
+};
+
+struct SceNpCommunicationSignature
+{
+	u8 data[160];
+};
+
+struct SceNpCommunicationConfig
+{
+	vm::psv::ptr<const SceNpCommunicationId> commId;
+	vm::psv::ptr<const SceNpCommunicationPassphrase> commPassphrase;
+	vm::psv::ptr<const SceNpCommunicationSignature> commSignature;
+};
+
+struct SceNpCountryCode
+{
+	char data[2];
+	char term;
+	char padding[1];
+};
+
+struct SceNpOnlineId
+{
+	char data[16];
+	char term;
+	char dummy[3];
+};
+
+struct SceNpId
+{
+	SceNpOnlineId handle;
+	u8 opt[8];
+	u8 reserved[8];
+};
+
+struct SceNpAvatarUrl
+{
+	char data[127];
+	char term;
+};
+
+struct SceNpUserInformation
+{
+	SceNpId userId;
+	SceNpAvatarUrl icon;
+	u8 reserved[52];
+};
+
+struct SceNpMyLanguages
+{
+	s32 language1;
+	s32 language2;
+	s32 language3;
+	u8 padding[4];
+};
+
+struct SceNpAvatarImage
+{
+	u8 data[200 * 1024];
+	u32 size;
+	u8 reserved[12];
+};
+
+enum SceNpAvatarSizeType : s32
+{
+	SCE_NP_AVATAR_SIZE_LARGE,
+	SCE_NP_AVATAR_SIZE_MIDDLE,
+	SCE_NP_AVATAR_SIZE_SMALL
+};
+
+struct SceNpAboutMe
+{
+	char data[64];
+};
+
+typedef s32 SceNpAuthRequestId;
+typedef u64 SceNpTime;
+
+struct SceNpDate
+{
+	u16 year;
+	u8 month;
+	u8 day;
+};
+
+union SceNpTicketParam
+{
+	s32 i32;
+	s64 i64;
+	u32 u32;
+	u64 u64;
+	SceNpDate date;
+	u8 data[256];
+};
+
+struct SceNpTicketVersion
+{
+	u16 major;
+	u16 minor;
+};
+
+typedef vm::psv::ptr<s32(SceNpAuthRequestId id, s32 result, vm::psv::ptr<void> arg)> SceNpAuthCallback;
+
+struct SceNpAuthRequestParameter
+{
+	u32 size;
+	SceNpTicketVersion version;
+	vm::psv::ptr<const char> serviceId;
+	vm::psv::ptr<const void> cookie;
+	u32 cookieSize;
+	vm::psv::ptr<const char> entitlementId;
+	u32 consumedCount;
+	SceNpAuthCallback ticketCb;
+	vm::psv::ptr<void> cbArg;
+};
+
+struct SceNpEntitlementId
+{
+	u8 data[32];
+};
+
+struct SceNpEntitlement
+{
+	SceNpEntitlementId id;
+	SceNpTime createdDate;
+	SceNpTime expireDate;
+	u32 type;
+	s32 remainingCount;
+	u32 consumedCount;
+	char padding[4];
+};
+
+extern psv_log_base sceNpCommon;
diff --git a/rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp b/rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp
index 4771107b92..5fce1c946e 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp
@@ -2,8 +2,67 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceNpCommon.h"
+
 extern psv_log_base sceNpManager;
 
+struct SceNpOptParam
+{
+	u32 optParamSize;
+};
+
+typedef vm::psv::ptr<void(SceNpServiceState state, vm::psv::ptr<void> userdata)> SceNpServiceStateCallback;
+
+s32 sceNpInit(vm::psv::ptr<const SceNpCommunicationConfig> commConf, vm::psv::ptr<SceNpOptParam> opt)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpTerm(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpCheckCallback()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpGetServiceState(vm::psv::ptr<SceNpServiceState> state)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpRegisterServiceStateCallback(SceNpServiceStateCallback callback, vm::psv::ptr<void> userdata)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpUnregisterServiceStateCallback()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetNpId(vm::psv::ptr<SceNpId> npId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetAccountRegion(vm::psv::ptr<SceNpCountryCode> countryCode, vm::psv::ptr<s32> languageCode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetContentRatingFlag(vm::psv::ptr<s32> isRestricted, vm::psv::ptr<s32> age)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetChatRestrictionFlag(vm::psv::ptr<s32> isRestricted)
+{
+	throw __FUNCTION__;
+}
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpManager, #name, name)
 
 psv_log_base sceNpManager("SceNpManager", []()
@@ -12,14 +71,14 @@ psv_log_base sceNpManager("SceNpManager", []()
 	sceNpManager.on_unload = nullptr;
 	sceNpManager.on_stop = nullptr;
 
-	//REG_FUNC(0x04D9F484, sceNpInit);
-	//REG_FUNC(0x19E40AE1, sceNpTerm);
-	//REG_FUNC(0x3C94B4B4, sceNpManagerGetNpId);
-	//REG_FUNC(0x54060DF6, sceNpGetServiceState);
-	//REG_FUNC(0x44239C35, sceNpRegisterServiceStateCallback);
-	//REG_FUNC(0xD9E6E56C, sceNpUnregisterServiceStateCallback);
-	//REG_FUNC(0x3B0AE9A9, sceNpCheckCallback);
-	//REG_FUNC(0xFE835967, sceNpManagerGetAccountRegion);
-	//REG_FUNC(0xAF0073B2, sceNpManagerGetContentRatingFlag);
-	//REG_FUNC(0x60C575B1, sceNpManagerGetChatRestrictionFlag);
+	REG_FUNC(0x04D9F484, sceNpInit);
+	REG_FUNC(0x19E40AE1, sceNpTerm);
+	REG_FUNC(0x3C94B4B4, sceNpManagerGetNpId);
+	REG_FUNC(0x54060DF6, sceNpGetServiceState);
+	REG_FUNC(0x44239C35, sceNpRegisterServiceStateCallback);
+	REG_FUNC(0xD9E6E56C, sceNpUnregisterServiceStateCallback);
+	REG_FUNC(0x3B0AE9A9, sceNpCheckCallback);
+	REG_FUNC(0xFE835967, sceNpManagerGetAccountRegion);
+	REG_FUNC(0xAF0073B2, sceNpManagerGetContentRatingFlag);
+	REG_FUNC(0x60C575B1, sceNpManagerGetChatRestrictionFlag);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp b/rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp
index ffc7d962a7..cdb9f5aa8e 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp
@@ -2,8 +2,1306 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceNet.h"
+#include "sceNpCommon.h"
+
 extern psv_log_base sceNpMatching;
 
+struct SceNpMatching2MemoryInfo
+{
+	u32 totalMemSize;
+	u32 curMemUsage;
+	u32 maxMemUsage;
+	u8 reserved[12];
+};
+
+typedef u16 SceNpMatching2ServerId;
+typedef u32 SceNpMatching2WorldId;
+typedef u16 SceNpMatching2WorldNumber;
+typedef u64 SceNpMatching2LobbyId;
+typedef u16 SceNpMatching2LobbyNumber;
+typedef u64 SceNpMatching2RoomId;
+typedef u16 SceNpMatching2RoomNumber;
+typedef u16 SceNpMatching2ContextId;
+typedef u32 SceNpMatching2RequestId;
+typedef u32 SceNpMatching2SignalingRequestId;
+typedef u8 SceNpMatching2NatType;
+typedef u8 SceNpMatching2Operator;
+typedef u8 SceNpMatching2CastType;
+
+struct SceNpMatching2SessionPassword
+{
+	u8 data[8];
+};
+
+typedef u8 SceNpMatching2SessionType;
+typedef u8 SceNpMatching2EventCause;
+
+struct SceNpMatching2PresenceOptionData
+{
+	u8 data[16];
+	u32 len;
+};
+
+typedef u16 SceNpMatching2AttributeId;
+typedef u32 SceNpMatching2FlagAttr;
+
+struct SceNpMatching2IntAttr
+{
+	SceNpMatching2AttributeId id;
+	u8 padding[2];
+	u32 num;
+};
+
+
+struct SceNpMatching2BinAttr
+{
+	SceNpMatching2AttributeId id;
+	u8 padding[2];
+	vm::psv::ptr<void> ptr;
+	u32 size;
+};
+
+
+struct SceNpMatching2RangeFilter
+{
+	u32 startIndex;
+	u32 max;
+};
+
+
+struct SceNpMatching2IntSearchFilter
+{
+	SceNpMatching2Operator searchOperator;
+	u8 padding[3];
+	SceNpMatching2IntAttr attr;
+};
+
+
+struct SceNpMatching2BinSearchFilter
+{
+	SceNpMatching2Operator searchOperator;
+	u8 padding[3];
+	SceNpMatching2BinAttr attr;
+};
+
+
+struct SceNpMatching2Range
+{
+	u32 startIndex;
+	u32 total;
+	u32 resultCount;
+};
+
+
+struct SceNpMatching2JoinedSessionInfo
+{
+	SceNpMatching2SessionType sessionType;
+	u8 padding1[1];
+	SceNpMatching2ServerId serverId;
+	SceNpMatching2WorldId worldId;
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2RoomId roomId;
+	u64 joinDate;
+};
+
+
+struct SceNpMatching2UserInfo
+{
+	vm::psv::ptr<SceNpMatching2UserInfo> next;
+	SceNpId npId;
+	vm::psv::ptr<SceNpMatching2BinAttr> userBinAttr;
+	u32 userBinAttrNum;
+	vm::psv::ptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	u32 joinedSessionInfoNum;
+};
+
+typedef u8 SceNpMatching2ServerStatus;
+
+struct SceNpMatching2Server
+{
+	SceNpMatching2ServerId serverId;
+	SceNpMatching2ServerStatus status;
+	u8 padding[1];
+};
+
+
+struct SceNpMatching2World
+{
+	vm::psv::ptr<SceNpMatching2World> next;
+	SceNpMatching2WorldId worldId;
+	u32 numOfLobby;
+	u32 maxNumOfTotalLobbyMember;
+	u32 curNumOfTotalLobbyMember;
+	u32 curNumOfRoom;
+	u32 curNumOfTotalRoomMember;
+	bool withEntitlementId;
+	SceNpEntitlementId entitlementId;
+	u8 padding[3];
+};
+
+typedef u16 SceNpMatching2LobbyMemberId;
+
+struct SceNpMatching2LobbyMemberBinAttrInternal
+{
+	u64 updateDate;
+	SceNpMatching2BinAttr data;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2LobbyMemberDataInternal
+{
+	vm::psv::ptr<SceNpMatching2LobbyMemberDataInternal> next;
+	SceNpId npId;
+
+	u64 joinDate;
+	SceNpMatching2LobbyMemberId memberId;
+	u8 padding[2];
+
+	SceNpMatching2FlagAttr flagAttr;
+
+	vm::psv::ptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	u32 joinedSessionInfoNum;
+	vm::psv::ptr<SceNpMatching2LobbyMemberBinAttrInternal> lobbyMemberBinAttrInternal;
+	u32 lobbyMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2LobbyMemberIdList
+{
+	vm::psv::ptr<SceNpMatching2LobbyMemberId> memberId;
+	u32 memberIdNum;
+	SceNpMatching2LobbyMemberId me;
+	u8 padding[6];
+};
+
+
+struct SceNpMatching2LobbyBinAttrInternal
+{
+	u64 updateDate;
+	SceNpMatching2LobbyMemberId updateMemberId;
+	u8 padding[2];
+	SceNpMatching2BinAttr data;
+};
+
+
+struct SceNpMatching2LobbyDataExternal
+{
+	vm::psv::ptr<SceNpMatching2LobbyDataExternal> next;
+	SceNpMatching2ServerId serverId;
+	u8 padding1[2];
+	SceNpMatching2WorldId worldId;
+	u8 padding2[4];
+	SceNpMatching2LobbyId lobbyId;
+	u32 maxSlot;
+	u32 curMemberNum;
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2IntAttr> lobbySearchableIntAttrExternal;
+	u32 lobbySearchableIntAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> lobbySearchableBinAttrExternal;
+	u32 lobbySearchableBinAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> lobbyBinAttrExternal;
+	u32 lobbyBinAttrExternalNum;
+	u8 padding3[4];
+};
+
+
+struct SceNpMatching2LobbyDataInternal
+{
+	SceNpMatching2ServerId serverId;
+	u8 padding1[2];
+	SceNpMatching2WorldId worldId;
+	SceNpMatching2LobbyId lobbyId;
+
+	u32 maxSlot;
+	SceNpMatching2LobbyMemberIdList memberIdList;
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2LobbyBinAttrInternal> lobbyBinAttrInternal;
+	u32 lobbyBinAttrInternalNum;
+};
+
+
+union SceNpMatching2LobbyMessageDestination
+{
+	SceNpMatching2LobbyMemberId unicastTarget;
+	struct
+	{
+		vm::psv::ptr<SceNpMatching2LobbyMemberId> memberId;
+		u32 memberIdNum;
+
+	} multicastTarget;
+};
+
+typedef u8 SceNpMatching2RoomGroupId;
+typedef u16 SceNpMatching2RoomMemberId;
+typedef u8 SceNpMatching2TeamId;
+typedef u8 SceNpMatching2Role;
+typedef u8 SceNpMatching2BlockKickFlag;
+
+struct SceNpMatching2GroupLabel
+{
+	u8 data[8];
+};
+
+typedef u64 SceNpMatching2RoomPasswordSlotMask;
+typedef u64 SceNpMatching2RoomJoinedSlotMask;
+
+struct SceNpMatching2RoomGroupConfig
+{
+	u32 slotNum;
+	bool withLabel;
+	SceNpMatching2GroupLabel label;
+	bool withPassword;
+	u8 padding[2];
+};
+
+
+struct SceNpMatching2RoomGroupPasswordConfig
+{
+	SceNpMatching2RoomGroupId groupId;
+	bool withPassword;
+	u8 padding[1];
+};
+
+
+struct SceNpMatching2RoomMemberBinAttrInternal
+{
+	u64 updateDate;
+	SceNpMatching2BinAttr data;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2RoomGroup
+{
+	SceNpMatching2RoomGroupId groupId;
+	bool withPassword;
+	bool withLabel;
+	u8 padding[1];
+	SceNpMatching2GroupLabel label;
+	u32 slotNum;
+	u32 curGroupMemberNum;
+};
+
+
+struct SceNpMatching2RoomMemberDataExternal
+{
+	struct vm::psv::ptr<SceNpMatching2RoomMemberDataExternal> next;
+	SceNpId npId;
+	u64 joinDate;
+	SceNpMatching2Role role;
+	u8 padding[7];
+};
+
+
+struct SceNpMatching2RoomMemberDataInternal
+{
+	struct vm::psv::ptr<SceNpMatching2RoomMemberDataInternal> next;
+	SceNpId npId;
+
+	u64 joinDate;
+	SceNpMatching2RoomMemberId memberId;
+	SceNpMatching2TeamId teamId;
+	u8 padding1[1];
+
+	vm::psv::ptr<SceNpMatching2RoomGroup> roomGroup;
+
+	SceNpMatching2NatType natType;
+	u8 padding2[3];
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2RoomMemberBinAttrInternal> roomMemberBinAttrInternal;
+	u32 roomMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2RoomMemberDataInternalList
+{
+	vm::psv::ptr<SceNpMatching2RoomMemberDataInternal> members;
+	u32 membersNum;
+	vm::psv::ptr<SceNpMatching2RoomMemberDataInternal> me;
+	vm::psv::ptr<SceNpMatching2RoomMemberDataInternal> owner;
+};
+
+
+struct SceNpMatching2RoomBinAttrInternal
+{
+	u64 updateDate;
+	SceNpMatching2RoomMemberId updateMemberId;
+	u8 padding[2];
+	SceNpMatching2BinAttr data;
+};
+
+
+struct SceNpMatching2RoomDataExternal
+{
+	vm::psv::ptr<SceNpMatching2RoomDataExternal> next;
+
+	u16 maxSlot;
+	u16 curMemberNum;
+
+	SceNpMatching2ServerId serverId;
+	u8 padding[2];
+	SceNpMatching2WorldId worldId;
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2RoomId roomId;
+
+	SceNpMatching2RoomPasswordSlotMask passwordSlotMask;
+	SceNpMatching2RoomJoinedSlotMask joinedSlotMask;
+	u16 publicSlotNum;
+	u16 privateSlotNum;
+	u16 openPublicSlotNum;
+	u16 openPrivateSlotNum;
+
+	vm::psv::ptr<SceNpId> owner;
+	SceNpMatching2FlagAttr flagAttr;
+
+	vm::psv::ptr<SceNpMatching2RoomGroup> roomGroup;
+	u32 roomGroupNum;
+	vm::psv::ptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
+	u32 roomSearchableIntAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
+	u32 roomSearchableBinAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomBinAttrExternal;
+	u32 roomBinAttrExternalNum;
+};
+
+
+struct SceNpMatching2RoomDataInternal
+{
+	u16 maxSlot;
+
+	SceNpMatching2ServerId serverId;
+	SceNpMatching2WorldId worldId;
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2RoomId roomId;
+
+	SceNpMatching2RoomPasswordSlotMask passwordSlotMask;
+	SceNpMatching2RoomJoinedSlotMask joinedSlotMask;
+	u16 publicSlotNum;
+	u16 privateSlotNum;
+	u16 openPublicSlotNum;
+	u16 openPrivateSlotNum;
+
+	SceNpMatching2RoomMemberDataInternalList memberList;
+
+	vm::psv::ptr<SceNpMatching2RoomGroup> roomGroup;
+	u32 roomGroupNum;
+
+	SceNpMatching2FlagAttr flagAttr;
+	u8 padding[4];
+	vm::psv::ptr<SceNpMatching2RoomBinAttrInternal> roomBinAttrInternal;
+	u32 roomBinAttrInternalNum;
+};
+
+
+union SceNpMatching2RoomMessageDestination
+{
+	SceNpMatching2RoomMemberId unicastTarget;
+	struct
+	{
+		vm::psv::ptr<SceNpMatching2RoomMemberId> memberId;
+		u32 memberIdNum;
+
+	} multicastTarget;
+	SceNpMatching2TeamId multicastTargetTeamId;
+};
+
+
+struct SceNpMatching2InvitationData
+{
+	vm::psv::ptr<SceNpMatching2JoinedSessionInfo> targetSession;
+	u32 targetSessionNum;
+	vm::psv::ptr<void> optData;
+	u32 optDataLen;
+};
+
+typedef u16 SceNpMatching2Event;
+
+typedef vm::psv::ptr<void(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2RequestId reqId,
+	SceNpMatching2Event event,
+	s32 errorCode,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> arg
+	)> SceNpMatching2RequestCallback;
+
+typedef vm::psv::ptr<void(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2LobbyId lobbyId,
+	SceNpMatching2Event event,
+	s32 errorCode,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> arg
+	)> SceNpMatching2LobbyEventCallback;
+
+typedef vm::psv::ptr<void(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2RoomId roomId,
+	SceNpMatching2Event event,
+	s32 errorCode,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> arg
+	)> SceNpMatching2RoomEventCallback;
+
+typedef vm::psv::ptr<void(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2LobbyId lobbyId,
+	SceNpMatching2LobbyMemberId srcMemberId,
+	SceNpMatching2Event event,
+	s32 errorCode,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> arg
+	)> SceNpMatching2LobbyMessageCallback;
+
+typedef vm::psv::ptr<void(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2RoomId roomId,
+	SceNpMatching2RoomMemberId srcMemberId,
+	SceNpMatching2Event event,
+	s32 errorCode,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> arg
+	)> SceNpMatching2RoomMessageCallback;
+
+typedef vm::psv::ptr<void(SceNpMatching2ContextId ctxId,
+	SceNpMatching2RoomId roomId,
+	SceNpMatching2RoomMemberId peerMemberId,
+	SceNpMatching2Event event,
+	s32 errorCode,
+	vm::psv::ptr<void> arg
+	)> SceNpMatching2SignalingCallback;
+
+typedef vm::psv::ptr<void(SceNpMatching2ContextId ctxId,
+	SceNpMatching2Event event,
+	SceNpMatching2EventCause eventCause,
+	s32 errorCode,
+	vm::psv::ptr<void> arg
+	)> SceNpMatching2ContextCallback;
+
+
+struct SceNpMatching2RequestOptParam
+{
+	SceNpMatching2RequestCallback cbFunc;
+	vm::psv::ptr<void> cbFuncArg;
+	u32 timeout;
+	u16 appReqId;
+	u8 padding[2];
+};
+
+
+struct SceNpMatching2GetWorldInfoListRequest
+{
+	SceNpMatching2ServerId serverId;
+};
+
+
+
+struct SceNpMatching2GetWorldInfoListResponse
+{
+	vm::psv::ptr<SceNpMatching2World> world;
+	u32 worldNum;
+};
+
+struct SceNpMatching2SetUserInfoRequest
+{
+	SceNpMatching2ServerId serverId;
+	u8 padding[2];
+	vm::psv::ptr<SceNpMatching2BinAttr> userBinAttr;
+	u32 userBinAttrNum;
+};
+
+
+struct SceNpMatching2GetUserInfoListRequest
+{
+	SceNpMatching2ServerId serverId;
+	u8 padding[2];
+	vm::psv::ptr<SceNpId> npId;
+	u32 npIdNum;
+	vm::psv::ptr<SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+	s32 option;
+};
+
+
+
+struct SceNpMatching2GetUserInfoListResponse
+{
+	vm::psv::ptr<SceNpMatching2UserInfo> userInfo;
+	u32 userInfoNum;
+};
+
+
+struct SceNpMatching2GetRoomMemberDataExternalListRequest
+{
+	SceNpMatching2RoomId roomId;
+};
+
+
+
+struct SceNpMatching2GetRoomMemberDataExternalListResponse
+{
+	vm::psv::ptr<SceNpMatching2RoomMemberDataExternal> roomMemberDataExternal;
+	u32 roomMemberDataExternalNum;
+};
+
+
+struct SceNpMatching2SetRoomDataExternalRequest
+{
+	SceNpMatching2RoomId roomId;
+	vm::psv::ptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
+	u32 roomSearchableIntAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
+	u32 roomSearchableBinAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomBinAttrExternal;
+	u32 roomBinAttrExternalNum;
+};
+
+
+struct SceNpMatching2GetRoomDataExternalListRequest
+{
+	vm::psv::ptr<SceNpMatching2RoomId> roomId;
+	u32 roomIdNum;
+	vm::psv::ptr<const SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetRoomDataExternalListResponse
+{
+	vm::psv::ptr<SceNpMatching2RoomDataExternal> roomDataExternal;
+	u32 roomDataExternalNum;
+};
+
+typedef u8 SceNpMatching2SignalingType;
+typedef u8 SceNpMatching2SignalingFlag;
+
+struct SceNpMatching2SignalingOptParam
+{
+	SceNpMatching2SignalingType type;
+	SceNpMatching2SignalingFlag flag;
+	SceNpMatching2RoomMemberId hubMemberId;
+	u8 reserved2[4];
+};
+
+
+
+struct SceNpMatching2CreateJoinRoomRequest
+{
+	SceNpMatching2WorldId worldId;
+	u8 padding1[4];
+	SceNpMatching2LobbyId lobbyId;
+
+	u32 maxSlot;
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomBinAttrInternal;
+	u32 roomBinAttrInternalNum;
+	vm::psv::ptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
+	u32 roomSearchableIntAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
+	u32 roomSearchableBinAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomBinAttrExternal;
+	u32 roomBinAttrExternalNum;
+	vm::psv::ptr<SceNpMatching2SessionPassword> roomPassword;
+	vm::psv::ptr<SceNpMatching2RoomGroupConfig> groupConfig;
+	u32 groupConfigNum;
+	vm::psv::ptr<SceNpMatching2RoomPasswordSlotMask> passwordSlotMask;
+	vm::psv::ptr<SceNpId> allowedUser;
+	u32 allowedUserNum;
+	vm::psv::ptr<SceNpId> blockedUser;
+	u32 blockedUserNum;
+
+	vm::psv::ptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
+	u32 roomMemberBinAttrInternalNum;
+	SceNpMatching2TeamId teamId;
+	u8 padding2[3];
+
+	vm::psv::ptr<SceNpMatching2SignalingOptParam> sigOptParam;
+	u8 padding3[4];
+};
+
+
+
+struct SceNpMatching2CreateJoinRoomResponse
+{
+	vm::psv::ptr<SceNpMatching2RoomDataInternal> roomDataInternal;
+};
+
+
+struct SceNpMatching2JoinRoomRequest
+{
+	SceNpMatching2RoomId roomId;
+	vm::psv::ptr<SceNpMatching2SessionPassword> roomPassword;
+	vm::psv::ptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
+	u32 roomMemberBinAttrInternalNum;
+	SceNpMatching2PresenceOptionData optData;
+	SceNpMatching2TeamId teamId;
+	u8 padding[3];
+	vm::psv::ptr<SceNpId> blockedUser;
+	u32 blockedUserNum;
+};
+
+
+
+struct SceNpMatching2JoinRoomResponse
+{
+	vm::psv::ptr<SceNpMatching2RoomDataInternal> roomDataInternal;
+};
+
+
+struct SceNpMatching2LeaveRoomRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2PresenceOptionData optData;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2GrantRoomOwnerRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2RoomMemberId newOwner;
+	u8 padding[2];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2KickoutRoomMemberRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2RoomMemberId target;
+	SceNpMatching2BlockKickFlag blockKickFlag;
+	u8 padding[1];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2SearchRoomRequest
+{
+	s32 option;
+	SceNpMatching2WorldId worldId;
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2RangeFilter rangeFilter;
+	SceNpMatching2FlagAttr flagFilter;
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2IntSearchFilter> intFilter;
+	u32 intFilterNum;
+	vm::psv::ptr<SceNpMatching2BinSearchFilter> binFilter;
+	u32 binFilterNum;
+	vm::psv::ptr<SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+};
+
+
+
+struct SceNpMatching2SearchRoomResponse
+{
+	SceNpMatching2Range range;
+	vm::psv::ptr<SceNpMatching2RoomDataExternal> roomDataExternal;
+};
+
+
+struct SceNpMatching2SendRoomMessageRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2CastType castType;
+	u8 padding[3];
+	SceNpMatching2RoomMessageDestination dst;
+	vm::psv::ptr<const void> msg;
+	u32 msgLen;
+	s32 option;
+};
+
+
+struct SceNpMatching2SendRoomChatMessageRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2CastType castType;
+	u8 padding[3];
+	SceNpMatching2RoomMessageDestination dst;
+	vm::psv::ptr<const void> msg;
+	u32 msgLen;
+	s32 option;
+};
+
+
+
+struct SceNpMatching2SendRoomChatMessageResponse
+{
+	bool filtered;
+};
+
+
+struct SceNpMatching2SetRoomDataInternalRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2FlagAttr flagFilter;
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomBinAttrInternal;
+	u32 roomBinAttrInternalNum;
+	vm::psv::ptr<SceNpMatching2RoomGroupPasswordConfig> passwordConfig;
+	u32 passwordConfigNum;
+	vm::psv::ptr<SceNpMatching2RoomPasswordSlotMask> passwordSlotMask;
+	vm::psv::ptr<SceNpMatching2RoomMemberId> ownerPrivilegeRank;
+	u32 ownerPrivilegeRankNum;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2GetRoomDataInternalRequest
+{
+	SceNpMatching2RoomId roomId;
+	vm::psv::ptr<const SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetRoomDataInternalResponse
+{
+	vm::psv::ptr<SceNpMatching2RoomDataInternal> roomDataInternal;
+};
+
+
+struct SceNpMatching2SetRoomMemberDataInternalRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2RoomMemberId memberId;
+	SceNpMatching2TeamId teamId;
+	u8 padding[5];
+	SceNpMatching2FlagAttr flagFilter;
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
+	u32 roomMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2GetRoomMemberDataInternalRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2RoomMemberId memberId;
+	u8 padding[6];
+	vm::psv::ptr<const SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetRoomMemberDataInternalResponse
+{
+	vm::psv::ptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
+};
+
+
+struct SceNpMatching2SetSignalingOptParamRequest
+{
+	SceNpMatching2RoomId roomId;
+	SceNpMatching2SignalingOptParam sigOptParam;
+};
+
+
+struct SceNpMatching2GetLobbyInfoListRequest
+{
+	SceNpMatching2WorldId worldId;
+	SceNpMatching2RangeFilter rangeFilter;
+	vm::psv::ptr<SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetLobbyInfoListResponse
+{
+	SceNpMatching2Range range;
+	vm::psv::ptr<SceNpMatching2LobbyDataExternal> lobbyDataExternal;
+};
+
+
+struct SceNpMatching2JoinLobbyRequest
+{
+	SceNpMatching2LobbyId lobbyId;
+	vm::psv::ptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	u32 joinedSessionInfoNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
+	u32 lobbyMemberBinAttrInternalNum;
+	SceNpMatching2PresenceOptionData optData;
+	u8 padding[4];
+};
+
+
+
+struct SceNpMatching2JoinLobbyResponse
+{
+	vm::psv::ptr<SceNpMatching2LobbyDataInternal> lobbyDataInternal;
+};
+
+
+struct SceNpMatching2LeaveLobbyRequest
+{
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2PresenceOptionData optData;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2SetLobbyMemberDataInternalRequest
+{
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2LobbyMemberId memberId;
+	u8 padding1[2];
+	SceNpMatching2FlagAttr flagFilter;
+	SceNpMatching2FlagAttr flagAttr;
+	vm::psv::ptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	u32 joinedSessionInfoNum;
+	vm::psv::ptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
+	u32 lobbyMemberBinAttrInternalNum;
+	u8 padding2[4];
+};
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalRequest
+{
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2LobbyMemberId memberId;
+	u8 padding[6];
+	vm::psv::ptr<const SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalResponse
+{
+	vm::psv::ptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
+};
+
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalListRequest
+{
+	SceNpMatching2LobbyId lobbyId;
+	vm::psv::ptr<SceNpMatching2LobbyMemberId> memberId;
+	u32 memberIdNum;
+	vm::psv::ptr<const SceNpMatching2AttributeId> attrId;
+	u32 attrIdNum;
+	bool extendedData;
+	u8 padding[7];
+};
+
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalListResponse
+{
+	vm::psv::ptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
+	u32 lobbyMemberDataInternalNum;
+};
+
+
+struct SceNpMatching2SendLobbyChatMessageRequest
+{
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2CastType castType;
+	u8 padding[3];
+	SceNpMatching2LobbyMessageDestination dst;
+	vm::psv::ptr<const void> msg;
+	u32 msgLen;
+	s32 option;
+};
+
+
+
+struct SceNpMatching2SendLobbyChatMessageResponse
+{
+	bool filtered;
+};
+
+
+struct SceNpMatching2SendLobbyInvitationRequest
+{
+	SceNpMatching2LobbyId lobbyId;
+	SceNpMatching2CastType castType;
+	u8 padding[3];
+	SceNpMatching2LobbyMessageDestination dst;
+	SceNpMatching2InvitationData invitationData;
+	s32 option;
+};
+
+
+struct SceNpMatching2RoomMemberUpdateInfo
+{
+	vm::psv::ptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
+	SceNpMatching2EventCause eventCause;
+	u8 padding[3];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2RoomOwnerUpdateInfo
+{
+	SceNpMatching2RoomMemberId prevOwner;
+	SceNpMatching2RoomMemberId newOwner;
+	SceNpMatching2EventCause eventCause;
+	u8 padding[3];
+	vm::psv::ptr<SceNpMatching2SessionPassword> roomPassword;
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2RoomUpdateInfo
+{
+	SceNpMatching2EventCause eventCause;
+	u8 padding[3];
+	s32 errorCode;
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2RoomDataInternalUpdateInfo
+{
+	vm::psv::ptr<SceNpMatching2RoomDataInternal> newRoomDataInternal;
+	vm::psv::ptr<SceNpMatching2FlagAttr> newFlagAttr;
+	vm::psv::ptr<SceNpMatching2FlagAttr> prevFlagAttr;
+	vm::psv::ptr<SceNpMatching2RoomPasswordSlotMask> newRoomPasswordSlotMask;
+	vm::psv::ptr<SceNpMatching2RoomPasswordSlotMask> prevRoomPasswordSlotMask;
+	vm::psv::ptr<SceNpMatching2RoomGroup> *newRoomGroup;
+	u32 newRoomGroupNum;
+	vm::psv::ptr<SceNpMatching2RoomBinAttrInternal> *newRoomBinAttrInternal;
+	u32 newRoomBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2RoomMemberDataInternalUpdateInfo
+{
+	vm::psv::ptr<SceNpMatching2RoomMemberDataInternal> newRoomMemberDataInternal;
+	vm::psv::ptr<SceNpMatching2FlagAttr> newFlagAttr;
+	vm::psv::ptr<SceNpMatching2FlagAttr> prevFlagAttr;
+	vm::psv::ptr<SceNpMatching2TeamId> newTeamId;
+	vm::psv::ptr<SceNpMatching2RoomMemberBinAttrInternal> *newRoomMemberBinAttrInternal;
+	u32 newRoomMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2SignalingOptParamUpdateInfo
+{
+	SceNpMatching2SignalingOptParam newSignalingOptParam;
+};
+
+
+struct SceNpMatching2RoomMessageInfo
+{
+	bool filtered;
+	SceNpMatching2CastType castType;
+	u8 padding[2];
+	vm::psv::ptr<SceNpMatching2RoomMessageDestination> dst;
+	vm::psv::ptr<SceNpId> srcMember;
+	vm::psv::ptr<const void> msg;
+	u32 msgLen;
+};
+
+
+struct SceNpMatching2LobbyMemberUpdateInfo
+{
+	vm::psv::ptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
+	SceNpMatching2EventCause eventCause;
+	u8 padding[3];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2LobbyUpdateInfo
+{
+	SceNpMatching2EventCause eventCause;
+	u8 padding[3];
+	s32 errorCode;
+};
+
+
+struct SceNpMatching2LobbyMemberDataInternalUpdateInfo
+{
+	SceNpMatching2LobbyMemberId memberId;
+	u8 padding[2];
+	SceNpId npId;
+	SceNpMatching2FlagAttr flagFilter;
+	SceNpMatching2FlagAttr newFlagAttr;
+	vm::psv::ptr<SceNpMatching2JoinedSessionInfo> newJoinedSessionInfo;
+	u32 newJoinedSessionInfoNum;
+	vm::psv::ptr<SceNpMatching2LobbyMemberBinAttrInternal> newLobbyMemberBinAttrInternal;
+	u32 newLobbyMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2LobbyMessageInfo
+{
+	bool filtered;
+	SceNpMatching2CastType castType;
+	u8 padding[2];
+	vm::psv::ptr<SceNpMatching2LobbyMessageDestination> dst;
+	vm::psv::ptr<SceNpId> srcMember;
+	vm::psv::ptr<const void> msg;
+	u32 msgLen;
+};
+
+
+struct SceNpMatching2LobbyInvitationInfo
+{
+	SceNpMatching2CastType castType;
+	u8 padding[3];
+	vm::psv::ptr<SceNpMatching2LobbyMessageDestination> dst;
+	vm::psv::ptr<SceNpId> srcMember;
+	SceNpMatching2InvitationData invitationData;
+};
+
+union SceNpMatching2SignalingConnectionInfo
+{
+	u32 rtt;
+	u32 bandwidth;
+	SceNpId npId;
+	struct
+	{
+		SceNetInAddr addr;
+		u16 port;
+		u8 padding[2];
+
+	} address;
+	u32 packetLoss;
+};
+
+struct SceNpMatching2SignalingNetInfo
+{
+	u32 size;
+	SceNetInAddr localAddr;
+	SceNetInAddr mappedAddr;
+	s32 natStatus;
+};
+
+// Functions
+
+s32 sceNpMatching2Init(
+	const u32 poolSize,
+	const s32 threadPriority,
+	const s32 cpuAffinityMask,
+	const u32 threadStackSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2Term()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2CreateContext(
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<const SceNpCommunicationId> commId,
+	vm::psv::ptr<const SceNpCommunicationPassphrase> passPhrase,
+	vm::psv::ptr<SceNpMatching2ContextId> ctxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2DestroyContext(const SceNpMatching2ContextId ctxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2ContextStart(const SceNpMatching2ContextId ctxId, const u64 timeout)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2AbortContextStart(const SceNpMatching2ContextId ctxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2ContextStop(const SceNpMatching2ContextId ctxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SetDefaultRequestOptParam(const SceNpMatching2ContextId ctxId, vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2RegisterRoomEventCallback(const SceNpMatching2ContextId ctxId, SceNpMatching2RoomEventCallback cbFunc, vm::psv::ptr<void> cbFuncArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2RegisterRoomMessageCallback(const SceNpMatching2ContextId ctxId, SceNpMatching2RoomMessageCallback cbFunc, vm::psv::ptr<void> cbFuncArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2RegisterSignalingCallback(const SceNpMatching2ContextId ctxId, SceNpMatching2SignalingCallback cbFunc, vm::psv::ptr<void> cbFuncArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2RegisterContextCallback(SceNpMatching2ContextCallback cbFunc, vm::psv::ptr<void> cbFuncArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2AbortRequest(const SceNpMatching2ContextId ctxId, const SceNpMatching2RequestId reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2GetMemoryInfo(vm::psv::ptr<SceNpMatching2MemoryInfo> memInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2GetServerLocal(const SceNpMatching2ContextId ctxId, vm::psv::ptr<SceNpMatching2Server> server)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2GetWorldInfoList(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2GetWorldInfoListRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2CreateJoinRoom(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2CreateJoinRoomRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SearchRoom(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2SearchRoomRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2JoinRoom(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2JoinRoomRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2LeaveRoom(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2LeaveRoomRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2GetSignalingOptParamLocal(
+	const SceNpMatching2ContextId ctxId,
+	const SceNpMatching2RoomId roomId,
+	vm::psv::ptr<SceNpMatching2SignalingOptParam> signalingOptParam)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SetRoomDataExternal(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2SetRoomDataExternalRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2KickoutRoomMember(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2KickoutRoomMemberRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SendRoomChatMessage(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2SendRoomChatMessageRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SendRoomMessage(
+	const SceNpMatching2ContextId ctxId,
+	vm::psv::ptr<const SceNpMatching2SendRoomMessageRequest> reqParam,
+	vm::psv::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::psv::ptr<SceNpMatching2RequestId> assignedReqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SignalingGetConnectionStatus(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2RoomId roomId,
+	SceNpMatching2RoomMemberId memberId,
+	vm::psv::ptr<s32> connStatus,
+	vm::psv::ptr<SceNetInAddr> peerAddr,
+	vm::psv::ptr<u16> peerPort)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SignalingGetConnectionInfo(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2RoomId roomId,
+	SceNpMatching2RoomMemberId memberId,
+	s32 code,
+	vm::psv::ptr<SceNpMatching2SignalingConnectionInfo> info)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SignalingGetLocalNetInfo(vm::psv::ptr<SceNpMatching2SignalingNetInfo> netinfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SignalingGetPeerNetInfo(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2RoomId roomId,
+	SceNpMatching2RoomMemberId memberId,
+	vm::psv::ptr<SceNpMatching2SignalingRequestId> reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SignalingCancelPeerNetInfo(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2SignalingRequestId reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpMatching2SignalingGetPeerNetInfoResult(
+	SceNpMatching2ContextId ctxId,
+	SceNpMatching2SignalingRequestId reqId,
+	vm::psv::ptr<SceNpMatching2SignalingNetInfo> netinfo)
+{
+	throw __FUNCTION__;
+}
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpMatching, #name, name)
 
 psv_log_base sceNpMatching("SceNpMatching2", []()
@@ -12,35 +1310,35 @@ psv_log_base sceNpMatching("SceNpMatching2", []()
 	sceNpMatching.on_unload = nullptr;
 	sceNpMatching.on_stop = nullptr;
 
-	//REG_FUNC(0xEBB1FE74, sceNpMatching2Init);
-	//REG_FUNC(0x0124641C, sceNpMatching2Term);
-	//REG_FUNC(0xADF578E1, sceNpMatching2CreateContext);
-	//REG_FUNC(0x368AA759, sceNpMatching2DestroyContext);
-	//REG_FUNC(0xBB2E7559, sceNpMatching2ContextStart);
-	//REG_FUNC(0xF2847E3B, sceNpMatching2AbortContextStart);
-	//REG_FUNC(0x506454DE, sceNpMatching2ContextStop);
-	//REG_FUNC(0xF3A43C50, sceNpMatching2SetDefaultRequestOptParam);
-	//REG_FUNC(0xF486991B, sceNpMatching2RegisterRoomEventCallback);
-	//REG_FUNC(0xFA51949B, sceNpMatching2RegisterRoomMessageCallback);
-	//REG_FUNC(0xF9E35566, sceNpMatching2RegisterContextCallback);
-	//REG_FUNC(0x74EB6CE9, sceNpMatching2AbortRequest);
-	//REG_FUNC(0x7BD39E50, sceNpMatching2GetMemoryInfo);
-	//REG_FUNC(0x65C0FEED, sceNpMatching2GetServerLocal);
-	//REG_FUNC(0xC086B560, sceNpMatching2GetWorldInfoList);
-	//REG_FUNC(0x818A9499, sceNpMatching2CreateJoinRoom);
-	//REG_FUNC(0xD48BAF13, sceNpMatching2SearchRoom);
-	//REG_FUNC(0x33F7D5AE, sceNpMatching2JoinRoom);
-	//REG_FUNC(0xC8B0C9EE, sceNpMatching2LeaveRoom);
-	//REG_FUNC(0x495D2B46, sceNpMatching2GetSignalingOptParamLocal);
-	//REG_FUNC(0xE0BE0510, sceNpMatching2SendRoomChatMessage);
-	//REG_FUNC(0x7B908D99, sceNpMatching2SendRoomMessage);
-	//REG_FUNC(0x4E4C55BD, sceNpMatching2SignalingGetConnectionStatus);
-	//REG_FUNC(0x20598618, sceNpMatching2SignalingGetConnectionInfo);
-	//REG_FUNC(0x79310806, sceNpMatching2SignalingGetLocalNetInfo);
-	//REG_FUNC(0xF0CB1DD3, sceNpMatching2SignalingGetPeerNetInfo);
-	//REG_FUNC(0xADCD102C, sceNpMatching2SignalingCancelPeerNetInfo);
-	//REG_FUNC(0xFDC7B2C9, sceNpMatching2SignalingGetPeerNetInfoResult);
-	//REG_FUNC(0x1C60BC5B, sceNpMatching2RegisterSignalingCallback);
-	//REG_FUNC(0x8F88AC7E, sceNpMatching2SetRoomDataExternal);
-	//REG_FUNC(0xA8021394, sceNpMatching2KickoutRoomMember);
+	REG_FUNC(0xEBB1FE74, sceNpMatching2Init);
+	REG_FUNC(0x0124641C, sceNpMatching2Term);
+	REG_FUNC(0xADF578E1, sceNpMatching2CreateContext);
+	REG_FUNC(0x368AA759, sceNpMatching2DestroyContext);
+	REG_FUNC(0xBB2E7559, sceNpMatching2ContextStart);
+	REG_FUNC(0xF2847E3B, sceNpMatching2AbortContextStart);
+	REG_FUNC(0x506454DE, sceNpMatching2ContextStop);
+	REG_FUNC(0xF3A43C50, sceNpMatching2SetDefaultRequestOptParam);
+	REG_FUNC(0xF486991B, sceNpMatching2RegisterRoomEventCallback);
+	REG_FUNC(0xFA51949B, sceNpMatching2RegisterRoomMessageCallback);
+	REG_FUNC(0xF9E35566, sceNpMatching2RegisterContextCallback);
+	REG_FUNC(0x74EB6CE9, sceNpMatching2AbortRequest);
+	REG_FUNC(0x7BD39E50, sceNpMatching2GetMemoryInfo);
+	REG_FUNC(0x65C0FEED, sceNpMatching2GetServerLocal);
+	REG_FUNC(0xC086B560, sceNpMatching2GetWorldInfoList);
+	REG_FUNC(0x818A9499, sceNpMatching2CreateJoinRoom);
+	REG_FUNC(0xD48BAF13, sceNpMatching2SearchRoom);
+	REG_FUNC(0x33F7D5AE, sceNpMatching2JoinRoom);
+	REG_FUNC(0xC8B0C9EE, sceNpMatching2LeaveRoom);
+	REG_FUNC(0x495D2B46, sceNpMatching2GetSignalingOptParamLocal);
+	REG_FUNC(0xE0BE0510, sceNpMatching2SendRoomChatMessage);
+	REG_FUNC(0x7B908D99, sceNpMatching2SendRoomMessage);
+	REG_FUNC(0x4E4C55BD, sceNpMatching2SignalingGetConnectionStatus);
+	REG_FUNC(0x20598618, sceNpMatching2SignalingGetConnectionInfo);
+	REG_FUNC(0x79310806, sceNpMatching2SignalingGetLocalNetInfo);
+	REG_FUNC(0xF0CB1DD3, sceNpMatching2SignalingGetPeerNetInfo);
+	REG_FUNC(0xADCD102C, sceNpMatching2SignalingCancelPeerNetInfo);
+	REG_FUNC(0xFDC7B2C9, sceNpMatching2SignalingGetPeerNetInfoResult);
+	REG_FUNC(0x1C60BC5B, sceNpMatching2RegisterSignalingCallback);
+	REG_FUNC(0x8F88AC7E, sceNpMatching2SetRoomDataExternal);
+	REG_FUNC(0xA8021394, sceNpMatching2KickoutRoomMember);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp b/rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp
index 612114af70..f093ab8b31 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp
@@ -2,8 +2,337 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceNpCommon.h"
+
 extern psv_log_base sceNpScore;
 
+typedef u32 SceNpScoreBoardId;
+typedef s64 SceNpScoreValue;
+typedef u32 SceNpScoreRankNumber;
+typedef s32 SceNpScorePcId;
+
+struct SceNpScoreGameInfo
+{
+	u32 infoSize;
+	u8 pad[4];
+	u8 data[192];
+};
+
+struct SceNpScoreComment
+{
+	char utf8Comment[64];
+};
+
+struct SceNpScoreRankData
+{
+	SceNpId npId;
+	u8 reserved[49];
+	u8 pad0[3];
+	SceNpScorePcId pcId;
+	SceNpScoreRankNumber serialRank;
+	SceNpScoreRankNumber rank;
+	SceNpScoreRankNumber highestRank;
+	s32 hasGameData;
+	u8 pad1[4];
+	SceNpScoreValue scoreValue;
+	u64 recordDate;
+};
+
+struct SceNpScorePlayerRankData
+{
+	s32 hasData;
+	u8 pad0[4];
+	SceNpScoreRankData rankData;
+};
+
+struct SceNpScoreBoardInfo
+{
+	u32 rankLimit;
+	u32 updateMode;
+	u32 sortMode;
+	u32 uploadNumLimit;
+	u32 uploadSizeLimit;
+};
+
+struct SceNpScoreNpIdPcId
+{
+	SceNpId npId;
+	SceNpScorePcId pcId;
+	u8 pad[4];
+};
+
+s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreTerm(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpCommunicationPassphrase> passphrase, vm::psv::ptr<const SceNpId> selfNpId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreDeleteTitleCtx(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreCreateRequest(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreDeleteRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreAbortRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connTimeout, s32 sendTimeout, s32 recvTimeout)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreSetPlayerCharacterId(s32 id, SceNpScorePcId pcId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetBoardInfo(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordScore(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	vm::psv::ptr<const SceNpScoreComment> scoreComment,
+	vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
+	vm::psv::ptr<const u64> compareDate,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordGameData(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	u32 totalSize,
+	u32 sendSize,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetGameData(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<u32> totalSize,
+	u32 recvSize,
+	vm::psv::ptr<void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByNpId(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npIdArray,
+	u32 npIdArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByRange(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreRankNumber startSerialRank,
+	vm::psv::ptr<SceNpScoreRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+
+s32 sceNpScoreGetRankingByNpIdPcId(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
+	u32 idArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreCensorComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreSanitizeComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreWaitAsync(s32 id, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScorePollAsync(s32 reqId, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetBoardInfoAsync(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordScoreAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	vm::psv::ptr<const SceNpScoreComment> scoreComment,
+	vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
+	vm::psv::ptr<const u64> compareDate,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordGameDataAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	u32 totalSize,
+	u32 sendSize,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetGameDataAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<u32> totalSize,
+	u32 recvSize,
+	vm::psv::ptr<void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByNpIdAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npIdArray,
+	u32 npIdArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByRangeAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreRankNumber startSerialRank,
+	vm::psv::ptr<SceNpScoreRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByNpIdPcIdAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
+	u32 idArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpScore, #name, name)
 
 psv_log_base sceNpScore("SceNpScore", []()
@@ -12,33 +341,33 @@ psv_log_base sceNpScore("SceNpScore", []()
 	sceNpScore.on_unload = nullptr;
 	sceNpScore.on_stop = nullptr;
 
-	//REG_FUNC(0x0433069F, sceNpScoreInit);
-	//REG_FUNC(0x2050F98F, sceNpScoreTerm);
-	//REG_FUNC(0x5685F225, sceNpScoreCreateTitleCtx);
-	//REG_FUNC(0xD30D1993, sceNpScoreCreateRequest);
-	//REG_FUNC(0xF52EA88A, sceNpScoreDeleteTitleCtx);
-	//REG_FUNC(0xFFF24BB1, sceNpScoreDeleteRequest);
-	//REG_FUNC(0x320C0277, sceNpScoreRecordScore);
-	//REG_FUNC(0x24B09634, sceNpScoreRecordScoreAsync);
-	//REG_FUNC(0xC2862B67, sceNpScoreRecordGameData);
-	//REG_FUNC(0x40573917, sceNpScoreRecordGameDataAsync);
-	//REG_FUNC(0xDFAD64D3, sceNpScoreGetGameData);
-	//REG_FUNC(0xCE416993, sceNpScoreGetGameDataAsync);
-	//REG_FUNC(0x427D3412, sceNpScoreGetRankingByRange);
-	//REG_FUNC(0xC45E3FCD, sceNpScoreGetRankingByRangeAsync);
-	//REG_FUNC(0xBAE55B34, sceNpScoreGetRankingByNpId);
-	//REG_FUNC(0x45CD1D00, sceNpScoreGetRankingByNpIdAsync);
-	//REG_FUNC(0x871F28AA, sceNpScoreGetRankingByNpIdPcId);
-	//REG_FUNC(0xCE3A9544, sceNpScoreGetRankingByNpIdPcIdAsync);
-	//REG_FUNC(0xA7E93CE1, sceNpScoreAbortRequest);
-	//REG_FUNC(0x31733BF3, sceNpScoreWaitAsync);
-	//REG_FUNC(0x9F2A7AC9, sceNpScorePollAsync);
-	//REG_FUNC(0x00F90E7B, sceNpScoreGetBoardInfo);
-	//REG_FUNC(0x3CD9974E, sceNpScoreGetBoardInfoAsync);
-	//REG_FUNC(0xA0C94D46, sceNpScoreCensorComment);
-	//REG_FUNC(0xAA0BBF8E, sceNpScoreCensorCommentAsync);
-	//REG_FUNC(0x6FD2041A, sceNpScoreSanitizeComment);
-	//REG_FUNC(0x15981858, sceNpScoreSanitizeCommentAsync);
-	//REG_FUNC(0x5EF44841, sceNpScoreSetTimeout);
-	//REG_FUNC(0x53D77883, sceNpScoreSetPlayerCharacterId);
+	REG_FUNC(0x0433069F, sceNpScoreInit);
+	REG_FUNC(0x2050F98F, sceNpScoreTerm);
+	REG_FUNC(0x5685F225, sceNpScoreCreateTitleCtx);
+	REG_FUNC(0xD30D1993, sceNpScoreCreateRequest);
+	REG_FUNC(0xF52EA88A, sceNpScoreDeleteTitleCtx);
+	REG_FUNC(0xFFF24BB1, sceNpScoreDeleteRequest);
+	REG_FUNC(0x320C0277, sceNpScoreRecordScore);
+	REG_FUNC(0x24B09634, sceNpScoreRecordScoreAsync);
+	REG_FUNC(0xC2862B67, sceNpScoreRecordGameData);
+	REG_FUNC(0x40573917, sceNpScoreRecordGameDataAsync);
+	REG_FUNC(0xDFAD64D3, sceNpScoreGetGameData);
+	REG_FUNC(0xCE416993, sceNpScoreGetGameDataAsync);
+	REG_FUNC(0x427D3412, sceNpScoreGetRankingByRange);
+	REG_FUNC(0xC45E3FCD, sceNpScoreGetRankingByRangeAsync);
+	REG_FUNC(0xBAE55B34, sceNpScoreGetRankingByNpId);
+	REG_FUNC(0x45CD1D00, sceNpScoreGetRankingByNpIdAsync);
+	REG_FUNC(0x871F28AA, sceNpScoreGetRankingByNpIdPcId);
+	REG_FUNC(0xCE3A9544, sceNpScoreGetRankingByNpIdPcIdAsync);
+	REG_FUNC(0xA7E93CE1, sceNpScoreAbortRequest);
+	REG_FUNC(0x31733BF3, sceNpScoreWaitAsync);
+	REG_FUNC(0x9F2A7AC9, sceNpScorePollAsync);
+	REG_FUNC(0x00F90E7B, sceNpScoreGetBoardInfo);
+	REG_FUNC(0x3CD9974E, sceNpScoreGetBoardInfoAsync);
+	REG_FUNC(0xA0C94D46, sceNpScoreCensorComment);
+	REG_FUNC(0xAA0BBF8E, sceNpScoreCensorCommentAsync);
+	REG_FUNC(0x6FD2041A, sceNpScoreSanitizeComment);
+	REG_FUNC(0x15981858, sceNpScoreSanitizeCommentAsync);
+	REG_FUNC(0x5EF44841, sceNpScoreSetTimeout);
+	REG_FUNC(0x53D77883, sceNpScoreSetPlayerCharacterId);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp b/rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp
index 5ce2ca80ad..1aab007361 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp
@@ -2,8 +2,140 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceNpCommon.h"
+
 extern psv_log_base sceNpUtility;
 
+struct SceNpBandwidthTestResult
+{
+	double uploadBps;
+	double downloadBps;
+	s32 result;
+	char padding[4];
+};
+
+s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupTerm(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpId> selfNpId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupDeleteTitleCtx(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupCreateRequest(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupDeleteRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupAbortRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupSetTimeout(s32 id, s32 resolveRetry, u32 resolveTimeout, u32 connTimeout, u32 sendTimeout, u32 recvTimeout)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupWaitAsync(s32 reqId, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupPollAsync(s32 reqId, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupNpId(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupUserProfile(
+	s32 reqId,
+	s32 avatarSizeType,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<SceNpUserInformation> userInfo,
+	vm::psv::ptr<SceNpAboutMe> aboutMe,
+	vm::psv::ptr<SceNpMyLanguages> languages,
+	vm::psv::ptr<SceNpCountryCode> countryCode,
+	vm::psv::ptr<void> avatarImageData,
+	u32 avatarImageDataMaxSize,
+	vm::psv::ptr<u32> avatarImageDataSize,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupUserProfileAsync(
+	s32 reqId,
+	s32 avatarSizeType,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<SceNpUserInformation> userInfo,
+	vm::psv::ptr<SceNpAboutMe> aboutMe,
+	vm::psv::ptr<SceNpMyLanguages> languages,
+	vm::psv::ptr<SceNpCountryCode> countryCode,
+	vm::psv::ptr<void> avatarImageData,
+	u32 avatarImageDataMaxSize,
+	vm::psv::ptr<u32> avatarImageDataSize,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupAvatarImage(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestInitStart(s32 initPriority, s32 cpuAffinityMask)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestShutdown(vm::psv::ptr<SceNpBandwidthTestResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestAbort()
+{
+	throw __FUNCTION__;
+}
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpUtility, #name, name)
 
 psv_log_base sceNpUtility("SceNpUtility", []()
@@ -12,24 +144,24 @@ psv_log_base sceNpUtility("SceNpUtility", []()
 	sceNpUtility.on_unload = nullptr;
 	sceNpUtility.on_stop = nullptr;
 
-	//REG_FUNC(0x9246A673, sceNpLookupInit);
-	//REG_FUNC(0x0158B61B, sceNpLookupTerm);
-	//REG_FUNC(0x5110E17E, sceNpLookupCreateTitleCtx);
-	//REG_FUNC(0x33B64699, sceNpLookupDeleteTitleCtx);
-	//REG_FUNC(0x9E42E922, sceNpLookupCreateRequest);
-	//REG_FUNC(0x8B608BF6, sceNpLookupDeleteRequest);
-	//REG_FUNC(0x027587C4, sceNpLookupAbortRequest);
-	//REG_FUNC(0xB0C9DC45, sceNpLookupSetTimeout);
-	//REG_FUNC(0xCF956F23, sceNpLookupWaitAsync);
-	//REG_FUNC(0xFCDBA234, sceNpLookupPollAsync);
-	//REG_FUNC(0xB1A14879, sceNpLookupNpId);
-	//REG_FUNC(0x5387BABB, sceNpLookupNpIdAsync);
-	//REG_FUNC(0x6A1BF429, sceNpLookupUserProfile);
-	//REG_FUNC(0xE5285E0F, sceNpLookupUserProfileAsync);
-	//REG_FUNC(0xFDB0AE47, sceNpLookupAvatarImage);
-	//REG_FUNC(0x282BD43C, sceNpLookupAvatarImageAsync);
-	//REG_FUNC(0x081FA13C, sceNpBandwidthTestInitStart);
-	//REG_FUNC(0xE0EBFBF6, sceNpBandwidthTestGetStatus);
-	//REG_FUNC(0x58D92EFD, sceNpBandwidthTestShutdown);
-	//REG_FUNC(0x32B068C4, sceNpBandwidthTestAbort);
+	REG_FUNC(0x9246A673, sceNpLookupInit);
+	REG_FUNC(0x0158B61B, sceNpLookupTerm);
+	REG_FUNC(0x5110E17E, sceNpLookupCreateTitleCtx);
+	REG_FUNC(0x33B64699, sceNpLookupDeleteTitleCtx);
+	REG_FUNC(0x9E42E922, sceNpLookupCreateRequest);
+	REG_FUNC(0x8B608BF6, sceNpLookupDeleteRequest);
+	REG_FUNC(0x027587C4, sceNpLookupAbortRequest);
+	REG_FUNC(0xB0C9DC45, sceNpLookupSetTimeout);
+	REG_FUNC(0xCF956F23, sceNpLookupWaitAsync);
+	REG_FUNC(0xFCDBA234, sceNpLookupPollAsync);
+	REG_FUNC(0xB1A14879, sceNpLookupNpId);
+	REG_FUNC(0x5387BABB, sceNpLookupNpIdAsync);
+	REG_FUNC(0x6A1BF429, sceNpLookupUserProfile);
+	REG_FUNC(0xE5285E0F, sceNpLookupUserProfileAsync);
+	REG_FUNC(0xFDB0AE47, sceNpLookupAvatarImage);
+	REG_FUNC(0x282BD43C, sceNpLookupAvatarImageAsync);
+	REG_FUNC(0x081FA13C, sceNpBandwidthTestInitStart);
+	REG_FUNC(0xE0EBFBF6, sceNpBandwidthTestGetStatus);
+	REG_FUNC(0x58D92EFD, sceNpBandwidthTestShutdown);
+	REG_FUNC(0x32B068C4, sceNpBandwidthTestAbort);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceUlt.cpp b/rpcs3/Emu/ARMv7/Modules/sceUlt.cpp
index 6fb390fbd8..68216d7ddc 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceUlt.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceUlt.cpp
@@ -2,8 +2,545 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceLibKernel.h"
+
 extern psv_log_base sceUlt;
 
+#define CHECK_SIZE(type, size) static_assert(sizeof(type) == size, "Invalid " #type " size")
+
+struct _SceUltOptParamHeader
+{
+	s64 reserved[2];
+};
+
+struct SceUltWaitingQueueResourcePoolOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltWaitingQueueResourcePoolOptParam, 128);
+
+struct SceUltWaitingQueueResourcePool
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltWaitingQueueResourcePool, 256);
+
+struct SceUltQueueDataResourcePoolOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltQueueDataResourcePoolOptParam, 128);
+
+struct SceUltQueueDataResourcePool
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltQueueDataResourcePool, 256);
+
+struct SceUltMutexOptParam
+{
+	_SceUltOptParamHeader header;
+	u32 attribute;
+	u32 reserved_0;
+	u64 reserved[13];
+};
+
+CHECK_SIZE(SceUltMutexOptParam, 128);
+
+struct SceUltMutex
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltMutex, 256);
+
+struct SceUltConditionVariableOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltConditionVariableOptParam, 128);
+
+struct SceUltConditionVariable
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltConditionVariable, 256);
+
+struct SceUltQueueOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltQueueOptParam, 128);
+
+struct SceUltQueue
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltQueue, 256);
+
+struct SceUltReaderWriterLockOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltReaderWriterLockOptParam, 128);
+
+struct SceUltReaderWriterLock
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltReaderWriterLock, 256);
+
+struct SceUltSemaphoreOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltSemaphoreOptParam, 128);
+
+struct SceUltSemaphore
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltSemaphore, 256);
+
+struct SceUltUlthreadRuntimeOptParam
+{
+	_SceUltOptParamHeader header;
+
+	u32 oneShotThreadStackSize;
+	s32 workerThreadPriority;
+	u32 workerThreadCpuAffinityMask;
+	u32 workerThreadAttr;
+	vm::psv::ptr<const SceKernelThreadOptParam> workerThreadOptParam;
+
+	u64 reserved[11];
+};
+
+CHECK_SIZE(SceUltUlthreadRuntimeOptParam, 128);
+
+struct SceUltUlthreadRuntime
+{
+	u64 reserved[128];
+};
+
+CHECK_SIZE(SceUltUlthreadRuntime, 1024);
+
+struct SceUltUlthreadOptParam
+{
+	_SceUltOptParamHeader header;
+	u32 attribute;
+	u32 reserved_0;
+	u64 reserved[13];
+};
+
+CHECK_SIZE(SceUltUlthreadOptParam, 128);
+
+struct SceUltUlthread
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltUlthread, 256);
+
+typedef vm::psv::ptr<s32(u32 arg)> SceUltUlthreadEntry;
+
+// Functions
+
+s32 _sceUltWaitingQueueResourcePoolOptParamInitialize(vm::psv::ptr<SceUltWaitingQueueResourcePoolOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltWaitingQueueResourcePoolGetWorkAreaSize(u32 numThreads, u32 numSyncObjects)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltWaitingQueueResourcePoolCreate(
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> pool,
+	vm::psv::ptr<const char> name,
+	u32 numThreads,
+	u32 numSyncObjects,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltWaitingQueueResourcePoolOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltWaitingQueueResourcePoolDestroy(vm::psv::ptr<SceUltWaitingQueueResourcePool> pool)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueDataResourcePoolOptParamInitialize(vm::psv::ptr<SceUltQueueDataResourcePoolOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltQueueDataResourcePoolGetWorkAreaSize(u32 numData, u32 dataSize, u32 numQueueObject)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueDataResourcePoolCreate(
+	vm::psv::ptr<SceUltQueueDataResourcePool> pool,
+	vm::psv::ptr<const char> name,
+	u32 numData,
+	u32 dataSize,
+	u32 numQueueObject,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltQueueDataResourcePoolOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueDataResourcePoolDestroy(vm::psv::ptr<SceUltQueueDataResourcePool> pool)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltMutexGetStandaloneWorkAreaSize(u32 waitingQueueDepth, u32 numConditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltMutexOptParamInitialize(vm::psv::ptr<SceUltMutexOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltMutexCreate(
+	vm::psv::ptr<SceUltMutex> mutex,
+	vm::psv::ptr<const char> name,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<const SceUltMutexOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltMutexCreateStandalone(
+	vm::psv::ptr<SceUltMutex> mutex,
+	vm::psv::ptr<const char> name,
+	u32 numConditionVariable,
+	u32 maxNumThreads,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltMutexOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexLock(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexTryLock(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexUnlock(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexDestroy(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltConditionVariableOptParamInitialize(vm::psv::ptr<SceUltConditionVariableOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltConditionVariableCreate(
+	vm::psv::ptr<SceUltConditionVariable> conditionVariable,
+	vm::psv::ptr<const char> name,
+	vm::psv::ptr<SceUltMutex> mutex,
+	vm::psv::ptr<const SceUltConditionVariableOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableSignal(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableSignalAll(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableWait(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableDestroy(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueOptParamInitialize(vm::psv::ptr<SceUltQueueOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltQueueGetStandaloneWorkAreaSize(u32 queueDepth,
+	u32 dataSize,
+	u32 waitingQueueLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueCreate(
+	vm::psv::ptr<SceUltQueue> queue,
+	vm::psv::ptr<const char> _name,
+	u32 dataSize,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> resourcePool,
+	vm::psv::ptr<SceUltQueueDataResourcePool> queueResourcePool,
+	vm::psv::ptr<const SceUltQueueOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueCreateStandalone(
+	vm::psv::ptr<SceUltQueue> queue,
+	vm::psv::ptr<const char> name,
+	u32 queueDepth,
+	u32 dataSize,
+	u32 waitingQueueLength,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltQueueOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueuePush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueTryPush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueuePop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueTryPop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueDestroy(vm::psv::ptr<SceUltQueue> queue)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltReaderWriterLockOptParamInitialize(vm::psv::ptr<SceUltReaderWriterLockOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltReaderWriterLockCreate(
+	vm::psv::ptr<SceUltReaderWriterLock> rwlock,
+	vm::psv::ptr<const char> name,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltReaderWriterLockCreateStandalone(
+	vm::psv::ptr<SceUltReaderWriterLock> rwlock,
+	vm::psv::ptr<const char> name,
+	u32 waitingQueueDepth,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltReaderWriterLockGetStandaloneWorkAreaSize(u32 waitingQueueDepth)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockTryLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockUnlockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockTryLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockUnlockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockDestroy(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltSemaphoreOptParamInitialize(vm::psv::ptr<SceUltSemaphoreOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltSemaphoreCreate(
+	vm::psv::ptr<SceUltSemaphore> semaphore,
+	vm::psv::ptr<const char> name,
+	s32 numInitialResource,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<const SceUltSemaphoreOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreTryAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreRelease(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreDestroy(vm::psv::ptr<SceUltSemaphore> semaphore)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadRuntimeOptParamInitialize(vm::psv::ptr<SceUltUlthreadRuntimeOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltUlthreadRuntimeGetWorkAreaSize(u32 numMaxUlthread, u32 numWorkerThread)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadRuntimeCreate(
+	vm::psv::ptr<SceUltUlthreadRuntime> runtime,
+	vm::psv::ptr<const char> name,
+	u32 numMaxUlthread,
+	u32 numWorkerThread,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltUlthreadRuntimeOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadRuntimeDestroy(vm::psv::ptr<SceUltUlthreadRuntime> runtime)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadOptParamInitialize(vm::psv::ptr<SceUltUlthreadOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadCreate(
+	vm::psv::ptr<SceUltUlthread> ulthread,
+	vm::psv::ptr<const char> name,
+	SceUltUlthreadEntry entry,
+	u32 arg,
+	vm::psv::ptr<void> context,
+	u32 sizeContext,
+	vm::psv::ptr<SceUltUlthreadRuntime> runtime,
+	vm::psv::ptr<const SceUltUlthreadOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadYield()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadExit(s32 status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadTryJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadGetSelf(vm::psv::ptr<vm::psv::ptr<SceUltUlthread>> ulthread)
+{
+	throw __FUNCTION__;
+}
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceUlt, #name, name)
 
 psv_log_base sceUlt("SceUlt", []()
@@ -12,57 +549,57 @@ psv_log_base sceUlt("SceUlt", []()
 	sceUlt.on_unload = nullptr;
 	sceUlt.on_stop = nullptr;
 
-	//REG_FUNC(0xEF094E35, _sceUltWaitingQueueResourcePoolOptParamInitialize);
-	//REG_FUNC(0x644DA029, sceUltWaitingQueueResourcePoolGetWorkAreaSize);
-	//REG_FUNC(0x62F9493E, _sceUltWaitingQueueResourcePoolCreate);
-	//REG_FUNC(0xC9E96714, sceUltWaitingQueueResourcePoolDestroy);
-	//REG_FUNC(0x8A4F88A2, _sceUltQueueDataResourcePoolOptParamInitialize);
-	//REG_FUNC(0xECDA7FEE, sceUltQueueDataResourcePoolGetWorkAreaSize);
-	//REG_FUNC(0x40856827, _sceUltQueueDataResourcePoolCreate);
-	//REG_FUNC(0x2B8D33F1, sceUltQueueDataResourcePoolDestroy);
-	//REG_FUNC(0x24D87E05, _sceUltMutexOptParamInitialize);
-	//REG_FUNC(0x5AFEC7A1, _sceUltMutexCreate);
-	//REG_FUNC(0x001EAC8A, sceUltMutexLock);
-	//REG_FUNC(0xE5936A69, sceUltMutexTryLock);
-	//REG_FUNC(0x897C9097, sceUltMutexUnlock);
-	//REG_FUNC(0xEEBD9052, sceUltMutexDestroy);
-	//REG_FUNC(0x0603FCC1, _sceUltConditionVariableOptParamInitialize);
-	//REG_FUNC(0xD76A156C, _sceUltConditionVariableCreate);
-	//REG_FUNC(0x9FE7CB9F, sceUltConditionVariableSignal);
-	//REG_FUNC(0xEBB6FC1E, sceUltConditionVariableSignalAll);
-	//REG_FUNC(0x2CD0F57C, sceUltConditionVariableWait);
-	//REG_FUNC(0x53420ED2, sceUltConditionVariableDestroy);
-	//REG_FUNC(0xF7A83023, _sceUltQueueOptParamInitialize);
-	//REG_FUNC(0x14DA1BB4, _sceUltQueueCreate);
-	//REG_FUNC(0xA7E78FF9, sceUltQueuePush);
-	//REG_FUNC(0x6D356B29, sceUltQueueTryPush);
-	//REG_FUNC(0x1AD58A53, sceUltQueuePop);
-	//REG_FUNC(0x2A1A8EA6, sceUltQueueTryPop);
-	//REG_FUNC(0xF37862DE, sceUltQueueDestroy);
-	//REG_FUNC(0xD8334A1F, _sceUltReaderWriterLockOptParamInitialize);
-	//REG_FUNC(0x2FB0EB32, _sceUltReaderWriterLockCreate);
-	//REG_FUNC(0x9AD07630, sceUltReaderWriterLockLockRead);
-	//REG_FUNC(0x2629C055, sceUltReaderWriterLockTryLockRead);
-	//REG_FUNC(0x218D4743, sceUltReaderWriterLockUnlockRead);
-	//REG_FUNC(0xF5F63E2C, sceUltReaderWriterLockLockWrite);
-	//REG_FUNC(0x944FB222, sceUltReaderWriterLockTryLockWrite);
-	//REG_FUNC(0x2A5741F5, sceUltReaderWriterLockUnlockWrite);
-	//REG_FUNC(0xB1FEB79B, sceUltReaderWriterLockDestroy);
-	//REG_FUNC(0x8E31B9FE, _sceUltSemaphoreOptParamInitialize);
-	//REG_FUNC(0xDD59562C, _sceUltSemaphoreCreate);
-	//REG_FUNC(0xF220D3AE, sceUltSemaphoreAcquire);
-	//REG_FUNC(0xAF15606D, sceUltSemaphoreTryAcquire);
-	//REG_FUNC(0x65376E2D, sceUltSemaphoreRelease);
-	//REG_FUNC(0x8EC57420, sceUltSemaphoreDestroy);
-	//REG_FUNC(0x8486DDE6, _sceUltUlthreadRuntimeOptParamInitialize);
-	//REG_FUNC(0x5435C586, sceUltUlthreadRuntimeGetWorkAreaSize);
-	//REG_FUNC(0x86DDA3AE, _sceUltUlthreadRuntimeCreate);
-	//REG_FUNC(0x4E9A745C, sceUltUlthreadRuntimeDestroy);
-	//REG_FUNC(0x7F373376, _sceUltUlthreadOptParamInitialize);
-	//REG_FUNC(0xB1290375, _sceUltUlthreadCreate);
-	//REG_FUNC(0xCAD57BAD, sceUltUlthreadYield);
-	//REG_FUNC(0x1E401DF8, sceUltUlthreadExit);
-	//REG_FUNC(0x63483381, sceUltUlthreadJoin);
-	//REG_FUNC(0xB4CF88AC, sceUltUlthreadTryJoin);
-	//REG_FUNC(0xA798C5D7, sceUltUlthreadGetSelf);
+	REG_FUNC(0xEF094E35, _sceUltWaitingQueueResourcePoolOptParamInitialize);
+	REG_FUNC(0x644DA029, sceUltWaitingQueueResourcePoolGetWorkAreaSize);
+	REG_FUNC(0x62F9493E, _sceUltWaitingQueueResourcePoolCreate);
+	REG_FUNC(0xC9E96714, sceUltWaitingQueueResourcePoolDestroy);
+	REG_FUNC(0x8A4F88A2, _sceUltQueueDataResourcePoolOptParamInitialize);
+	REG_FUNC(0xECDA7FEE, sceUltQueueDataResourcePoolGetWorkAreaSize);
+	REG_FUNC(0x40856827, _sceUltQueueDataResourcePoolCreate);
+	REG_FUNC(0x2B8D33F1, sceUltQueueDataResourcePoolDestroy);
+	REG_FUNC(0x24D87E05, _sceUltMutexOptParamInitialize);
+	REG_FUNC(0x5AFEC7A1, _sceUltMutexCreate);
+	REG_FUNC(0x001EAC8A, sceUltMutexLock);
+	REG_FUNC(0xE5936A69, sceUltMutexTryLock);
+	REG_FUNC(0x897C9097, sceUltMutexUnlock);
+	REG_FUNC(0xEEBD9052, sceUltMutexDestroy);
+	REG_FUNC(0x0603FCC1, _sceUltConditionVariableOptParamInitialize);
+	REG_FUNC(0xD76A156C, _sceUltConditionVariableCreate);
+	REG_FUNC(0x9FE7CB9F, sceUltConditionVariableSignal);
+	REG_FUNC(0xEBB6FC1E, sceUltConditionVariableSignalAll);
+	REG_FUNC(0x2CD0F57C, sceUltConditionVariableWait);
+	REG_FUNC(0x53420ED2, sceUltConditionVariableDestroy);
+	REG_FUNC(0xF7A83023, _sceUltQueueOptParamInitialize);
+	REG_FUNC(0x14DA1BB4, _sceUltQueueCreate);
+	REG_FUNC(0xA7E78FF9, sceUltQueuePush);
+	REG_FUNC(0x6D356B29, sceUltQueueTryPush);
+	REG_FUNC(0x1AD58A53, sceUltQueuePop);
+	REG_FUNC(0x2A1A8EA6, sceUltQueueTryPop);
+	REG_FUNC(0xF37862DE, sceUltQueueDestroy);
+	REG_FUNC(0xD8334A1F, _sceUltReaderWriterLockOptParamInitialize);
+	REG_FUNC(0x2FB0EB32, _sceUltReaderWriterLockCreate);
+	REG_FUNC(0x9AD07630, sceUltReaderWriterLockLockRead);
+	REG_FUNC(0x2629C055, sceUltReaderWriterLockTryLockRead);
+	REG_FUNC(0x218D4743, sceUltReaderWriterLockUnlockRead);
+	REG_FUNC(0xF5F63E2C, sceUltReaderWriterLockLockWrite);
+	REG_FUNC(0x944FB222, sceUltReaderWriterLockTryLockWrite);
+	REG_FUNC(0x2A5741F5, sceUltReaderWriterLockUnlockWrite);
+	REG_FUNC(0xB1FEB79B, sceUltReaderWriterLockDestroy);
+	REG_FUNC(0x8E31B9FE, _sceUltSemaphoreOptParamInitialize);
+	REG_FUNC(0xDD59562C, _sceUltSemaphoreCreate);
+	REG_FUNC(0xF220D3AE, sceUltSemaphoreAcquire);
+	REG_FUNC(0xAF15606D, sceUltSemaphoreTryAcquire);
+	REG_FUNC(0x65376E2D, sceUltSemaphoreRelease);
+	REG_FUNC(0x8EC57420, sceUltSemaphoreDestroy);
+	REG_FUNC(0x8486DDE6, _sceUltUlthreadRuntimeOptParamInitialize);
+	REG_FUNC(0x5435C586, sceUltUlthreadRuntimeGetWorkAreaSize);
+	REG_FUNC(0x86DDA3AE, _sceUltUlthreadRuntimeCreate);
+	REG_FUNC(0x4E9A745C, sceUltUlthreadRuntimeDestroy);
+	REG_FUNC(0x7F373376, _sceUltUlthreadOptParamInitialize);
+	REG_FUNC(0xB1290375, _sceUltUlthreadCreate);
+	REG_FUNC(0xCAD57BAD, sceUltUlthreadYield);
+	REG_FUNC(0x1E401DF8, sceUltUlthreadExit);
+	REG_FUNC(0x63483381, sceUltUlthreadJoin);
+	REG_FUNC(0xB4CF88AC, sceUltUlthreadTryJoin);
+	REG_FUNC(0xA798C5D7, sceUltUlthreadGetSelf);
 });
diff --git a/rpcs3/emucore.vcxproj b/rpcs3/emucore.vcxproj
index 1e6d47a50e..8864e59975 100644
--- a/rpcs3/emucore.vcxproj
+++ b/rpcs3/emucore.vcxproj
@@ -340,6 +340,7 @@
     <ClInclude Include="Emu\ARMv7\Modules\sceIme.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceNet.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceNpCommon.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceSsl.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceTouch.h" />
     <ClInclude Include="Emu\ARMv7\PSVFuncList.h" />
diff --git a/rpcs3/emucore.vcxproj.filters b/rpcs3/emucore.vcxproj.filters
index ac1531ee30..b45c4de188 100644
--- a/rpcs3/emucore.vcxproj.filters
+++ b/rpcs3/emucore.vcxproj.filters
@@ -1501,5 +1501,8 @@
     <ClInclude Include="Emu\ARMv7\Modules\sceTouch.h">
       <Filter>Emu\CPU\ARMv7\Modules</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceNpCommon.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file