f_pc mostly linked for Wii/Shield (#3015)

20 files changed, 93 insertions, 93 deletions

diff --git a/include/f_pc/f_pc_create_tag.h b/include/f_pc/f_pc_create_tag.h
index 117235b0d4..45b1f2ea8b 100644
--- a/include/f_pc/f_pc_create_tag.h
+++ b/include/f_pc/f_pc_create_tag.h
@@ -11,7 +11,7 @@ typedef struct create_tag {
 
 void fpcCtTg_ToCreateQ(create_tag* i_createTag);
 void fpcCtTg_CreateQTo(create_tag* i_createTag);
-s32 fpcCtTg_Init(create_tag* i_createTag, void* i_data);
+int fpcCtTg_Init(create_tag* i_createTag, void* i_data);
 
 extern node_list_class g_fpcCtTg_Queue;
 
diff --git a/include/f_pc/f_pc_delete_tag.h b/include/f_pc/f_pc_delete_tag.h
index 9661092d3f..57b049c2f2 100644
--- a/include/f_pc/f_pc_delete_tag.h
+++ b/include/f_pc/f_pc_delete_tag.h
@@ -22,8 +22,8 @@ typedef struct delete_tag_class {
 BOOL fpcDtTg_IsEmpty();
 void fpcDtTg_ToDeleteQ(delete_tag_class* i_deleteTag);
 void fpcDtTg_DeleteQTo(delete_tag_class* i_deleteTag);
-s32 fpcDtTg_Do(delete_tag_class* i_deleteTag, delete_tag_func i_func);
-s32 fpcDtTg_Init(delete_tag_class* i_deleteTag, void* i_data);
+int fpcDtTg_Do(delete_tag_class* i_deleteTag, delete_tag_func i_func);
+int fpcDtTg_Init(delete_tag_class* i_deleteTag, void* i_data);
 
 extern node_list_class g_fpcDtTg_Queue;
 
diff --git a/include/f_pc/f_pc_deletor.h b/include/f_pc/f_pc_deletor.h
index 3b5a512b22..4470217e3b 100644
--- a/include/f_pc/f_pc_deletor.h
+++ b/include/f_pc/f_pc_deletor.h
@@ -7,9 +7,9 @@
 typedef struct base_process_class base_process_class;
 
 BOOL fpcDt_IsComplete();
-s32 fpcDt_ToDeleteQ(base_process_class* i_proc);
-s32 fpcDt_ToQueue(base_process_class* i_proc);
+int fpcDt_ToDeleteQ(base_process_class* i_proc);
+int fpcDt_ToQueue(base_process_class* i_proc);
 void fpcDt_Handler();
-s32 fpcDt_Delete(void* i_proc);
+int fpcDt_Delete(void* i_proc);
 
 #endif
diff --git a/include/f_pc/f_pc_draw.h b/include/f_pc/f_pc_draw.h
index 1d02d47b15..447d3926de 100644
--- a/include/f_pc/f_pc_draw.h
+++ b/include/f_pc/f_pc_draw.h
@@ -8,7 +8,7 @@ typedef struct base_process_class base_process_class;
 typedef int (*fpcDw_HandlerFunc)(void*, void*);
 typedef int (*fpcDw_HandlerFuncFunc)(fpcDw_HandlerFunc);
 
-s32 fpcDw_Execute(base_process_class* i_proc);
-s32 fpcDw_Handler(fpcDw_HandlerFuncFunc i_iterHandler, fpcDw_HandlerFunc i_func);
+int fpcDw_Execute(base_process_class* i_proc);
+int fpcDw_Handler(fpcDw_HandlerFuncFunc i_iterHandler, fpcDw_HandlerFunc i_func);
 
 #endif
diff --git a/include/f_pc/f_pc_executor.h b/include/f_pc/f_pc_executor.h
index 1ccaa2acc4..8e2b86b104 100644
--- a/include/f_pc/f_pc_executor.h
+++ b/include/f_pc/f_pc_executor.h
@@ -11,10 +11,10 @@ typedef struct base_process_class base_process_class;
 base_process_class* fpcEx_Search(fpcLyIt_JudgeFunc i_judgeFunc, void* i_data);
 base_process_class* fpcEx_SearchByID(fpc_ProcID i_id);
 BOOL fpcEx_IsExist(fpc_ProcID i_id);
-s32 fpcEx_ToLineQ(base_process_class* i_proc);
-s32 fpcEx_ExecuteQTo(base_process_class* i_proc);
-s32 fpcEx_Execute(base_process_class* i_proc);
-s32 fpcEx_ToExecuteQ(base_process_class* i_proc);
+int fpcEx_ToLineQ(base_process_class* i_proc);
+int fpcEx_ExecuteQTo(base_process_class* i_proc);
+int fpcEx_Execute(base_process_class* i_proc);
+int fpcEx_ToExecuteQ(base_process_class* i_proc);
 void fpcEx_Handler(fpcLnIt_QueueFunc i_queueFunc);
 
 #endif
diff --git a/include/f_pc/f_pc_fstcreate_req.h b/include/f_pc/f_pc_fstcreate_req.h
index fed7550c86..859b746354 100644
--- a/include/f_pc/f_pc_fstcreate_req.h
+++ b/include/f_pc/f_pc_fstcreate_req.h
@@ -14,8 +14,8 @@ typedef struct fast_create_request {
     /* 0x4C */ void* data;
 } fast_create_request;  // Size: 0x50
 
-s32 fpcFCtRq_Do(fast_create_request* i_createReq);
-s32 fpcFCtRq_Delete(fast_create_request* i_createReq);
+int fpcFCtRq_Do(fast_create_request* i_createReq);
+int fpcFCtRq_Delete(fast_create_request* i_createReq);
 base_process_class* fpcFCtRq_Request(layer_class* i_layer, s16 i_procname,
                                      fstCreateFunc i_createFunc, void* i_createData, void* i_append);
 
diff --git a/include/f_pc/f_pc_layer.h b/include/f_pc/f_pc_layer.h
index 966b536bd2..7a61cf2755 100644
--- a/include/f_pc/f_pc_layer.h
+++ b/include/f_pc/f_pc_layer.h
@@ -37,18 +37,18 @@ void fpcLy_DeletingMesg(layer_class* i_layer);
 BOOL fpcLy_IsCreatingMesg(layer_class* i_layer);
 BOOL fpcLy_IsDeletingMesg(layer_class* i_layer);
 
-s32 fpcLy_IntoQueue(layer_class* i_layer, int i_treeListNo, create_tag_class* i_createTag, int i_no);
-s32 fpcLy_ToQueue(layer_class* i_layer, int treeListIdx, create_tag_class* i_createTag);
-s32 fpcLy_QueueTo(layer_class* i_layer, create_tag_class* i_createTag);
+int fpcLy_IntoQueue(layer_class* i_layer, int i_treeListNo, create_tag_class* i_createTag, int i_no);
+int fpcLy_ToQueue(layer_class* i_layer, int treeListIdx, create_tag_class* i_createTag);
+int fpcLy_QueueTo(layer_class* i_layer, create_tag_class* i_createTag);
 
 int fpcLy_Cancel(layer_class* i_layer);
 BOOL fpcLy_CancelMethod(process_method_tag_class* i_layer);
 
 void fpcLy_CancelQTo(process_method_tag_class* i_methods);
-s32 fpcLy_ToCancelQ(layer_class* i_layer, process_method_tag_class* i_methods);
+int fpcLy_ToCancelQ(layer_class* i_layer, process_method_tag_class* i_methods);
 
 void fpcLy_Create(layer_class* i_layer, void* i_node, node_list_class* i_nodeList, int i_numLists);
 
-s32 fpcLy_Delete(layer_class* i_layer);
+int fpcLy_Delete(layer_class* i_layer);
 
 #endif
diff --git a/include/f_pc/f_pc_layer_iter.h b/include/f_pc/f_pc_layer_iter.h
index 49e6bf5eaf..f5554b6e57 100644
--- a/include/f_pc/f_pc_layer_iter.h
+++ b/include/f_pc/f_pc_layer_iter.h
@@ -13,9 +13,9 @@ typedef struct layer_iter {
 typedef int (*fpcLyIt_OnlyHereFunc)(void*, void*);
 typedef void* (*fpcLyIt_JudgeFunc)(void*, void*);
 
-s32 fpcLyIt_OnlyHere(layer_class* i_layer, fpcLyIt_OnlyHereFunc i_func, void* i_data);
-s32 fpcLyIt_OnlyHereLY(layer_class* i_layer, fpcLyIt_OnlyHereFunc i_func, void* i_data);
-s32 fpcLyIt_All(fpcLyIt_OnlyHereFunc i_func, void* i_data);
+int fpcLyIt_OnlyHere(layer_class* i_layer, fpcLyIt_OnlyHereFunc i_func, void* i_data);
+int fpcLyIt_OnlyHereLY(layer_class* i_layer, fpcLyIt_OnlyHereFunc i_func, void* i_data);
+int fpcLyIt_All(fpcLyIt_OnlyHereFunc i_func, void* i_data);
 void* fpcLyIt_Judge(layer_class* i_layer, fpcLyIt_JudgeFunc i_func, void* i_data);
 void* fpcLyIt_AllJudge(fpcLyIt_JudgeFunc i_func, void* i_data);
 
diff --git a/include/f_pc/f_pc_layer_tag.h b/include/f_pc/f_pc_layer_tag.h
index 9d72545ab3..e0d4abc53a 100644
--- a/include/f_pc/f_pc_layer_tag.h
+++ b/include/f_pc/f_pc_layer_tag.h
@@ -21,11 +21,11 @@ typedef struct layer_management_tag_class {
     /* 0x1A */ u16 node_list_priority;
 } layer_management_tag_class;
 
-s32 fpcLyTg_QueueTo(layer_management_tag_class* i_layer_tag);
-s32 fpcLyTg_ToQueue(layer_management_tag_class* i_layer_tag, unsigned int i_layerID, u16 i_listID,
+int fpcLyTg_QueueTo(layer_management_tag_class* i_layer_tag);
+int fpcLyTg_ToQueue(layer_management_tag_class* i_layer_tag, unsigned int i_layerID, u16 i_listID,
                     u16 i_listPriority);
-s32 fpcLyTg_Move(layer_management_tag_class* i_layer_tag, unsigned int i_layerID, u16 i_listID,
+int fpcLyTg_Move(layer_management_tag_class* i_layer_tag, unsigned int i_layerID, u16 i_listID,
                  u16 i_listPriority);
-s32 fpcLyTg_Init(layer_management_tag_class* i_layer_tag, unsigned int i_id, void* i_data);
+int fpcLyTg_Init(layer_management_tag_class* i_layer_tag, unsigned int i_id, void* i_data);
 
 #endif
diff --git a/include/f_pc/f_pc_leaf.h b/include/f_pc/f_pc_leaf.h
index c2cfb1090e..d9de82659c 100644
--- a/include/f_pc/f_pc_leaf.h
+++ b/include/f_pc/f_pc_leaf.h
@@ -28,12 +28,12 @@ typedef struct leaf_process_profile_definition {
 } leaf_process_profile_definition;
 
 s16 fpcLf_GetPriority(const leafdraw_class* i_leaf);
-s32 fpcLf_DrawMethod(leafdraw_method_class* i_method, void* i_process);
-s32 fpcLf_Draw(leafdraw_class* i_method);
-s32 fpcLf_Execute(leafdraw_class* i_leaf);
-s32 fpcLf_IsDelete(leafdraw_class* i_leaf);
-s32 fpcLf_Delete(leafdraw_class* i_leaf);
-s32 fpcLf_Create(leafdraw_class* i_leaf);
+int fpcLf_DrawMethod(leafdraw_method_class* i_method, void* i_process);
+int fpcLf_Draw(leafdraw_class* i_method);
+int fpcLf_Execute(leafdraw_class* i_leaf);
+int fpcLf_IsDelete(leafdraw_class* i_leaf);
+int fpcLf_Delete(leafdraw_class* i_leaf);
+int fpcLf_Create(leafdraw_class* i_leaf);
 
 extern int g_fpcLf_type;
 extern leafdraw_method_class g_fpcLf_Method;
diff --git a/include/f_pc/f_pc_line_tag.h b/include/f_pc/f_pc_line_tag.h
index 86eccf0011..d8b1424266 100644
--- a/include/f_pc/f_pc_line_tag.h
+++ b/include/f_pc/f_pc_line_tag.h
@@ -9,9 +9,9 @@ typedef struct line_tag {
     /* 0x14 */ int list_id;
 } line_tag;
 
-s32 fpcLnTg_Move(line_tag* i_lineTag, int i_newListID);
+int fpcLnTg_Move(line_tag* i_lineTag, int i_newListID);
 void fpcLnTg_QueueTo(line_tag* i_lineTag);
-s32 fpcLnTg_ToQueue(line_tag* i_lineTag, int lineListID);
+int fpcLnTg_ToQueue(line_tag* i_lineTag, int lineListID);
 void fpcLnTg_Init(line_tag* i_lineTag, void* i_data);
 
 #endif
diff --git a/include/f_pc/f_pc_load.h b/include/f_pc/f_pc_load.h
index e36bfcf60b..dc5137cd3d 100644
--- a/include/f_pc/f_pc_load.h
+++ b/include/f_pc/f_pc_load.h
@@ -7,6 +7,6 @@
 BOOL fpcLd_Use(s16 i_procName);
 BOOL fpcLd_IsLoaded(s16 i_procName);
 void fpcLd_Free(s16 i_procName);
-s32 fpcLd_Load(s16 i_procName);
+int fpcLd_Load(s16 i_procName);
 
 #endif
diff --git a/include/f_pc/f_pc_manager.h b/include/f_pc/f_pc_manager.h
index f2399a39b6..f772949d85 100644
--- a/include/f_pc/f_pc_manager.h
+++ b/include/f_pc/f_pc_manager.h
@@ -10,7 +10,8 @@
 #include "f_pc/f_pc_searcher.h"
 
 enum {
-    fpcM_ERROR_PROCESS_ID_e = 0xFFFFFFFF
+    fpcM_UNK_PROCESS_ID_e = 0xFFFFFFFE,
+    fpcM_ERROR_PROCESS_ID_e = 0xFFFFFFFF,
 };
 
 typedef int (*FastCreateReqFunc)(void*);
@@ -42,15 +43,15 @@ inline fpc_ProcID fpcM_Create(s16 i_procName, FastCreateReqFunc i_createFunc, vo
                             i_append);
 }
 
-inline s32 fpcM_DrawPriority(const void* i_process) {
-    return (s16)fpcLf_GetPriority((const leafdraw_class*)i_process);
+inline int fpcM_DrawPriority(const void* i_process) {
+    return fpcLf_GetPriority((const leafdraw_class*)i_process);
 }
 
-inline s32 fpcM_ChangeLayerID(void* i_process, int i_layerID) {
+inline int fpcM_ChangeLayerID(void* i_process, int i_layerID) {
     return fpcPi_Change(&((base_process_class*)i_process)->priority, i_layerID, 0xFFFD, 0xFFFD);
 }
 
-inline s32 fpcM_MakeOfType(int* i_type) {
+inline int fpcM_MakeOfType(int* i_type) {
     return fpcBs_MakeOfType(i_type);
 }
 
@@ -95,15 +96,15 @@ inline process_node_class* fpcM_Layer(void* i_process) {
 }
 
 void fpcM_Draw(void* i_process);
-s32 fpcM_DrawIterater(fpcM_DrawIteraterFunc i_drawIterFunc);
-s32 fpcM_Execute(void* i_process);
-s32 fpcM_Delete(void* i_process);
+int fpcM_DrawIterater(fpcM_DrawIteraterFunc i_drawIterFunc);
+int fpcM_Execute(void* i_process);
+int fpcM_Delete(void* i_process);
 BOOL fpcM_IsCreating(fpc_ProcID i_id);
 void fpcM_Management(fpcM_ManagementFunc i_preExecuteFn, fpcM_ManagementFunc i_postExecuteFn);
 void fpcM_Init();
 base_process_class* fpcM_FastCreate(s16 i_procname, FastCreateReqFunc i_createReqFunc,
                                     void* i_createData, void* i_append);
-s32 fpcM_IsPause(void* i_process, u8 i_flag);
+int fpcM_IsPause(void* i_process, u8 i_flag);
 void fpcM_PauseEnable(void* i_process, u8 i_flag);
 void fpcM_PauseDisable(void* i_process, u8 i_flag);
 void* fpcM_JudgeInLayer(fpc_ProcID i_layerID, fpcCtIt_JudgeFunc i_judgeFunc, void* i_data);
diff --git a/include/f_pc/f_pc_method.h b/include/f_pc/f_pc_method.h
index 1a9dfa9d33..e10b756a59 100644
--- a/include/f_pc/f_pc_method.h
+++ b/include/f_pc/f_pc_method.h
@@ -1,4 +1,3 @@
-
 #ifndef F_PC_METHOD_H_
 #define F_PC_METHOD_H_
 
@@ -13,10 +12,10 @@ typedef struct process_method_class {
     /* 0xC */ process_method_func is_delete_method;
 } process_method_class;
 
-s32 fpcMtd_Method(process_method_func i_method, void* i_process);
-s32 fpcMtd_Execute(process_method_class* i_methods, void* i_process);
-s32 fpcMtd_IsDelete(process_method_class* i_methods, void* i_process);
-s32 fpcMtd_Delete(process_method_class* i_methods, void* i_process);
-s32 fpcMtd_Create(process_method_class* i_methods, void* i_process);
+int fpcMtd_Method(process_method_func i_method, void* i_process);
+int fpcMtd_Execute(process_method_class* i_methods, void* i_process);
+int fpcMtd_IsDelete(process_method_class* i_methods, void* i_process);
+int fpcMtd_Delete(process_method_class* i_methods, void* i_process);
+int fpcMtd_Create(process_method_class* i_methods, void* i_process);
 
 #endif
diff --git a/include/f_pc/f_pc_method_tag.h b/include/f_pc/f_pc_method_tag.h
index 9f2e7918dc..0cdca03a26 100644
--- a/include/f_pc/f_pc_method_tag.h
+++ b/include/f_pc/f_pc_method_tag.h
@@ -12,9 +12,9 @@ typedef struct process_method_tag_class {
     /* 0x18 */ void* data;
 } process_method_tag_class;
 
-s32 fpcMtdTg_Do(process_method_tag_class* i_methodTag);
-s32 fpcMtdTg_ToMethodQ(node_list_class* i_nodelist, process_method_tag_class* i_methodTag);
+int fpcMtdTg_Do(process_method_tag_class* i_methodTag);
+int fpcMtdTg_ToMethodQ(node_list_class* i_nodelist, process_method_tag_class* i_methodTag);
 void fpcMtdTg_MethodQTo(process_method_tag_class* i_methodTag);
-s32 fpcMtdTg_Init(process_method_tag_class* i_methodTag, process_method_tag_func i_method, void* i_data);
+int fpcMtdTg_Init(process_method_tag_class* i_methodTag, process_method_tag_func i_method, void* i_data);
 
 #endif
diff --git a/include/f_pc/f_pc_node.h b/include/f_pc/f_pc_node.h
index 840c1cd0aa..3be7fe6c8f 100644
--- a/include/f_pc/f_pc_node.h
+++ b/include/f_pc/f_pc_node.h
@@ -25,14 +25,14 @@ typedef struct node_process_profile_definition {
     /* 0x1C */ process_method_class* sub_methods;
 } node_process_profile_definition;
 
-s32 fpcNd_DrawMethod(nodedraw_method_class* pNodeMethod, void* pData);
-s32 fpcNd_Draw(process_node_class* pProcNode);
-s32 fpcNd_Execute(process_node_class* pProcNode);
+int fpcNd_DrawMethod(nodedraw_method_class* pNodeMethod, void* pData);
+int fpcNd_Draw(process_node_class* pProcNode);
+int fpcNd_Execute(process_node_class* pProcNode);
 void* fpcNd_IsCreatingFromUnder(void* pProcNode);
-s32 fpcNd_IsDeleteTiming(process_node_class* pProcNode);
-s32 fpcNd_IsDelete(process_node_class* pProcNode);
-s32 fpcNd_Delete(process_node_class* pProcNode);
-s32 fpcNd_Create(process_node_class* pProcNode);
+int fpcNd_IsDeleteTiming(process_node_class* pProcNode);
+int fpcNd_IsDelete(process_node_class* pProcNode);
+int fpcNd_Delete(process_node_class* pProcNode);
+int fpcNd_Create(process_node_class* pProcNode);
 
 extern int g_fpcNd_type;
 extern nodedraw_method_class g_fpcNd_Method;
diff --git a/include/f_pc/f_pc_node_req.h b/include/f_pc/f_pc_node_req.h
index bc446b4c6e..d710379c89 100644
--- a/include/f_pc/f_pc_node_req.h
+++ b/include/f_pc/f_pc_node_req.h
@@ -49,18 +49,18 @@ typedef struct request_node_class {
 
 void fpcNdRq_RequestQTo(node_create_request* i_request);
 void fpcNdRq_ToRequestQ(node_create_request* i_request);
-s32 fpcNdRq_phase_IsCreated(node_create_request* i_request);
-s32 fpcNdRq_phase_Create(node_create_request* i_request);
-s32 fpcNdRq_phase_IsDeleteTiming(node_create_request* i_request);
-s32 fpcNdRq_phase_IsDeleted(node_create_request* i_request);
-s32 fpcNdRq_phase_Delete(node_create_request* i_request);
-s32 fpcNdRq_DoPhase(node_create_request* i_request);
-s32 fpcNdRq_Execute(node_create_request* i_request);
-s32 fpcNdRq_Delete(node_create_request* i_request);
-s32 fpcNdRq_Cancel(node_create_request* i_request);
-s32 fpcNdRq_Handler();
-s32 fpcNdRq_IsPossibleTarget(process_node_class* i_procNode);
-s32 fpcNdRq_IsIng(process_node_class* i_procNode);
+int fpcNdRq_phase_IsCreated(node_create_request* i_request);
+int fpcNdRq_phase_Create(node_create_request* i_request);
+int fpcNdRq_phase_IsDeleteTiming(node_create_request* i_request);
+int fpcNdRq_phase_IsDeleted(node_create_request* i_request);
+int fpcNdRq_phase_Delete(node_create_request* i_request);
+int fpcNdRq_DoPhase(node_create_request* i_request);
+int fpcNdRq_Execute(node_create_request* i_request);
+int fpcNdRq_Delete(node_create_request* i_request);
+int fpcNdRq_Cancel(node_create_request* i_request);
+int fpcNdRq_Handler();
+int fpcNdRq_IsPossibleTarget(process_node_class* i_procNode);
+int fpcNdRq_IsIng(process_node_class* i_procNode);
 node_create_request* fpcNdRq_Create(u32 i_requestSize);
 node_create_request* fpcNdRq_ChangeNode(u32 i_requestSize, process_node_class* i_procNode,
                                         s16 i_procName, void* i_data);
@@ -70,7 +70,7 @@ node_create_request*
 fpcNdRq_Request(u32 i_requestSize, int i_reqType,
                 process_node_class* i_procNode, s16 i_procName, void* i_data,
                 node_create_request_method_class* i_create_req_methods);
-s32 fpcNdRq_ReChangeNode(fpc_ProcID i_requestID, s16 i_procName, void* i_data);
-s32 fpcNdRq_ReRequest(fpc_ProcID i_requestID, s16 i_procName, void* i_data);
+int fpcNdRq_ReChangeNode(fpc_ProcID i_requestID, s16 i_procName, void* i_data);
+int fpcNdRq_ReRequest(fpc_ProcID i_requestID, s16 i_procName, void* i_data);
 
 #endif
diff --git a/include/f_pc/f_pc_pause.h b/include/f_pc/f_pc_pause.h
index 895b25af95..557734f923 100644
--- a/include/f_pc/f_pc_pause.h
+++ b/include/f_pc/f_pc_pause.h
@@ -3,9 +3,9 @@
 
 #include "dolphin/types.h"
 
-s32 fpcPause_IsEnable(void* pProc, u8 expected);
-s32 fpcPause_Enable(void* pProc, u8 pauseMask);
-s32 fpcPause_Disable(void* pProc, u8 pauseMask);
+int fpcPause_IsEnable(void* pProc, u8 expected);
+int fpcPause_Enable(void* pProc, u8 pauseMask);
+int fpcPause_Disable(void* pProc, u8 pauseMask);
 void fpcPause_Init(void* pProc);
 
 #endif
diff --git a/include/f_pc/f_pc_priority.h b/include/f_pc/f_pc_priority.h
index 62b4b84507..d3c9d75076 100644
--- a/include/f_pc/f_pc_priority.h
+++ b/include/f_pc/f_pc_priority.h
@@ -23,15 +23,15 @@ typedef struct process_priority_class {
     /* 0x38 */ priority_id current_info;
 } process_priority_class;
 
-s32 fpcPi_IsInQueue(process_priority_class* pPi);
-s32 fpcPi_QueueTo(process_priority_class* pPi);
-s32 fpcPi_ToQueue(process_priority_class* pPi);
+int fpcPi_IsInQueue(process_priority_class* pPi);
+int fpcPi_QueueTo(process_priority_class* pPi);
+int fpcPi_ToQueue(process_priority_class* pPi);
 process_priority_class* fpcPi_GetFromQueue(void);
-s32 fpcPi_Delete(process_priority_class* pPi);
-s32 fpcPi_IsNormal(unsigned int layer, u16 listID, u16 priority);
-s32 fpcPi_Change(process_priority_class* pPi, unsigned int layer, u16 listID, u16 priority);
-s32 fpcPi_Handler(void);
-s32 fpcPi_Init(process_priority_class* pPi, void* pUserData, unsigned int layer, u16 listID,
+int fpcPi_Delete(process_priority_class* pPi);
+int fpcPi_IsNormal(unsigned int layer, u16 listID, u16 priority);
+int fpcPi_Change(process_priority_class* pPi, unsigned int layer, u16 listID, u16 priority);
+int fpcPi_Handler(void);
+int fpcPi_Init(process_priority_class* pPi, void* pUserData, unsigned int layer, u16 listID,
                u16 priority);
 
 #endif
diff --git a/include/f_pc/f_pc_stdcreate_req.h b/include/f_pc/f_pc_stdcreate_req.h
index 94d30ba83d..5c561f8bdc 100644
--- a/include/f_pc/f_pc_stdcreate_req.h
+++ b/include/f_pc/f_pc_stdcreate_req.h
@@ -19,14 +19,14 @@ typedef struct standard_create_request_class {
 #endif
 } standard_create_request_class;
 
-s32 fpcSCtRq_phase_CreateProcess(standard_create_request_class* i_request);
-s32 fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* i_request);
-s32 fpcSCtRq_phase_IsComplete(standard_create_request_class* i_request);
-s32 fpcSCtRq_phase_PostMethod(standard_create_request_class* i_request);
-s32 fpcSCtRq_phase_Done(standard_create_request_class* i_request);
-s32 fpcSCtRq_Handler(standard_create_request_class* i_request);
-s32 fpcSCtRq_Delete(standard_create_request_class* i_request);
-s32 fpcSCtRq_Cancel(standard_create_request_class* i_request);
+int fpcSCtRq_phase_CreateProcess(standard_create_request_class* i_request);
+int fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* i_request);
+int fpcSCtRq_phase_IsComplete(standard_create_request_class* i_request);
+int fpcSCtRq_phase_PostMethod(standard_create_request_class* i_request);
+int fpcSCtRq_phase_Done(standard_create_request_class* i_request);
+int fpcSCtRq_Handler(standard_create_request_class* i_request);
+int fpcSCtRq_Delete(standard_create_request_class* i_request);
+int fpcSCtRq_Cancel(standard_create_request_class* i_request);
 fpc_ProcID fpcSCtRq_Request(layer_class* i_layer, s16 i_procName, stdCreateFunc i_createFunc,
                             void* param_4, void* i_append);