Import project

Original repository: https://github.com/encounter/ww

src/f_pc/f_pc_base.cpp

@@ -0,0 +1,131 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_base.cpp
+//
+
+#include "f_pc/f_pc_base.h"
+#include "SSystem/SComponent/c_malloc.h"
+#include "SSystem/SComponent/c_phase.h"
+#include "SSystem/SStandard/s_basic.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_method.h"
+#include "f_pc/f_pc_pause.h"
+#include "f_pc/f_pc_profile.h"
+#include "dolphin/types.h"
+
+/* 8003C88C-8003C89C       .text fpcBs_Is_JustOfType__Fii */
+bool fpcBs_Is_JustOfType(int i_typeA, int i_typeB) {
+    return i_typeB == i_typeA;
+}
+
+static int g_fpcBs_type;
+
+/* 8003C89C-8003C8DC       .text fpcBs_MakeOfType__FPi */
+s32 fpcBs_MakeOfType(int* i_type) {
+    static s32 t_type = 0x9130000;
+    if (*i_type == 0) {
+        *i_type = ++t_type;
+    }
+    return *i_type;
+}
+
+/* 8003C8DC-8003C904       .text fpcBs_MakeOfId__Fv */
+s32 fpcBs_MakeOfId() {
+    static s32 process_id = 1;
+    return process_id++;
+}
+
+/* 8003C904-8003C960       .text fpcBs_Execute__FP18base_process_class */
+s32 fpcBs_Execute(base_process_class* i_proc) {
+    s32 result;
+    layer_class* savedLayer = fpcLy_CurrentLayer();
+    fpcLy_SetCurrentLayer(i_proc->mLyTg.mpLayer);
+    result = fpcMtd_Execute(i_proc->mpPcMtd, i_proc);
+    fpcLy_SetCurrentLayer(savedLayer);
+    return result;
+}
+
+/* 8003C960-8003C9A0       .text fpcBs_DeleteAppend__FP18base_process_class */
+void fpcBs_DeleteAppend(base_process_class* i_proc) {
+    if (i_proc->mpUserData != NULL) {
+        cMl::free(i_proc->mpUserData);
+        i_proc->mpUserData = NULL;
+    }
+}
+
+/* 8003C9A0-8003C9FC       .text fpcBs_IsDelete__FP18base_process_class */
+s32 fpcBs_IsDelete(base_process_class* i_proc) {
+    s32 result;
+    layer_class* savedLayer = fpcLy_CurrentLayer();
+    fpcLy_SetCurrentLayer(i_proc->mLyTg.mpLayer);
+    result = fpcMtd_IsDelete(i_proc->mpPcMtd, i_proc);
+    fpcLy_SetCurrentLayer(savedLayer);
+    return result;
+}
+
+/* 8003C9FC-8003CA60       .text fpcBs_Delete__FP18base_process_class */
+s32 fpcBs_Delete(base_process_class* i_proc) {
+    s32 deleteResult = fpcMtd_Delete(i_proc->mpPcMtd, i_proc);
+    if (deleteResult == 1) {
+        fpcBs_DeleteAppend(i_proc);
+        i_proc->mBsType = 0;
+        cMl::free(i_proc);
+    }
+    return deleteResult;
+}
+
+/* 8003CA60-8003CB5C       .text fpcBs_Create__FsUiPv */
+base_process_class* fpcBs_Create(s16 i_procTypeID, unsigned int i_procID, void* i_data) {
+    process_profile_definition* procProfDef;
+    base_process_class* procClass;
+    u32 size;
+
+    procProfDef = (process_profile_definition*)fpcPf_Get(i_procTypeID);
+    size = procProfDef->mSize + procProfDef->mSizeOther;
+    procClass = (base_process_class*)cMl::memalignB(-4, size);
+    if (procClass == NULL) {
+        return NULL;
+    } else {
+        sBs_ClearArea(procClass, size);
+        fpcLyTg_Init(&procClass->mLyTg, procProfDef->mLayerID, procClass);
+        fpcLnTg_Init(&procClass->mLnTg, procClass);
+        fpcDtTg_Init(&procClass->mDtTg, procClass);
+        fpcPi_Init(&procClass->mPi, procClass, procProfDef->mLayerID, procProfDef->mListID,
+                   procProfDef->mListPrio);
+        procClass->mInitState = 0;
+        procClass->mUnk0 = 0;
+        procClass->mBsPcId = i_procID;
+        procClass->mBsTypeId = i_procTypeID;
+        procClass->mBsType = fpcBs_MakeOfType(&g_fpcBs_type);
+        procClass->mProcName = procProfDef->mProcName;
+        fpcPause_Init(procClass);
+        procClass->mpPcMtd = procProfDef->mSubMtd;
+        procClass->mpProf = procProfDef;
+        procClass->mpUserData = i_data;
+        procClass->mParameters = procProfDef->mParameters;
+        return procClass;
+    }
+}
+
+/* 8003CB5C-8003CC08       .text fpcBs_SubCreate__FP18base_process_class */
+s32 fpcBs_SubCreate(base_process_class* i_proc) {
+    switch (fpcMtd_Create(i_proc->mpPcMtd, i_proc)) {
+    case 2:
+    case cPhs_COMPLEATE_e:
+        fpcBs_DeleteAppend(i_proc);
+        i_proc->mUnk2 = 2;
+        return 2;
+    case cPhs_INIT_e:
+    case 1:
+        i_proc->mInitState = 1;
+        i_proc->mUnk2 = 0;
+        return cPhs_INIT_e;
+    case 3:
+        i_proc->mUnk2 = 3;
+        return 3;
+    case cPhs_ERROR_e:
+    default:
+        i_proc->mUnk2 = 5;
+        return cPhs_ERROR_e;
+    }
+}

src/f_pc/f_pc_create_iter.cpp

@@ -0,0 +1,45 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_create_iter.cpp
+//
+
+#include "SSystem/SComponent/c_list_iter.h"
+#include "SSystem/SComponent/c_tag_iter.h"
+#include "f_pc/f_pc_create_iter.h"
+#include "f_pc/f_pc_create_req.h"
+#include "f_pc/f_pc_layer.h"
+
+/* 8003CC08-8003CC44       .text fpcCtIt_Method__FPFPvPv_iPv */
+s32 fpcCtIt_Method(fpcCtIt_MethodFunc i_judgeFunc, void* i_data) {
+    node_method_data iter;
+    iter.mFunc = i_judgeFunc;
+    iter.mpUserData = i_data;
+    return cLsIt_Method(&g_fpcCtTg_Queue, (cNdIt_MethodFunc)cTgIt_MethodCall, &iter);
+}
+
+/* 8003CC44-8003CC80       .text fpcCtIt_Judge__FPFPvPv_PvPv */
+void* fpcCtIt_Judge(fpcCtIt_JudgeFunc i_judgeFunc, void* i_data) {
+    node_judge_data iter;
+    iter.mFunc = i_judgeFunc;
+    iter.mpUserData = i_data;
+    return cLsIt_Judge(&g_fpcCtTg_Queue, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &iter);
+}
+
+/* 8003CC80-8003CCD4       .text fpcCtIt_filter_JudgeInLayer__FP10create_tagP16fpcCtIt_jilprm_c */
+void* fpcCtIt_filter_JudgeInLayer(create_tag* i_createTag, fpcCtIt_jilprm_c* i_iterData) {
+    create_request* create_req = static_cast<create_request*>(i_createTag->mBase.mpTagData);
+    if (create_req->mpLayer->mLayerID == i_iterData->mLayerID) {
+        return i_iterData->mFunc((node_class*)create_req->mpRes, i_iterData->mpUserData);
+    } else {
+        return NULL;
+    }
+}
+
+/* 8003CCD4-8003CD0C       .text fpcCtIt_JudgeInLayer__FUiPFPvPv_PvPv */
+void* fpcCtIt_JudgeInLayer(unsigned int i_layerID, fpcCtIt_JudgeFunc i_judgeFunc, void* i_data) {
+    fpcCtIt_jilprm_c data;
+    data.mLayerID = i_layerID;
+    data.mFunc = i_judgeFunc;
+    data.mpUserData = i_data;
+    return fpcCtIt_Judge((fpcCtIt_JudgeFunc)fpcCtIt_filter_JudgeInLayer, &data);
+}

src/f_pc/f_pc_create_req.cpp

@@ -0,0 +1,131 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_create_req.cpp
+//
+
+#include "f_pc/f_pc_create_req.h"
+#include "SSystem/SComponent/c_malloc.h"
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_create_iter.h"
+#include "f_pc/f_pc_deletor.h"
+#include "f_pc/f_pc_executor.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_layer_iter.h"
+
+/* 8003CD0C-8003CD28       .text fpcCtRq_isCreatingByID__FP10create_tagPUi */
+bool fpcCtRq_isCreatingByID(create_tag* i_createTag, unsigned int* i_procID) {
+    create_request* pReq = static_cast<create_request*>(i_createTag->mBase.mpTagData);
+    return pReq->mBsPcId == *i_procID;
+}
+
+/* 8003CD28-8003CD60       .text fpcCtRq_IsCreatingByID__FUi */
+BOOL fpcCtRq_IsCreatingByID(unsigned int i_id) {
+    return fpcCtIt_Judge((fpcLyIt_JudgeFunc)fpcCtRq_isCreatingByID, &i_id) != NULL ? TRUE : FALSE;
+}
+
+/* 8003CD60-8003CD9C       .text fpcCtRq_CreateQTo__FP14create_request */
+void fpcCtRq_CreateQTo(create_request* i_request) {
+    fpcCtTg_CreateQTo(&i_request->mBase);
+    fpcLy_CreatedMesg(i_request->mpLayer);
+    fpcLy_CancelQTo(&i_request->mMtdTg);
+}
+
+/* 8003CD9C-8003CDE0       .text fpcCtRq_ToCreateQ__FP14create_request */
+void fpcCtRq_ToCreateQ(create_request* i_request) {
+    fpcLy_CreatingMesg(i_request->mpLayer);
+    fpcLy_ToCancelQ(i_request->mpLayer, &i_request->mMtdTg);
+    fpcCtTg_ToCreateQ(&i_request->mBase);
+}
+
+/* 8003CDE0-8003CE54       .text fpcCtRq_Delete__FP14create_request */
+BOOL fpcCtRq_Delete(create_request* i_request) {
+    fpcCtRq_CreateQTo(i_request);
+    if (i_request->mpCtRqMtd != NULL && fpcMtd_Method(i_request->mpCtRqMtd->mpDelete, i_request) == 0) {
+        return 0;
+    } else {
+        if (i_request->mpRes) {
+            i_request->mpRes->mpCtRq = NULL;
+        }
+        cMl::free(i_request);
+        return 1;
+    }
+}
+
+/* 8003CE54-8003CEEC       .text fpcCtRq_Cancel__FP14create_request */
+BOOL fpcCtRq_Cancel(create_request* i_request) {
+    base_process_class* pProc;
+    if (i_request != NULL && !i_request->mbIsCancelling) {
+        i_request->mbIsCancelling = TRUE;
+        pProc = i_request->mpRes;
+
+        if (pProc != NULL && !fpcDt_Delete(pProc))
+            return FALSE;
+
+        if (i_request->mpCtRqMtd != NULL && !fpcMtd_Method(i_request->mpCtRqMtd->mpCancel, i_request))
+            return FALSE;
+
+        return fpcCtRq_Delete(i_request);
+    } else {
+        return TRUE;
+    }
+}
+
+/* 8003CEEC-8003CF08       .text fpcCtRq_IsDoing__FP14create_request */
+s32 fpcCtRq_IsDoing(create_request* i_request) {
+    if (i_request != NULL)
+        return i_request->mbIsCreating;
+    else
+        return FALSE;
+}
+
+/* 8003CF08-8003CFC4       .text fpcCtRq_Do__FP14create_request */
+BOOL fpcCtRq_Do(create_request* i_request) {
+    s32 phase = cPhs_COMPLEATE_e;
+
+    if (i_request->mpCtRqMtd != NULL) {
+        cPhs__Handler pHandler = i_request->mpCtRqMtd->mpHandler;
+        if (pHandler != NULL) {
+            i_request->mbIsCreating = TRUE;
+            phase = pHandler(i_request);
+            i_request->mbIsCreating = FALSE;
+        }
+    }
+
+    switch (phase) {
+    case cPhs_COMPLEATE_e: {
+        s32 success = fpcEx_ToExecuteQ(i_request->mpRes);
+        if (success == 0)
+            return fpcCtRq_Cancel(i_request);
+        else
+            return fpcCtRq_Delete(i_request);
+    }
+    case 3:
+    case cPhs_ERROR_e:
+        return fpcCtRq_Cancel(i_request);
+    }
+
+    return 1;
+}
+
+/* 8003CFC4-8003CFF0       .text fpcCtRq_Handler__Fv */
+void fpcCtRq_Handler() {
+    fpcCtIt_Method((fpcCtIt_MethodFunc)fpcCtRq_Do, NULL);
+}
+
+/* 8003CFF0-8003D078       .text fpcCtRq_Create__FP11layer_classUlP27create_request_method_class */
+create_request* fpcCtRq_Create(layer_class* i_layer, u32 i_size, create_request_method_class* i_CtRqMethods) {
+    create_request* pReq = (create_request*)cMl::memalignB(-4, i_size);
+
+    if (pReq != NULL) {
+        fpcCtTg_Init(&pReq->mBase, pReq);
+        fpcMtdTg_Init(&pReq->mMtdTg, (process_method_tag_func)fpcCtRq_Cancel, pReq);
+        pReq->mpLayer = i_layer;
+        pReq->mpCtRqMtd = i_CtRqMethods;
+        pReq->mBsPcId = fpcBs_MakeOfId();
+        pReq->mpRes = NULL;
+        pReq->mbIsCancelling = FALSE;
+        fpcCtRq_ToCreateQ(pReq);
+    }
+
+    return pReq;
+}

src/f_pc/f_pc_create_tag.cpp

@@ -0,0 +1,24 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_create_tag.cpp
+//
+
+#include "f_pc/f_pc_create_tag.h"
+
+node_list_class g_fpcCtTg_Queue = {NULL, NULL, 0};
+
+/* 8003D078-8003D0A4       .text fpcCtTg_ToCreateQ__FP10create_tag */
+void fpcCtTg_ToCreateQ(create_tag* i_createTag) {
+    cTg_Addition(&g_fpcCtTg_Queue, &i_createTag->mBase);
+}
+
+/* 8003D0A4-8003D0C4       .text fpcCtTg_CreateQTo__FP10create_tag */
+void fpcCtTg_CreateQTo(create_tag* i_createTag) {
+    cTg_SingleCut(&i_createTag->mBase);
+}
+
+/* 8003D0C4-8003D0E8       .text fpcCtTg_Init__FP10create_tagPv */
+s32 fpcCtTg_Init(create_tag* i_createTag, void* i_data) {
+    cTg_Create(&i_createTag->mBase, i_data);
+    return 1;
+}

src/f_pc/f_pc_creator.cpp

@@ -0,0 +1,28 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_creator.cpp
+//
+
+#include "f_pc/f_pc_creator.h"
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_create_req.h"
+
+/* 8003D0E8-8003D108       .text fpcCt_IsCreatingByID__FUi */
+BOOL fpcCt_IsCreatingByID(unsigned int i_id) {
+    return fpcCtRq_IsCreatingByID(i_id);
+}
+
+/* 8003D108-8003D12C       .text fpcCt_IsDoing__FP18base_process_class */
+s32 fpcCt_IsDoing(base_process_class* i_proc) {
+    return fpcCtRq_IsDoing(i_proc->mpCtRq);
+}
+
+/* 8003D12C-8003D150       .text fpcCt_Abort__FP18base_process_class */
+BOOL fpcCt_Abort(base_process_class* i_proc) {
+    return fpcCtRq_Cancel(i_proc->mpCtRq);
+}
+
+/* 8003D150-8003D170       .text fpcCt_Handler__Fv */
+void fpcCt_Handler() {
+    fpcCtRq_Handler();
+}

src/f_pc/f_pc_delete_tag.cpp

@@ -0,0 +1,50 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_delete_tag.cpp
+//
+
+#include "SSystem/SComponent/c_list.h"
+#include "f_pc/f_pc_delete_tag.h"
+#include "dolphin/types.h"
+
+node_list_class g_fpcDtTg_Queue = {NULL, NULL, 0};
+
+/* 8003D170-8003D188       .text fpcDtTg_IsEmpty__Fv */
+bool fpcDtTg_IsEmpty() {
+    return g_fpcDtTg_Queue.mSize == 0;
+}
+
+/* 8003D188-8003D1BC       .text fpcDtTg_ToDeleteQ__FP16delete_tag_class */
+void fpcDtTg_ToDeleteQ(delete_tag_class* i_deleteTag) {
+    i_deleteTag->mTimer = 1;
+    cTg_Addition(&g_fpcDtTg_Queue, &i_deleteTag->mBase);
+}
+
+/* 8003D1BC-8003D1DC       .text fpcDtTg_DeleteQTo__FP16delete_tag_class */
+void fpcDtTg_DeleteQTo(delete_tag_class* i_deleteTag) {
+    cTg_SingleCut(&i_deleteTag->mBase);
+}
+
+/* 8003D1DC-8003D25C       .text fpcDtTg_Do__FP16delete_tag_classPFPv_i */
+s32 fpcDtTg_Do(delete_tag_class* i_deleteTag, delete_tag_func i_func) {
+    if (i_deleteTag->mTimer <= 0) {
+        s32 ret;
+        fpcDtTg_DeleteQTo(i_deleteTag);
+        ret = i_func(i_deleteTag->mBase.mpTagData);
+        if (ret == 0) {
+            fpcDtTg_ToDeleteQ(i_deleteTag);
+            return 0;
+        } else {
+            return 1;
+        }
+    } else {
+        i_deleteTag->mTimer--;
+        return 0;
+    }
+}
+
+/* 8003D25C-8003D280       .text fpcDtTg_Init__FP16delete_tag_classPv */
+s32 fpcDtTg_Init(delete_tag_class* i_deleteTag, void* i_data) {
+    cTg_Create(&i_deleteTag->mBase, i_data);
+    return 1;
+}

src/f_pc/f_pc_deletor.cpp

@@ -0,0 +1,114 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_deletor.cpp
+//
+
+#include "f_pc/f_pc_deletor.h"
+#include "JSystem/JUtility/JUTAssert.h"
+#include "SSystem/SComponent/c_list_iter.h"
+#include "f_pc/f_pc_creator.h"
+#include "f_pc/f_pc_executor.h"
+#include "f_pc/f_pc_load.h"
+#include "f_pc/f_pc_node.h"
+
+/* 8003D280-8003D2A0       .text fpcDt_IsComplete__Fv */
+bool fpcDt_IsComplete() {
+    return fpcDtTg_IsEmpty();
+}
+
+/* 8003D2A0-8003D314       .text fpcDt_deleteMethod__FP18base_process_class */
+s32 fpcDt_deleteMethod(base_process_class* i_proc) {
+    layer_class* layer = i_proc->mDtTg.mpLayer;
+    s16 typeID = i_proc->mBsTypeId;
+
+    fpcLy_SetCurrentLayer(layer);
+    fpcLnTg_QueueTo(&i_proc->mLnTg);
+    if (fpcBs_Delete(i_proc) == 1) {
+        fpcLy_DeletedMesg(layer);
+        fpcLd_Free(typeID);
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 8003D314-8003D34C       .text fpcDt_Handler__Fv */
+void fpcDt_Handler(void) {
+    cLsIt_Method(&g_fpcDtTg_Queue, (cNdIt_MethodFunc)fpcDtTg_Do, fpcDt_deleteMethod);
+}
+
+/* 8003D34C-8003D3C8       .text fpcDt_ToQueue__FP18base_process_class */
+s32 fpcDt_ToQueue(base_process_class* i_proc) {
+    if (i_proc->mUnk0 != 1 && fpcBs_IsDelete(i_proc) == 1) {
+        if (fpcPi_IsInQueue(&i_proc->mPi) == 1) {
+            fpcPi_Delete(&i_proc->mPi);
+        }
+        i_proc->mDtTg.mpLayer = i_proc->mLyTg.mpLayer;
+        fpcDtTg_ToDeleteQ(&i_proc->mDtTg);
+        fpcLy_DeletingMesg(i_proc->mLyTg.mpLayer);
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 8003D3C8-8003D51C       .text fpcDt_ToDeleteQ__FP18base_process_class */
+s32 fpcDt_ToDeleteQ(base_process_class* i_proc) {
+    if (i_proc->mUnk0 == 1) {
+        return 0;
+    } else {
+        if (cTg_IsUse(&i_proc->mDtTg.mBase) != 0) {
+            return 1;
+        } else {
+            if (fpcBs_Is_JustOfType(g_fpcNd_type, i_proc->mSubType)) {
+                process_node_class* procNode = (process_node_class*)i_proc;
+                if (fpcNd_IsDeleteTiming(procNode) == 0) {
+                    return 0;
+                } else {
+                    layer_class* layer = &procNode->mLayer;
+
+                    if (!fpcLy_Cancel(layer))
+                        JUT_ASSERT("f_pc_deletor.cpp", 196, 0);
+
+                    if (fpcLyIt_OnlyHereLY(layer, (fpcLyIt_OnlyHereFunc)fpcDt_ToDeleteQ, NULL) == 0) {
+                        return 0;
+                    }
+                }
+            }
+
+            if (fpcDt_ToQueue(i_proc) == 1) {
+                // return type has to be BOOL
+                if (fpcEx_IsExist(i_proc->mBsPcId) == 1) {
+                    if (fpcEx_ExecuteQTo(i_proc) == 0) {
+                        return 0;
+                    }
+                } else {
+                    // return type is wrong, has to be BOOL
+                    if (fpcCt_Abort(i_proc) == 0) {
+                        return 0;
+                    }
+                }
+                i_proc->mInitState = 3;
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+    }
+}
+
+/* 8003D51C-8003D580       .text fpcDt_Delete__FPv */
+s32 fpcDt_Delete(void* i_proc) {
+    base_process_class* proc = static_cast<base_process_class*>(i_proc);
+    if (proc != NULL) {
+        if (fpcCt_IsDoing(proc) == 1)
+            return 0;
+
+        if (proc->mInitState == 3)
+            return 0;
+
+        return fpcDt_ToDeleteQ(proc);
+    } else {
+        return 1;
+    }
+}

src/f_pc/f_pc_draw.cpp

@@ -0,0 +1,40 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_draw.cpp
+//
+
+#include "f_pc/f_pc_draw.h"
+#include "SSystem/SComponent/c_API_graphic.h"
+#include "f_pc/f_pc_leaf.h"
+#include "f_pc/f_pc_node.h"
+#include "f_pc/f_pc_pause.h"
+
+/* 8004042C-800404CC       .text fpcDw_Execute__FP18base_process_class */
+s32 fpcDw_Execute(base_process_class* i_proc) {
+    if (!fpcPause_IsEnable(i_proc, 2)) {
+        layer_class* curLay;
+        s32 ret;
+        process_method_func draw_func;
+        curLay = fpcLy_CurrentLayer();
+        if (fpcBs_Is_JustOfType(g_fpcLf_type, i_proc->mSubType)) {
+            draw_func = ((leafdraw_method_class*)i_proc->mpPcMtd)->mpDrawFunc;
+        } else {
+            draw_func = ((nodedraw_method_class*)i_proc->mpPcMtd)->mpDrawFunc;
+        }
+        fpcLy_SetCurrentLayer(i_proc->mLyTg.mpLayer);
+        ret = draw_func(i_proc);
+        fpcLy_SetCurrentLayer(curLay);
+        return ret;
+    } else {
+        return 0;
+    }
+}
+
+/* 800404CC-80040520       .text fpcDw_Handler__FPFPFPvPv_i_iPFPvPv_i */
+s32 fpcDw_Handler(fpcDw_HandlerFuncFunc param_1, fpcDw_HandlerFunc param_2) {
+    s32 ret;
+    cAPIGph_BeforeOfDraw();
+    ret = param_1(param_2);
+    cAPIGph_AfterOfDraw();
+    return ret;
+}

src/f_pc/f_pc_draw_priority.cpp

@@ -0,0 +1,21 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_draw_priority.cpp
+//
+
+#include "f_pc/f_pc_draw_priority.h"
+
+/* 8003D580-8003D588       .text fpcDwPi_Get__FP19draw_priority_class */
+s16 fpcDwPi_Get(draw_priority_class* i_drawPrioClass) {
+    return i_drawPrioClass->mPriority;
+}
+
+/* 8003D588-8003D590       .text fpcDwPi_Set__FP19draw_priority_classs */
+void fpcDwPi_Set(draw_priority_class* i_drawPrioClass, s16 i_priority) {
+    i_drawPrioClass->mPriority = i_priority;
+}
+
+/* 8003D590-8003D5B0       .text fpcDwPi_Init__FP19draw_priority_classs */
+void fpcDwPi_Init(draw_priority_class* i_drawPrioClass, s16 i_priority) {
+    fpcDwPi_Set(i_drawPrioClass, i_priority);
+}

src/f_pc/f_pc_executor.cpp

@@ -0,0 +1,86 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_executor.cpp
+//
+
+#include "f_pc/f_pc_executor.h"
+#include "f_pc/f_pc_node.h"
+#include "f_pc/f_pc_pause.h"
+#include "f_pc/f_pc_searcher.h"
+
+/* 8003D5B0-8003D5D0       .text fpcEx_Search__FPFPvPv_PvPv */
+base_process_class* fpcEx_Search(fpcLyIt_JudgeFunc i_judgeFunc, void* i_data) {
+    return (base_process_class*)fpcLyIt_AllJudge(i_judgeFunc, i_data);
+}
+
+/* 8003D5D0-8003D614       .text fpcEx_SearchByID__FUi */
+base_process_class* fpcEx_SearchByID(unsigned int i_id) {
+    if (i_id + 2 <= 1)
+        return NULL;
+
+    return fpcEx_Search(fpcSch_JudgeByID, &i_id);
+}
+
+/* 8003D614-8003D63C       .text fpcEx_IsExist__FUi */
+BOOL fpcEx_IsExist(unsigned int i_id) {
+    return fpcEx_SearchByID(i_id) != NULL ? TRUE : FALSE;
+}
+
+/* 8003D63C-8003D690       .text fpcEx_Execute__FP18base_process_class */
+s32 fpcEx_Execute(base_process_class* i_proc) {
+    if (i_proc->mInitState != 2 || fpcPause_IsEnable(i_proc, 1) == 1)
+        return 0;
+    return fpcBs_Execute(i_proc);
+}
+
+/* 8003D690-8003D73C       .text fpcEx_ToLineQ__FP18base_process_class */
+s32 fpcEx_ToLineQ(base_process_class* i_proc) {
+    layer_class* pLayer = i_proc->mLyTg.mpLayer;
+    base_process_class* pLayerPcNode = &pLayer->mpPcNode->mBase;
+
+    if (pLayer->mLayerID == 0 || cTg_IsUse(&pLayerPcNode->mLnTg.mBase) == TRUE) {
+        s32 ret = fpcLnTg_ToQueue(&i_proc->mLnTg, i_proc->mPi.mInfoCurr.mListID);
+        if (ret == 0) {
+            fpcLyTg_QueueTo(&i_proc->mLyTg);
+            return 0;
+        }
+
+        i_proc->mInitState = 2;
+        if (fpcBs_Is_JustOfType(g_fpcNd_type, i_proc->mSubType)) {
+            process_node_class* pNode = (process_node_class*)i_proc;
+            fpcLyIt_OnlyHere(&pNode->mLayer, (fpcLyIt_OnlyHereFunc)fpcEx_ToLineQ, pNode);
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+/* 8003D73C-8003D788       .text fpcEx_ExecuteQTo__FP18base_process_class */
+s32 fpcEx_ExecuteQTo(base_process_class* i_proc) {
+    s32 ret = fpcLyTg_QueueTo(&i_proc->mLyTg);
+    if (ret == 1) {
+        i_proc->mInitState = 3;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 8003D788-8003D7E0       .text fpcEx_ToExecuteQ__FP18base_process_class */
+s32 fpcEx_ToExecuteQ(base_process_class* i_proc) {
+    s32 ret = fpcLyTg_ToQueue(&i_proc->mLyTg, i_proc->mPi.mInfoCurr.mLayer,
+                              i_proc->mPi.mInfoCurr.mListID, i_proc->mPi.mInfoCurr.mListPrio);
+    if (ret == 1) {
+        fpcEx_ToLineQ(i_proc);
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 8003D7E0-8003D800       .text fpcEx_Handler__FPFPvPv_i */
+void fpcEx_Handler(fpcLnIt_QueueFunc i_queueFunc) {
+    fpcLnIt_Queue(i_queueFunc);
+}

src/f_pc/f_pc_fstcreate_req.cpp

@@ -0,0 +1,55 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_fstcreate_req.cpp
+//
+
+#include "f_pc/f_pc_fstcreate_req.h"
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_load.h"
+#include "SSystem/SComponent/c_phase.h"
+
+/* 80040520-80040570       .text fpcFCtRq_Do__FP19fast_create_request */
+s32 fpcFCtRq_Do(fast_create_request* i_createReq) {
+    if (i_createReq->mpFastCreateFunc != NULL && i_createReq->mpFastCreateFunc(i_createReq->mBase.mpRes, i_createReq->mpFastCreateData) == 0) {
+        return cPhs_UNK3_e;
+    } else {
+        return cPhs_COMPLEATE_e;
+    }
+}
+
+/* 80040570-80040578       .text fpcFCtRq_Delete__FP19fast_create_request */
+s32 fpcFCtRq_Delete(fast_create_request* i_createReq) {
+    return 1;
+}
+
+/* 80040578-80040648       .text fpcFCtRq_Request__FP11layer_classsPFPvPv_iPvPv */
+base_process_class* fpcFCtRq_Request(layer_class* i_layer, s16 i_procTypeID,
+                                     fstCreateFunc i_createFunc, void* i_createData, void* pData) {
+    static create_request_method_class submethod = {(cPhs__Handler)fpcFCtRq_Do, NULL,
+                                                    (process_method_func)fpcFCtRq_Delete};
+
+    if (!fpcLd_Use(i_procTypeID)) {
+        return NULL;
+    } else {
+        fast_create_request* request =
+            (fast_create_request*)fpcCtRq_Create(i_layer, 0x50, &submethod);
+        if (request != NULL) {
+            base_process_class* proc;
+            fpcLy_SetCurrentLayer(i_layer);
+            proc = fpcBs_Create(i_procTypeID, fpcBs_MakeOfId(), pData);
+            if (proc != NULL) {
+                proc->mpCtRq = (struct create_request*)request;
+                request->mBase.mpRes = proc;
+                request->mBase.mBsPcId = proc->mBsPcId;
+                if (fpcBs_SubCreate(proc) == 2) {
+                    request->mpFastCreateFunc = i_createFunc;
+                    request->mpFastCreateData = i_createData;
+                    return proc;
+                }
+            }
+            fpcCtRq_Cancel(&request->mBase);
+        }
+        return NULL;
+    }
+}

src/f_pc/f_pc_layer.cpp

@@ -0,0 +1,166 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_layer.cpp
+//
+
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_method_iter.h"
+#include "f_pc/f_pc_method_tag.h"
+
+/* 8003D800-8003D820       .text fpcLy_CancelQTo__FP24process_method_tag_class */
+void fpcLy_CancelQTo(process_method_tag_class* i_methods) {
+    fpcMtdTg_MethodQTo(i_methods);
+}
+
+/* 8003D820-8003D844       .text fpcLy_ToCancelQ__FP11layer_classP24process_method_tag_class */
+s32 fpcLy_ToCancelQ(layer_class* i_layer, process_method_tag_class* i_methods) {
+    return fpcMtdTg_ToMethodQ(&i_layer->mCancelList, i_methods);
+}
+
+/* 8003D844-8003D870       .text fpcLy_CancelMethod__FP24process_method_tag_class */
+bool fpcLy_CancelMethod(process_method_tag_class* i_layer) {
+    return fpcMtdTg_Do(i_layer) == 1;
+}
+
+/* 8003D870-8003D894       .text fpcLy_IntoQueue__FP11layer_classiP16create_tag_classi */
+s32 fpcLy_IntoQueue(layer_class* i_layer, int i_treeListNo, create_tag_class* i_createTag, int i_no) {
+    return cTg_InsertToTree(&i_layer->mNodeListTree, i_treeListNo, i_createTag, i_no);
+}
+
+/* 8003D894-8003D8B8       .text fpcLy_ToQueue__FP11layer_classiP16create_tag_class */
+s32 fpcLy_ToQueue(layer_class* i_layer, int i_treeListNo, create_tag_class* i_createTag) {
+    return cTg_AdditionToTree(&i_layer->mNodeListTree, i_treeListNo, i_createTag);
+}
+
+/* 8003D8B8-8003D8DC       .text fpcLy_QueueTo__FP11layer_classP16create_tag_class */
+s32 fpcLy_QueueTo(layer_class* i_layer, create_tag_class* i_createTag) {
+    return cTg_SingleCutFromTree(i_createTag);
+}
+
+/* 8003D8DC-8003D8F0       .text fpcLy_IsDeletingMesg__FP11layer_class */
+BOOL fpcLy_IsDeletingMesg(layer_class* i_layer) {
+    return i_layer->counts.mDeletingCount > 0;
+}
+
+/* 8003D8F0-8003D900       .text fpcLy_DeletingMesg__FP11layer_class */
+void fpcLy_DeletingMesg(layer_class* i_layer) {
+    i_layer->counts.mDeletingCount++;
+}
+
+/* 8003D900-8003D918       .text fpcLy_DeletedMesg__FP11layer_class */
+void fpcLy_DeletedMesg(layer_class* i_layer) {
+    if (i_layer->counts.mDeletingCount > 0) {
+        i_layer->counts.mDeletingCount--;
+    }
+}
+
+/* 8003D918-8003D92C       .text fpcLy_IsCreatingMesg__FP11layer_class */
+BOOL fpcLy_IsCreatingMesg(layer_class* i_layer) {
+    return i_layer->counts.mCreatingCount > 0;
+}
+
+/* 8003D92C-8003D93C       .text fpcLy_CreatingMesg__FP11layer_class */
+void fpcLy_CreatingMesg(layer_class* i_layer) {
+    i_layer->counts.mCreatingCount++;
+}
+
+/* 8003D93C-8003D954       .text fpcLy_CreatedMesg__FP11layer_class */
+void fpcLy_CreatedMesg(layer_class* i_layer) {
+    if (i_layer->counts.mCreatingCount > 0) {
+        i_layer->counts.mCreatingCount--;
+    }
+}
+
+layer_class l_fpcLy_Crear = {
+    NULL, NULL, 0, 0xFFFFFFFF, NULL, 0, NULL, NULL, NULL, 0, 0, 0,
+};
+
+node_list_class l_fpcLy_LayerList = {
+    NULL,
+    NULL,
+    0,
+};
+
+/* 8003D954-8003D964       .text fpcLy_RootLayer__Fv */
+layer_class* fpcLy_RootLayer(void) {
+    return (layer_class*)l_fpcLy_LayerList.mpHead;
+}
+
+static layer_class* l_fpcLy_CurrLayer_p;
+
+/* 8003D964-8003D96C       .text fpcLy_SetCurrentLayer__FP11layer_class */
+void fpcLy_SetCurrentLayer(layer_class* i_layer) {
+    l_fpcLy_CurrLayer_p = i_layer;
+}
+
+/* 8003D96C-8003D974       .text fpcLy_CurrentLayer__Fv */
+layer_class* fpcLy_CurrentLayer() {
+    return l_fpcLy_CurrLayer_p;
+}
+
+/* 8003D974-8003D9C4       .text fpcLy_Search__FUi */
+layer_class* fpcLy_Search(unsigned int i_id) {
+    layer_class* layer_p = fpcLy_RootLayer();
+    while (layer_p != NULL) {
+        if (layer_p->mLayerID == i_id) {
+            return layer_p;
+        }
+        layer_p = (layer_class*)layer_p->mNode.mpNextNode;
+    }
+    return NULL;
+}
+
+/* 8003D9C4-8003DA34       .text fpcLy_Layer__FUi */
+layer_class* fpcLy_Layer(unsigned int i_id) {
+    if (i_id == 0 || fpcLy_RootLayer()->mLayerID == i_id) {
+        return fpcLy_RootLayer();
+    } else if (i_id == ~2 || fpcLy_CurrentLayer()->mLayerID == i_id) {
+        return fpcLy_CurrentLayer();
+    } else {
+        return fpcLy_Search(i_id);
+    }
+}
+
+/* 8003DA34-8003DA60       .text fpcLy_Regist__FP11layer_class */
+void fpcLy_Regist(layer_class* i_layer) {
+    cLs_Addition(&l_fpcLy_LayerList, (node_class*)i_layer);
+}
+
+/* 8003DA60-8003DB14       .text fpcLy_Delete__FP11layer_class */
+s32 fpcLy_Delete(layer_class* i_layer) {
+    if (i_layer->mNodeListTree.mpLists->mSize == 0 && i_layer->mCancelList.mSize == 0) {
+        cLs_SingleCut((node_class*)i_layer);
+        *i_layer = l_fpcLy_Crear;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 8003DB14-8003DB40       .text fpcLy_Cancel__FP11layer_class */
+s32 fpcLy_Cancel(layer_class* i_layer) {
+    return fpcMtdIt_Method(&i_layer->mCancelList, (fpcMtdIt_MethodFunc)fpcLy_CancelMethod);
+}
+
+/* 8003DB40-8003DC78       .text fpcLy_Create__FP11layer_classPvP15node_list_classi */
+void fpcLy_Create(layer_class* i_layer, void* i_node, node_list_class* i_nodeList, int i_numLists) {
+    void* pvVar1;
+    s32 iVar2;
+
+    static int IsInitOfLayerList = 1;
+    static int layer_id = 0;
+    *i_layer = l_fpcLy_Crear;
+    cNd_Create((node_class*)i_layer, NULL);
+    i_layer->mLayerID = layer_id++;
+    i_layer->mpPcNode = static_cast<process_node_class*>(i_node);
+    if (IsInitOfLayerList == 1) {
+        IsInitOfLayerList = 0;
+        cLs_Create(&l_fpcLy_LayerList);
+        fpcLy_SetCurrentLayer(i_layer);
+    }
+    (i_layer->mNodeListTree).mpLists = i_nodeList;
+    (i_layer->mNodeListTree).mNumLists = i_numLists;
+    cTr_Create(&i_layer->mNodeListTree, (i_layer->mNodeListTree).mpLists,
+               (i_layer->mNodeListTree).mNumLists);
+    fpcLy_Regist(i_layer);
+}

src/f_pc/f_pc_layer_iter.cpp

@@ -0,0 +1,54 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_layer_iter.cpp
+//
+
+#include "f_pc/f_pc_layer_iter.h"
+#include "SSystem/SComponent/c_tag_iter.h"
+#include "SSystem/SComponent/c_tree_iter.h"
+#include "f_pc/f_pc_layer.h"
+
+/* 8003DE00-8003DE38       .text fpcLyIt_OnlyHere__FP11layer_classPFPvPv_iPv */
+s32 fpcLyIt_OnlyHere(layer_class* i_layer, fpcLyIt_OnlyHereFunc i_func, void* i_data) {
+    layer_iter lIter;
+    lIter.mpFunc = i_func;
+    lIter.mpUserData = i_data;
+    return cTrIt_Method(&i_layer->mNodeListTree, (cNdIt_MethodFunc)cTgIt_MethodCall, &lIter);
+}
+
+/* 8003DE38-8003DEA0       .text fpcLyIt_OnlyHereLY__FP11layer_classPFPvPv_iPv */
+s32 fpcLyIt_OnlyHereLY(layer_class* i_layer, fpcLyIt_OnlyHereFunc i_func, void* i_data) {
+    s32 result;
+    layer_class* currentLayer = fpcLy_CurrentLayer();
+    fpcLy_SetCurrentLayer(i_layer);
+    result = fpcLyIt_OnlyHere(i_layer, i_func, i_data);
+    fpcLy_SetCurrentLayer(currentLayer);
+    return result;
+}
+
+/* 8003DEA0-8003DED8       .text fpcLyIt_Judge__FP11layer_classPFPvPv_PvPv */
+void* fpcLyIt_Judge(layer_class* i_layer, fpcLyIt_JudgeFunc i_func, void* i_data) {
+    layer_iter lIter;
+    lIter.mpFunc = i_func;
+    lIter.mpUserData = i_data;
+    return cTrIt_Judge(&i_layer->mNodeListTree, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &lIter);
+}
+
+/* 8003DED8-8003DF4C       .text fpcLyIt_AllJudge__FPFPvPv_PvPv */
+void* fpcLyIt_AllJudge(fpcLyIt_JudgeFunc i_func, void* i_data) {
+    layer_iter lIter;
+    layer_class* current;
+    lIter.mpFunc = i_func;
+    lIter.mpUserData = i_data;
+
+    current = fpcLy_RootLayer();
+    while (current != NULL) {
+        void* result =
+            cTrIt_Judge(&current->mNodeListTree, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &lIter);
+        if (result != NULL) {
+            return result;
+        }
+        current = (layer_class*)current->mNode.mpNextNode;
+    }
+    return NULL;
+}

src/f_pc/f_pc_layer_tag.cpp

@@ -0,0 +1,79 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_layer_tag.cpp
+//
+
+#include "f_pc/f_pc_layer_tag.h"
+#include "f_pc/f_pc_layer.h"
+
+/* 8003DF4C-8003E044       .text fpcLyTg_ToQueue__FP26layer_management_tag_classUiUsUs */
+s32 fpcLyTg_ToQueue(layer_management_tag_class* i_LyTag, unsigned int i_layerID, u16 i_listID,
+                    u16 i_listPriority) {
+    if (i_LyTag->mpLayer == NULL && i_layerID == -1) {
+        return 0;
+    } else {
+        // ghidra says i_layerID is unsigned?
+        if (i_layerID != -1 && i_layerID != -3 && i_LyTag->mpLayer->mLayerID != i_layerID) {
+            i_LyTag->mpLayer = fpcLy_Layer(i_layerID);
+        }
+        if (i_layerID == -1 || i_layerID == -3) {
+            s32 tmp = fpcLy_ToQueue(i_LyTag->mpLayer, i_listID, &i_LyTag->mCreateTag);
+            if (tmp != 0) {
+                i_LyTag->mNodeListID = i_listID;
+                i_LyTag->mNodeListIdx = tmp - 1;
+                return 1;
+            }
+        } else if (fpcLy_IntoQueue(i_LyTag->mpLayer, i_listID, &i_LyTag->mCreateTag,
+                                   i_listPriority) != 0)
+        {
+            i_LyTag->mNodeListID = i_listID;
+            i_LyTag->mNodeListIdx = i_listPriority;
+            return 1;
+        }
+        return 0;
+    }
+}
+
+/* 8003E044-8003E0A4       .text fpcLyTg_QueueTo__FP26layer_management_tag_class */
+s32 fpcLyTg_QueueTo(layer_management_tag_class* i_LyTag) {
+    if (fpcLy_QueueTo(i_LyTag->mpLayer, &i_LyTag->mCreateTag) == 1) {
+        i_LyTag->mpLayer = NULL;
+        i_LyTag->mNodeListID = 0xFFFF;
+        i_LyTag->mNodeListIdx = 0xFFFF;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 8003E0A4-8003E128       .text fpcLyTg_Move__FP26layer_management_tag_classUiUsUs */
+s32 fpcLyTg_Move(layer_management_tag_class* i_LyTag, unsigned int i_layerID, u16 i_listID,
+                 u16 i_listPriority) {
+    layer_class* layer = fpcLy_Layer(i_layerID);
+    if (layer == NULL) {
+        return 0;
+    } else if (fpcLyTg_QueueTo(i_LyTag) == 0x1) {
+        i_LyTag->mpLayer = layer;
+        return fpcLyTg_ToQueue(i_LyTag, i_layerID, i_listID, i_listPriority);
+    } else {
+        return 0;
+    }
+}
+
+/* 8003E128-8003E1DC       .text fpcLyTg_Init__FP26layer_management_tag_classUiPv */
+s32 fpcLyTg_Init(layer_management_tag_class* i_LyTag, unsigned int i_id, void* i_data) {
+    static layer_management_tag_class crear = {
+        NULL, NULL, NULL, NULL, 0, NULL, 0xFFFF, 0xFFFF,
+    };
+
+    layer_class* layer;
+    *i_LyTag = crear;
+    cTg_Create(&i_LyTag->mCreateTag, i_data);
+    layer = fpcLy_Layer(i_id);
+    if (layer != NULL) {
+        i_LyTag->mpLayer = layer;
+        return 1;
+    } else {
+        return 0;
+    }
+}

src/f_pc/f_pc_leaf.cpp

@@ -0,0 +1,66 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_leaf.cpp
+//
+
+#include "f_pc/f_pc_leaf.h"
+
+/* 8003DC78-8003DC9C       .text fpcLf_GetPriority__FP14leafdraw_class */
+s16 fpcLf_GetPriority(leafdraw_class* i_leaf) {
+    return fpcDwPi_Get(&i_leaf->mDwPi);
+}
+
+/* 8003DC9C-8003DCC0       .text fpcLf_DrawMethod__FP21leafdraw_method_classPv */
+s32 fpcLf_DrawMethod(leafdraw_method_class* i_methods, void* i_data) {
+    return fpcMtd_Method(i_methods->mpDrawFunc, i_data);
+}
+
+/* 8003DCC0-8003DCF8       .text fpcLf_Draw__FP14leafdraw_class */
+s32 fpcLf_Draw(leafdraw_class* i_leaf) {
+    s32 ret = 0;
+    if (i_leaf->mbUnk0 == 0)
+        ret = fpcLf_DrawMethod(i_leaf->mpDrawMtd, i_leaf);
+    return ret;
+}
+
+/* 8003DCF8-8003DD20       .text fpcLf_Execute__FP14leafdraw_class */
+s32 fpcLf_Execute(leafdraw_class* i_leaf) {
+    return fpcMtd_Execute(&i_leaf->mpDrawMtd->mBase, i_leaf);
+}
+
+/* 8003DD20-8003DD48       .text fpcLf_IsDelete__FP14leafdraw_class */
+s32 fpcLf_IsDelete(leafdraw_class* i_leaf) {
+    return fpcMtd_IsDelete(&i_leaf->mpDrawMtd->mBase, i_leaf);
+}
+
+/* 8003DD48-8003DD8C       .text fpcLf_Delete__FP14leafdraw_class */
+s32 fpcLf_Delete(leafdraw_class* i_leaf) {
+    s32 ret = fpcMtd_Delete(&i_leaf->mpDrawMtd->mBase, i_leaf);
+    if (ret == 1) {
+        i_leaf->mBase.mSubType = 0;
+    }
+    return ret;
+}
+
+int g_fpcLf_type;
+
+/* 8003DD8C-8003DE00       .text fpcLf_Create__FP14leafdraw_class */
+s32 fpcLf_Create(leafdraw_class* i_leaf) {
+    leaf_process_profile_definition* profDef;
+    if (i_leaf->mBase.mInitState == 0) {
+        profDef = (leaf_process_profile_definition*)i_leaf->mBase.mpProf;
+        i_leaf->mpDrawMtd = profDef->mSubMtd;
+        i_leaf->mBase.mSubType = fpcBs_MakeOfType(&g_fpcLf_type);
+        fpcDwPi_Init(&i_leaf->mDwPi, profDef->mPriority);
+        i_leaf->mbUnk0 = 0;
+    }
+    return fpcMtd_Create(&i_leaf->mpDrawMtd->mBase, i_leaf);
+}
+
+leafdraw_method_class g_fpcLf_Method = {
+    (process_method_func)fpcLf_Create,
+    (process_method_func)fpcLf_Delete,
+    (process_method_func)fpcLf_Execute,
+    (process_method_func)fpcLf_IsDelete,
+    (process_method_func)fpcLf_Draw,
+};

src/f_pc/f_pc_line.cpp

@@ -0,0 +1,23 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_line.cpp
+//
+
+#include "f_pc/f_pc_line.h"
+#include "f_pc/f_pc_node.h"
+#include "global.h"
+
+static node_list_class l_fpcLn_Line[16];
+
+/* 8003E1DC-8003E230       .text fpcLn_Create__Fv */
+void fpcLn_Create() {
+    s32 i = ARRAY_SIZE(l_fpcLn_Line);
+    node_list_class* pLine = l_fpcLn_Line;
+    while (i-- > 0)
+        cLs_Create(pLine++);
+}
+
+node_lists_tree_class g_fpcLn_Queue = {
+    l_fpcLn_Line,
+    ARRAY_SIZE(l_fpcLn_Line),
+};

src/f_pc/f_pc_line_iter.cpp

@@ -0,0 +1,32 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_line_iter.cpp
+//
+
+#include "f_pc/f_pc_line_iter.h"
+#include "SSystem/SComponent/c_tag_iter.h"
+#include "SSystem/SComponent/c_tree_iter.h"
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_line.h"
+
+/* 80040198-80040200       .text fpcLnIt_MethodCall__FP16create_tag_classP13method_filter */
+static s32 fpcLnIt_MethodCall(create_tag_class* i_createTag, method_filter* i_filter) {
+    layer_class* pLayer = static_cast<base_process_class*>(i_createTag->mpTagData)->mLyTg.mpLayer;
+    layer_class* pCurLayer = fpcLy_CurrentLayer();
+    s32 ret;
+
+    fpcLy_SetCurrentLayer(pLayer);
+    ret = cTgIt_MethodCall(i_createTag, i_filter);
+    fpcLy_SetCurrentLayer(pCurLayer);
+
+    return ret;
+}
+
+/* 80040200-8004023C       .text fpcLnIt_Queue__FPFPvPv_i */
+void fpcLnIt_Queue(fpcLnIt_QueueFunc i_queueFunc) {
+    method_filter filter;
+    filter.mpMethodFunc = (cNdIt_MethodFunc)i_queueFunc;
+    filter.mpUserData = NULL;
+    cTrIt_Method(&g_fpcLn_Queue, (cNdIt_MethodFunc)fpcLnIt_MethodCall, &filter);
+}

src/f_pc/f_pc_line_tag.cpp

@@ -0,0 +1,41 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_line_tag.cpp
+//
+
+#include "f_pc/f_pc_line_tag.h"
+#include "f_pc/f_pc_line.h"
+
+/* 80040080-800400D8       .text fpcLnTg_Move__FP8line_tagi */
+s32 fpcLnTg_Move(line_tag* i_lineTag, int i_newListID) {
+    if (i_lineTag->mLineListID != i_newListID) {
+        fpcLnTg_QueueTo(i_lineTag);
+        return fpcLnTg_ToQueue(i_lineTag, i_newListID);
+    }
+
+    return 1;
+}
+
+/* 800400D8-8004010C       .text fpcLnTg_QueueTo__FP8line_tag */
+void fpcLnTg_QueueTo(line_tag* i_lineTag) {
+    cTg_SingleCutFromTree(&i_lineTag->mBase);
+    i_lineTag->mLineListID = -1;
+}
+
+/* 8004010C-80040164       .text fpcLnTg_ToQueue__FP8line_tagi */
+s32 fpcLnTg_ToQueue(line_tag* i_lineTag, int lineListID) {
+    s32 ret = cTg_AdditionToTree(&g_fpcLn_Queue, lineListID, &i_lineTag->mBase);
+
+    if (ret) {
+        i_lineTag->mLineListID = lineListID;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 80040164-80040198       .text fpcLnTg_Init__FP8line_tagPv */
+void fpcLnTg_Init(line_tag* i_lineTag, void* i_data) {
+    cTg_Create(&i_lineTag->mBase, i_data);
+    i_lineTag->mLineListID = -1;
+}

src/f_pc/f_pc_load.cpp

@@ -0,0 +1,39 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_load.cpp
+//
+
+#include "c/c_dylink.h"
+#include "f_pc/f_pc_load.h"
+#include "SSystem/SComponent/c_phase.h"
+
+/* 8003E230-8003E280       .text fpcLd_Use__Fs */
+BOOL fpcLd_Use(s16 i_procName) {
+    if (fpcLd_IsLoaded(i_procName) == TRUE && fpcLd_Load(i_procName) == cPhs_COMPLEATE_e)
+        return TRUE;
+    return FALSE;
+}
+
+/* 8003E280-8003E2A4       .text fpcLd_IsLoaded__Fs */
+s32 fpcLd_IsLoaded(s16 i_procName) {
+    return cDyl_IsLinked((int)i_procName);
+}
+
+/* 8003E2A4-8003E2C8       .text fpcLd_Free__Fs */
+void fpcLd_Free(s16 i_procName) {
+    cDyl_Unlink((int)i_procName);
+}
+
+/* 8003E2C8-8003E318       .text fpcLd_Load__Fs */
+s32 fpcLd_Load(s16 i_procName) {
+    s32 phase = cDyl_LinkASync((int)i_procName);
+
+    switch (phase) {
+    case cPhs_COMPLEATE_e:
+        return cPhs_COMPLEATE_e;
+    case 0:
+        return 0;
+    default:
+        return cPhs_ERROR_e;
+    }
+}

src/f_pc/f_pc_manager.cpp

@@ -0,0 +1,82 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_manager.cpp
+//
+
+#include "f_pc/f_pc_manager.h"
+#include "dolphin/types.h"
+
+/* 8003E318-8003E338       .text fpcM_Draw__FPv */
+void fpcM_Draw(void* i_proc) {
+    fpcDw_Execute((base_process_class*)i_proc);
+}
+
+/* 8003E338-8003E370       .text fpcM_DrawIterater__FPFPvPv_i */
+s32 fpcM_DrawIterater(fpcM_DrawIteraterFunc i_drawIterFunc) {
+    return fpcLyIt_OnlyHere(fpcLy_RootLayer(), (fpcLyIt_OnlyHereFunc)i_drawIterFunc, NULL);
+}
+
+/* 8003E370-8003E390       .text fpcM_Execute__FPv */
+s32 fpcM_Execute(void* i_proc) {
+    return fpcEx_Execute((base_process_class*)i_proc);
+}
+
+/* 8003E390-8003E3B0       .text fpcM_Delete__FPv */
+s32 fpcM_Delete(void* i_proc) {
+    return fpcDt_Delete((base_process_class*)i_proc);
+}
+
+/* 8003E3B0-8003E3D0       .text fpcM_IsCreating__FUi */
+BOOL fpcM_IsCreating(unsigned int pID) {
+    return fpcCt_IsCreatingByID(pID);
+}
+
+/* 8003E3D0-8003E9F0       .text messageSet__FUl */
+void messageSet(unsigned long) {
+    /* Nonmatching */
+}
+
+/* 8003E9F0-8003EBD4       .text drawDvdCondition__Fl */
+void drawDvdCondition(long) {
+    /* Nonmatching */
+}
+
+/* 8003EBD4-8003EC84       .text checkDvdCondition__Fv */
+void checkDvdCondition() {
+    /* Nonmatching */
+}
+
+/* 8003EC84-8003ED90       .text fpcM_Management__FPFv_vPFv_v */
+void fpcM_Management(void (*)(void), void (*)(void)) {
+    /* Nonmatching */
+}
+
+/* 8003ED90-8003EDCC       .text fpcM_Init__Fv */
+void fpcM_Init() {
+    /* Nonmatching */
+}
+
+/* 8003EDCC-8003EE20       .text fpcM_FastCreate__FsPFPv_iPvPv */
+void fpcM_FastCreate(short, int (*)(void*), void*, void*) {
+    /* Nonmatching */
+}
+
+/* 8003EE20-8003EE44       .text fpcM_IsPause__FPvUc */
+void fpcM_IsPause(void*, unsigned char) {
+    /* Nonmatching */
+}
+
+/* 8003EE44-8003EE68       .text fpcM_PauseEnable__FPvUc */
+void fpcM_PauseEnable(void*, unsigned char) {
+    /* Nonmatching */
+}
+
+/* 8003EE68-8003EE8C       .text fpcM_PauseDisable__FPvUc */
+void fpcM_PauseDisable(void*, unsigned char) {
+    /* Nonmatching */
+}
+
+/* 8003EE8C-8003EF00       .text fpcM_JudgeInLayer__FUiPFPvPv_PvPv */
+void fpcM_JudgeInLayer(unsigned int, void* (*)(void*, void*), void*) {
+    /* Nonmatching */
+}

src/f_pc/f_pc_method.cpp

@@ -0,0 +1,34 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_method.cpp
+//
+
+#include "f_pc/f_pc_method.h"
+
+/* 8003EF00-8003EF38       .text fpcMtd_Method__FPFPv_iPv */
+s32 fpcMtd_Method(process_method_func i_methodFunc, void* i_data) {
+    if (i_methodFunc != NULL)
+        return i_methodFunc(i_data);
+    else
+        return 1;
+}
+
+/* 8003EF38-8003EF5C       .text fpcMtd_Execute__FP20process_method_classPv */
+s32 fpcMtd_Execute(process_method_class* i_methods, void* i_data) {
+    return fpcMtd_Method(i_methods->mpExecuteFunc, i_data);
+}
+
+/* 8003EF5C-8003EF80       .text fpcMtd_IsDelete__FP20process_method_classPv */
+s32 fpcMtd_IsDelete(process_method_class* i_methods, void* i_data) {
+    return fpcMtd_Method(i_methods->mpIsDeleteFunc, i_data);
+}
+
+/* 8003EF80-8003EFA4       .text fpcMtd_Delete__FP20process_method_classPv */
+s32 fpcMtd_Delete(process_method_class* i_methods, void* i_data) {
+    return fpcMtd_Method(i_methods->mpDeleteFunc, i_data);
+}
+
+/* 8003EFA4-8003EFC8       .text fpcMtd_Create__FP20process_method_classPv */
+s32 fpcMtd_Create(process_method_class* i_methods, void* i_data) {
+    return fpcMtd_Method(i_methods->mpCreateFunc, i_data);
+}

src/f_pc/f_pc_method_iter.cpp

@@ -0,0 +1,12 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_method_iter.cpp
+//
+
+#include "f_pc/f_pc_method_iter.h"
+#include "SSystem/SComponent/c_list_iter.h"
+
+/* 8004023C-80040260       .text fpcMtdIt_Method__FP15node_list_classPFPv_i */
+int fpcMtdIt_Method(node_list_class* i_nodeList, fpcMtdIt_MethodFunc i_methods) {
+    return cLsIt_Method(i_nodeList, (cNdIt_MethodFunc)i_methods, NULL);
+}

src/f_pc/f_pc_method_tag.cpp

@@ -0,0 +1,29 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_method_tag.cpp
+//
+
+#include "f_pc/f_pc_method_tag.h"
+
+/* 80040260-80040290       .text fpcMtdTg_Do__FP24process_method_tag_class */
+s32 fpcMtdTg_Do(process_method_tag_class* i_methodTag) {
+    return i_methodTag->mpFunc(i_methodTag->mpMthdData);
+}
+
+/* 80040290-800402B0       .text fpcMtdTg_ToMethodQ__FP15node_list_classP24process_method_tag_class */
+s32 fpcMtdTg_ToMethodQ(node_list_class* pList, process_method_tag_class* i_methodTag) {
+    return cTg_Addition(pList, &i_methodTag->mCreateTag);
+}
+
+/* 800402B0-800402D0       .text fpcMtdTg_MethodQTo__FP24process_method_tag_class */
+void fpcMtdTg_MethodQTo(process_method_tag_class* i_methodTag) {
+    cTg_SingleCut(&i_methodTag->mCreateTag);
+}
+
+/* 800402D0-8004031C       .text fpcMtdTg_Init__FP24process_method_tag_classPFPv_iPv */
+s32 fpcMtdTg_Init(process_method_tag_class* i_methodTag, process_method_tag_func i_mtdTgFunc, void* i_data) {
+    cTg_Create(&i_methodTag->mCreateTag, i_methodTag);
+    i_methodTag->mpFunc = i_mtdTgFunc;
+    i_methodTag->mpMthdData = i_data;
+    return 1;
+}

src/f_pc/f_pc_node.cpp

@@ -0,0 +1,108 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_node.cpp
+//
+
+#include "f_pc/f_pc_node.h"
+#include "f_pc/f_pc_layer_iter.h"
+
+/* 8003EFC8-8003EFEC       .text fpcNd_DrawMethod__FP21nodedraw_method_classPv */
+s32 fpcNd_DrawMethod(nodedraw_method_class* i_nodeMethods, void* i_data) {
+    return fpcMtd_Method(i_nodeMethods->mpDrawFunc, i_data);
+}
+
+/* 8003EFEC-8003F058       .text fpcNd_Draw__FP18process_node_class */
+s32 fpcNd_Draw(process_node_class* i_procNode) {
+    s32 ret = 0;
+    if (i_procNode->mUnk0 == 0) {
+        layer_class* curLayer_p = fpcLy_CurrentLayer();
+        fpcLy_SetCurrentLayer(&i_procNode->mLayer);
+        ret = fpcNd_DrawMethod(i_procNode->mpNodeMtd, i_procNode);
+        fpcLy_SetCurrentLayer(curLayer_p);
+    }
+    return ret;
+}
+
+/* 8003F058-8003F0B4       .text fpcNd_Execute__FP18process_node_class */
+s32 fpcNd_Execute(process_node_class* i_procNode) {
+    s32 ret;
+    layer_class* curLayer_p = fpcLy_CurrentLayer();
+    fpcLy_SetCurrentLayer(&i_procNode->mLayer);
+    ret = fpcMtd_Execute(&i_procNode->mpNodeMtd->mBase, i_procNode);
+    fpcLy_SetCurrentLayer(curLayer_p);
+    return ret;
+}
+
+int g_fpcNd_type;
+
+/* 8003F0B4-8003F134       .text fpcNd_IsCreatingFromUnder__FPv */
+void* fpcNd_IsCreatingFromUnder(void* i_procNode) {
+    layer_class* layer;
+    process_node_class* pProcNode = static_cast<process_node_class*>(i_procNode);
+    if (pProcNode != NULL && fpcBs_Is_JustOfType(g_fpcNd_type, pProcNode->mBase.mSubType) != FALSE) {
+        layer = &pProcNode->mLayer;
+        if (fpcLy_IsCreatingMesg(layer) == 0) {
+            return (process_node_class*)fpcLyIt_Judge(
+                layer, (fpcLyIt_JudgeFunc)fpcNd_IsCreatingFromUnder, NULL);
+        } else {
+            return pProcNode;
+        }
+    } else {
+        return NULL;
+    }
+}
+
+static s32 g_fpcNd_IsCheckOfDeleteTiming = 1;
+
+/* 8003F134-8003F174       .text fpcNd_IsDeleteTiming__FP18process_node_class */
+s32 fpcNd_IsDeleteTiming(process_node_class* i_procNode) {
+    if (g_fpcNd_IsCheckOfDeleteTiming == 1 && fpcNd_IsCreatingFromUnder(i_procNode) != NULL) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+/* 8003F174-8003F19C       .text fpcNd_IsDelete__FP18process_node_class */
+s32 fpcNd_IsDelete(process_node_class* i_procNode) {
+    return fpcMtd_IsDelete(&i_procNode->mpNodeMtd->mBase, i_procNode);
+}
+
+/* 8003F19C-8003F200       .text fpcNd_Delete__FP18process_node_class */
+s32 fpcNd_Delete(process_node_class* i_procNode) {
+    if ((fpcLy_IsDeletingMesg(&i_procNode->mLayer) == 0) && fpcMtd_Delete(&i_procNode->mpNodeMtd->mBase, i_procNode) == 1) {
+        i_procNode->mBase.mSubType = 0;
+        return fpcLy_Delete(&i_procNode->mLayer);
+    } else {
+        return 0;
+    }
+}
+
+/* 8003F200-8003F29C       .text fpcNd_Create__FP18process_node_class */
+s32 fpcNd_Create(process_node_class* i_procNode) {
+    // this cast looks like a fake match, but it doesn't match without the cast, naive approach
+    // swaps r31 and r30 most likely it gets casted to another unknown struct
+    process_node_class* pProcNode = (process_node_class*)i_procNode;
+    layer_class* curLayer_p;
+    s32 ret;
+    if (pProcNode->mBase.mInitState == 0) {
+        node_process_profile_definition* pProcProfileDef = (node_process_profile_definition*)pProcNode->mBase.mpProf;
+        pProcNode->mBase.mSubType = fpcBs_MakeOfType(&g_fpcNd_type);
+        pProcNode->mpNodeMtd = (nodedraw_method_class*)pProcProfileDef->mSubMtd;
+        fpcLy_Create(&pProcNode->mLayer, pProcNode, pProcNode->mLayerNodeLists, 0x10);
+        pProcNode->mUnk0 = 0;
+    }
+    curLayer_p = fpcLy_CurrentLayer();
+    fpcLy_SetCurrentLayer(&pProcNode->mLayer);
+    ret = fpcMtd_Create(&pProcNode->mpNodeMtd->mBase, pProcNode);
+    fpcLy_SetCurrentLayer(curLayer_p);
+    return ret;
+}
+
+nodedraw_method_class g_fpcNd_Method = {
+    (process_method_func)fpcNd_Create,
+    (process_method_func)fpcNd_Delete,
+    (process_method_func)fpcNd_Execute,
+    (process_method_func)fpcNd_IsDelete,
+    (process_method_func)fpcNd_Draw
+};

src/f_pc/f_pc_node_req.cpp

@@ -0,0 +1,318 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_node_req.cpp
+//
+
+#include "f_pc/f_pc_node_req.h"
+#include "SSystem/SComponent/c_malloc.h"
+#include "SSystem/SComponent/c_node.h"
+#include "SSystem/SStandard/s_basic.h"
+#include "f_pc/f_pc_deletor.h"
+#include "f_pc/f_pc_executor.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_node.h"
+#include "f_pc/f_pc_stdcreate_req.h"
+
+/* 8003F29C-8003F2DC       .text fpcNdRq_RequestQTo__FP19node_create_request */
+void fpcNdRq_RequestQTo(node_create_request* i_NdCtReq) {
+    fpcLy_CreatedMesg(i_NdCtReq->mpLayerClass);
+    fpcLy_CancelQTo(&i_NdCtReq->mProcMthCls);
+    cTg_SingleCut(&i_NdCtReq->mCreateTag);
+}
+
+static node_list_class l_fpcNdRq_Queue = {NULL, NULL, 0};
+
+/* 8003F2DC-8003F328       .text fpcNdRq_ToRequestQ__FP19node_create_request */
+void fpcNdRq_ToRequestQ(node_create_request* i_NdCtReq) {
+    cTg_Addition(&l_fpcNdRq_Queue, &i_NdCtReq->mCreateTag);
+    fpcLy_ToCancelQ(i_NdCtReq->mpLayerClass, &i_NdCtReq->mProcMthCls);
+    fpcLy_CreatingMesg(i_NdCtReq->mpLayerClass);
+}
+
+/* 8003F328-8003F380       .text fpcNdRq_phase_IsCreated__FP19node_create_request */
+s32 fpcNdRq_phase_IsCreated(node_create_request* i_NdCtReq) {
+    if (fpcCtRq_IsCreatingByID(i_NdCtReq->mCreatingID) == TRUE) {
+        return cPhs_INIT_e;
+    } else {
+        return fpcEx_IsExist(i_NdCtReq->mCreatingID) == TRUE ? 2 : 3;
+    }
+}
+
+/* 8003F380-8003F3DC       .text fpcNdRq_phase_Create__FP19node_create_request */
+s32 fpcNdRq_phase_Create(node_create_request* i_NdCtReq) {
+    i_NdCtReq->mCreatingID = fpcSCtRq_Request(i_NdCtReq->mpLayerClass, i_NdCtReq->mProcName,
+        (stdCreateFunc)i_NdCtReq->mpNodeCrReqMthCls->mpPostMethodFunc, i_NdCtReq,
+        i_NdCtReq->mpUserData);
+    return i_NdCtReq->mCreatingID == -1 ? 3 : 2;
+}
+
+/* 8003F3DC-8003F3E4       .text fpcNdRq_phase_IsDeleteTiming__FP19node_create_request */
+s32 fpcNdRq_phase_IsDeleteTiming(node_create_request* i_NdCtReq) {
+    return 2;
+}
+
+/* 8003F3E4-8003F414       .text fpcNdRq_phase_IsDeleted__FP19node_create_request */
+s32 fpcNdRq_phase_IsDeleted(node_create_request* i_NdCtReq) {
+    return fpcDt_IsComplete() == 0 ? cPhs_INIT_e : 2;
+}
+
+/* 8003F414-8003F468       .text fpcNdRq_phase_Delete__FP19node_create_request */
+s32 fpcNdRq_phase_Delete(node_create_request* i_NdCtReq) {
+    if (i_NdCtReq->mNodeProc.mpNodeProc != NULL) {
+        if (fpcDt_Delete(&i_NdCtReq->mNodeProc.mpNodeProc->mBase) == 0) {
+            return cPhs_INIT_e;
+        }
+        i_NdCtReq->mNodeProc.mpNodeProc = NULL;
+    }
+    return 2;
+}
+
+/* 8003F468-8003F4B0       .text fpcNdRq_DoPhase__FP19node_create_request */
+s32 fpcNdRq_DoPhase(node_create_request* i_NdCtReq) {
+    s32 result = cPhs_Handler(&i_NdCtReq->mReqPhsProc, i_NdCtReq->mpPhsHandler, i_NdCtReq);
+    if (result == 2) {
+        return fpcNdRq_DoPhase(i_NdCtReq);
+    }
+    return result;
+}
+
+/* 8003F4B0-8003F514       .text fpcNdRq_Execute__FP19node_create_request */
+s32 fpcNdRq_Execute(node_create_request* i_NdCtReq) {
+    s32 result = fpcNdRq_DoPhase(i_NdCtReq);
+    switch (result) {
+    case cPhs_INIT_e:
+    case cPhs_LOADING_e:
+        return cPhs_INIT_e;
+    case cPhs_COMPLEATE_e:
+        return cPhs_NEXT_e;
+    case cPhs_ERROR_e:
+    case cPhs_UNK3_e:
+        return cPhs_UNK3_e;
+    default:
+        return result;
+    }
+}
+
+/* 8003F514-8003F57C       .text fpcNdRq_Delete__FP19node_create_request */
+s32 fpcNdRq_Delete(node_create_request* i_NdCtReq) {
+    fpcNdRq_RequestQTo(i_NdCtReq);
+    if (i_NdCtReq->mpNodeCrReqMthCls != NULL && i_NdCtReq->mpNodeCrReqMthCls->mpUnkFunc != NULL && fpcMtd_Method(i_NdCtReq->mpNodeCrReqMthCls->mpUnkFunc, i_NdCtReq) == 0)
+        return 0;
+    cMl::free(i_NdCtReq);
+    return 1;
+}
+
+/* 8003F57C-8003F5D4       .text fpcNdRq_Cancel__FP19node_create_request */
+s32 fpcNdRq_Cancel(node_create_request* i_NdCtReq) {
+    if (i_NdCtReq->mpNodeCrReqMthCls != NULL && fpcMtd_Method(i_NdCtReq->mpNodeCrReqMthCls->mpCancelFunc, i_NdCtReq) == 0)
+        return 0;
+    return fpcNdRq_Delete(i_NdCtReq);
+}
+
+/* 8003F5D4-8003F6BC       .text fpcNdRq_Handler__Fv */
+s32 fpcNdRq_Handler() {
+    node_class* currentNode = l_fpcNdRq_Queue.mpHead;
+    while (currentNode != NULL) {
+        node_create_request* req = ((request_node_class*)currentNode)->mNodeCrReq;
+        switch (req->mpNodeCrReqMthCls->mpExecuteFunc(req)) {
+        case cPhs_UNK3_e:
+        case cPhs_ERROR_e:
+            currentNode = NODE_GET_NEXT(currentNode);
+            if (fpcNdRq_Cancel(req) == 0) {
+                return 0;
+            }
+            break;
+        case cPhs_COMPLEATE_e:
+            currentNode = NODE_GET_NEXT(currentNode);
+            if (fpcNdRq_Delete(req) == 0) {
+                return 0;
+            }
+            break;
+        default:
+            currentNode = NODE_GET_NEXT(currentNode);
+            break;
+        }
+    }
+    return 1;
+}
+
+/* 8003F6BC-8003F728       .text fpcNdRq_IsPossibleTarget__FP18process_node_class */
+s32 fpcNdRq_IsPossibleTarget(process_node_class* i_procNode) {
+    s32 bsPcId = i_procNode->mBase.mBsPcId;
+    request_node_class* currentNode;
+    node_create_request* currentNdCr;
+    currentNode = (request_node_class*)l_fpcNdRq_Queue.mpHead;
+    while (currentNode != NULL) {
+        currentNdCr = currentNode->mNodeCrReq;
+        if ((currentNdCr->mParameter == 2 || currentNdCr->mParameter == 4 || currentNdCr->mParameter == 1) && currentNdCr->mNodeProc.mProcId == bsPcId)
+            return 0;
+        currentNode = (request_node_class*)NODE_GET_NEXT((&currentNode->mBase));
+    }
+    return 1;
+}
+
+/* 8003F728-8003F774       .text fpcNdRq_IsIng__FP18process_node_class */
+s32 fpcNdRq_IsIng(process_node_class* i_procNode) {
+    request_node_class* currentNode;
+    node_create_request* currentNodeReq;
+    s32 bsPcId = i_procNode->mBase.mBsPcId;
+    currentNode = (request_node_class*)l_fpcNdRq_Queue.mpHead;
+    while (currentNode != NULL) {
+        currentNodeReq = currentNode->mNodeCrReq;
+        if (currentNodeReq->mCreatingID == bsPcId)
+            return 1;
+        currentNode = (request_node_class*)NODE_GET_NEXT((&currentNode->mBase));
+    }
+    return 0;
+}
+
+/* 8003F774-8003F8EC       .text fpcNdRq_Create__FUl */
+node_create_request* fpcNdRq_Create(u32 i_requestSize) {
+    static node_create_request clear = {
+        NULL, NULL,       NULL, NULL,       0,      NULL, NULL,   NULL, NULL,
+        0,    NULL,       NULL, NULL,       0,      0,    NULL,   5,    0xFFFFFFFF,
+        NULL, 0xFFFFFFFE, NULL, 0xFFFFFFFE, 0x7FFF, NULL, 0x7FFF,
+    };
+
+    node_create_request* req = (node_create_request*)cMl::memalignB(-4, i_requestSize);
+    if (req != NULL) {
+        static int request_id = 0;
+        sBs_ClearArea(req, i_requestSize);
+        *req = clear;
+        cTg_Create(&req->mCreateTag, req);
+        fpcMtdTg_Init(&req->mProcMthCls, (process_method_tag_func)fpcNdRq_Cancel, req);
+        req->mRequestId = request_id++;
+    }
+    return req;
+}
+
+/* 8003F8EC-8003F988       .text fpcNdRq_ChangeNode__FUlP18process_node_classsPv */
+node_create_request* fpcNdRq_ChangeNode(u32 i_requestSize, process_node_class* i_procNode,
+                                        s16 i_procName, void* i_data) {
+    static cPhs__Handler methods[] = {
+        (cPhs__Handler)fpcNdRq_phase_IsDeleteTiming,
+        (cPhs__Handler)fpcNdRq_phase_Delete,
+        (cPhs__Handler)fpcNdRq_phase_IsDeleted,
+        (cPhs__Handler)fpcNdRq_phase_Create,
+        (cPhs__Handler)fpcNdRq_phase_IsCreated,
+        NULL,
+    };
+
+    if (fpcNdRq_IsPossibleTarget(i_procNode) == 1 && fpcNdRq_IsIng(i_procNode) == 0) {
+        node_create_request* req = fpcNdRq_Create(i_requestSize);
+        if (req != NULL) {
+            req->mpPhsHandler = methods;
+            req->mNodeProc.mpNodeProc = i_procNode;
+            req->mNodeProc.mProcId = i_procNode->mBase.mBsPcId;
+            req->mpLayerClass = i_procNode->mBase.mLyTg.mpLayer;
+            req->mProcName = i_procName;
+            req->mpUserData = i_data;
+        }
+        return req;
+    } else {
+        return NULL;
+    }
+}
+
+/* 8003F988-8003FA14       .text fpcNdRq_DeleteNode__FUlP18process_node_class */
+node_create_request* fpcNdRq_DeleteNode(u32 i_requestSize, process_node_class* i_procNode) {
+    static cPhs__Handler methods[] = {
+        (cPhs__Handler)fpcNdRq_phase_IsDeleteTiming,
+        (cPhs__Handler)fpcNdRq_phase_Delete,
+        (cPhs__Handler)fpcNdRq_phase_IsDeleted,
+        NULL,
+    };
+
+    if (fpcNdRq_IsPossibleTarget(i_procNode) == 1 && fpcNdRq_IsIng(i_procNode) == 0) {
+        node_create_request* req = fpcNdRq_Create(i_requestSize);
+        if (req != NULL) {
+            req->mpPhsHandler = methods;
+            req->mNodeProc.mpNodeProc = i_procNode;
+            req->mNodeProc.mProcId = i_procNode->mBase.mBsPcId;
+            req->mpLayerClass = i_procNode->mBase.mLyTg.mpLayer;
+        }
+        return req;
+    } else {
+        return NULL;
+    }
+}
+
+/* 8003FA14-8003FAC0       .text fpcNdRq_CreateNode__FUlsPv */
+node_create_request* fpcNdRq_CreateNode(u32 i_requestSize, s16 i_procName, void* i_data) {
+    static cPhs__Handler methods[] = {
+        (cPhs__Handler)fpcNdRq_phase_Create,
+        (cPhs__Handler)fpcNdRq_phase_IsCreated,
+        NULL,
+    };
+
+    layer_class* layer = fpcLy_CurrentLayer();
+    if (layer->mLayerID != 0 && fpcNdRq_IsPossibleTarget(layer->mpPcNode) == 0) {
+        return NULL;
+    } else {
+        node_create_request* req = fpcNdRq_Create(i_requestSize);
+        if (req != NULL) {
+            req->mpPhsHandler = methods;
+            if (layer->mLayerID != 0) {
+                req->mNodeProc.mpNodeProc = layer->mpPcNode;
+                req->mNodeProc.mProcId = layer->mpPcNode->mBase.mBsPcId;
+            }
+            req->mpLayerClass = layer;
+            req->mProcName = i_procName;
+            req->mpUserData = i_data;
+        }
+        return req;
+    }
+}
+
+/* 8003FAC0-8003FB70       .text fpcNdRq_Request__FUliP18process_node_classsPvP32node_create_request_method_class */
+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_nodeCtRqMtd) {
+    node_create_request* req;
+    switch (i_reqType) {
+    case 0:
+        req = fpcNdRq_CreateNode(i_requestSize, i_procName, i_data);
+        break;
+    case 1:
+        req = fpcNdRq_DeleteNode(i_requestSize, i_procNode);
+        break;
+    case 2:
+        req = fpcNdRq_ChangeNode(i_requestSize, i_procNode, i_procName, i_data);
+        break;
+    case 4:
+        break;
+    }
+
+    if (req != NULL) {
+        req->mParameter = i_reqType;
+        req->mpNodeCrReqMthCls = i_nodeCtRqMtd;
+        fpcNdRq_ToRequestQ(req);
+    }
+
+    return req;
+}
+
+/* 8003FB70-8003FBE8       .text fpcNdRq_ReChangeNode__FUisPv */
+s32 fpcNdRq_ReChangeNode(unsigned int i_requestID, s16 i_procName, void* i_data) {
+    request_node_class* currentNode;
+    node_create_request* found;
+    currentNode = (request_node_class*)l_fpcNdRq_Queue.mpHead;
+    while (currentNode != NULL) {
+        found = currentNode->mNodeCrReq;
+        if (found->mParameter == 2 && found->mRequestId == i_requestID) {
+            if (found->mCreatingID == -2) {
+                found->mProcName = i_procName;
+                found->mpUserData = i_data;
+                return 1;
+            }
+            return 0;
+        }
+        currentNode = (request_node_class*)NODE_GET_NEXT((&currentNode->mBase));
+    }
+    return 0;
+}
+
+/* 8003FBE8-8003FC08       .text fpcNdRq_ReRequest__FUisPv */
+s32 fpcNdRq_ReRequest(unsigned int i_requestID, s16 i_procName, void* i_data) {
+    return fpcNdRq_ReChangeNode(i_requestID, i_procName, i_data);
+}

src/f_pc/f_pc_pause.cpp

@@ -0,0 +1,50 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_pause.cpp
+//
+
+#include "f_pc/f_pc_pause.h"
+#include "f_pc/f_pc_node.h"
+#include "f_pc/f_pc_layer_iter.h"
+
+/* 8004031C-80040340       .text fpcPause_IsEnable__FPvUc */
+s32 fpcPause_IsEnable(void* i_proc, u8 i_flag) {
+    base_process_class* pProc = (base_process_class*)i_proc;
+    if ((pProc->mPauseFlag & i_flag) == i_flag) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* 80040340-800403AC       .text fpcPause_Enable__FPvUc */
+s32 fpcPause_Enable(void* i_proc, u8 i_flag) {
+    base_process_class* pProc = (base_process_class*)i_proc;
+    pProc->mPauseFlag |= i_flag;
+
+    if (fpcBs_Is_JustOfType(g_fpcNd_type, pProc->mSubType)) {
+        process_node_class* pNode = (process_node_class*)pProc;
+        fpcLyIt_OnlyHere(&pNode->mLayer, (fpcLyIt_OnlyHereFunc)fpcPause_Enable,
+                         (void*)(i_flag & 0xFF));
+    }
+    return 1;
+}
+
+/* 800403AC-80040420       .text fpcPause_Disable__FPvUc */
+s32 fpcPause_Disable(void* i_proc, u8 i_flag) {
+    base_process_class* pProc = (base_process_class*)i_proc;
+    pProc->mPauseFlag &= (0xFF - i_flag) & 0xFF;
+
+    if (fpcBs_Is_JustOfType(g_fpcNd_type, pProc->mSubType)) {
+        process_node_class* pNode = (process_node_class*)pProc;
+        fpcLyIt_OnlyHere(&pNode->mLayer, (fpcLyIt_OnlyHereFunc)fpcPause_Disable, (void*)i_flag);
+    }
+
+    return 1;
+}
+
+/* 80040420-8004042C       .text fpcPause_Init__FPv */
+void fpcPause_Init(void* i_proc) {
+    base_process_class* pProc = (base_process_class*)i_proc;
+    pProc->mPauseFlag = 0;
+}

src/f_pc/f_pc_priority.cpp

@@ -0,0 +1,161 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_priority.cpp
+//
+
+#include "f_pc/f_pc_priority.h"
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_layer.h"
+
+/* 8003FC08-8003FC28       .text fpcPi_IsInQueue__FP22process_priority_class */
+s32 fpcPi_IsInQueue(process_priority_class* i_procPriority) {
+    return cTg_IsUse(&i_procPriority->mBase);
+}
+
+/* 8003FC28-8003FC60       .text fpcPi_QueueTo__FP22process_priority_class */
+s32 fpcPi_QueueTo(process_priority_class* i_procPriority) {
+    cTg_SingleCut(&i_procPriority->mBase);
+    fpcLy_CancelQTo(&i_procPriority->mMtdTag);
+    return 1;
+}
+
+static node_list_class l_fpcPi_Queue;
+
+/* 8003FC60-8003FCEC       .text fpcPi_ToQueue__FP22process_priority_class */
+s32 fpcPi_ToQueue(process_priority_class* i_procPriority) {
+    u32 layer = i_procPriority->mInfoQ.mLayer;
+
+    if (cTg_Addition(&l_fpcPi_Queue, &i_procPriority->mBase)) {
+        if (layer != 0xFFFFFFFD) {
+            layer_class* pLayer = fpcLy_Layer(layer);
+
+            if (!fpcLy_ToCancelQ(pLayer, &i_procPriority->mMtdTag)) {
+                cTg_SingleCut(&i_procPriority->mBase);
+                return 0;
+            }
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+/* 8003FCEC-8003FD40       .text fpcPi_GetFromQueue__Fv */
+process_priority_class* fpcPi_GetFromQueue() {
+    process_priority_class* i_procPriority = (process_priority_class*)cTg_GetFirst(&l_fpcPi_Queue);
+
+    if (i_procPriority != NULL) {
+        base_process_class* pProc = (base_process_class*)i_procPriority->mBase.mpTagData;
+        process_priority_class* pProcPi = &pProc->mPi;
+        fpcLy_CancelQTo(&pProcPi->mMtdTag);
+        return pProcPi;
+    }
+
+    return NULL;
+}
+
+/* 8003FD40-8003FD8C       .text fpcPi_Delete__FP22process_priority_class */
+s32 fpcPi_Delete(process_priority_class* i_procPriority) {
+    static process_priority_queue_info crear = {
+        0xFFFFFFFF,
+        0xFFFF,
+        0xFFFF,
+    };
+
+    fpcPi_QueueTo(i_procPriority);
+    i_procPriority->mInfoQ.mLayer = crear.mLayer;
+    i_procPriority->mInfoQ.mListID = crear.mListID;
+    i_procPriority->mInfoQ.mListPrio = crear.mListPrio;
+    return 1;
+}
+
+/* 8003FD8C-8003FDC0       .text fpcPi_IsNormal__FUiUsUs */
+s32 fpcPi_IsNormal(unsigned int i_layer, u16 i_listID, u16 i_priority) {
+    if ((i_layer < 0xFFFFFFFE) && (i_listID < 0xFFFE) && (i_priority < 0xFFFE))
+        return 1;
+
+    return 0;
+}
+
+/* 8003FDC0-8003FF00       .text fpcPi_Change__FP22process_priority_classUiUsUs */
+s32 fpcPi_Change(process_priority_class* i_procPriority, unsigned int i_layer, u16 i_listID, u16 i_priority) {
+    base_process_class* pProc = (base_process_class*)i_procPriority->mBase.mpTagData;
+    BOOL changed = 0;
+
+    if (pProc->mInitState == 3)
+        return 0;
+
+    if (!fpcPi_IsNormal(i_layer, i_listID, i_priority))
+        return 0;
+
+    i_procPriority->mInfoQ.mLayer = i_procPriority->mInfoCurr.mLayer;
+    i_procPriority->mInfoQ.mListID = i_procPriority->mInfoCurr.mListID;
+    i_procPriority->mInfoQ.mListPrio = i_procPriority->mInfoCurr.mListPrio;
+
+    if (i_layer != 0xFFFFFFFD && i_procPriority->mInfoCurr.mLayer != i_layer) {
+        i_procPriority->mInfoQ.mLayer = i_layer;
+        changed = 1;
+    }
+
+    if (i_listID != 0xFFFD && i_procPriority->mInfoCurr.mListID != i_listID) {
+        i_procPriority->mInfoQ.mListID = i_listID;
+        changed = 1;
+    }
+
+    if (i_priority != 0xFFFD && i_procPriority->mInfoCurr.mListPrio != i_priority) {
+        i_procPriority->mInfoQ.mListPrio = i_priority;
+        changed = 1;
+    }
+
+    if (pProc->mInitState == 0 || pProc->mInitState == 1) {
+        i_procPriority->mInfoCurr.mLayer = i_procPriority->mInfoQ.mLayer;
+        i_procPriority->mInfoCurr.mListID = i_procPriority->mInfoQ.mListID;
+        i_procPriority->mInfoCurr.mListPrio = i_procPriority->mInfoQ.mListPrio;
+        return 1;
+    }
+
+    if (changed == 1)
+        return fpcPi_ToQueue(i_procPriority);
+    else
+        return 0;
+}
+
+/* 8003FF00-8003FF94       .text fpcPi_Handler__Fv */
+s32 fpcPi_Handler() {
+    process_priority_class* i_procPriority;
+    while (i_procPriority = fpcPi_GetFromQueue()) {
+        base_process_class* pProc = (base_process_class*)i_procPriority->mBase.mpTagData;
+        layer_management_tag_class* pLayerTag = &pProc->mLyTg;
+        line_tag* pLineTag = &pProc->mLnTg;
+        if (fpcLyTg_Move(pLayerTag, i_procPriority->mInfoQ.mLayer, i_procPriority->mInfoQ.mListID,
+                         i_procPriority->mInfoQ.mListPrio) == 1) {
+            fpcLnTg_Move(pLineTag, i_procPriority->mInfoCurr.mListID);
+            i_procPriority->mInfoCurr.mLayer = i_procPriority->mInfoQ.mLayer;
+            i_procPriority->mInfoCurr.mListID = i_procPriority->mInfoQ.mListID;
+            i_procPriority->mInfoCurr.mListPrio = i_procPriority->mInfoQ.mListPrio;
+        } else {
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+/* 8003FF94-8004003C       .text fpcPi_Init__FP22process_priority_classPvUiUsUs */
+s32 fpcPi_Init(process_priority_class* i_procPriority, void* i_data, unsigned int i_layer, u16 i_listID,
+               u16 i_priority) {
+    if (!fpcPi_IsNormal(i_layer, i_listID, i_priority))
+        return 0;
+
+    i_procPriority->mInfoQ.mLayer = i_layer;
+    i_procPriority->mInfoQ.mListID = i_listID;
+    i_procPriority->mInfoQ.mListPrio = i_priority;
+
+    i_procPriority->mInfoCurr.mLayer = i_procPriority->mInfoQ.mLayer;
+    i_procPriority->mInfoCurr.mListID = i_procPriority->mInfoQ.mListID;
+    i_procPriority->mInfoCurr.mListPrio = i_procPriority->mInfoQ.mListPrio;
+    cTg_Create(&i_procPriority->mBase, i_data);
+    fpcMtdTg_Init(&i_procPriority->mMtdTag, (process_method_tag_func)fpcPi_Delete, i_procPriority);
+    return 1;
+}

src/f_pc/f_pc_profile.cpp

@@ -0,0 +1,13 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_profile.cpp
+//
+
+#include "f_pc/f_pc_profile.h"
+
+process_profile_definition** g_fpcPf_ProfileList_p;
+
+/* 8004003C-80040050       .text fpcPf_Get__Fs */
+process_profile_definition* fpcPf_Get(s16 i_profName) {
+    return g_fpcPf_ProfileList_p[i_profName];
+}

src/f_pc/f_pc_searcher.cpp

@@ -0,0 +1,24 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_searcher.cpp
+//
+
+#include "f_pc/f_pc_searcher.h"
+
+/* 80040050-80040068       .text fpcSch_JudgeForPName__FPvPv */
+void* fpcSch_JudgeForPName(void* i_proc, void* i_data) {
+    s16 proc_name = *(s16*)i_data;
+
+    if (((base_process_class*)i_proc)->mProcName == proc_name)
+        return i_proc;
+    return NULL;
+}
+
+/* 80040068-80040080       .text fpcSch_JudgeByID__FPvPv */
+void* fpcSch_JudgeByID(void* i_proc, void* i_data) {
+    s32 process_id = *(s32*)i_data;
+
+    if (((base_process_class*)i_proc)->mBsPcId == process_id)
+        return i_proc;
+    return NULL;
+}

src/f_pc/f_pc_stdcreate_req.cpp

@@ -0,0 +1,128 @@
+//
+// Generated by dtk
+// Translation Unit: f_pc_stdcreate_req.cpp
+//
+
+#include "f_pc/f_pc_stdcreate_req.h"
+#include "f_pc/f_pc_load.h"
+#include "f_pc/f_pc_node.h"
+
+/* 80040648-8004069C       .text fpcSCtRq_phase_Load__FP29standard_create_request_class */
+s32 fpcSCtRq_phase_Load(standard_create_request_class* i_SCtReq) {
+    switch (fpcLd_Load(i_SCtReq->mProcName)) {
+    case cPhs_INIT_e:
+        return cPhs_INIT_e;
+    case cPhs_COMPLEATE_e:
+        return cPhs_NEXT_e;
+    case cPhs_ERROR_e:
+    default:
+        return cPhs_ERROR_e;
+    }
+}
+
+
+/* 8004069C-80040704       .text fpcSCtRq_phase_CreateProcess__FP29standard_create_request_class */
+s32 fpcSCtRq_phase_CreateProcess(standard_create_request_class* i_SCtReq) {
+    fpcLy_SetCurrentLayer(i_SCtReq->mBase.mpLayer);
+    i_SCtReq->mBase.mpRes = fpcBs_Create(i_SCtReq->mProcName, i_SCtReq->mBase.mBsPcId, i_SCtReq->mpUserData);
+    if (i_SCtReq->mBase.mpRes == NULL) {
+        fpcLd_Free(i_SCtReq->mProcName);
+        return cPhs_ERROR_e;
+    } else {
+        i_SCtReq->mBase.mpRes->mpCtRq = (struct create_request*)i_SCtReq;
+        return cPhs_NEXT_e;
+    }
+}
+
+/* 80040704-8004073C       .text fpcSCtRq_phase_SubCreateProcess__FP29standard_create_request_class */
+s32 fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* i_SCtReq) {
+    fpcLy_SetCurrentLayer(i_SCtReq->mBase.mpLayer);
+    return fpcBs_SubCreate(i_SCtReq->mBase.mpRes);
+}
+
+/* 8004073C-80040794       .text fpcSCtRq_phase_IsComplete__FP29standard_create_request_class */
+s32 fpcSCtRq_phase_IsComplete(standard_create_request_class* i_SCtReq) {
+    process_node_class* procNode = (process_node_class*)i_SCtReq->mBase.mpRes;
+    if (fpcBs_Is_JustOfType(g_fpcNd_type, procNode->mBase.mSubType) == 1) {
+        if (fpcLy_IsCreatingMesg(&procNode->mLayer) == 1) {
+            return cPhs_INIT_e;
+        }
+    }
+    return cPhs_NEXT_e;
+}
+
+/* 80040794-800407E4       .text fpcSCtRq_phase_PostMethod__FP29standard_create_request_class */
+s32 fpcSCtRq_phase_PostMethod(standard_create_request_class* i_SCtReq) {
+    if (i_SCtReq->mpCallBack != NULL && i_SCtReq->mpCallBack(i_SCtReq->mBase.mpRes, i_SCtReq->mpCallBackUserData) == 0) {
+        return cPhs_INIT_e;
+    } else {
+        return cPhs_NEXT_e;
+    }
+}
+
+/* 800407E4-800407EC       .text fpcSCtRq_phase_Done__FP29standard_create_request_class */
+s32 fpcSCtRq_phase_Done(standard_create_request_class* i_SCtReq) {
+    return cPhs_NEXT_e;
+}
+
+/* 800407EC-8004085C       .text fpcSCtRq_Handler__FP29standard_create_request_class */
+s32 fpcSCtRq_Handler(standard_create_request_class* i_SCtReq) {
+    s32 phase_state = cPhs_Do(&i_SCtReq->mPhase, i_SCtReq);
+
+    switch (phase_state) {
+    case cPhs_NEXT_e:
+        return fpcSCtRq_Handler(i_SCtReq);
+    case cPhs_COMPLEATE_e:
+        return cPhs_COMPLEATE_e;
+    case cPhs_LOADING_e:
+    case cPhs_ERROR_e:
+    default:
+        return phase_state;
+    }
+}
+
+/* 8004085C-80040864       .text fpcSCtRq_Delete__FP29standard_create_request_class */
+s32 fpcSCtRq_Delete(standard_create_request_class* i_SCtReq) {
+    return 1;
+}
+
+/* 80040864-8004086C       .text fpcSCtRq_Cancel__FP29standard_create_request_class */
+s32 fpcSCtRq_Cancel(standard_create_request_class* i_SCtReq) {
+    return 1;
+}
+
+/* 8004086C-80040900       .text fpcSCtRq_Request__FP11layer_classsPFPvPv_iPvPv */
+s32 fpcSCtRq_Request(layer_class* i_layer, s16 i_procName, stdCreateFunc i_createFunc,
+                     void* param_4, void* param_5) {
+    static create_request_method_class submethod = {
+        (cPhs__Handler)fpcSCtRq_Handler,
+        (process_method_func)fpcSCtRq_Cancel,
+        (process_method_func)fpcSCtRq_Delete,
+    };
+
+    static cPhs__Handler method[] = {
+        (cPhs__Handler)fpcSCtRq_phase_Load,
+        (cPhs__Handler)fpcSCtRq_phase_CreateProcess,
+        (cPhs__Handler)fpcSCtRq_phase_SubCreateProcess,
+        (cPhs__Handler)fpcSCtRq_phase_IsComplete,
+        (cPhs__Handler)fpcSCtRq_phase_PostMethod,
+        (cPhs__Handler)fpcSCtRq_phase_Done,
+        NULL,
+    };
+
+    if (i_procName >= 0x7FFF) {
+        return -1;
+    } else {
+        standard_create_request_class* request = (standard_create_request_class*)fpcCtRq_Create(i_layer, sizeof(standard_create_request_class), &submethod);
+        if (request == NULL) {
+            return -1;
+        } else {
+            cPhs_Set(&request->mPhase, method);
+            request->mProcName = i_procName;
+            request->mpCallBack = i_createFunc;
+            request->mpCallBackUserData = param_4;
+            request->mpUserData = param_5;
+            return request->mBase.mBsPcId;
+        }
+    }
+}