diff --git a/rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp b/rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp
index 6d1739d789..815efa0461 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp
@@ -2,73 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceAppUtil;
-
-struct SceAppUtilInitParam
-{
-	u32 workBufSize;
-	char reserved[60];
-};
-
-struct SceAppUtilBootParam
-{
-	u32 attr;
-	u32 appVersion;
-	char reserved[32];
-};
-
-struct SceAppUtilSaveDataMountPoint
-{
-	char data[16];
-};
-
-struct SceAppUtilSaveDataSlotParam
-{
-	u32 status;
-	char title[64];
-	char subTitle[128];
-	char detail[512];
-	char iconPath[64];
-	s32 userParam;
-	u32 sizeKB;
-	SceDateTime modifiedTime;
-	char reserved[48];
-};
-
-struct SceAppUtilSaveDataSlotEmptyParam
-{
-	vm::psv::ptr<char> title;
-	vm::psv::ptr<char> iconPath;
-	vm::psv::ptr<void> iconBuf;
-	u32 iconBufSize;
-	char reserved[32];
-};
-
-struct SceAppUtilSaveDataSlot
-{
-	u32 id;
-	u32 status;
-	s32 userParam;
-	vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
-};
-
-struct SceAppUtilSaveDataFile
-{
-	vm::psv::ptr<const char> filePath;
-	vm::psv::ptr<void> buf;
-	u32 bufSize;
-	s64 offset;
-	u32 mode;
-	u32 progDelta;
-	char reserved[32];
-};
-
-struct SceAppUtilSaveDataFileSlot
-{
-	u32 id;
-	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
-	char reserved[32];
-};
+#include "sceAppUtil.h"
 
 s32 sceAppUtilInit(vm::psv::ptr<const SceAppUtilInitParam> initParam, vm::psv::ptr<SceAppUtilBootParam> bootParam)
 {
diff --git a/rpcs3/Emu/ARMv7/Modules/sceAppUtil.h b/rpcs3/Emu/ARMv7/Modules/sceAppUtil.h
new file mode 100644
index 0000000000..2e489cab22
--- /dev/null
+++ b/rpcs3/Emu/ARMv7/Modules/sceAppUtil.h
@@ -0,0 +1,69 @@
+#pragma once
+
+struct SceAppUtilInitParam
+{
+	u32 workBufSize;
+	char reserved[60];
+};
+
+struct SceAppUtilBootParam
+{
+	u32 attr;
+	u32 appVersion;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataMountPoint
+{
+	char data[16];
+};
+
+struct SceAppUtilSaveDataSlotParam
+{
+	u32 status;
+	char title[64];
+	char subTitle[128];
+	char detail[512];
+	char iconPath[64];
+	s32 userParam;
+	u32 sizeKB;
+	SceDateTime modifiedTime;
+	char reserved[48];
+};
+
+struct SceAppUtilSaveDataSlotEmptyParam
+{
+	vm::psv::ptr<char> title;
+	vm::psv::ptr<char> iconPath;
+	vm::psv::ptr<void> iconBuf;
+	u32 iconBufSize;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataSlot
+{
+	u32 id;
+	u32 status;
+	s32 userParam;
+	vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
+};
+
+struct SceAppUtilSaveDataFile
+{
+	vm::psv::ptr<const char> filePath;
+	vm::psv::ptr<void> buf;
+	u32 bufSize;
+	s64 offset;
+	u32 mode;
+	u32 progDelta;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataFileSlot
+{
+	u32 id;
+	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
+	char reserved[32];
+};
+
+extern psv_log_base sceAppUtil;
diff --git a/rpcs3/Emu/ARMv7/Modules/sceCamera.cpp b/rpcs3/Emu/ARMv7/Modules/sceCamera.cpp
index 79c219443c..e341d6d75f 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceCamera.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceCamera.cpp
@@ -4,6 +4,249 @@
 
 extern psv_log_base sceCamera;
 
+struct SceCameraInfo
+{
+	u32 sizeThis;
+	u32 wPriority;
+	u32 wFormat;
+	u32 wResolution;
+	u32 wFramerate;
+	u32 wWidth;
+	u32 wHeight;
+	u32 wRange;
+	u32 _padding_0;
+	u32 sizeIBase;
+	u32 sizeUBase;
+	u32 sizeVBase;
+	vm::psv::ptr<void> pvIBase;
+	vm::psv::ptr<void> pvUBase;
+	vm::psv::ptr<void> pvVBase;
+	u32 wPitch;
+	u32 wBuffer;
+};
+
+struct SceCameraRead
+{
+	u32 sizeThis;
+	s32 dwMode;
+	s32 _padding_0;
+	s32 dwStatus;
+	u32 qwFrame;
+	u32 qwTimestamp;
+	u32 sizeIBase;
+	u32 sizeUBase;
+	u32 sizeVBase;
+	vm::psv::ptr<void> pvIBase;
+	vm::psv::ptr<void> pvUBase;
+	vm::psv::ptr<void> pvVBase;
+};
+
+s32 sceCameraOpen(s32 devnum, vm::psv::ptr<SceCameraInfo> pInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraClose(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraStart(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraStop(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraRead(s32 devnum, vm::psv::ptr<SceCameraRead> pRead)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraIsActive(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSaturation(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSaturation(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetBrightness(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetBrightness(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetContrast(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetContrast(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSharpness(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSharpness(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetReverse(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetReverse(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetEffect(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetEffect(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetEV(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetEV(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetZoom(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetZoom(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetAntiFlicker(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetAntiFlicker(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetISO(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetISO(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetGain(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetGain(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetWhiteBalance(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetWhiteBalance(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetBacklight(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetBacklight(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetNightmode(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetNightmode(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraLedSwitch(s32 devnum, s32 iSwitch)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraLedBlink(s32 devnum, s32 iOnCount, s32 iOffCount, s32 iBlinkCount)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetNoiseReductionForDebug(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSharpnessOffForDebug(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+void sceCameraUseCacheMemoryForTrial(s32 isCache)
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceCamera, #name, name)
 
 psv_log_base sceCamera("SceCamera", []()
@@ -12,45 +255,45 @@ psv_log_base sceCamera("SceCamera", []()
 	sceCamera.on_unload = nullptr;
 	sceCamera.on_stop = nullptr;
 
-	//REG_FUNC(0xA462F801, sceCameraOpen);
-	//REG_FUNC(0xCD6E1CFC, sceCameraClose);
-	//REG_FUNC(0xA8FEAE35, sceCameraStart);
-	//REG_FUNC(0x1DD9C9CE, sceCameraStop);
-	//REG_FUNC(0x79B5C2DE, sceCameraRead);
-	//REG_FUNC(0x103A75B8, sceCameraIsActive);
-	//REG_FUNC(0x624F7653, sceCameraGetSaturation);
-	//REG_FUNC(0xF9F7CA3D, sceCameraSetSaturation);
-	//REG_FUNC(0x85D5951D, sceCameraGetBrightness);
-	//REG_FUNC(0x98D71588, sceCameraSetBrightness);
-	//REG_FUNC(0x8FBE84BE, sceCameraGetContrast);
-	//REG_FUNC(0x06FB2900, sceCameraSetContrast);
-	//REG_FUNC(0xAA72C3DC, sceCameraGetSharpness);
-	//REG_FUNC(0xD1A5BB0B, sceCameraSetSharpness);
-	//REG_FUNC(0x44F6043F, sceCameraGetReverse);
-	//REG_FUNC(0x1175F477, sceCameraSetReverse);
-	//REG_FUNC(0x7E8EF3B2, sceCameraGetEffect);
-	//REG_FUNC(0xE9D2CFB1, sceCameraSetEffect);
-	//REG_FUNC(0x8B5E6147, sceCameraGetEV);
-	//REG_FUNC(0x62AFF0B8, sceCameraSetEV);
-	//REG_FUNC(0x06D3816C, sceCameraGetZoom);
-	//REG_FUNC(0xF7464216, sceCameraSetZoom);
-	//REG_FUNC(0x9FDACB99, sceCameraGetAntiFlicker);
-	//REG_FUNC(0xE312958A, sceCameraSetAntiFlicker);
-	//REG_FUNC(0x4EBD5C68, sceCameraGetISO);
-	//REG_FUNC(0x3CF630A1, sceCameraSetISO);
-	//REG_FUNC(0x2C36D6F3, sceCameraGetGain);
-	//REG_FUNC(0xE65CFE86, sceCameraSetGain);
-	//REG_FUNC(0xDBFFA1DA, sceCameraGetWhiteBalance);
-	//REG_FUNC(0x4D4514AC, sceCameraSetWhiteBalance);
-	//REG_FUNC(0x8DD1292B, sceCameraGetBacklight);
-	//REG_FUNC(0xAE071044, sceCameraSetBacklight);
-	//REG_FUNC(0x12B6FF26, sceCameraGetNightmode);
-	//REG_FUNC(0x3F26233E, sceCameraSetNightmode);
-	//REG_FUNC(0xD02CFA5C, sceCameraLedSwitch);
-	//REG_FUNC(0x89B16030, sceCameraLedBlink);
-	//REG_FUNC(0x7670474C, sceCameraUseCacheMemoryForTrial);
-	//REG_FUNC(0x27BB0528, sceCameraGetNoiseReductionForDebug);
-	//REG_FUNC(0x233C9E27, sceCameraSetNoiseReductionForDebug);
-	//REG_FUNC(0xC387F4DC, sceCameraGetSharpnessOffForDebug);
-	//REG_FUNC(0xE22C2375, sceCameraSetSharpnessOffForDebug);
+	REG_FUNC(0xA462F801, sceCameraOpen);
+	REG_FUNC(0xCD6E1CFC, sceCameraClose);
+	REG_FUNC(0xA8FEAE35, sceCameraStart);
+	REG_FUNC(0x1DD9C9CE, sceCameraStop);
+	REG_FUNC(0x79B5C2DE, sceCameraRead);
+	REG_FUNC(0x103A75B8, sceCameraIsActive);
+	REG_FUNC(0x624F7653, sceCameraGetSaturation);
+	REG_FUNC(0xF9F7CA3D, sceCameraSetSaturation);
+	REG_FUNC(0x85D5951D, sceCameraGetBrightness);
+	REG_FUNC(0x98D71588, sceCameraSetBrightness);
+	REG_FUNC(0x8FBE84BE, sceCameraGetContrast);
+	REG_FUNC(0x06FB2900, sceCameraSetContrast);
+	REG_FUNC(0xAA72C3DC, sceCameraGetSharpness);
+	REG_FUNC(0xD1A5BB0B, sceCameraSetSharpness);
+	REG_FUNC(0x44F6043F, sceCameraGetReverse);
+	REG_FUNC(0x1175F477, sceCameraSetReverse);
+	REG_FUNC(0x7E8EF3B2, sceCameraGetEffect);
+	REG_FUNC(0xE9D2CFB1, sceCameraSetEffect);
+	REG_FUNC(0x8B5E6147, sceCameraGetEV);
+	REG_FUNC(0x62AFF0B8, sceCameraSetEV);
+	REG_FUNC(0x06D3816C, sceCameraGetZoom);
+	REG_FUNC(0xF7464216, sceCameraSetZoom);
+	REG_FUNC(0x9FDACB99, sceCameraGetAntiFlicker);
+	REG_FUNC(0xE312958A, sceCameraSetAntiFlicker);
+	REG_FUNC(0x4EBD5C68, sceCameraGetISO);
+	REG_FUNC(0x3CF630A1, sceCameraSetISO);
+	REG_FUNC(0x2C36D6F3, sceCameraGetGain);
+	REG_FUNC(0xE65CFE86, sceCameraSetGain);
+	REG_FUNC(0xDBFFA1DA, sceCameraGetWhiteBalance);
+	REG_FUNC(0x4D4514AC, sceCameraSetWhiteBalance);
+	REG_FUNC(0x8DD1292B, sceCameraGetBacklight);
+	REG_FUNC(0xAE071044, sceCameraSetBacklight);
+	REG_FUNC(0x12B6FF26, sceCameraGetNightmode);
+	REG_FUNC(0x3F26233E, sceCameraSetNightmode);
+	REG_FUNC(0xD02CFA5C, sceCameraLedSwitch);
+	REG_FUNC(0x89B16030, sceCameraLedBlink);
+	REG_FUNC(0x7670474C, sceCameraUseCacheMemoryForTrial);
+	REG_FUNC(0x27BB0528, sceCameraGetNoiseReductionForDebug);
+	REG_FUNC(0x233C9E27, sceCameraSetNoiseReductionForDebug);
+	REG_FUNC(0xC387F4DC, sceCameraGetSharpnessOffForDebug);
+	REG_FUNC(0xE22C2375, sceCameraSetSharpnessOffForDebug);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp b/rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp
index 013f4ff52b..cda018a995 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp
@@ -4,6 +4,33 @@
 
 extern psv_log_base sceCodecEngine;
 
+struct SceCodecEnginePmonProcessorLoad
+{
+	u32 size;
+	u32 average;
+};
+
+s32 sceCodecEnginePmonStart()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonStop()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonGetProcessorLoad(vm::psv::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonReset()
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceCodecEngine, #name, name)
 
 psv_log_base sceCodecEngine("SceCodecEngine", []()
@@ -12,8 +39,8 @@ psv_log_base sceCodecEngine("SceCodecEngine", []()
 	sceCodecEngine.on_unload = nullptr;
 	sceCodecEngine.on_stop = nullptr;
 
-	//REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
-	//REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);
-	//REG_FUNC(0x859E4A68, sceCodecEnginePmonGetProcessorLoad);
-	//REG_FUNC(0xA097E4C8, sceCodecEnginePmonReset);
+	REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
+	REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);
+	REG_FUNC(0x859E4A68, sceCodecEnginePmonGetProcessorLoad);
+	REG_FUNC(0xA097E4C8, sceCodecEnginePmonReset);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp b/rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp
index 1f5a4863a3..3e7b998f63 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp
@@ -2,8 +2,509 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceGxm.h"
+#include "sceAppUtil.h"
+#include "sceIme.h"
+
 extern psv_log_base sceCommonDialog;
 
+enum SceCommonDialogStatus : s32
+{
+	SCE_COMMON_DIALOG_STATUS_NONE = 0,
+	SCE_COMMON_DIALOG_STATUS_RUNNING = 1,
+	SCE_COMMON_DIALOG_STATUS_FINISHED = 2
+};
+
+enum SceCommonDialogResult : s32
+{
+	SCE_COMMON_DIALOG_RESULT_OK,
+	SCE_COMMON_DIALOG_RESULT_USER_CANCELED,
+	SCE_COMMON_DIALOG_RESULT_ABORTED
+};
+
+struct SceCommonDialogRenderTargetInfo
+{
+	vm::psv::ptr<void> depthSurfaceData;
+	vm::psv::ptr<void> colorSurfaceData;
+	SceGxmColorSurfaceType surfaceType;
+	SceGxmColorFormat colorFormat;
+	u32 width;
+	u32 height;
+	u32 strideInPixels;
+	u8 reserved[32];
+};
+
+struct SceCommonDialogUpdateParam
+{
+	SceCommonDialogRenderTargetInfo renderTarget;
+	vm::psv::ptr<SceGxmSyncObject> displaySyncObject;
+	u8 reserved[32];
+};
+
+struct SceMsgDialogUserMessageParam
+{
+	s32 buttonType;
+	vm::psv::ptr<const char> msg;
+	char reserved[32];
+};
+
+struct SceMsgDialogSystemMessageParam
+{
+	s32 sysMsgType;
+	s32 value;
+	char reserved[32];
+};
+
+struct SceMsgDialogErrorCodeParam
+{
+	s32 errorCode;
+	char reserved[32];
+};
+
+struct SceMsgDialogProgressBarParam
+{
+	s32 barType;
+	SceMsgDialogSystemMessageParam sysMsgParam;
+	vm::psv::ptr<const char> msg;
+	char reserved[32];
+};
+
+struct SceMsgDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	vm::psv::ptr<SceMsgDialogUserMessageParam> userMsgParam;
+	vm::psv::ptr<SceMsgDialogSystemMessageParam> sysMsgParam;
+	vm::psv::ptr<SceMsgDialogErrorCodeParam> errorCodeParam;
+	vm::psv::ptr<SceMsgDialogProgressBarParam> progBarParam;
+	u32 flag;
+	char reserved[32];
+};
+
+struct SceMsgDialogResult
+{
+	s32 mode;
+	s32 result;
+	s32 buttonId;
+	u8 reserved[32];
+};
+
+
+struct SceNetCheckDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	u8 reserved[128];
+};
+
+struct SceNetCheckDialogResult
+{
+	s32 result;
+	u8 reserved[128];
+};
+
+struct SceSaveDataDialogFixedParam
+{
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogListParam
+{
+	vm::psv::ptr<const u32> slotList;
+	u32 slotListSize;
+	s32 focusPos;
+	u32 focusId;
+	vm::psv::ptr<const char> listTitle;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogUserMessageParam
+{
+	s32 buttonType;
+	vm::psv::ptr<const char> msg;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSystemMessageParam
+{
+	s32 sysMsgType;
+	s32 value;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogErrorCodeParam
+{
+	s32 errorCode;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogProgressBarParam
+{
+	s32 barType;
+	SceSaveDataDialogSystemMessageParam sysMsgParam;
+	vm::psv::ptr<const char> msg;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSlotConfigParam
+{
+	vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint;
+	vm::psv::ptr<const char> appSubDir;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	s32 dispType;
+	vm::psv::ptr<SceSaveDataDialogFixedParam> fixedParam;
+	vm::psv::ptr<SceSaveDataDialogListParam> listParam;
+	vm::psv::ptr<SceSaveDataDialogUserMessageParam> userMsgParam;
+	vm::psv::ptr<SceSaveDataDialogSystemMessageParam> sysMsgParam;
+	vm::psv::ptr<SceSaveDataDialogErrorCodeParam> errorCodeParam;
+	vm::psv::ptr<SceSaveDataDialogProgressBarParam> progBarParam;
+	vm::psv::ptr<SceSaveDataDialogSlotConfigParam> slotConfParam;
+	u32 flag;
+	vm::psv::ptr<void> userdata;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogFinishParam
+{
+	u32 flag;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSlotInfo
+{
+	u32 isExist;
+	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
+	u8 reserved[32];
+};
+
+struct SceSaveDataDialogResult
+{
+	s32 mode;
+	s32 result;
+	s32 buttonId;
+	u32 slotId;
+	vm::psv::ptr<SceSaveDataDialogSlotInfo> slotInfo;
+	vm::psv::ptr<void> userdata;
+	char reserved[32];
+};
+
+
+struct SceImeDialogParam
+{
+	u32 sdkVersion;
+	u32 inputMethod;
+	u64 supportedLanguages;
+	s32 languagesForced;
+	u32 type;
+	u32 option;
+	vm::psv::ptr<SceImeCharFilter> filter;
+	u32 dialogMode;
+	u32 textBoxMode;
+	vm::psv::ptr<const u16> title;
+	u32 maxTextLength;
+	vm::psv::ptr<u16> initialText;
+	vm::psv::ptr<u16> inputTextBuffer;
+	char reserved[32];
+};
+
+struct SceImeDialogResult
+{
+	s32 result;
+	char reserved[32];
+};
+
+enum ScePhotoImportDialogFormatType : s32
+{
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_UNKNOWN = 0,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_JPEG,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_PNG,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_GIF,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_BMP,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_TIFF
+};
+
+enum ScePhotoImportDialogOrientation : s32
+{
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_UNKNOWN = 0,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_LEFT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_RIGHT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_RIGHT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_LEFT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_TOP,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_TOP,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_BOTTOM,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_BOTTOM
+};
+
+struct ScePhotoImportDialogFileDataSub
+{
+	u32 width;
+	u32 height;
+	ScePhotoImportDialogFormatType format;
+	ScePhotoImportDialogOrientation orientation;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogFileData
+{
+	char fileName[1024];
+	char photoTitle[256];
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogItemData
+{
+	ScePhotoImportDialogFileData fileData;
+	ScePhotoImportDialogFileDataSub dataSub;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogResult
+{
+	s32 result;
+	u32 importedItemNum;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	u32 visibleCategory;
+	u32 itemCount;
+	vm::psv::ptr<ScePhotoImportDialogItemData> itemData;
+	char reserved[32];
+};
+
+struct ScePhotoReviewDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	char fileName[1024];
+	vm::psv::ptr<void> workMemory;
+	u32 workMemorySize;
+	char reserved[32];
+};
+
+struct ScePhotoReviewDialogResult
+{
+	s32 result;
+	char reserved[32];
+};
+
+
+s32 sceCommonDialogUpdate(vm::psv::ptr<const SceCommonDialogUpdateParam> updateParam)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogInit(vm::psv::ptr<const SceMsgDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceMsgDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogGetResult(vm::psv::ptr<SceMsgDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogClose()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogProgressBarInc(s32 target, u32 delta)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogProgressBarSetValue(s32 target, u32 rate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogInit(vm::psv::ptr<SceNetCheckDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceNetCheckDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogGetResult(vm::psv::ptr<SceNetCheckDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogInit(vm::psv::ptr<const SceSaveDataDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceSaveDataDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogGetResult(vm::psv::ptr<SceSaveDataDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceSaveDataDialogGetSubStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogSubClose()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogContinue(vm::psv::ptr<const SceSaveDataDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogFinish(vm::psv::ptr<const SceSaveDataDialogFinishParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogProgressBarInc(s32 target, u32 delta)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogInit(vm::psv::ptr<const SceImeDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceImeDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogGetResult(vm::psv::ptr<SceImeDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogInit(vm::psv::ptr<const ScePhotoImportDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus scePhotoImportDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogGetResult(vm::psv::ptr<ScePhotoImportDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogInit(vm::psv::ptr<const ScePhotoReviewDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus scePhotoReviewDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogGetResult(vm::psv::ptr<ScePhotoReviewDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceCommonDialog, #name, name)
 
 psv_log_base sceCommonDialog("SceCommonDialog", []()
@@ -12,44 +513,44 @@ psv_log_base sceCommonDialog("SceCommonDialog", []()
 	sceCommonDialog.on_unload = nullptr;
 	sceCommonDialog.on_stop = nullptr;
 
-	//REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
-	//REG_FUNC(0x755FF270, sceMsgDialogInit);
-	//REG_FUNC(0x4107019E, sceMsgDialogGetStatus);
-	//REG_FUNC(0xC296D396, sceMsgDialogClose);
-	//REG_FUNC(0x0CC66115, sceMsgDialogAbort);
-	//REG_FUNC(0xBB3BFC89, sceMsgDialogGetResult);
-	//REG_FUNC(0x81ACF695, sceMsgDialogTerm);
-	//REG_FUNC(0x7BE0E08B, sceMsgDialogProgressBarInc);
-	//REG_FUNC(0x9CDA5E0D, sceMsgDialogProgressBarSetValue);
-	//REG_FUNC(0xA38A4A0D, sceNetCheckDialogInit);
-	//REG_FUNC(0x8027292A, sceNetCheckDialogGetStatus);
-	//REG_FUNC(0x2D8EDF09, sceNetCheckDialogAbort);
-	//REG_FUNC(0xB05FCE9E, sceNetCheckDialogGetResult);
-	//REG_FUNC(0x8BE51C15, sceNetCheckDialogTerm);
-	//REG_FUNC(0xBF5248FA, sceSaveDataDialogInit);
-	//REG_FUNC(0x6E258046, sceSaveDataDialogGetStatus);
-	//REG_FUNC(0x013E7F74, sceSaveDataDialogAbort);
-	//REG_FUNC(0xB2FF576E, sceSaveDataDialogGetResult);
-	//REG_FUNC(0x2192A10A, sceSaveDataDialogTerm);
-	//REG_FUNC(0x19192C8B, sceSaveDataDialogContinue);
-	//REG_FUNC(0xBA0542CA, sceSaveDataDialogGetSubStatus);
-	//REG_FUNC(0x415D6068, sceSaveDataDialogSubClose);
-	//REG_FUNC(0x6C49924B, sceSaveDataDialogFinish);
-	//REG_FUNC(0xBDE00A83, sceSaveDataDialogProgressBarInc);
-	//REG_FUNC(0x5C322D1E, sceSaveDataDialogProgressBarSetValue);
-	//REG_FUNC(0x1E7043BF, sceImeDialogInit);
-	//REG_FUNC(0xCF0431FD, sceImeDialogGetStatus);
-	//REG_FUNC(0x594A220E, sceImeDialogAbort);
-	//REG_FUNC(0x2EB3D046, sceImeDialogGetResult);
-	//REG_FUNC(0x838A3AF4, sceImeDialogTerm);
-	//REG_FUNC(0x73EE7C9C, scePhotoImportDialogInit);
-	//REG_FUNC(0x032206D8, scePhotoImportDialogGetStatus);
-	//REG_FUNC(0xD855414C, scePhotoImportDialogGetResult);
-	//REG_FUNC(0x7FE5BD77, scePhotoImportDialogTerm);
-	//REG_FUNC(0x4B125581, scePhotoImportDialogAbort);
-	//REG_FUNC(0xCD990375, scePhotoReviewDialogInit);
-	//REG_FUNC(0xF4F600CA, scePhotoReviewDialogGetStatus);
-	//REG_FUNC(0xFFA35858, scePhotoReviewDialogGetResult);
-	//REG_FUNC(0xC700B2DF, scePhotoReviewDialogTerm);
-	//REG_FUNC(0x74FF2A8B, scePhotoReviewDialogAbort);
+	REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
+	REG_FUNC(0x755FF270, sceMsgDialogInit);
+	REG_FUNC(0x4107019E, sceMsgDialogGetStatus);
+	REG_FUNC(0xC296D396, sceMsgDialogClose);
+	REG_FUNC(0x0CC66115, sceMsgDialogAbort);
+	REG_FUNC(0xBB3BFC89, sceMsgDialogGetResult);
+	REG_FUNC(0x81ACF695, sceMsgDialogTerm);
+	REG_FUNC(0x7BE0E08B, sceMsgDialogProgressBarInc);
+	REG_FUNC(0x9CDA5E0D, sceMsgDialogProgressBarSetValue);
+	REG_FUNC(0xA38A4A0D, sceNetCheckDialogInit);
+	REG_FUNC(0x8027292A, sceNetCheckDialogGetStatus);
+	REG_FUNC(0x2D8EDF09, sceNetCheckDialogAbort);
+	REG_FUNC(0xB05FCE9E, sceNetCheckDialogGetResult);
+	REG_FUNC(0x8BE51C15, sceNetCheckDialogTerm);
+	REG_FUNC(0xBF5248FA, sceSaveDataDialogInit);
+	REG_FUNC(0x6E258046, sceSaveDataDialogGetStatus);
+	REG_FUNC(0x013E7F74, sceSaveDataDialogAbort);
+	REG_FUNC(0xB2FF576E, sceSaveDataDialogGetResult);
+	REG_FUNC(0x2192A10A, sceSaveDataDialogTerm);
+	REG_FUNC(0x19192C8B, sceSaveDataDialogContinue);
+	REG_FUNC(0xBA0542CA, sceSaveDataDialogGetSubStatus);
+	REG_FUNC(0x415D6068, sceSaveDataDialogSubClose);
+	REG_FUNC(0x6C49924B, sceSaveDataDialogFinish);
+	REG_FUNC(0xBDE00A83, sceSaveDataDialogProgressBarInc);
+	REG_FUNC(0x5C322D1E, sceSaveDataDialogProgressBarSetValue);
+	REG_FUNC(0x1E7043BF, sceImeDialogInit);
+	REG_FUNC(0xCF0431FD, sceImeDialogGetStatus);
+	REG_FUNC(0x594A220E, sceImeDialogAbort);
+	REG_FUNC(0x2EB3D046, sceImeDialogGetResult);
+	REG_FUNC(0x838A3AF4, sceImeDialogTerm);
+	REG_FUNC(0x73EE7C9C, scePhotoImportDialogInit);
+	REG_FUNC(0x032206D8, scePhotoImportDialogGetStatus);
+	REG_FUNC(0xD855414C, scePhotoImportDialogGetResult);
+	REG_FUNC(0x7FE5BD77, scePhotoImportDialogTerm);
+	REG_FUNC(0x4B125581, scePhotoImportDialogAbort);
+	REG_FUNC(0xCD990375, scePhotoReviewDialogInit);
+	REG_FUNC(0xF4F600CA, scePhotoReviewDialogGetStatus);
+	REG_FUNC(0xFFA35858, scePhotoReviewDialogGetResult);
+	REG_FUNC(0xC700B2DF, scePhotoReviewDialogTerm);
+	REG_FUNC(0x74FF2A8B, scePhotoReviewDialogAbort);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceDbg.cpp b/rpcs3/Emu/ARMv7/Modules/sceDbg.cpp
index 6fe3856b9c..6a2cc4c9a2 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceDbg.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceDbg.cpp
@@ -4,6 +4,33 @@
 
 extern psv_log_base sceDbg;
 
+enum SceDbgBreakOnErrorState : s32
+{
+	SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
+	SCE_DBG_ENABLE_BREAK_ON_ERROR
+};
+
+s32 sceDbgSetMinimumLogLevel(s32 minimumLogLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDbgSetBreakOnErrorState(SceDbgBreakOnErrorState state)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDbgAssertionHandler(vm::psv::ptr<const char> pFile, s32 line, bool stop, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDbgLoggingHandler(vm::psv::ptr<const char> pFile, s32 line, s32 severity, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceDbg, #name, name)
 
 psv_log_base sceDbg("SceDbg", []()
@@ -12,8 +39,8 @@ psv_log_base sceDbg("SceDbg", []()
 	sceDbg.on_unload = nullptr;
 	sceDbg.on_stop = nullptr;
 
-	//REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
-	//REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);
-	//REG_FUNC(0x6605AB19, sceDbgLoggingHandler);
-	//REG_FUNC(0xED4A00BA, sceDbgSetBreakOnErrorState);
+	REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
+	REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);
+	REG_FUNC(0x6605AB19, sceDbgLoggingHandler);
+	REG_FUNC(0xED4A00BA, sceDbgSetBreakOnErrorState);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp b/rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp
index d90fcca74f..f0cf7e3c8e 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp
@@ -4,7 +4,7 @@
 
 extern psv_log_base sceDeci4p;
 
-typedef s32(*SceKernelDeci4pCallback)(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon);
+typedef vm::psv::ptr<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon)> SceKernelDeci4pCallback;
 
 s32 sceKernelDeci4pOpen(vm::psv::ptr<const char> protoname, u32 protonum, u32 bufsize)
 {
diff --git a/rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp b/rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp
index 6d7e440c2f..8e31b95c72 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp
@@ -4,6 +4,72 @@
 
 extern psv_log_base sceDeflt;
 
+s32 sceGzipIsValid(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceGzipGetInfo(vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<vm::psv::ptr<const char>> ppszName, vm::psv::ptr<vm::psv::ptr<const char>> ppszComment, vm::psv::ptr<u16> pusCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceGzipGetName(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceGzipGetComment(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const void> sceGzipGetCompressedData(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceGzipDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<u32> puiCrc32)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZlibIsValid(vm::psv::ptr<const void> pSrcZlib)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZlibGetInfo(vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u8> pbCmf, vm::psv::ptr<u8> pbFlg, vm::psv::ptr<u32> puiDictId, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const void> sceZlibGetCompressedData(vm::psv::ptr<const void> pSrcZlib)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZlibDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u32> puiAdler32)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceZlibAdler32(u32 uiAdler, vm::psv::ptr<const u8> pSrc, u32 uiSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDeflateDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcDeflate, vm::psv::ptr<vm::psv::ptr<const void>> ppNext)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZipGetInfo(vm::psv::ptr<const void> pSrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<u32> puiCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceDeflt, #name, name)
 
 psv_log_base sceDeflt("SceDeflt", []()
@@ -12,16 +78,16 @@ psv_log_base sceDeflt("SceDeflt", []()
 	sceDeflt.on_unload = nullptr;
 	sceDeflt.on_stop = nullptr;
 
-	//REG_FUNC(0xCD83A464, sceZlibAdler32);
-	//REG_FUNC(0x110D5050, sceDeflateDecompress);
-	//REG_FUNC(0xE3CB51A3, sceGzipDecompress);
-	//REG_FUNC(0xBABCF5CF, sceGzipGetComment);
-	//REG_FUNC(0xE1844802, sceGzipGetCompressedData);
-	//REG_FUNC(0x1B8E5862, sceGzipGetInfo);
-	//REG_FUNC(0xAEBAABE6, sceGzipGetName);
-	//REG_FUNC(0xDEDADC31, sceGzipIsValid);
-	//REG_FUNC(0xE38F754D, sceZlibDecompress);
-	//REG_FUNC(0xE680A65A, sceZlibGetCompressedData);
-	//REG_FUNC(0x4C0A685D, sceZlibGetInfo);
-	//REG_FUNC(0x14A0698D, sceZlibIsValid);
+	REG_FUNC(0xCD83A464, sceZlibAdler32);
+	REG_FUNC(0x110D5050, sceDeflateDecompress);
+	REG_FUNC(0xE3CB51A3, sceGzipDecompress);
+	REG_FUNC(0xBABCF5CF, sceGzipGetComment);
+	REG_FUNC(0xE1844802, sceGzipGetCompressedData);
+	REG_FUNC(0x1B8E5862, sceGzipGetInfo);
+	REG_FUNC(0xAEBAABE6, sceGzipGetName);
+	REG_FUNC(0xDEDADC31, sceGzipIsValid);
+	REG_FUNC(0xE38F754D, sceZlibDecompress);
+	REG_FUNC(0xE680A65A, sceZlibGetCompressedData);
+	REG_FUNC(0x4C0A685D, sceZlibGetInfo);
+	REG_FUNC(0x14A0698D, sceZlibIsValid);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp b/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp
index 73678a396c..8d21dc8f66 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceFiber.cpp
@@ -4,6 +4,79 @@
 
 extern psv_log_base sceFiber;
 
+typedef vm::psv::ptr<void(u32 argOnInitialize, u32 argOnRun)> SceFiberEntry;
+
+union SceFiber
+{
+	static const uint size = 128;
+	static const uint align = 8;
+	u64 padding[size / sizeof(u64)];
+};
+
+union SceFiberOptParam 
+{
+	static const uint size = 128;
+	static const uint align = 8;
+	u64 padding[size / sizeof(u64)];
+};
+
+union SceFiberInfo
+{
+	static const uint size = 128;
+	static const uint align = 8;
+	u64 padding[size / sizeof(u64)];
+
+	struct
+	{
+		SceFiberEntry entry;
+		u32 argOnInitialize;
+		vm::psv::ptr<void> addrContext;
+		s32 sizeContext;
+		char name[32];
+	};
+};
+
+s32 _sceFiberInitializeImpl(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<const char> name, SceFiberEntry entry, u32 argOnInitialize, vm::psv::ptr<void> addrContext, u32 sizeContext, vm::psv::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberOptParamInitialize(vm::psv::ptr<SceFiberOptParam> optParam)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberFinalize(vm::psv::ptr<SceFiber> fiber)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberRun(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnReturn)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberSwitch(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnRun)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberGetSelf(vm::psv::ptr<vm::psv::ptr<SceFiber>> fiber)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberReturnToThread(u32 argOnReturn, vm::psv::ptr<u32> argOnRun)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberGetInfo(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<SceFiberInfo> fiberInfo)
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceFiber, #name, name)
 
 psv_log_base sceFiber("SceFiber", []()
@@ -12,15 +85,15 @@ psv_log_base sceFiber("SceFiber", []()
 	sceFiber.on_unload = nullptr;
 	sceFiber.on_stop = nullptr;
 
-	//REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
+	REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
 	//REG_FUNC(0xC6A3F9BB, _sceFiberInitializeWithInternalOptionImpl);
 	//REG_FUNC(0x7D0C7DDB, _sceFiberAttachContextAndRun);
 	//REG_FUNC(0xE00B9AFE, _sceFiberAttachContextAndSwitch);
-	//REG_FUNC(0x801AB334, sceFiberOptParamInitialize);
-	//REG_FUNC(0xE160F844, sceFiberFinalize);
-	//REG_FUNC(0x7DF23243, sceFiberRun);
-	//REG_FUNC(0xE4283144, sceFiberSwitch);
-	//REG_FUNC(0x414D8CA5, sceFiberGetSelf);
-	//REG_FUNC(0x3B42921F, sceFiberReturnToThread);
-	//REG_FUNC(0x189599B4, sceFiberGetInfo);
+	REG_FUNC(0x801AB334, sceFiberOptParamInitialize);
+	REG_FUNC(0xE160F844, sceFiberFinalize);
+	REG_FUNC(0x7DF23243, sceFiberRun);
+	REG_FUNC(0xE4283144, sceFiberSwitch);
+	REG_FUNC(0x414D8CA5, sceFiberGetSelf);
+	REG_FUNC(0x3B42921F, sceFiberReturnToThread);
+	REG_FUNC(0x189599B4, sceFiberGetInfo);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceFios.cpp b/rpcs3/Emu/ARMv7/Modules/sceFios.cpp
index d04af5b3cd..d542e97549 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceFios.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceFios.cpp
@@ -4,6 +4,804 @@
 
 extern psv_log_base sceFios;
 
+typedef s64 SceFiosOffset;
+typedef s64 SceFiosSize;
+typedef u8 SceFiosOpEvent;
+typedef s32 SceFiosHandle;
+typedef SceFiosHandle SceFiosOp;
+typedef SceFiosHandle SceFiosFH;
+typedef SceFiosHandle SceFiosDH;
+typedef s64 SceFiosTime;
+typedef s8 SceFiosPriority;
+typedef SceFiosTime SceFiosTimeInterval;
+typedef u64 SceFiosDate;
+typedef s32 SceFiosOverlayID;
+
+typedef vm::psv::ptr<s32(vm::psv::ptr<void> pContext, SceFiosOp op, SceFiosOpEvent event, s32 err)> SceFiosOpCallback;
+typedef vm::psv::ptr<s32(vm::psv::ptr<const char> fmt, va_list ap)> SceFiosVprintfCallback;
+typedef vm::psv::ptr<vm::psv::ptr<void>(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 len)> SceFiosMemcpyCallback;
+
+enum SceFiosWhence : s32
+{
+	SCE_FIOS_SEEK_SET = 0,
+	SCE_FIOS_SEEK_CUR = 1,
+	SCE_FIOS_SEEK_END = 2
+};
+
+struct SceFiosBuffer
+{
+	vm::psv::ptr<void> pPtr;
+	u32 length;
+};
+
+struct SceFiosOpAttr
+{
+	SceFiosTime deadline;
+	SceFiosOpCallback pCallback;
+	vm::psv::ptr<void> pCallbackContext;
+	s32 priority : 8;
+	u32 opflags : 24;
+	u32 userTag;
+	vm::psv::ptr<void> userPtr;
+	vm::psv::ptr<void> pReserved;
+};
+
+struct SceFiosDirEntry
+{
+	SceFiosOffset fileSize;
+	u32 statFlags;
+	u16 nameLength;
+	u16 fullPathLength;
+	u16 offsetToName;
+	u16 reserved[3];
+	char fullPath[1024];
+};
+
+struct SceFiosStat
+{
+	SceFiosOffset fileSize;
+	SceFiosDate accessDate;
+	SceFiosDate modificationDate;
+	SceFiosDate creationDate;
+	u32 statFlags;
+	u32 reserved;
+	s64 uid;
+	s64 gid;
+	s64 dev;
+	s64 ino;
+	s64 mode;
+};
+
+struct SceFiosOpenParams
+{
+	u32 openFlags;
+	u32 reserved;
+	SceFiosBuffer buffer;
+};
+
+struct SceFiosTuple
+{
+	SceFiosOffset offset;
+	SceFiosSize size;
+	char path[1024];
+};
+
+struct SceFiosParams
+{
+	u32 initialized : 1;
+	u32 paramsSize : 14;
+	u32 pathMax : 16;
+	u32 profiling;
+	SceFiosBuffer opStorage;
+	SceFiosBuffer fhStorage;
+	SceFiosBuffer dhStorage;
+	SceFiosBuffer chunkStorage;
+	SceFiosVprintfCallback pVprintf;
+	SceFiosMemcpyCallback pMemcpy;
+	s32 threadPriority[2];
+	s32 threadAffinity[2];
+};
+
+struct SceFiosOverlay
+{
+	u8 type;
+	u8 order;
+	u8 reserved[10];
+	SceFiosOverlayID id;
+	char dst[292];
+	char src[292];
+};
+
+typedef vm::psv::ptr<void()> SceFiosIOFilterCallback;
+
+struct SceFiosPsarcDearchiverContext
+{
+	u32 sizeOfContext;
+	u32 workBufferSize;
+	vm::psv::ptr<void> pWorkBuffer;
+	s32 reserved[4];
+};
+
+s32 sceFiosInitialize(vm::psv::ptr<const SceFiosParams> pParameters)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosTerminate()
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsInitialized(vm::psv::ptr<SceFiosParams> pOutParameters)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosUpdateParameters(vm::psv::ptr<const SceFiosParams> pParameters)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosSetGlobalDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosGetGlobalDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosSetThreadDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosGetThreadDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosGetDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosSuspend()
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetSuspendCount()
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsSuspended()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosResume()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosShutdownAndCancelOps()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosCancelAllOps()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosCloseAllFiles()
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsIdle()
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetAllFHs(vm::psv::ptr<SceFiosFH> pOutArray, u32 arraySize)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetAllDHs(vm::psv::ptr<SceFiosDH> pOutArray, u32 arraySize)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetAllOps(vm::psv::ptr<SceFiosOp> pOutArray, u32 arraySize)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsValidHandle(SceFiosHandle h)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosPathcmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosPathncmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB, u32 n)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosPrintf(vm::psv::ptr<const char> pFormat) // va_args...
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosVprintf(vm::psv::ptr<const char> pFormat) // va_list
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosFileExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileGetSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosSize> pOutSize)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFileGetSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFileDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDirectoryExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosDirectoryExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDirectoryCreate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDirectoryCreateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDirectoryDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDirectoryDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosResolve(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosResolveSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosRename(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosRenameSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFileReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFileWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFileTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHSyncSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHReadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHReadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHWritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHWritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPread(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPreadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPwrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPwriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPreadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPreadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPwritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPwritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOffset sceFiosFHSeek(SceFiosFH fh, SceFiosOffset offset, SceFiosWhence whence)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOffset sceFiosFHTell(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceFiosFHGetPath(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHGetSize(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+//SceFiosOp sceFiosDHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
+//{
+//	throw __FUNCTION__;
+//}
+//
+//s32 sceFiosDHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
+//{
+//	throw __FUNCTION__;
+//}
+
+SceFiosOp sceFiosDHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceFiosDHGetPath(SceFiosDH dh)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosOpIsDone(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpWait(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpWaitUntil(SceFiosOp op, SceFiosTime deadline)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosOpDelete(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpSyncWait(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosOpSyncWaitForIO(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpGetError(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosOpCancel(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosOpIsCancelled(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceFiosOpGetPath(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<void> sceFiosOpGetBuffer(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOffset sceFiosOpGetOffset(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosOpGetRequestCount(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosOpGetActualCount(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosOpReschedule(SceFiosOp op, SceFiosTime newDeadline)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosTime sceFiosTimeGetCurrent()
+{
+	throw __FUNCTION__;
+}
+
+s64 sceFiosTimeIntervalToNanoseconds(SceFiosTimeInterval interval)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosTimeInterval sceFiosTimeIntervalFromNanoseconds(s64 ns)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosDate sceFiosDateGetCurrent()
+{
+	throw __FUNCTION__;
+}
+
+SceFiosDate sceFiosDateFromComponents(const struct vm::psv::ptr<tm> pComponents)
+{
+	throw __FUNCTION__;
+}
+
+struct vm::psv::ptr<tm> sceFiosDateToComponents(SceFiosDate date, struct vm::psv::ptr<tm> pOutComponents)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosDate sceFiosDateFromSceDateTime(vm::psv::ptr<const SceDateTime> pSceDateTime)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<SceDateTime> sceFiosDateToSceDateTime(SceFiosDate date, vm::psv::ptr<SceDateTime> pSceDateTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayAdd(vm::psv::ptr<const SceFiosOverlay> pOverlay, vm::psv::ptr<SceFiosOverlayID> pOutID)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayRemove(SceFiosOverlayID id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayGetInfo(SceFiosOverlayID id, vm::psv::ptr<SceFiosOverlay> pOutOverlay)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayModify(SceFiosOverlayID id, vm::psv::ptr<const SceFiosOverlay> pNewValue)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayGetList(vm::psv::ptr<SceFiosOverlayID> pOutIDs, u32 maxIDs, vm::psv::ptr<u32> pActualIDs)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::psv::ptr<const char> pInPath, vm::psv::ptr<char> pOutPath, u32 maxPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosArchiveGetMountBufferSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosArchiveGetMountBufferSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+{
+	throw __FUNCTION__;
+}
+
+//SceFiosOp sceFiosArchiveMount(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+//{
+//	throw __FUNCTION__;
+//}
+//
+//s32 sceFiosArchiveMountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+//{
+//	throw __FUNCTION__;
+//}
+
+SceFiosOp sceFiosArchiveUnmount(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosArchiveUnmountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpError(s32 err, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpOp(SceFiosOp op, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpFH(SceFiosFH fh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpDH(SceFiosDH dh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpDate(SceFiosDate date, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosIOFilterAdd(s32 index, SceFiosIOFilterCallback pFilterCallback, vm::psv::ptr<void> pFilterContext)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosIOFilterGetInfo(s32 index, vm::psv::ptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::psv::ptr<vm::psv::ptr<void>> pOutFilterContext)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosIOFilterRemove(s32 index)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosIOFilterPsarcDearchiver()
+{
+	throw __FUNCTION__;
+}
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceFios, #name, name)
 
 psv_log_base sceFios("SceFios2", []()
@@ -12,136 +810,136 @@ psv_log_base sceFios("SceFios2", []()
 	sceFios.on_unload = nullptr;
 	sceFios.on_stop = nullptr;
 
-	//REG_FUNC(0x15857180, sceFiosArchiveGetMountBufferSize);
-	//REG_FUNC(0xDF3352FC, sceFiosArchiveGetMountBufferSizeSync);
+	REG_FUNC(0x15857180, sceFiosArchiveGetMountBufferSize);
+	REG_FUNC(0xDF3352FC, sceFiosArchiveGetMountBufferSizeSync);
 	//REG_FUNC(0x92E76BBD, sceFiosArchiveMount);
 	//REG_FUNC(0xC4822276, sceFiosArchiveMountSync);
-	//REG_FUNC(0xFE1E1D28, sceFiosArchiveUnmount);
-	//REG_FUNC(0xB26DC24D, sceFiosArchiveUnmountSync);
-	//REG_FUNC(0x1E920B1D, sceFiosCancelAllOps);
-	//REG_FUNC(0xF85C208B, sceFiosCloseAllFiles);
-	//REG_FUNC(0xF6CACFC7, sceFiosDHClose);
-	//REG_FUNC(0x1F3CC428, sceFiosDHCloseSync);
-	//REG_FUNC(0x2B406DEB, sceFiosDHGetPath);
+	REG_FUNC(0xFE1E1D28, sceFiosArchiveUnmount);
+	REG_FUNC(0xB26DC24D, sceFiosArchiveUnmountSync);
+	REG_FUNC(0x1E920B1D, sceFiosCancelAllOps);
+	REG_FUNC(0xF85C208B, sceFiosCloseAllFiles);
+	REG_FUNC(0xF6CACFC7, sceFiosDHClose);
+	REG_FUNC(0x1F3CC428, sceFiosDHCloseSync);
+	REG_FUNC(0x2B406DEB, sceFiosDHGetPath);
 	//REG_FUNC(0xEA9855BA, sceFiosDHOpen);
 	//REG_FUNC(0x34BC3713, sceFiosDHOpenSync);
-	//REG_FUNC(0x72A0A851, sceFiosDHRead);
-	//REG_FUNC(0xB7E79CAD, sceFiosDHReadSync);
-	//REG_FUNC(0x280D284A, sceFiosDateFromComponents);
-	//REG_FUNC(0x5C593C1E, sceFiosDateGetCurrent);
-	//REG_FUNC(0x5CFF6EA0, sceFiosDateToComponents);
-	//REG_FUNC(0x44B9F8EB, sceFiosDebugDumpDH);
-	//REG_FUNC(0x159B1FA8, sceFiosDebugDumpDate);
-	//REG_FUNC(0x51E677DF, sceFiosDebugDumpError);
-	//REG_FUNC(0x5506ACAB, sceFiosDebugDumpFH);
-	//REG_FUNC(0xE438D4F0, sceFiosDebugDumpOp);
-	//REG_FUNC(0x764DFA7A, sceFiosDelete);
-	//REG_FUNC(0xAAC54B44, sceFiosDeleteSync);
-	//REG_FUNC(0x9198ED8B, sceFiosDirectoryCreate);
-	//REG_FUNC(0xE037B076, sceFiosDirectoryCreateSync);
-	//REG_FUNC(0xDA93677C, sceFiosDirectoryDelete);
-	//REG_FUNC(0xB9573146, sceFiosDirectoryDeleteSync);
-	//REG_FUNC(0x48D50D97, sceFiosDirectoryExists);
-	//REG_FUNC(0x726E01BE, sceFiosDirectoryExistsSync);
-	//REG_FUNC(0x6F12D8A5, sceFiosExists);
-	//REG_FUNC(0x125EFD34, sceFiosExistsSync);
-	//REG_FUNC(0xA88EDCA8, sceFiosFHClose);
-	//REG_FUNC(0x45182328, sceFiosFHCloseSync);
-	//REG_FUNC(0xC55DB73B, sceFiosFHGetOpenParams);
-	//REG_FUNC(0x37143AE3, sceFiosFHGetPath);
-	//REG_FUNC(0xC5C26581, sceFiosFHGetSize);
-	//REG_FUNC(0xBF699BD4, sceFiosFHOpen);
-	//REG_FUNC(0xC3E7C3DB, sceFiosFHOpenSync);
-	//REG_FUNC(0x6A51E688, sceFiosFHPread);
-	//REG_FUNC(0xE2805059, sceFiosFHPreadSync);
-	//REG_FUNC(0x7C4E0C42, sceFiosFHPreadv);
-	//REG_FUNC(0x4D42F95C, sceFiosFHPreadvSync);
-	//REG_FUNC(0xCF1FAA6F, sceFiosFHPwrite);
-	//REG_FUNC(0x1E962F57, sceFiosFHPwriteSync);
-	//REG_FUNC(0xBBC9AFD5, sceFiosFHPwritev);
-	//REG_FUNC(0x742ADDC4, sceFiosFHPwritevSync);
-	//REG_FUNC(0xB09AFBDF, sceFiosFHRead);
-	//REG_FUNC(0x76945919, sceFiosFHReadSync);
-	//REG_FUNC(0x7DB0AFAF, sceFiosFHReadv);
-	//REG_FUNC(0x1BC977FA, sceFiosFHReadvSync);
-	//REG_FUNC(0xA75F3C4A, sceFiosFHSeek);
-	//REG_FUNC(0xD97C4DF7, sceFiosFHStat);
-	//REG_FUNC(0xF8BEAC88, sceFiosFHStatSync);
-	//REG_FUNC(0xE485F35E, sceFiosFHSync);
-	//REG_FUNC(0xA909CCE3, sceFiosFHSyncSync);
-	//REG_FUNC(0xD7F33130, sceFiosFHTell);
-	//REG_FUNC(0x2B39453B, sceFiosFHTruncate);
-	//REG_FUNC(0xFEF940B7, sceFiosFHTruncateSync);
-	//REG_FUNC(0xE663138E, sceFiosFHWrite);
-	//REG_FUNC(0x984024E5, sceFiosFHWriteSync);
-	//REG_FUNC(0x988DD7FF, sceFiosFHWritev);
-	//REG_FUNC(0x267E6CE3, sceFiosFHWritevSync);
-	//REG_FUNC(0xB647278B, sceFiosFileDelete);
-	//REG_FUNC(0xB5302E30, sceFiosFileDeleteSync);
-	//REG_FUNC(0x8758E62F, sceFiosFileExists);
-	//REG_FUNC(0x233B070C, sceFiosFileExistsSync);
-	//REG_FUNC(0x79D9BB50, sceFiosFileGetSize);
-	//REG_FUNC(0x789215C3, sceFiosFileGetSizeSync);
-	//REG_FUNC(0x84080161, sceFiosFileRead);
-	//REG_FUNC(0x1C488B32, sceFiosFileReadSync);
-	//REG_FUNC(0xC5513E13, sceFiosFileTruncate);
-	//REG_FUNC(0x6E1252B8, sceFiosFileTruncateSync);
-	//REG_FUNC(0x42C278E5, sceFiosFileWrite);
-	//REG_FUNC(0x132B6DE6, sceFiosFileWriteSync);
-	//REG_FUNC(0x681184A2, sceFiosGetAllDHs);
-	//REG_FUNC(0x90AB9195, sceFiosGetAllFHs);
-	//REG_FUNC(0x8F62832C, sceFiosGetAllOps);
-	//REG_FUNC(0xC897F6A7, sceFiosGetDefaultOpAttr);
-	//REG_FUNC(0x30583FCB, sceFiosGetGlobalDefaultOpAttr);
-	//REG_FUNC(0x156EAFDC, sceFiosGetSuspendCount);
-	//REG_FUNC(0xD55B8555, sceFiosIOFilterAdd);
-	//REG_FUNC(0x7C9B14EB, sceFiosIOFilterGetInfo);
-	//REG_FUNC(0x057252F2, sceFiosIOFilterPsarcDearchiver);
-	//REG_FUNC(0x22E35018, sceFiosIOFilterRemove);
-	//REG_FUNC(0x774C2C05, sceFiosInitialize);
-	//REG_FUNC(0x29104BF3, sceFiosIsIdle);
-	//REG_FUNC(0xF4F54E09, sceFiosIsInitialized);
-	//REG_FUNC(0xD2466EA5, sceFiosIsSuspended);
-	//REG_FUNC(0xB309E327, sceFiosIsValidHandle);
-	//REG_FUNC(0x3904F205, sceFiosOpCancel);
-	//REG_FUNC(0xE4EA92FA, sceFiosOpDelete);
-	//REG_FUNC(0x218A43EE, sceFiosOpGetActualCount);
-	//REG_FUNC(0xABFEE706, sceFiosOpGetAttr);
-	//REG_FUNC(0x68C436E4, sceFiosOpGetBuffer);
-	//REG_FUNC(0xBF099E16, sceFiosOpGetError);
-	//REG_FUNC(0xF21213B9, sceFiosOpGetOffset);
-	//REG_FUNC(0x157515CB, sceFiosOpGetPath);
-	//REG_FUNC(0x9C1084C5, sceFiosOpGetRequestCount);
-	//REG_FUNC(0x0C81D80E, sceFiosOpIsCancelled);
-	//REG_FUNC(0x1B9A575E, sceFiosOpIsDone);
-	//REG_FUNC(0x968CADBD, sceFiosOpReschedule);
-	//REG_FUNC(0xE6A66C70, sceFiosOpSyncWait);
-	//REG_FUNC(0x202079F9, sceFiosOpSyncWaitForIO);
-	//REG_FUNC(0x2AC79DFC, sceFiosOpWait);
-	//REG_FUNC(0xCC823B47, sceFiosOpWaitUntil);
-	//REG_FUNC(0x27AE468B, sceFiosOverlayAdd);
-	//REG_FUNC(0xF4C6B72A, sceFiosOverlayGetInfo);
-	//REG_FUNC(0x1C0BCAD5, sceFiosOverlayGetList);
-	//REG_FUNC(0x30F56704, sceFiosOverlayModify);
-	//REG_FUNC(0xF3C84D0F, sceFiosOverlayRemove);
-	//REG_FUNC(0x8A243E74, sceFiosOverlayResolveSync);
-	//REG_FUNC(0x5E75937A, sceFiosPathcmp);
-	//REG_FUNC(0xCC21C849, sceFiosPathncmp);
-	//REG_FUNC(0xAF7FAADF, sceFiosPrintf);
-	//REG_FUNC(0x25E399E5, sceFiosRename);
-	//REG_FUNC(0x030306F4, sceFiosRenameSync);
-	//REG_FUNC(0xD0B19C9F, sceFiosResolve);
-	//REG_FUNC(0x7FF33797, sceFiosResolveSync);
-	//REG_FUNC(0xBF2D3CC1, sceFiosResume);
-	//REG_FUNC(0x4E2FD311, sceFiosSetGlobalDefaultOpAttr);
-	//REG_FUNC(0x5B8D48C4, sceFiosShutdownAndCancelOps);
-	//REG_FUNC(0xFF04AF72, sceFiosStat);
-	//REG_FUNC(0xACBAF3E0, sceFiosStatSync);
-	//REG_FUNC(0x510953DC, sceFiosSuspend);
-	//REG_FUNC(0x2904B539, sceFiosTerminate);
-	//REG_FUNC(0xE76C8EC3, sceFiosTimeGetCurrent);
-	//REG_FUNC(0x35A82737, sceFiosTimeIntervalFromNanoseconds);
-	//REG_FUNC(0x397BF626, sceFiosTimeIntervalToNanoseconds);
-	//REG_FUNC(0x1915052A, sceFiosUpdateParameters);
-	//REG_FUNC(0x5BA4BD6D, sceFiosVprintf);
+	REG_FUNC(0x72A0A851, sceFiosDHRead);
+	REG_FUNC(0xB7E79CAD, sceFiosDHReadSync);
+	REG_FUNC(0x280D284A, sceFiosDateFromComponents);
+	REG_FUNC(0x5C593C1E, sceFiosDateGetCurrent);
+	REG_FUNC(0x5CFF6EA0, sceFiosDateToComponents);
+	REG_FUNC(0x44B9F8EB, sceFiosDebugDumpDH);
+	REG_FUNC(0x159B1FA8, sceFiosDebugDumpDate);
+	REG_FUNC(0x51E677DF, sceFiosDebugDumpError);
+	REG_FUNC(0x5506ACAB, sceFiosDebugDumpFH);
+	REG_FUNC(0xE438D4F0, sceFiosDebugDumpOp);
+	REG_FUNC(0x764DFA7A, sceFiosDelete);
+	REG_FUNC(0xAAC54B44, sceFiosDeleteSync);
+	REG_FUNC(0x9198ED8B, sceFiosDirectoryCreate);
+	REG_FUNC(0xE037B076, sceFiosDirectoryCreateSync);
+	REG_FUNC(0xDA93677C, sceFiosDirectoryDelete);
+	REG_FUNC(0xB9573146, sceFiosDirectoryDeleteSync);
+	REG_FUNC(0x48D50D97, sceFiosDirectoryExists);
+	REG_FUNC(0x726E01BE, sceFiosDirectoryExistsSync);
+	REG_FUNC(0x6F12D8A5, sceFiosExists);
+	REG_FUNC(0x125EFD34, sceFiosExistsSync);
+	REG_FUNC(0xA88EDCA8, sceFiosFHClose);
+	REG_FUNC(0x45182328, sceFiosFHCloseSync);
+	REG_FUNC(0xC55DB73B, sceFiosFHGetOpenParams);
+	REG_FUNC(0x37143AE3, sceFiosFHGetPath);
+	REG_FUNC(0xC5C26581, sceFiosFHGetSize);
+	REG_FUNC(0xBF699BD4, sceFiosFHOpen);
+	REG_FUNC(0xC3E7C3DB, sceFiosFHOpenSync);
+	REG_FUNC(0x6A51E688, sceFiosFHPread);
+	REG_FUNC(0xE2805059, sceFiosFHPreadSync);
+	REG_FUNC(0x7C4E0C42, sceFiosFHPreadv);
+	REG_FUNC(0x4D42F95C, sceFiosFHPreadvSync);
+	REG_FUNC(0xCF1FAA6F, sceFiosFHPwrite);
+	REG_FUNC(0x1E962F57, sceFiosFHPwriteSync);
+	REG_FUNC(0xBBC9AFD5, sceFiosFHPwritev);
+	REG_FUNC(0x742ADDC4, sceFiosFHPwritevSync);
+	REG_FUNC(0xB09AFBDF, sceFiosFHRead);
+	REG_FUNC(0x76945919, sceFiosFHReadSync);
+	REG_FUNC(0x7DB0AFAF, sceFiosFHReadv);
+	REG_FUNC(0x1BC977FA, sceFiosFHReadvSync);
+	REG_FUNC(0xA75F3C4A, sceFiosFHSeek);
+	REG_FUNC(0xD97C4DF7, sceFiosFHStat);
+	REG_FUNC(0xF8BEAC88, sceFiosFHStatSync);
+	REG_FUNC(0xE485F35E, sceFiosFHSync);
+	REG_FUNC(0xA909CCE3, sceFiosFHSyncSync);
+	REG_FUNC(0xD7F33130, sceFiosFHTell);
+	REG_FUNC(0x2B39453B, sceFiosFHTruncate);
+	REG_FUNC(0xFEF940B7, sceFiosFHTruncateSync);
+	REG_FUNC(0xE663138E, sceFiosFHWrite);
+	REG_FUNC(0x984024E5, sceFiosFHWriteSync);
+	REG_FUNC(0x988DD7FF, sceFiosFHWritev);
+	REG_FUNC(0x267E6CE3, sceFiosFHWritevSync);
+	REG_FUNC(0xB647278B, sceFiosFileDelete);
+	REG_FUNC(0xB5302E30, sceFiosFileDeleteSync);
+	REG_FUNC(0x8758E62F, sceFiosFileExists);
+	REG_FUNC(0x233B070C, sceFiosFileExistsSync);
+	REG_FUNC(0x79D9BB50, sceFiosFileGetSize);
+	REG_FUNC(0x789215C3, sceFiosFileGetSizeSync);
+	REG_FUNC(0x84080161, sceFiosFileRead);
+	REG_FUNC(0x1C488B32, sceFiosFileReadSync);
+	REG_FUNC(0xC5513E13, sceFiosFileTruncate);
+	REG_FUNC(0x6E1252B8, sceFiosFileTruncateSync);
+	REG_FUNC(0x42C278E5, sceFiosFileWrite);
+	REG_FUNC(0x132B6DE6, sceFiosFileWriteSync);
+	REG_FUNC(0x681184A2, sceFiosGetAllDHs);
+	REG_FUNC(0x90AB9195, sceFiosGetAllFHs);
+	REG_FUNC(0x8F62832C, sceFiosGetAllOps);
+	REG_FUNC(0xC897F6A7, sceFiosGetDefaultOpAttr);
+	REG_FUNC(0x30583FCB, sceFiosGetGlobalDefaultOpAttr);
+	REG_FUNC(0x156EAFDC, sceFiosGetSuspendCount);
+	REG_FUNC(0xD55B8555, sceFiosIOFilterAdd);
+	REG_FUNC(0x7C9B14EB, sceFiosIOFilterGetInfo);
+	REG_FUNC(0x057252F2, sceFiosIOFilterPsarcDearchiver);
+	REG_FUNC(0x22E35018, sceFiosIOFilterRemove);
+	REG_FUNC(0x774C2C05, sceFiosInitialize);
+	REG_FUNC(0x29104BF3, sceFiosIsIdle);
+	REG_FUNC(0xF4F54E09, sceFiosIsInitialized);
+	REG_FUNC(0xD2466EA5, sceFiosIsSuspended);
+	REG_FUNC(0xB309E327, sceFiosIsValidHandle);
+	REG_FUNC(0x3904F205, sceFiosOpCancel);
+	REG_FUNC(0xE4EA92FA, sceFiosOpDelete);
+	REG_FUNC(0x218A43EE, sceFiosOpGetActualCount);
+	REG_FUNC(0xABFEE706, sceFiosOpGetAttr);
+	REG_FUNC(0x68C436E4, sceFiosOpGetBuffer);
+	REG_FUNC(0xBF099E16, sceFiosOpGetError);
+	REG_FUNC(0xF21213B9, sceFiosOpGetOffset);
+	REG_FUNC(0x157515CB, sceFiosOpGetPath);
+	REG_FUNC(0x9C1084C5, sceFiosOpGetRequestCount);
+	REG_FUNC(0x0C81D80E, sceFiosOpIsCancelled);
+	REG_FUNC(0x1B9A575E, sceFiosOpIsDone);
+	REG_FUNC(0x968CADBD, sceFiosOpReschedule);
+	REG_FUNC(0xE6A66C70, sceFiosOpSyncWait);
+	REG_FUNC(0x202079F9, sceFiosOpSyncWaitForIO);
+	REG_FUNC(0x2AC79DFC, sceFiosOpWait);
+	REG_FUNC(0xCC823B47, sceFiosOpWaitUntil);
+	REG_FUNC(0x27AE468B, sceFiosOverlayAdd);
+	REG_FUNC(0xF4C6B72A, sceFiosOverlayGetInfo);
+	REG_FUNC(0x1C0BCAD5, sceFiosOverlayGetList);
+	REG_FUNC(0x30F56704, sceFiosOverlayModify);
+	REG_FUNC(0xF3C84D0F, sceFiosOverlayRemove);
+	REG_FUNC(0x8A243E74, sceFiosOverlayResolveSync);
+	REG_FUNC(0x5E75937A, sceFiosPathcmp);
+	REG_FUNC(0xCC21C849, sceFiosPathncmp);
+	REG_FUNC(0xAF7FAADF, sceFiosPrintf);
+	REG_FUNC(0x25E399E5, sceFiosRename);
+	REG_FUNC(0x030306F4, sceFiosRenameSync);
+	REG_FUNC(0xD0B19C9F, sceFiosResolve);
+	REG_FUNC(0x7FF33797, sceFiosResolveSync);
+	REG_FUNC(0xBF2D3CC1, sceFiosResume);
+	REG_FUNC(0x4E2FD311, sceFiosSetGlobalDefaultOpAttr);
+	REG_FUNC(0x5B8D48C4, sceFiosShutdownAndCancelOps);
+	REG_FUNC(0xFF04AF72, sceFiosStat);
+	REG_FUNC(0xACBAF3E0, sceFiosStatSync);
+	REG_FUNC(0x510953DC, sceFiosSuspend);
+	REG_FUNC(0x2904B539, sceFiosTerminate);
+	REG_FUNC(0xE76C8EC3, sceFiosTimeGetCurrent);
+	REG_FUNC(0x35A82737, sceFiosTimeIntervalFromNanoseconds);
+	REG_FUNC(0x397BF626, sceFiosTimeIntervalToNanoseconds);
+	REG_FUNC(0x1915052A, sceFiosUpdateParameters);
+	REG_FUNC(0x5BA4BD6D, sceFiosVprintf);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceIme.cpp b/rpcs3/Emu/ARMv7/Modules/sceIme.cpp
index d0e90298d9..797e282ace 100644
--- a/rpcs3/Emu/ARMv7/Modules/sceIme.cpp
+++ b/rpcs3/Emu/ARMv7/Modules/sceIme.cpp
@@ -2,7 +2,33 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceIme;
+#include "sceIme.h"
+
+s32 sceImeOpen(vm::psv::ptr<SceImeParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeUpdate()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeSetCaret(vm::psv::ptr<const SceImeCaret> caret)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeSetPreeditGeometry(vm::psv::ptr<const SceImePreeditGeometry> preedit)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeClose()
+{
+	throw __FUNCTION__;
+}
+
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceIme, #name, name)
 
@@ -12,9 +38,9 @@ psv_log_base sceIme("SceIme", []()
 	sceIme.on_unload = nullptr;
 	sceIme.on_stop = nullptr;
 
-	//REG_FUNC(0x0E050613, sceImeOpen);
-	//REG_FUNC(0x71D6898A, sceImeUpdate);
-	//REG_FUNC(0x889A8421, sceImeClose);
-	//REG_FUNC(0xD8342D2A, sceImeSetCaret);
-	//REG_FUNC(0x7B1EFAA5, sceImeSetPreeditGeometry);
+	REG_FUNC(0x0E050613, sceImeOpen);
+	REG_FUNC(0x71D6898A, sceImeUpdate);
+	REG_FUNC(0x889A8421, sceImeClose);
+	REG_FUNC(0xD8342D2A, sceImeSetCaret);
+	REG_FUNC(0x7B1EFAA5, sceImeSetPreeditGeometry);
 });
diff --git a/rpcs3/Emu/ARMv7/Modules/sceIme.h b/rpcs3/Emu/ARMv7/Modules/sceIme.h
new file mode 100644
index 0000000000..7e7fffb429
--- /dev/null
+++ b/rpcs3/Emu/ARMv7/Modules/sceIme.h
@@ -0,0 +1,70 @@
+#pragma once
+
+typedef s32(SceImeCharFilter)(u16 ch);
+
+struct SceImeRect
+{
+	u32 x;
+	u32 y;
+	u32 width;
+	u32 height;
+};
+
+struct SceImeEditText
+{
+	u32 preeditIndex;
+	u32 preeditLength;
+	u32 caretIndex;
+	vm::psv::ptr<u16> str;
+};
+
+union SceImeEventParam
+{
+	SceImeRect rect;
+	SceImeEditText text;
+	u32 caretIndex;
+};
+
+struct SceImeEvent
+{
+	u32 id;
+	SceImeEventParam param;
+};
+
+struct SceImeCaret
+{
+	u32 x;
+	u32 y;
+	u32 height;
+	u32 index;
+};
+
+struct SceImePreeditGeometry
+{
+	u32 x;
+	u32 y;
+	u32 height;
+};
+
+typedef void(SceImeEventHandler)(vm::psv::ptr<void> arg, vm::psv::ptr<const SceImeEvent> e);
+
+struct SceImeParam
+{
+	u32 size;
+	u32 inputMethod;
+	u64 supportedLanguages;
+	s32 languagesForced;
+	u32 type;
+	u32 option;
+	vm::psv::ptr<void> work;
+	vm::psv::ptr<void> arg;
+	vm::psv::ptr<SceImeEventHandler> handler;
+	vm::psv::ptr<SceImeCharFilter> filter;
+	vm::psv::ptr<u32> initialText;
+	u32 maxTextLength;
+	vm::psv::ptr<u32> inputTextBuffer;
+	u32 reserved0;
+	u32 reserved1;
+};
+
+extern psv_log_base sceIme;
diff --git a/rpcs3/Loader/ELF32.cpp b/rpcs3/Loader/ELF32.cpp
index 6a4884798b..01232eb579 100644
--- a/rpcs3/Loader/ELF32.cpp
+++ b/rpcs3/Loader/ELF32.cpp
@@ -256,9 +256,7 @@ namespace loader
 							}
 							case 0x0000002f: // movw r*,# instruction is replaced
 							{
-								const u32 addr = *++code;
-
-								if (!data)
+								if (!data) // probably, imported object
 								{
 									auto found = vnid_list.find(code.addr());
 									if (found != vnid_list.end())
@@ -269,36 +267,32 @@ namespace loader
 
 								if (!data)
 								{
-									LOG_ERROR(LOADER, ".sceRefs: movw writing failed (code=0x%x, addr=0x%x)", code, addr);
-									break;
+									LOG_ERROR(LOADER, ".sceRefs: movw writing failed (ref_addr=0x%x, addr=0x%x)", code, code[1]);
+								}
+								else //if (Ini.HLELogging.GetValue())
+								{
+									LOG_NOTICE(LOADER, ".sceRefs: movw written at 0x%x (ref_addr=0x%x, data=0x%x)", code[1], code, data);
 								}
 
+								const u32 addr = *++code;
 								vm::psv::write16(addr + 0, vm::psv::read16(addr + 0) | (data & 0x800) >> 1 | (data & 0xf000) >> 12);
 								vm::psv::write16(addr + 2, vm::psv::read16(addr + 2) | (data & 0x700) << 4 | (data & 0xff));
-
-								//if (Ini.HLELogging.GetValue())
-								{
-									LOG_NOTICE(LOADER, ".sceRefs: movw written at 0x%x (data=0x%x)", addr, data);
-								}
 								break;
 							}
 							case 0x00000030: // movt r*,# instruction is replaced
 							{
-								const u32 addr = *++code;
-
 								if (!data)
 								{
-									LOG_ERROR(LOADER, ".sceRefs: movt writing failed (code=0x%x, addr=0x%x)", code, addr);
-									break;
+									LOG_ERROR(LOADER, ".sceRefs: movt writing failed (ref_addr=0x%x, addr=0x%x)", code, code[1]);
 								}
-								
+								else //if (Ini.HLELogging.GetValue())
+								{
+									LOG_NOTICE(LOADER, ".sceRefs: movt written at 0x%x (ref_addr=0x%x, data=0x%x)", code[1], code, data);
+								}
+
+								const u32 addr = *++code;
 								vm::psv::write16(addr + 0, vm::psv::read16(addr + 0) | (data & 0x8000000) >> 17 | (data & 0xf0000000) >> 28);
 								vm::psv::write16(addr + 2, vm::psv::read16(addr + 2) | (data & 0x7000000) >> 12 | (data & 0xff0000) >> 16);
-
-								//if (Ini.HLELogging.GetValue())
-								{
-									LOG_NOTICE(LOADER, ".sceRefs: movt written at 0x%x (data=0x%x)", addr, data);
-								}
 								break;
 							}
 							case 0x00000000:
diff --git a/rpcs3/emucore.vcxproj b/rpcs3/emucore.vcxproj
index ca94bcbcc5..fb672d63a6 100644
--- a/rpcs3/emucore.vcxproj
+++ b/rpcs3/emucore.vcxproj
@@ -335,7 +335,9 @@
     <ClInclude Include="Emu\ARMv7\ARMv7Thread.h" />
     <ClInclude Include="Emu\ARMv7\Modules\psv_event_flag.h" />
     <ClInclude Include="Emu\ARMv7\Modules\psv_sema.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceAppUtil.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceGxm.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceIme.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h" />
     <ClInclude Include="Emu\ARMv7\PSVFuncList.h" />
     <ClInclude Include="Emu\ARMv7\PSVObjectList.h" />
diff --git a/rpcs3/emucore.vcxproj.filters b/rpcs3/emucore.vcxproj.filters
index ba692d9a05..6e45634fea 100644
--- a/rpcs3/emucore.vcxproj.filters
+++ b/rpcs3/emucore.vcxproj.filters
@@ -1486,5 +1486,11 @@
     <ClInclude Include="Emu\ARMv7\Modules\sceGxm.h">
       <Filter>Emu\CPU\ARMv7\Modules</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceAppUtil.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceIme.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file