save_manager OK

12 files changed, 2177 insertions, 38 deletions

diff --git a/src/REL/d/d_s_boot.cpp b/src/REL/d/d_s_boot.cpp
index e2733224..22f9982d 100644
--- a/src/REL/d/d_s_boot.cpp
+++ b/src/REL/d/d_s_boot.cpp
@@ -2,8 +2,10 @@
 
 #include "common.h"
 #include "d/d_base.h"
+#include "d/d_dvd_unk.h"
 #include "d/d_dylink.h"
 #include "d/d_font_manager.h"
+#include "d/d_gfx.h"
 #include "d/d_heap.h"
 #include "d/d_message.h"
 #include "d/d_scene.h"
@@ -24,7 +26,6 @@
 #include "toBeSorted/arc_managers/layout_arc_manager.h"
 #include "toBeSorted/arc_managers/oarc_manager.h"
 #include "toBeSorted/hbm.h"
-#include "toBeSorted/some_gxf_thing.h"
 #include "toBeSorted/reload_color_fader.h"
 
 sFPhase<dScBoot_c>::phaseCallback dScBoot_c::sCallbacks[] = {&dScBoot_c::cb1, &dScBoot_c::cb2, &dScBoot_c::cb3,
@@ -44,7 +45,6 @@ sFPhaseBase::sFPhaseState dScBoot_c::executeLoadPhase() {
 extern "C" u8 getUsedLanguageNTSCNum();
 extern "C" const char *getEventFlowFileNameByIndex(int, int);
 extern "C" u8 fn_80054F30();
-extern "C" nw4r::ut::ResFont *lbl_805750D8;
 
 sFPhaseBase::sFPhaseState dScBoot_c::cb1() {
     LayoutArcManager::GetInstance()->loadLayoutArcFromDisk("cursor", mHeap::g_archiveHeap);
@@ -235,9 +235,7 @@ sFPhaseBase::sFPhaseState dScBoot_c::cb6() {
         }
     }
 
-    // TODO we think this is a ResFont but
-    // the offset is larger than ResFont...
-    ((u8 *)lbl_805750D8)[0x2C] = 1;
+    dDvdUnk::FontUnk::GetInstance()->setField_0x2C(1);
     field_0x5DF = 1;
     return sFPhaseBase::PHASE_NEXT;
 }
@@ -520,7 +518,7 @@ void dScBoot_c::executeState_Strap() {
 
 void dScBoot_c::finalizeState_Strap() {
     // TODO
-    SomeGfxThing::setField0x09(1);
+    dGfx_c::GetInstance()->setField0x09(1);
 }
 
 void dScBoot_c::initializeState_Connect() {
diff --git a/src/d/d_sc_game.cpp b/src/d/d_sc_game.cpp
index 7decd4c1..a6b056a5 100644
--- a/src/d/d_sc_game.cpp
+++ b/src/d/d_sc_game.cpp
@@ -2,6 +2,7 @@
 
 #include "common.h"
 #include "d/d_base.h"
+#include "d/d_gfx.h"
 #include "d/d_stage_mgr.h"
 #include "d/flag/storyflag_manager.h"
 #include "f/f_base.h"
@@ -15,7 +16,6 @@
 #include "toBeSorted/file_manager.h"
 #include "toBeSorted/minigame_mgr.h"
 #include "toBeSorted/music_mgrs.h"
-#include "toBeSorted/some_gxf_thing.h"
 
 #include <cstring>
 
@@ -69,7 +69,7 @@ int dScGame_c::create() {
         return NOT_READY;
     }
 
-    SomeGfxThing::setDrawCallback(someGfxThingCallback);
+    dGfx_c::GetInstance()->setDrawCallback(someGfxThingCallback);
     return SUCCEEDED;
 }
 
@@ -97,7 +97,7 @@ int dScGame_c::draw() {
 }
 
 void dScGame_c::deleteReady() {
-    SomeGfxThing::setDrawCallback(nullptr);
+    dGfx_c::GetInstance()->setDrawCallback(nullptr);
 }
 
 sFPhaseBase::sFPhaseState dScGame_c::cb1() {
diff --git a/src/d/d_sc_title.cpp b/src/d/d_sc_title.cpp
index ffb231fb..f148b159 100644
--- a/src/d/d_sc_title.cpp
+++ b/src/d/d_sc_title.cpp
@@ -1,6 +1,7 @@
 #include "d/d_sc_title.h"
 
 #include "common.h"
+#include "d/d_dvd_unk.h"
 #include "d/d_heap.h"
 #include "d/d_message.h"
 #include "d/d_sc_game.h"
@@ -40,8 +41,6 @@ STATE_VIRTUAL_DEFINE(dScTitle_c, Action);
 
 extern "C" void *lbl_80575688;
 extern "C" void fn_801907F0(void *);
-extern "C" void *lbl_805750D8;
-extern "C" void fn_80052D50(void *);
 
 dScTitle_c::dScTitle_c() {
     sInstance = this;
@@ -55,7 +54,7 @@ dScTitle_c::dScTitle_c() {
     }
     FileManager::GetInstance()->clearTempFileData();
     FileManager::GetInstance()->initFile(1);
-    fn_80052D50(lbl_805750D8);
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D50();
     lbl_80575787 = 0;
     field_0x2AC = 0;
 }
diff --git a/src/d/lyt/d_lyt_battery.cpp b/src/d/lyt/d_lyt_battery.cpp
index 0f8681d9..5a522545 100644
--- a/src/d/lyt/d_lyt_battery.cpp
+++ b/src/d/lyt/d_lyt_battery.cpp
@@ -1,5 +1,6 @@
 #include "d/lyt/d_lyt_battery.h"
 
+#include "d/d_d2d.h"
 #include "egg/core/eggController.h"
 #include "m/m_pad.h"
 #include "toBeSorted/arc_managers/layout_arc_manager.h"
@@ -59,8 +60,6 @@ bool dLytBattery_c::init() {
     return true;
 }
 
-extern "C" void fn_80016200();
-
 bool dLytBattery_c::doDraw() {
     mStateMgr.executeState();
     if (*mStateMgr.getStateID() != StateID_Off) {
@@ -71,7 +70,7 @@ bool dLytBattery_c::doDraw() {
         }
 
         mLyt.calc();
-        fn_80016200();
+        d2d::defaultSet();
         mLyt.draw();
     }
 
diff --git a/src/d/lyt/d_lyt_fader.cpp b/src/d/lyt/d_lyt_fader.cpp
index 4b27ae73..a96b3b63 100644
--- a/src/d/lyt/d_lyt_fader.cpp
+++ b/src/d/lyt/d_lyt_fader.cpp
@@ -1,5 +1,6 @@
 #include "d/lyt/d_lyt_fader.h"
 
+#include "d/d_d2d.h"
 #include "toBeSorted/arc_managers/layout_arc_manager.h"
 
 
@@ -60,11 +61,9 @@ bool dLytFader_c::calc() {
     }
 }
 
-extern "C" void fn_80016200();
-
 void dLytFader_c::draw() {
     if (field_0x4DD) {
-        fn_80016200();
+        d2d::defaultSet();
         mLytBase.draw();
     }
 }
diff --git a/src/d/lyt/d_lyt_save_msg_window.cpp b/src/d/lyt/d_lyt_save_msg_window.cpp
new file mode 100644
index 00000000..cc8fd0f0
--- /dev/null
+++ b/src/d/lyt/d_lyt_save_msg_window.cpp
@@ -0,0 +1,392 @@
+#include "d/lyt/d_lyt_save_msg_window.h"
+
+#include "common.h"
+#include "d/d_message.h"
+#include "d/d_tag_processor.h"
+#include "d/lyt/d2d.h"
+#include "nw4r/lyt/lyt_group.h"
+#include "sized_string.h"
+#include "toBeSorted/arc_managers/layout_arc_manager.h"
+
+STATE_DEFINE(dLytSaveMsgWindow_c, Init);
+STATE_DEFINE(dLytSaveMsgWindow_c, In);
+STATE_DEFINE(dLytSaveMsgWindow_c, Wait);
+STATE_DEFINE(dLytSaveMsgWindow_c, Out);
+
+dLytSaveMsgWindow_c::dLytSaveMsgWindow_c() : mStateMgr(*this, sStateID::null) {
+    resetProperties();
+}
+
+static const d2d::LytBrlanMapping brlanMap[] = {
+    {         "save_00_in.brlan",       "G_inOut_00"},
+    {         "save_00_in.brlan",       "G_inOut_01"},
+    {        "save_00_bgV.brlan",         "G_bgV_00"},
+    {      "save_00_textV.brlan",       "G_textV_00"},
+    {"save_00_winPosition.brlan", "G_winPosition_00"},
+    {        "save_00_out.brlan",       "G_inOut_00"},
+    {        "save_00_out.brlan",       "G_inOut_01"},
+    {     "save_00_textIn.brlan",   "G_textInOut_00"},
+    {    "save_00_textOut.brlan",   "G_textInOut_00"},
+};
+
+#define SAVE_ANIM_IN_0 0
+#define SAVE_ANIM_IN_1 1
+#define SAVE_ANIM_BG_V 2
+#define SAVE_ANIM_TEXT_V 3
+#define SAVE_ANIM_WIN_POSITION 4
+#define SAVE_ANIM_OUT_0 5
+#define SAVE_ANIM_OUT_1 6
+#define SAVE_ANIM_TEXT_IN 7
+#define SAVE_ANIM_TEXT_OUT 8
+
+#define SAVE_NUM_ANIMS 9
+
+static const char *sGroupName = "G_ref_00";
+
+bool dLytSaveMsgWindow_c::build(bool arg) {
+    void *data = LayoutArcManager::GetInstance()->getLoadedData("System2D");
+    mResAcc.attach(data, "");
+    mLyt.build("save_00.brlyt", &mResAcc);
+
+    for (int i = 0; i < SAVE_NUM_ANIMS; i++) {
+        mAnm[i].init(brlanMap[i].mFile, &mResAcc, mLyt.getLayout(), brlanMap[i].mName);
+    }
+
+    mLyt.setPriority(0x8A);
+
+    for (int i = 0; i < 1; i++) {
+        mSubpanes[i].mpLytPane = &mBtn;
+        mBtn.build(&mResAcc);
+        mSubpaneList.PushBack(&mSubpanes[i]);
+    }
+
+    if (mLyt.getLayout()->GetGroupContainer() != nullptr) {
+        nw4r::lyt::Group *g = mLyt.getLayout()->GetGroupContainer()->FindGroupByName(sGroupName);
+        if (g != nullptr) {
+            d2d::dSubPane::linkMeters(g, &mSubpaneList);
+        }
+    }
+
+    mBtn.setField_0x9C4(1);
+    if (arg) {
+        mBtn.setField_0x99C(1);
+    }
+    mBtn.setField_0x9A0(1);
+
+    mStateMgr.changeState(StateID_Init);
+    mLineSpace = mLyt.getTextBox("T_text_00")->GetLineSpace();
+    field_0x10DC = 1;
+    return true;
+}
+
+bool dLytSaveMsgWindow_c::remove() {
+    for (d2d::SubPaneList::Iterator it = mSubpaneList.GetBeginIter(); it != mSubpaneList.GetEndIter(); ++it) {
+        d2d::dSubPane *subPane = it->mpLytPane;
+        if (subPane != nullptr) {
+            nw4r::lyt::Pane *parent = subPane->getPane()->GetParent();
+            parent->RemoveChild(subPane->getPane());
+        }
+    }
+
+    for (int i = 0; i < 1; i++) {
+        mSubpanes[i].mpLytPane->remove();
+    }
+    mLyt.unbindAnims();
+    for (int i = 0; i < SAVE_NUM_ANIMS; i++) {
+        mAnm[i].remove();
+    }
+    mResAcc.detach();
+    return true;
+}
+
+bool dLytSaveMsgWindow_c::execute() {
+    for (int i = 0; i < 1; i++) {
+        mSubpanes[i].mpLytPane->execute();
+    }
+    mStateMgr.executeState();
+    mLyt.calc();
+    return true;
+}
+
+bool dLytSaveMsgWindow_c::draw() {
+    if (field_0x10D8 != 1) {
+        return true;
+    }
+    mLyt.addToDrawList();
+    return true;
+}
+
+bool dLytSaveMsgWindow_c::drawNow() {
+    if (field_0x10D8 != 1) {
+        return true;
+    }
+    mLyt.draw();
+    return true;
+}
+
+void dLytSaveMsgWindow_c::reset() {
+    resetProperties();
+    mStateMgr.changeState(StateID_Init);
+}
+
+bool dLytSaveMsgWindow_c::setProperties(const char *message, s32 a1, s32 a2, u8 a3) {
+    mLabel = message;
+    field_0x10B0 = a1;
+    field_0x10B4 = a2;
+    field_0x10DD = a3;
+    field_0x10DA = 1;
+    mNumLines = 1;
+    field_0x10B8 = 0;
+    mSaveobjId = -1;
+    return true;
+}
+
+bool dLytSaveMsgWindow_c::checkIsWait() {
+    if (*mStateMgr.getStateID() == StateID_Wait) {
+        field_0x10DB = 1;
+        return true;
+    }
+    return false;
+}
+
+void dLytSaveMsgWindow_c::initializeState_Init() {
+    resetProperties();
+    for (int i = 0; i < SAVE_NUM_ANIMS; i++) {
+        mAnm[i].unbind();
+    }
+}
+void dLytSaveMsgWindow_c::executeState_Init() {
+    if (field_0x10DA != 1) {
+        return;
+    }
+    field_0x10DA = 0;
+    mStateMgr.changeState(StateID_In);
+}
+void dLytSaveMsgWindow_c::finalizeState_Init() {}
+
+void dLytSaveMsgWindow_c::initializeState_In() {
+    field_0x10D8 = 1;
+    if (field_0x10B8 == 1) {
+        setAnmFrame(SAVE_ANIM_TEXT_IN, 0.0f);
+    } else {
+        setAnmFrame(SAVE_ANIM_IN_0, 0.0f);
+        setAnmFrame(SAVE_ANIM_IN_1, 0.0f);
+    }
+    setupSaveTextMaybe();
+    f32 bgV = 0.0f;
+    if (field_0x10DD == 1) {
+        bgV = 1.0f;
+    }
+    setAnmFrame(SAVE_ANIM_BG_V, bgV);
+    f32 textV = 0.0f;
+    if (mNumLines != 1) {
+        textV = 1.0f;
+    }
+    setAnmFrame(SAVE_ANIM_TEXT_V, textV);
+    setAnmFrame(SAVE_ANIM_WIN_POSITION, field_0x10B4);
+    field_0x10DC = 0;
+}
+void dLytSaveMsgWindow_c::executeState_In() {
+    if (field_0x10C0 != 0) {
+        return;
+    }
+    s32 group = SAVE_ANIM_IN_0;
+    if (field_0x10B8 == 1) {
+        group = SAVE_ANIM_TEXT_IN;
+    }
+    d2d::AnmGroup_c &grp = mAnm[group];
+    if (grp.isEndReached() == true) {
+        updateSaveTextMaybe();
+        mStateMgr.changeState(StateID_Wait);
+    }
+    grp.play();
+    if (field_0x10B8 != 1) {
+        mAnm[SAVE_ANIM_IN_1].play();
+    }
+}
+void dLytSaveMsgWindow_c::finalizeState_In() {
+    if (field_0x10B8 == 1) {
+        unbindAnm(SAVE_ANIM_TEXT_IN);
+    } else {
+        unbindAnm(SAVE_ANIM_IN_0);
+        unbindAnm(SAVE_ANIM_IN_1);
+    }
+}
+
+void dLytSaveMsgWindow_c::initializeState_Wait() {
+    if (field_0x10B0 == 0) {
+        field_0x10C0 = 10;
+    } else {
+        field_0x10C0 = 0;
+    }
+}
+void dLytSaveMsgWindow_c::executeState_Wait() {
+    if (field_0x10C0 == 0) {
+        field_0x10C4 = mBtn.getField_0x9B4();
+        field_0x10C8 = mBtn.getField_0x9B0();
+    }
+    if (field_0x10DB == 1) {
+        field_0x10DB = 0;
+        mStateMgr.changeState(StateID_Out);
+    }
+    if (field_0x10DA == 1) {
+        field_0x10DA = 0;
+        field_0x10C4 = -1;
+        field_0x10C8 = -1;
+        mStateMgr.changeState(StateID_In);
+    }
+}
+void dLytSaveMsgWindow_c::finalizeState_Wait() {}
+
+void dLytSaveMsgWindow_c::initializeState_Out() {
+    field_0x10C0 = 0;
+    if (field_0x10BC == 1) {
+        setAnmFrame(SAVE_ANIM_TEXT_OUT, 0.0f);
+    } else if (field_0x10BC == 2) {
+        setAnmFrame(SAVE_ANIM_OUT_1, 0.0f);
+    } else {
+        setAnmFrame(SAVE_ANIM_OUT_0, 0.0f);
+        setAnmFrame(SAVE_ANIM_OUT_1, 0.0f);
+    }
+}
+void dLytSaveMsgWindow_c::executeState_Out() {
+    s32 group = SAVE_ANIM_OUT_0;
+    if (field_0x10BC == 1) {
+        group = SAVE_ANIM_TEXT_OUT;
+    } else if (field_0x10BC == 2) {
+        group = SAVE_ANIM_OUT_1;
+    }
+    d2d::AnmGroup_c &grp = mAnm[group];
+    switch (field_0x10C0) {
+        case 0:
+            if (grp.isEndReached() == true) {
+                mWillFinishOut = 1;
+                field_0x10C0 = 1;
+            }
+            break;
+        case 1:
+            if (field_0x10BC == 1) {
+                mStateMgr.changeState(StateID_Wait);
+            } else {
+                mStateMgr.changeState(StateID_Init);
+            }
+            return;
+    }
+
+    grp.play();
+    if (field_0x10BC == 0) {
+        mAnm[SAVE_ANIM_OUT_1].play();
+    }
+}
+void dLytSaveMsgWindow_c::finalizeState_Out() {
+    if (mBtn.getField_0x9A4() == 0) {
+        mLyt.findPane("N_messageBtn_00")->SetVisible(false);
+    }
+    mWillFinishOut = 0;
+    if (field_0x10BC == 1) {
+        unbindAnm(SAVE_ANIM_TEXT_OUT);
+    } else if (field_0x10BC == 2) {
+        unbindAnm(SAVE_ANIM_OUT_1);
+    } else {
+        unbindAnm(SAVE_ANIM_OUT_0);
+        unbindAnm(SAVE_ANIM_OUT_1);
+    }
+}
+
+void dLytSaveMsgWindow_c::resetProperties() {
+    field_0x10D8 = 0;
+    mWillFinishOut = 0;
+    field_0x10DA = 0;
+    field_0x10DB = 0;
+    field_0x10C4 = -1;
+    field_0x10C8 = -1;
+    field_0x10C0 = 0;
+    field_0x10B0 = 4;
+    field_0x10B4 = 4;
+    field_0x10B8 = 0;
+    field_0x10BC = 0;
+    mSaveobjId = -1;
+}
+
+void dLytSaveMsgWindow_c::setAnmFrame(s32 group, f32 frame) {
+    d2d::AnmGroup_c &anm = mAnm[group];
+    anm.bind(false);
+    anm.setAnimEnable(true);
+    anm.setFrame(frame);
+}
+
+void dLytSaveMsgWindow_c::unbindAnm(s32 group) {
+    d2d::AnmGroup_c &anm = mAnm[group];
+    anm.unbind();
+}
+
+void dLytSaveMsgWindow_c::updateSaveTextMaybe() {
+    // Redundant check, this is also checked internally
+    if (field_0x10B0 != 0) {
+        updateSaveText();
+    }
+}
+
+void dLytSaveMsgWindow_c::setupSaveTextMaybe() {
+    const wchar_t *text = dMessage_c::getTextMessageByLabel(mLabel, true, nullptr, 0);
+    dTextBox_c *box = mLyt.getTextBox("T_text_00");
+    dTagProcessor_c *tagProcessor = dMessage_c::getGlobalTagProcessor();
+    if (mSaveobjId != -1) {
+        SizedString<32> name;
+        if (mSaveobjId == 0xFF) {
+            name = "SAVEOBJ_NAME_UNKNOWN";
+        } else {
+            name.sprintf("SAVEOBJ_NAME_%02d", mSaveobjId);
+        }
+
+        if (tagProcessor != nullptr) {
+            const wchar_t *objMsg = dMessage_c::getTextMessageByLabel(name, true, nullptr, 0);
+            if (objMsg != nullptr) {
+                tagProcessor->setStringArg(objMsg, 0);
+            }
+        }
+    }
+    mNumLines = box->calcTextLines(text, tagProcessor);
+    if (mNumLines == 1) {
+        box->SetLineSpace(0.0f);
+    } else {
+        box->SetLineSpace(mLineSpace);
+    }
+    box->setTextWithGlobalTextProcessor(text);
+    dTextBox_c *boxShadow = mLyt.getTextBox("T_textS_00");
+    if (mNumLines == 1) {
+        boxShadow->SetLineSpace(0.0f);
+    } else {
+        boxShadow->SetLineSpace(mLineSpace);
+    }
+    boxShadow->setTextWithGlobalTextProcessor(text);
+    mLyt.findPane("N_messageBtn_00")->SetVisible(false);
+}
+
+void dLytSaveMsgWindow_c::updateSaveText() {
+    if (field_0x10B0 == 0) {
+        return;
+    }
+    mLyt.findPane("N_messageBtn_00")->SetVisible(true);
+    s32 numOptions = 2;
+    if (field_0x10B0 == 2) {
+        numOptions = 3;
+    } else if (field_0x10B0 == 3) {
+        numOptions = 4;
+    }
+    for (s32 i = 0; i < numOptions; i++) {
+        const wchar_t *text = dMessage_c::getGlobalTagProcessor()->getBuf(i);
+        mBtn.getSelectTextBox(i, 0)->setTextWithGlobalTextProcessor(text);
+        mBtn.getSelectTextBox(i, 1)->setTextWithGlobalTextProcessor(text);
+    }
+
+    if (field_0x10B0 != 0) {
+        mBtn.setTagProcessor(dMessage_c::getGlobalTagProcessor());
+        static const u32 sInts[] = {0, 2, 3, 4};
+        u32 unkInt = sInts[field_0x10B0];
+        s32 f = dMessage_c::getGlobalTagProcessor()->getField_0x828();
+        mBtn.setField_0x9BC(f);
+        mBtn.setField_0x990(f);
+        mBtn.fn_8011E5D0(unkInt, true);
+    }
+}
diff --git a/src/d/lyt/d_screen_fader.cpp b/src/d/lyt/d_screen_fader.cpp
index b43edebc..1ea4a5d7 100644
--- a/src/d/lyt/d_screen_fader.cpp
+++ b/src/d/lyt/d_screen_fader.cpp
@@ -1,5 +1,6 @@
 #include "d/lyt/d_screen_fader.h"
 
+#include "d/d_d2d.h"
 #include "egg/gfx/eggDrawGX.h"
 #include "egg/gfx/eggScreen.h"
 #include "m/m_mtx.h"
@@ -37,10 +38,8 @@ bool dScreenFader_c::calc() {
     return res;
 }
 
-extern "C" void fn_80016200();
-
 void dScreenFader_c::draw() {
-    fn_80016200();
+    d2d::defaultSet();
     EGG::DrawGX::BeginDrawScreen(false, false, true);
     f32 scaleX = EGG::Screen::GetSizeXMax();
     f32 scaleY = EGG::Screen::GetSizeYMax();
diff --git a/src/d/lyt/msg_window/d_lyt_msg_window.cpp b/src/d/lyt/msg_window/d_lyt_msg_window.cpp
index 2e043f0b..9dafff64 100644
--- a/src/d/lyt/msg_window/d_lyt_msg_window.cpp
+++ b/src/d/lyt/msg_window/d_lyt_msg_window.cpp
@@ -485,7 +485,7 @@ void dLytMsgWindow_c::initializeState_WaitKeySelectQuestion() {
     s32 tmp = mpTagProcessor->getField_0x828();
     mSelectBtn.setField_0x9BC(tmp);
     mSelectBtn.setField_0x990(tmp);
-    mSelectBtn.setField_0x998(mpTagProcessor);
+    mSelectBtn.setTagProcessor(mpTagProcessor);
 
     wchar_t **buf = sBufs;
 
@@ -510,7 +510,7 @@ void dLytMsgWindow_c::executeState_WaitKeySelectQuestion() {
             mpTagProcessor->setField_0x90E(0);
             mpTagProcessor->setField_0x82C(-1);
             mpTagProcessor->setField_0x828(-1);
-            mSelectBtn.setField_0x998(nullptr);
+            mSelectBtn.setTagProcessor(nullptr);
             field_0x824 = 0;
             mTextOptionSelection = selection;
             field_0x1220 = 0;
diff --git a/src/d/lyt/msg_window/d_lyt_msg_window_select_btn.cpp b/src/d/lyt/msg_window/d_lyt_msg_window_select_btn.cpp
index 4f1dc36f..65c97411 100644
--- a/src/d/lyt/msg_window/d_lyt_msg_window_select_btn.cpp
+++ b/src/d/lyt/msg_window/d_lyt_msg_window_select_btn.cpp
@@ -490,7 +490,7 @@ bool dLytMsgWindowSelectBtn_c::build(d2d::ResAccIf_c *resAcc) {
     mBtnHelper.panes[7] = mpBoundings[2];
     mBtnHelper.panes[8] = mpBoundings[3];
 
-    field_0x9C4 = nullptr;
+    field_0x9C4 = 0;
 
     mLyt.findPane("N_arrowIn_00")->SetVisible(true);
 
diff --git a/src/toBeSorted/file_manager.cpp b/src/toBeSorted/file_manager.cpp
index 266c6e45..5939075d 100644
--- a/src/toBeSorted/file_manager.cpp
+++ b/src/toBeSorted/file_manager.cpp
@@ -7,6 +7,8 @@
 // clang-format off
 #include "sized_string.h"
 #include "toBeSorted/dowsing_target.h"
+#include "toBeSorted/nand_request_thread.h"
+#include "toBeSorted/save_manager.h"
 // clang-format on
 
 // This class here makes no sense and the name might
@@ -58,8 +60,8 @@ extern "C" {
 /* 80009EF0 */ FileManager *FileManager::create(EGG::Heap *heap) {
     return new (heap, 0x04) FileManager();
 }
-/* 80009F30 */ bool FileManager::loadSaveData(void *out, char *name, bool isSkipData) {}
-/* 80009F70 */ void FileManager::saveSaveData(void *unk, bool isSkipData) {}
+/* 80009F30 */ bool FileManager::loadSaveData(NandRequestWriteHolder *out, const char *name, bool isSkipData) {}
+/* 80009F70 */ void FileManager::saveSaveData(NandRequestLoadSaveFileHolder *unk, bool isSkipData) {}
 /* 8000A000 */ void FileManager::refreshSaveFileData() {}
 /* 8000A260 */ wchar_t *FileManager::getFileHeroname(int fileNum) {}
 /* 8000A280 */ s64 FileManager::getFileSaveTime(int fileNum) {}
@@ -344,7 +346,7 @@ u16 *FileManager::getStoryFlagsMut() {
 }
 
 /* 80010000 */ void FileManager::initBlankSaveFiles() {
-    memset(mpSavedSaveFiles, 0, 0xfbe0);
+    memset(mpSavedSaveFiles, 0, sizeof(SavedSaveFiles));
     mSelectedFile = 0;
     memset(mIsFileEmpty, 0, 3);
     SkipData *data;
@@ -409,7 +411,7 @@ u16 *FileManager::getStoryFlagsMut() {
 }
 
 /* 800101F0 */ void FileManager::unsetFileANewFile() {}
-/* 80010220 */ void FileManager::saveT1SaveInfo(u8 entranceT1LoadFlag) {}
+/* 80010220 */ void FileManager::saveT1SaveInfo(bool entranceT1LoadFlag) {}
 /* 80010350 */ void FileManager::copyFileSkipData(int fileNum) {}
 extern "C" void fn_800C01F0(); // todo flag managers
 /* 80010440 */ void FileManager::clearTempFileData() {
@@ -449,7 +451,7 @@ extern "C" void fn_800C01F0(); // todo flag managers
 }
 /* 80011370 */ bool FileManager::isFileEmpty(u8 fileNum) {}
 /* 80011390 */ bool FileManager::isFileDirty(int fileNum) {}
-/* 800113B0 */ u8 FileManager::get_0xA84C() {}
+/* 800113B0 */ u32 FileManager::get_0xA84C() {}
 /* 800113C0 */ bool FileManager::checkRegionCode() {}
 /* 80011440 */ bool FileManager::checkFileCRC(u8 fileNum) {}
 /* 80011490 */
diff --git a/src/toBeSorted/nand_request_thread.cpp b/src/toBeSorted/nand_request_thread.cpp
index 591c627e..ac506a09 100644
--- a/src/toBeSorted/nand_request_thread.cpp
+++ b/src/toBeSorted/nand_request_thread.cpp
@@ -157,9 +157,6 @@ const char *splitComponent(const char *inPath, char *outPath, size_t size) {
     return inPath + 1;
 }
 
-extern "C" NANDResult NANDChangeDir(const char *path);
-extern "C" NANDResult NANDCreateDir(const char *path, u8 perm, u8 attr);
-
 bool NandRequestCreate::execute() {
     char homeDir[64];
     char pathComponent[64];
@@ -210,10 +207,6 @@ NandRequestWrite::NandRequestWrite(const char *someString, void *data, size_t da
     mFilePath = someString;
 }
 
-extern "C" NANDResult NANDSimpleSafeOpen(const char *path, NANDFileInfo *outInfo, int, void *buf, size_t bufLen);
-extern "C" NANDResult NANDSimpleSafeCancel(NANDFileInfo *info);
-extern "C" NANDResult NANDSimpleSafeClose(NANDFileInfo *info);
-
 bool NandRequestWrite::execute() {
     NANDFileInfo info;
     mStatus = NANDSimpleSafeOpen(
@@ -253,14 +246,14 @@ bool NandRequestHolderBase::isCompleted() const {
     return true;
 }
 
-NANDResult NandRequestHolderBase::getStatus() const {
+NANDResult NandRequestHolderBase::getResult() const {
     if (mpRequest != nullptr) {
         return mpRequest->getStatus();
     }
     return NAND_RESULT_BUSY;
 }
 
-bool NandRequestHolderBase::runToCompletion() {
+bool NandRequestHolderBase::finish() {
     if (mpRequest == nullptr) {
         return true;
     }
diff --git a/src/toBeSorted/save_manager.cpp b/src/toBeSorted/save_manager.cpp
index e69de29b..78c2ca0c 100644
--- a/src/toBeSorted/save_manager.cpp
+++ b/src/toBeSorted/save_manager.cpp
@@ -0,0 +1,1758 @@
+#include "toBeSorted/save_manager.h"
+
+#include "common.h"
+#include "d/d_cs_base.h"
+#include "d/d_d2d.h"
+#include "d/d_dvd_unk.h"
+#include "d/d_heap.h"
+#include "d/d_message.h"
+#include "d/d_s_boot.h"
+#include "d/d_sc_game.h"
+#include "d/d_sys.h"
+#include "d/lyt/d_lyt_save_msg_window.h"
+#include "d/lyt/d_lyt_system_window.h"
+#include "egg/core/eggHeap.h"
+#include "m/m_pad.h"
+#include "toBeSorted/arc_managers/layout_arc_manager.h"
+#include "toBeSorted/file_manager.h"
+#include "toBeSorted/nand_request_thread.h"
+#include "toBeSorted/nand_result_tracker.h"
+#include "toBeSorted/reload_color_fader.h"
+#include "toBeSorted/small_sound_mgr.h"
+
+#include "rvl/NAND.h"
+#include "rvl/TPL.h"
+
+#include <cstring>
+
+SaveMgr *SaveMgr::sInstance;
+
+static const char sSaveFileName[] = "wiiking2.sav";
+static const char sSkipDatFileName[] = "skip.dat";
+static const char sBannerBinFileName[] = "banner.bin";
+static const char sTmpBannerBinFileName[] = "/tmp/banner.bin";
+
+#define FILE_PERMS (NAND_PERM_RUSR | NAND_PERM_WUSR | NAND_PERM_RGRP | NAND_PERM_WGRP)
+
+const SaveMgr::StateFunc SaveMgr::sStateFuncs[STATE_MAX] = {
+    &SaveMgr::executeCheckForSave, &SaveMgr::executeCheckForFreeSpace, &SaveMgr::executeCreateFiles,
+    &SaveMgr::executeSaveBanner,   &SaveMgr::executeLoadSave,          &SaveMgr::executeWriteSave,
+    &SaveMgr::executeWriteSkipDat, &SaveMgr::executeCopySave,          &SaveMgr::executeClearSelectedFile,
+    &SaveMgr::executeSave,         &SaveMgr::executeDeleteAllData,     &SaveMgr::executeError,
+    &SaveMgr::executeNandError,
+};
+
+SaveMgr::SaveMgr()
+    : mCheckIsFileRequest(nullptr),
+      mCheckRequest(nullptr),
+      mCreateRequest(nullptr),
+      mWriteRequest(nullptr),
+      mSaveBannerRequest(nullptr),
+      mLoadSaveRequest(nullptr),
+      mDeleteRequest(nullptr) {
+    sInstance = this;
+    mpWindow = nullptr;
+}
+// Not used but this spawns the weak dtors
+SaveMgr::~SaveMgr() {
+    delete mpWindow;
+}
+
+void SaveMgr::create(EGG::Heap *heap) {
+    new (heap, 4) SaveMgr();
+    sInstance->init();
+}
+
+void SaveMgr::init() {
+    mCurrentState = STATE_MAX;
+    field_0x824 = 2;
+    mCheckForFreeSpaceResult = 0;
+    mCopyToFile = 0;
+    mCopyFromFile = 0;
+    field_0x836 = 0;
+    field_0x837 = 0;
+    field_0x838 = 0;
+    field_0x839 = 0;
+    field_0x83A = 0;
+    field_0x83B = 0;
+    field_0x83C = 0;
+    field_0x83D = 0;
+    field_0x83E = 0;
+    mDelayTimer = 0;
+    FileManager::GetInstance()->setField0xA840(1);
+    if (dCsBase_c::GetInstance() != nullptr) {
+        dCsBase_c::GetInstance()->setField704(false);
+    }
+    if (mpWindow != nullptr) {
+        mpWindow->reset();
+    }
+    field_0x83F = 0;
+}
+
+void SaveMgr::execute() {
+    if (mCurrentState != STATE_MAX) {
+        StateFunc f = sStateFuncs[mCurrentState];
+        if (f != nullptr) {
+            (this->*f)();
+        }
+    }
+}
+
+void SaveMgr::draw() {
+    d2d::defaultSet();
+    if (mpWindow != nullptr) {
+        mpWindow->drawNow();
+    }
+}
+
+void SaveMgr::createSaveMsgWindow() {
+    if (mpWindow == nullptr) {
+        mpWindow = new dLytSaveMsgWindow_c();
+        mpWindow->build(false);
+    }
+}
+
+bool SaveMgr::checkForSave() {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    field_0x836 = 0;
+    initializeCheckForSave();
+    return true;
+}
+
+bool SaveMgr::checkForFreeSpace() {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    field_0x836 = 0;
+    initializeCheckForFreeSpace();
+    return true;
+}
+
+bool SaveMgr::createFiles() {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    field_0x836 = 0;
+    initializeCreateFiles();
+    return true;
+}
+
+bool SaveMgr::loadSave() {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    field_0x836 = 0;
+    initializeLoadSave();
+    return true;
+}
+
+bool SaveMgr::save(bool entranceT1LoadFlag, bool full) {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    if (FileManager::GetInstance()->get_0xA84C()) {
+        return false;
+    }
+    field_0x836 = 0;
+    if (full == 1) {
+        FileManager::GetInstance()->saveT1SaveInfo(entranceT1LoadFlag);
+    } else {
+        FileManager::GetInstance()->setEntranceLoadFlagT1(entranceT1LoadFlag);
+    }
+    FileManager::GetInstance()->setFileTimes();
+    initializeSave();
+    field_0x83E = 0;
+    return true;
+}
+
+bool SaveMgr::saveAfterCredits() {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    if (FileManager::GetInstance()->get_0xA84C()) {
+        return false;
+    }
+    field_0x836 = 0;
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(true);
+    FileManager::GetInstance()->setFileTimes();
+    FileManager::GetInstance()->saveAfterCredits();
+    initializeSave();
+    field_0x83E = 0;
+    return true;
+}
+
+bool SaveMgr::writeSkipDat() {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    field_0x836 = 0;
+    initializeWriteSkipDat();
+    return true;
+}
+
+bool SaveMgr::copySave(u8 to, u8 from) {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    field_0x836 = 0;
+    mCopyToFile = to;
+    mCopyFromFile = from;
+    initializeCopySave();
+    field_0x83F = 0;
+    return true;
+}
+
+bool SaveMgr::clearSelectedFile() {
+    if (mCurrentState != STATE_MAX) {
+        return false;
+    }
+    field_0x836 = 0;
+    initializeClearSelectedFile();
+    field_0x83F = 0;
+    return true;
+}
+
+void SaveMgr::initializeCheckForSave() {
+    beginState(STATE_CHECK_FOR_SAVE);
+    mCheckIsFileRequest.checkIsFile(sSaveFileName);
+    field_0x839 = 0;
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(false);
+}
+
+void SaveMgr::executeCheckForSave() {
+    FileManager *fileManager = FileManager::GetInstance();
+    NandResultTracker *t = NandResultTracker::GetInstance();
+    switch (mStep) {
+        case 0:
+            if (mCheckIsFileRequest.isCompleted()) {
+                if (t->isFailure(mCheckIsFileRequest.getResult()) && mCheckIsFileRequest.finish()) {
+                    return;
+                }
+                if (mCheckIsFileRequest.getCheckResult()) {
+                    field_0x839 |= 2;
+                }
+                if (mCheckIsFileRequest.finish()) {
+                    mCheckIsFileRequest.checkIsFile(sSkipDatFileName);
+                    mStep = 1;
+                }
+            }
+            break;
+        case 1:
+            if (mCheckIsFileRequest.isCompleted()) {
+                if (t->isFailure(mCheckIsFileRequest.getResult()) && mCheckIsFileRequest.finish()) {
+                    return;
+                }
+                if (mCheckIsFileRequest.getCheckResult()) {
+                    field_0x839 |= 4;
+                }
+                if (mCheckIsFileRequest.finish()) {
+                    mCheckIsFileRequest.checkIsFile(sBannerBinFileName);
+                    mStep = 2;
+                }
+            }
+            break;
+        case 2:
+            if (mCheckIsFileRequest.isCompleted()) {
+                if (t->isFailure(mCheckIsFileRequest.getResult()) && mCheckIsFileRequest.finish()) {
+                    return;
+                }
+                if (mCheckIsFileRequest.getCheckResult()) {
+                    field_0x839 |= 1;
+                }
+                if (mCheckIsFileRequest.finish()) {
+                    mStep = 3;
+                }
+            }
+            break;
+        case 3:
+            if (field_0x839 == (1 | 2) || field_0x839 == (1 | 2 | 4)) {
+                fileManager->setField0xA841(1);
+                if (field_0x839 == (1 | 2)) {
+                    fileManager->setField0xA842(0);
+                } else {
+                    fileManager->setField0xA842(1);
+                }
+            } else {
+                fileManager->setField0xA841(0);
+                fileManager->setField0xA842(0);
+                if (field_0x839) {
+                    t->isFailure(NAND_RESULT_AUTHENTICATION);
+                    initializeError();
+                    return;
+                }
+            }
+            endState();
+            break;
+    }
+}
+
+void SaveMgr::initializeCheckForFreeSpace() {
+    beginState(STATE_CHECK_FOR_FREE_SPACE);
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(false);
+    mCheckRequest.check(7, 3);
+    mCheckForFreeSpaceResult = 0;
+}
+
+void SaveMgr::executeCheckForFreeSpace() {
+    if (mCheckRequest.isCompleted()) {
+        if (NandResultTracker::GetInstance()->isFailure(mCheckRequest.getResult()) && mCheckRequest.finish()) {
+            return;
+        }
+        u32 result = mCheckRequest.getCheckResult();
+        if ((result & (NAND_CHECK_TOO_MANY_APP_BLOCKS | NAND_CHECK_TOO_MANY_USER_BLOCKS)) != 0) {
+            if (mCheckRequest.finish()) {
+                mCheckForFreeSpaceResult = 1;
+                initializeNandError();
+            }
+        } else if ((result & (NAND_CHECK_TOO_MANY_APP_FILES | NAND_CHECK_TOO_MANY_USER_FILES)) != 0) {
+            if (mCheckRequest.finish()) {
+                mCheckForFreeSpaceResult = 2;
+                initializeNandError();
+            }
+        } else {
+            if (mCheckRequest.finish()) {
+                if (field_0x838 == 1 || field_0x83A == 1) {
+                    initializeCreateFiles();
+                } else {
+                    endState();
+                }
+            }
+        }
+    }
+}
+
+void SaveMgr::initializeCreateFiles() {
+    beginState(STATE_CREATE_FILES);
+    field_0x838 = 1;
+    FileManager::GetInstance()->setField0xA84D(1);
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(false);
+}
+
+void SaveMgr::executeCreateFiles() {
+    FileManager *fileMgr = FileManager::GetInstance();
+    switch (mStep) {
+        case 0: {
+            s32 numLines = 0;
+            if (field_0x83A != 0) {
+                if (field_0x837 == 1) {
+                    // "Restoring save data. Please do not touch the POWER Button or RESET."
+                    if (mpWindow->setProperties("SYS_INIT_06", 0, 1, field_0x83E)) {
+                        numLines = 2;
+                    }
+                } else {
+                    // "Creating save data again. Please do not touch the POWER Button or RESET."
+                    if (mpWindow->setProperties("SYS_INIT_08", 0, 1, field_0x83E)) {
+                        numLines = 2;
+                    }
+                }
+            } else {
+                // "Creating save data. Please do not touch the POWER Button or RESET."
+                if (mpWindow->setProperties("SYS_INIT_02", 0, 1, field_0x83E)) {
+                    numLines = 2;
+                }
+            }
+            if (numLines != 0) {
+                mDelayTimer = 0;
+                mStep++;
+                mpWindow->setNumLines(numLines);
+            }
+            break;
+        }
+        case 1: {
+            if (mDelayTimer < 30) {
+                mDelayTimer++;
+            } else {
+                mCreateRequest.create(sSaveFileName, FILE_PERMS, 0);
+                mDelayTimer = 0;
+                mStep++;
+            }
+            break;
+        }
+        case 2: {
+            if (!mCreateRequest.isCompleted()) {
+                return;
+            }
+            NANDResult status = mCreateRequest.getResult();
+            if (!mCreateRequest.finish()) {
+                return;
+            }
+            if (NandResultTracker::GetInstance()->isFailure(status)) {
+                return;
+            }
+            fileMgr->setField0xA841(1);
+            mStep++;
+            break;
+        }
+        case 3: {
+            mCreateRequest.create(sSkipDatFileName, FILE_PERMS, 0);
+            mStep++;
+            break;
+        }
+        case 4: {
+            if (!mCreateRequest.isCompleted()) {
+                return;
+            }
+            NANDResult status = mCreateRequest.getResult();
+            if (!mCreateRequest.finish()) {
+                return;
+            }
+            if (NandResultTracker::GetInstance()->isFailure(status)) {
+                return;
+            }
+            if (dScGame_c::GetInstance() != nullptr && dScGame_c::GetInstance()->profile_name == fProfile::GAME) {
+                fileMgr->copySelectedFileSkipData();
+            }
+            fileMgr->setField0xA842(1);
+            initializeWriteSave();
+            mStep = 1; // Skips something in other state!
+            break;
+        }
+    }
+    mpWindow->execute();
+}
+
+void SaveMgr::initializeSaveBanner() {
+    beginState(STATE_SAVE_BANNER);
+    // "Zelda: Skyward Sword"
+    const wchar_t *title = dMessage_c::getTextMessageByLabel("SYS_ZELDA_01", true, nullptr, 0);
+    // Need to stash title as next call to getTextMessageByLabel will reuse internal buffer
+    // Missed optimization: Could've passed mTextBuf directly
+    for (s32 i = 0; i < 0x3FF; i++) {
+        mTextBuf[i] = title[i];
+    }
+    // "A story of Link and Zelda."
+    const wchar_t *subtitle = dMessage_c::getTextMessageByLabel("SYS_ZELDA_02", true, nullptr, 0);
+    void *data = LayoutArcManager::GetInstance()->getData("saveBannerU", "tmp/saveBanner.tpl");
+    mSaveBannerRequest.saveBanner(sTmpBannerBinFileName, (TPLPalette *)data, mTextBuf, subtitle, FILE_PERMS, 0);
+    FileManager::GetInstance()->setField0xA84D(1);
+}
+
+void SaveMgr::executeSaveBanner() {
+    dDvdUnk::FontUnk *fontUnk = dDvdUnk::FontUnk::GetInstance();
+    switch (mStep) {
+        case 0: {
+            mDelayTimer++;
+            if (!mSaveBannerRequest.isCompleted()) {
+                return;
+            }
+            FileManager::GetInstance()->setField0xA84D(0);
+            NANDResult result = mSaveBannerRequest.getResult();
+            bool bFailed = mSaveBannerRequest.hasFailed();
+            if (!mSaveBannerRequest.finish()) {
+                return;
+            }
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                mStep = 20;
+                return;
+            }
+            if (bFailed) {
+                // retry
+                mStep = 10;
+                return;
+            }
+            mStep = 1;
+            break;
+        }
+        case 1: {
+            if (mDelayTimer < getFrameRate()) {
+                mDelayTimer++;
+            } else {
+                if (mpWindow->checkIsWait()) {
+                    mDelayTimer = 0;
+                    mStep++;
+                }
+            }
+            break;
+        }
+        case 2: {
+            if (mpWindow->getWillFinishOut() == 1) {
+                mStep++;
+            }
+            break;
+        }
+        case 3: {
+            bool b = false;
+            if (field_0x83A == 1) {
+                if (field_0x837 != 0) {
+                    // "Save data is restored."
+                    if (mpWindow->setProperties("SYS_INIT_07", 0, 1, field_0x83E) == true) {
+                        b = true;
+                    }
+                } else {
+                    // "New save data has been created."
+                    if (mpWindow->setProperties("SYS_INIT_09", 0, 1, field_0x83E) == true) {
+                        b = true;
+                    }
+                }
+            } else if (field_0x838 == 1) {
+                // "Save data for The Legend of Zelda: Skyward Sword has been created."
+                if (mpWindow->setProperties("SYS_INIT_03", 0, 1, field_0x83E) == true) {
+                    b = true;
+                    mpWindow->setNumLines(2);
+                }
+            } else if (field_0x83B == 1) {
+                // "Copying complete."
+                if (mpWindow->setProperties("SYS_COPY_02", 0, 1, field_0x83E) == true) {
+                    b = true;
+                }
+            } else if (field_0x83C == 1) {
+                // "Deleting complete."
+                if (mpWindow->setProperties("SYS_DELETE_02", 0, 1, field_0x83E) == true) {
+                    b = true;
+                }
+            } else {
+                // "Saved."
+                if (mpWindow->setProperties("SYS_SAVE_02", 0, 1, field_0x83E) == true) {
+                    b = true;
+                }
+            }
+
+            if (b == 1) {
+                if (!dDvdUnk::FontUnk::GetInstance()->getField_0x28()) {
+                    SmallSoundManager::GetInstance()->playSound(SE_S_SAVE_FINISH);
+                }
+                mDelayTimer = 0;
+                mStep++;
+            }
+            break;
+        }
+
+        case 4: {
+            if (mDelayTimer < getFrameRate() + 30) {
+                mDelayTimer++;
+            } else {
+                if (mpWindow->checkIsWait() == true) {
+                    mDelayTimer = 0;
+                    mStep++;
+                }
+            }
+            break;
+        }
+        case 5: {
+            if (mpWindow->getWillFinishOut() == 1) {
+                if (fontUnk->getField_0x29() == 1) {
+                    fontUnk->fn_80052C90();
+                }
+                field_0x838 = 0;
+                field_0x83A = 0;
+                field_0x837 = 1;
+                endState();
+            }
+            break;
+        }
+        case 10: {
+            // retry
+            initializeSaveBanner();
+            break;
+        }
+        case 20: {
+            if (mpWindow->checkIsWait()) {
+                mStep++;
+            }
+            break;
+        }
+        case 21: {
+            initializeError();
+            break;
+        }
+    }
+    mpWindow->execute();
+}
+
+void SaveMgr::initializeLoadSave() {
+    beginState(STATE_LOAD_SAVE);
+    mLoadSaveRequest.loadSave(sSaveFileName, sizeof(SavedSaveFiles), 0, nullptr);
+}
+
+void SaveMgr::executeLoadSave() {
+    FileManager *fileManager = FileManager::GetInstance();
+    switch (mStep) {
+        case 0: {
+            if (!mLoadSaveRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mLoadSaveRequest.getResult();
+            NandResultTracker *tracker = NandResultTracker::GetInstance();
+            if (tracker->isFailure(result)) {
+                mLoadSaveRequest.remove();
+                if (mLoadSaveRequest.finish()) {
+                    initializeError();
+                }
+                return;
+            }
+            if (mLoadSaveRequest.getBuf() != nullptr) {
+                fileManager->saveSaveData(&mLoadSaveRequest, false);
+            }
+            mLoadSaveRequest.remove();
+            if (!mLoadSaveRequest.finish()) {
+                return;
+            }
+            fileManager->checkFileStatus();
+            if (fileManager->isFileInvalid() == true) {
+                tracker->isFailure(NAND_RESULT_AUTHENTICATION);
+                initializeError();
+            } else if (fileManager->getField_0xA842() != 1) {
+                mStep = 10;
+            } else {
+                mStep = 1;
+            }
+            break;
+        }
+        case 1: {
+            mLoadSaveRequest.loadSave(sSkipDatFileName, 0x80, 0, nullptr);
+            mStep = 2;
+            break;
+        }
+        case 2: {
+            if (!mLoadSaveRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mLoadSaveRequest.getResult();
+            NandResultTracker *tracker = NandResultTracker::GetInstance();
+            if (tracker->isFailure(result)) {
+                mLoadSaveRequest.remove();
+                if (mLoadSaveRequest.finish()) {
+                    mStep = 30;
+                }
+                return;
+            }
+            if (mLoadSaveRequest.getBuf() != nullptr) {
+                fileManager->saveSaveData(&mLoadSaveRequest, true);
+            }
+            mLoadSaveRequest.remove();
+            if (mLoadSaveRequest.finish()) {
+                if (fileManager->checkSkipDataCRCs() == 1) {
+                    mStep = 3;
+                } else {
+                    fileManager->updateEmptyFiles();
+                    field_0x837 = 1;
+                    endState();
+                }
+            }
+            break;
+        }
+        case 3: {
+            for (int i = 0; i < 3; i++) {
+                fileManager->copyFileSkipData(i);
+            }
+            mStep++;
+            break;
+        }
+        case 4: {
+            fileManager->updateEmptyFiles();
+            field_0x837 = 1;
+            initializeWriteSkipDat();
+            break;
+        }
+        case 10: {
+            mCheckRequest.check(1, 1);
+            mStep++;
+            break;
+        }
+        case 11: {
+            if (!mCheckRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mCheckRequest.getResult();
+            if (!NandResultTracker::GetInstance()->isFailure(result) || !mCheckRequest.finish()) {
+                u32 check = mCheckRequest.getCheckResult();
+                if (mCheckRequest.finish()) {
+                    if (check) {
+                        fileManager->updateEmptyFiles();
+                        field_0x837 = 1;
+                        endState();
+                    } else {
+                        mStep += 1;
+                    }
+                }
+            }
+            break;
+        }
+        case 12: {
+            fileManager->setField0xA84D(1);
+            mCreateRequest.create(sSkipDatFileName, FILE_PERMS, 0);
+            mStep += 1;
+            break;
+        }
+        case 13: {
+            if (mCreateRequest.isCompleted()) {
+                NANDResult result = mCreateRequest.getResult();
+                if (mCreateRequest.finish()) {
+                    if (!NandResultTracker::GetInstance()->isFailure(result)) {
+                        for (int i = 0; i < 3; i++) {
+                            fileManager->copyFileSkipData(i);
+                        }
+                        fileManager->setField0xA842(1);
+                        mStep = 4;
+                    }
+                }
+            }
+            break;
+        }
+        case 30: {
+            fileManager->setField0xA84D(1);
+            mDeleteRequest.doDelete(sSkipDatFileName);
+            mStep += 1;
+            break;
+        }
+        case 31: {
+            if (!mDeleteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mDeleteRequest.getResult();
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                if (mDeleteRequest.finish()) {
+                    initializeError();
+                }
+
+            } else {
+                if (mDeleteRequest.finish()) {
+                    mStep = 10;
+                }
+            }
+
+            break;
+        }
+    }
+}
+
+void SaveMgr::initializeWriteSave() {
+    beginState(STATE_WRITE);
+    mDelayTimer = 0;
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(false);
+    FileManager::GetInstance()->setField0xA84D(1);
+    field_0x83D = 1;
+}
+
+void SaveMgr::executeWriteSave() {
+    FileManager *fileManager = FileManager::GetInstance();
+    switch (mStep) {
+        case 0: {
+            bool anyAction = false;
+            if (field_0x83B == 1) {
+                // "Copying... Please do not touch the POWER Button or RESET."
+                if (mpWindow->setProperties("SYS_COPY_01", 0, 1, field_0x83E)) {
+                    anyAction = true;
+                }
+            } else if (field_0x83C == 1) {
+                // "Deleting... Please do not touch the POWER Button or RESET."
+                if (mpWindow->setProperties("SYS_DELETE_01", 0, 1, field_0x83E)) {
+                    anyAction = true;
+                }
+            } else {
+                // "Saving in progress. Please do not\\ntouch the POWER Button or RESET."
+                if (mpWindow->setProperties("SYS_SAVE_01", 0, 1, field_0x83E)) {
+                    anyAction = true;
+                }
+            }
+
+            if (anyAction == true) {
+                mStep = 1;
+                mDelayTimer = 0;
+                mpWindow->setNumLines(2);
+            }
+            break;
+        }
+        case 1: {
+            if (mDelayTimer >= 30) {
+                fileManager->loadSaveData(&mWriteRequest, sSaveFileName, false);
+                mDelayTimer = 0;
+                mStep++;
+            } else {
+                mDelayTimer++;
+            }
+            break;
+        }
+        case 2: {
+            mDelayTimer++;
+            if (!mWriteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mWriteRequest.getResult();
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                if (mWriteRequest.finish()) {
+                    mStep = 10;
+                }
+                return;
+            }
+            if (mWriteRequest.failedWrite() == 1) {
+                if (mWriteRequest.finish()) {
+                    mStep = 5;
+                }
+                return;
+            }
+            if (!mWriteRequest.finish()) {
+                return;
+            }
+            if (fileManager->getField_0xA842() == 1) {
+                mStep = 3;
+            } else {
+                mStep = 40;
+            }
+            break;
+        }
+        case 3: {
+            fileManager->loadSaveData(&mWriteRequest, sSkipDatFileName, true);
+            mStep = 4;
+            break;
+        }
+        case 4: {
+            mDelayTimer++;
+            if (!mWriteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mWriteRequest.getResult();
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                if (mWriteRequest.finish()) {
+                    mStep = 30;
+                }
+                return;
+            }
+            if (mWriteRequest.failedWrite() == 1) {
+                if (mWriteRequest.finish()) {
+                    mStep = 6;
+                }
+                return;
+            }
+            if (!mWriteRequest.finish()) {
+                return;
+            }
+            mStep = 40;
+            break;
+        }
+        case 5: {
+            fileManager->loadSaveData(&mWriteRequest, sSaveFileName, false);
+            mStep = 2;
+            mDelayTimer = 0;
+            break;
+        }
+        case 6: {
+            fileManager->loadSaveData(&mWriteRequest, sSkipDatFileName, true);
+            mStep = 4;
+            mDelayTimer = 0;
+            break;
+        }
+        case 10: {
+            if (mpWindow->checkIsWait()) {
+                initializeError();
+            }
+            break;
+        }
+        case 20: {
+            if (mpWindow->checkIsWait()) {
+                mStep++;
+            }
+            break;
+        }
+        case 21: {
+            if (mpWindow->getWillFinishOut() == true) {
+                fileManager->checkFileStatus();
+                if (fileManager->isFileInvalid() == 1) {
+                    NandResultTracker::GetInstance()->isFailure(NAND_RESULT_AUTHENTICATION);
+                    initializeError();
+                    return;
+                }
+                initializeSaveBanner();
+            }
+            break;
+        }
+        case 30: {
+            mDelayTimer++;
+            mDeleteRequest.doDelete(sSkipDatFileName);
+            mStep++;
+            break;
+        }
+        case 31: {
+            mDelayTimer++;
+            if (!mDeleteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mDeleteRequest.getResult();
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                if (!mDeleteRequest.finish()) {
+                    return;
+                }
+                mpWindow->checkIsWait();
+                initializeError();
+                return;
+            }
+            if (!mDeleteRequest.finish()) {
+                return;
+            }
+            fileManager->setField0xA842(0);
+            mStep++;
+            break;
+        }
+        case 32: {
+            mDelayTimer++;
+            mCheckRequest.check(1, 1);
+            mStep++;
+            break;
+        }
+        case 33: {
+            mDelayTimer++;
+            if (!mCheckRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mCheckRequest.getResult();
+            if (NandResultTracker::GetInstance()->isFailure(result) && mCheckRequest.finish()) {
+                mpWindow->checkIsWait();
+                initializeError();
+            } else {
+                u32 result = mCheckRequest.getCheckResult();
+                if (!mCheckRequest.finish()) {
+                    return;
+                }
+                if (result) {
+                    mStep = 40;
+                } else {
+                    mStep++;
+                }
+            }
+            break;
+        }
+        case 34: {
+            mDelayTimer++;
+            mCreateRequest.create(sSkipDatFileName, FILE_PERMS, 0);
+            mStep++;
+            break;
+        }
+        case 35: {
+            mDelayTimer++;
+            if (!mCreateRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mCreateRequest.getResult();
+            if (!mCreateRequest.finish()) {
+                return;
+            }
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                mpWindow->checkIsWait();
+                initializeError();
+                return;
+            }
+            for (int i = 0; i < 3; i++) {
+                fileManager->copyFileSkipData(i);
+            }
+            mStep = 3;
+            fileManager->setField0xA842(1);
+            break;
+        }
+        case 40: {
+            fileManager->checkFileStatus();
+            if (fileManager->isFileInvalid() == true) {
+                NandResultTracker::GetInstance()->isFailure(NAND_RESULT_UNKNOWN);
+                mpWindow->checkIsWait();
+                initializeError();
+                return;
+            }
+            u32 oldTimer = mDelayTimer;
+            initializeSaveBanner();
+            mDelayTimer = oldTimer;
+            break;
+        }
+    }
+    mpWindow->execute();
+}
+
+void SaveMgr::initializeWriteSkipDat() {
+    beginState(STATE_WRITE_SKIP_DAT);
+    if (FileManager::GetInstance()->get_0xA84C() || FileManager::GetInstance()->getField_0xA842() != 1) {
+        mStep = 10;
+    } else {
+        FileManager::GetInstance()->setField0xA84D(1);
+        FileManager::GetInstance()->copySelectedFileSkipData();
+        FileManager::GetInstance()->loadSaveData(&mWriteRequest, sSkipDatFileName, true);
+    }
+}
+
+void SaveMgr::executeWriteSkipDat() {
+    FileManager *fileManager = FileManager::GetInstance();
+    switch (mStep) {
+        case 0: {
+            if (mWriteRequest.isCompleted()) {
+                FileManager::GetInstance()->setField0xA84D(0);
+                NANDResult result = mWriteRequest.getResult();
+                if (NandResultTracker::GetInstance()->isFailure(result)) {
+                    if (mWriteRequest.finish()) {
+                        mStep = 30;
+                    }
+                } else {
+                    if (mWriteRequest.failedWrite() == true) {
+                        if (mWriteRequest.finish()) {
+                            mStep = 1;
+                        }
+                    } else {
+                        if (mWriteRequest.finish()) {
+                            endState();
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case 1: {
+            fileManager->loadSaveData(&mWriteRequest, sSkipDatFileName, true);
+            FileManager::GetInstance()->setField0xA84D(1);
+            mStep = 0;
+            mDelayTimer = 0;
+            break;
+        }
+        case 10: {
+            fileManager->setField0xA84D(0);
+            endState();
+            break;
+        }
+        case 30: {
+            fileManager->setField0xA84D(1);
+            mDeleteRequest.doDelete(sSkipDatFileName);
+            mStep++;
+            break;
+        }
+        case 31: {
+            if (!mDeleteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mDeleteRequest.getResult();
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                if (mDeleteRequest.finish()) {
+                    initializeError();
+                }
+            } else {
+                if (mDeleteRequest.finish()) {
+                    fileManager->setField0xA842(0);
+                    mStep++;
+                }
+            }
+            break;
+        }
+        case 32: {
+            mCheckRequest.check(1, 1);
+            mStep++;
+            break;
+        }
+        case 33: {
+            if (mCheckRequest.isCompleted()) {
+                NANDResult result = mCheckRequest.getResult();
+                if (NandResultTracker::GetInstance()->isFailure(result) && mCheckRequest.finish()) {
+                    initializeError();
+                } else {
+                    u32 result = mCheckRequest.getCheckResult();
+                    if (mCheckRequest.finish()) {
+                        if (result) {
+                            mStep = 10;
+                        } else {
+                            mStep++;
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case 34: {
+            mDelayTimer++;
+            mCreateRequest.create(sSkipDatFileName, FILE_PERMS, 0);
+            mStep++;
+            break;
+        }
+        case 35: {
+            if (!mCreateRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mCreateRequest.getResult();
+            if (!mCreateRequest.finish()) {
+                return;
+            }
+            if (NandResultTracker::GetInstance()->isFailure(result)) {
+                initializeError();
+                return;
+            }
+            for (int i = 0; i < 3; i++) {
+                fileManager->copyFileSkipData(i);
+            }
+            fileManager->setField0xA842(1);
+            FileManager::GetInstance()->loadSaveData(&mWriteRequest, sSkipDatFileName, true);
+            mStep = 0;
+            break;
+        }
+    }
+}
+
+void SaveMgr::initializeCopySave() {
+    beginState(STATE_COPY_SAVE);
+    FileManager::GetInstance()->setField0xA840(0);
+    field_0x83B = 1;
+}
+
+void SaveMgr::executeCopySave() {
+    FileManager *fileManager = FileManager::GetInstance();
+    fileManager->copyFile(mCopyFromFile, mCopyToFile);
+    fileManager->setSelectedFileNum(mCopyToFile);
+    initializeWriteSave();
+    FileManager::GetInstance()->setField0xA840(1);
+}
+
+void SaveMgr::initializeClearSelectedFile() {
+    beginState(STATE_CLEAR_SELECTED_FILE);
+    FileManager::GetInstance()->setField0xA840(0);
+    field_0x83C = 1;
+}
+
+void SaveMgr::executeClearSelectedFile() {
+    FileManager::GetInstance()->clearFileA();
+    FileManager::GetInstance()->saveFileAToSelectedFile();
+    initializeWriteSave();
+    FileManager::GetInstance()->setField0xA840(1);
+}
+
+void SaveMgr::initializeSave() {
+    beginState(STATE_SAVE);
+    FileManager::GetInstance()->setField0xA840(0);
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(false);
+    FileManager::GetInstance()->setField_0xA843(1);
+}
+
+void SaveMgr::executeSave() {
+    FileManager *fileManager = FileManager::GetInstance();
+    switch (mStep) {
+        case 0: {
+            if (fileManager->get_0xA84C() != 1 && fileManager->getField_0xA843()) {
+                if (fileManager->getField_0xA841() == 1) {
+                    FileManager::GetInstance()->unsetFileANewFile();
+                    FileManager::GetInstance()->copyFileAToSelectedFile();
+                    initializeWriteSave();
+                    FileManager::GetInstance()->setField0xA840(1);
+                } else {
+                    FileManager::GetInstance()->copyFileAToSelectedFile();
+                    FileManager::GetInstance()->setField0xA840(1);
+                    initializeCheckForFreeSpace();
+                    field_0x838 = 1;
+                }
+            }
+            break;
+        }
+    }
+}
+
+void SaveMgr::initializeDeleteAllData() {
+    beginState(STATE_DELETE_ALL_DATA);
+    field_0x83A = 1;
+}
+
+void SaveMgr::executeDeleteAllData() {
+    NandResultTracker *tracker = NandResultTracker::GetInstance();
+    switch (mStep) {
+        case 0: {
+            FileManager::GetInstance()->setField0xA84D(1);
+            mDeleteRequest.doDelete(sBannerBinFileName);
+            if (field_0x837 != 1 || FileManager::GetInstance()->isFileInvalid() == 1) {
+                FileManager::GetInstance()->initBlankSaveFiles();
+            }
+            mStep = 1;
+            break;
+        }
+        case 1: {
+            if (!mDeleteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mDeleteRequest.getResult();
+            if (tracker->isFailure(result)) {
+                if (mDeleteRequest.finish()) {
+                    initializeError();
+                }
+            } else {
+                if (mDeleteRequest.finish()) {
+                    mStep = 2;
+                }
+            }
+            break;
+        }
+        case 2: {
+            mDeleteRequest.doDelete(sSaveFileName);
+            mStep = 3;
+            break;
+        }
+        case 3: {
+            if (!mDeleteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mDeleteRequest.getResult();
+            if (tracker->isFailure(result)) {
+                if (mDeleteRequest.finish()) {
+                    initializeError();
+                }
+            } else {
+                if (mDeleteRequest.finish()) {
+                    mStep = 4;
+                }
+            }
+            break;
+        }
+        case 4: {
+            mDeleteRequest.doDelete(sSkipDatFileName);
+            mStep = 5;
+            break;
+        }
+        case 5: {
+            if (!mDeleteRequest.isCompleted()) {
+                return;
+            }
+            NANDResult result = mDeleteRequest.getResult();
+            if (tracker->isFailure(result)) {
+                if (mDeleteRequest.finish()) {
+                    initializeError();
+                }
+            } else {
+                if (mDeleteRequest.finish()) {
+                    initializeCheckForFreeSpace();
+                }
+            }
+            break;
+        }
+    }
+}
+
+void SaveMgr::initializeError() {
+    FileManager::GetInstance()->setField0xA84D(0);
+    field_0x83D = 0;
+    beginState(STATE_ERROR);
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(true);
+    field_0x83F = 0;
+}
+
+void SaveMgr::executeError() {
+    dLytSystemWindow_c *systemWindow = dLytSystemWindow_c::GetInstance();
+    FileManager *fileManager = FileManager::GetInstance();
+    switch (mStep) {
+        case 0: {
+            if (dDvdUnk::FontUnk::GetInstance()->getField_0x24() == 4) {
+                if (field_0x837 == true) {
+                    // "The save data is corrupted. Save data will be restored."
+                    if (systemWindow->setProperties("SYS_INIT_05", false, nullptr) == true) {
+                        systemWindow->showMaybe();
+                        mStep = 20;
+                    }
+                } else if (field_0x838 == true) {
+                    // "Save data could not be created. Try again?[1]Yes[2]No"
+                    if (systemWindow->setProperties("SYS_INIT_04", false, nullptr) == true) {
+                        systemWindow->showMaybe(4);
+                        mStep = 1;
+                        dCsBase_c::GetInstance()->setField704(true);
+                    }
+                } else {
+                    // "The file cannot be used because nthe data is corrupted. All data saved up to this point will be
+                    // lost. Create new save data?[1]Yes[2]No"
+                    if (systemWindow->setProperties("SYS_NAND_07", false, nullptr) == true) {
+                        systemWindow->showMaybe(4);
+                        mStep = 1;
+                        dCsBase_c::GetInstance()->setField704(true);
+                    }
+                }
+            }
+            break;
+        }
+        case 1: {
+            if (systemWindow->getField_0xE10() != 0 && mPad::g_currentCore->downTrigger(/* A */ 0x800) &&
+                systemWindow->getField_0xDE0() != 2) {
+                if (systemWindow->getField_0xDE0() == 0) {
+                    if (systemWindow->fn_80152F60() == true) {
+                        mStep = 2;
+                    }
+                } else {
+                    if (systemWindow->fn_80152F50() == true) {
+                        mStep = 2;
+                    }
+                }
+            }
+            break;
+        }
+        case 2: {
+            if (systemWindow->fn_80152F70() == true) {
+                if (systemWindow->getField_0xDE0() == false) {
+                    mStep = 3;
+                } else {
+                    initializeDeleteAllData();
+                    dCsBase_c::GetInstance()->setField704(false);
+                }
+            }
+            break;
+        }
+        case 3: {
+            if (dScBoot_c::GetInstance() != nullptr) {
+                // "You will not be able to save. Do you want to begin your game anyway? [1]Begin[2-]Quit"
+                if (systemWindow->setProperties("SYS_SAVE_10", false, nullptr) == true) {
+                    systemWindow->showMaybe(4);
+                    mpWindow->setNumLines(2);
+                    mStep = 4;
+                }
+            } else {
+                // "It is not possible to save. Continue your adventure anyway? [1]Continue[2]Quit"
+                if (systemWindow->setProperties("SYS_SAVE_11", false, nullptr) == true) {
+                    systemWindow->showMaybe(4);
+                    mpWindow->setNumLines(2);
+                    mStep = 4;
+                }
+            }
+            break;
+        }
+        case 4: {
+            if (mPad::g_currentCore->downTrigger(/* A */ 0x800) && systemWindow->getField_0xDE0() != 2) {
+                if (systemWindow->getField_0xDE0() == 0) {
+                    if (systemWindow->fn_80152F60() == true) {
+                        mStep = 5;
+                    }
+                } else {
+                    if (systemWindow->fn_80152F50()) {
+                        mStep = 10;
+                    }
+                }
+            }
+            break;
+        }
+        case 5: {
+            if (systemWindow->fn_80152F70() == true) {
+                mStep = 6;
+            }
+            break;
+        }
+        case 6: {
+            if (field_0x837 == true) {
+                // "The save data is corrupted. Save data will be restored."
+                if (systemWindow->setProperties("SYS_INIT_05", false, nullptr) == true) {
+                    systemWindow->showMaybe(4);
+                    mStep = 1;
+                }
+            } else {
+                // "The file cannot be used because nthe data is corrupted. All data saved up to this point will be
+                // lost. Create new save data?[1]Yes[2]No"
+                if (systemWindow->setProperties("SYS_NAND_07", false, nullptr) == true) {
+                    systemWindow->showMaybe(4);
+                    mStep = 1;
+                }
+            }
+            break;
+        }
+        case 10: {
+            if (systemWindow->fn_80152F70() == true) {
+                dDvdUnk::FontUnk::GetInstance()->fn_80052C90();
+                if (field_0x837 != true) {
+                    fileManager->setField0xA84C(1);
+                }
+                dCsBase_c::GetInstance()->setField704(false);
+                endState();
+            }
+            break;
+        }
+        case 20: {
+            if (systemWindow->fn_80152F70() == true) {
+                mStep++;
+            }
+            break;
+        }
+        case 21: {
+            if (systemWindow->getField_0xDFC() == true && mPad::g_currentCore->downTrigger(/* A */ 0x800) &&
+                systemWindow->fn_80152F50() == true) {
+                mStep++;
+            }
+            break;
+        }
+        case 22: {
+            if (systemWindow->fn_80152F70() == true) {
+                initializeDeleteAllData();
+            }
+        }
+    }
+    if (mpWindow != nullptr) {
+        mpWindow->execute();
+    }
+}
+
+void SaveMgr::initializeNandError() {
+    FileManager::GetInstance()->setField0xA84D(0);
+    field_0x83D = 0;
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(true);
+    beginState(STATE_NAND_ERROR);
+}
+
+void SaveMgr::executeNandError() {
+    FileManager *fileManager = FileManager::GetInstance();
+    dLytSystemWindow_c *systemWindow = dLytSystemWindow_c::GetInstance();
+    switch (mStep) {
+        case 0: {
+            bool anyAction = false;
+            if (mCheckForFreeSpaceResult == 1) {
+                // "There is not enough available space in Wii system memory. Create 1 block of free space either by
+                // moving data to an SD Card or deleting data in the Wii console's Data Management screen."
+                if (systemWindow->setProperties("SYS_NAND_02", false, nullptr) == true) {
+                    anyAction = true;
+                }
+            } else {
+                // "There is not enough available space in Wii system memory. Either move data to an SD Card or delete
+                // data in the Wii console's Data Management screen."
+                if (systemWindow->setProperties("SYS_NAND_03", false, nullptr) == true) {
+                    anyAction = true;
+                }
+            }
+            if (anyAction) {
+                systemWindow->showMaybe();
+                mStep = 1;
+            }
+            break;
+        }
+        case 1: {
+            if (systemWindow->fn_80152F70() == 1) {
+                mStep = 2;
+            }
+            break;
+        }
+        case 2: {
+            if (systemWindow->getField_0xDFC() == 1 && mPad::g_currentCore->downTrigger(/* A */ 0x800) &&
+                systemWindow->fn_80152F60() == 1) {
+                mStep = 3;
+            }
+            break;
+        }
+        case 3: {
+            if (systemWindow->fn_80152F70() == 1) {
+                mStep = 4;
+            }
+            break;
+        }
+        case 4: {
+            // "Do you want to go to the Wii console's Data Management screen to edit data? [1]Yes[2]No"
+            if (systemWindow->setProperties("SYS_NAND_04", false, nullptr) == true) {
+                systemWindow->showMaybe(4);
+                dCsBase_c::GetInstance()->setField704(true);
+                mStep = 5;
+            }
+            break;
+        }
+        case 5: {
+            if (systemWindow->fn_80152F70() == 1) {
+                mStep = 6;
+            }
+            break;
+        }
+        case 6: {
+            if (systemWindow->getField_0xE10() != 0) {
+                if (!ReloadColorFader::GetInstance()->fn_80068E80() &&
+                    !ReloadColorFader::GetInstance()->fn_80067F60() &&
+                    mPad::g_currentCore->downTrigger(/* A */ 0x800) && systemWindow->getField_0xDE0() != 2 &&
+                    systemWindow->fn_80152F60() == true) {
+                    mStep = 7;
+                }
+            }
+            break;
+        }
+        case 7: {
+            if (systemWindow->fn_80152F70() == 1) {
+                mStep = 8;
+            }
+            break;
+        }
+        case 8: {
+            if (systemWindow->getField_0xDE0() == 0) {
+                mStep = 9;
+            } else {
+                dCsBase_c::GetInstance()->setField704(false);
+                ReloadColorFader::GetInstance()->fn_80067FE0();
+                endState();
+                field_0x836 = 0;
+            }
+            break;
+        }
+        case 9: {
+            // "You will not be able to save. Do you want to begin your game anyway? [1]Begin[2-]Quit"
+            if (systemWindow->setProperties("SYS_SAVE_10", false, nullptr) == true) {
+                systemWindow->showMaybe(4);
+                // Why save mgs window and not system window?
+                mpWindow->setNumLines(2);
+                mStep = 10;
+            }
+            break;
+        }
+        case 10: {
+            if (systemWindow->fn_80152F70() == 1) {
+                mStep = 11;
+            }
+            break;
+        }
+        case 11: {
+            if (systemWindow->getField_0xE10() != 0 && mPad::g_currentCore->downTrigger(/* A */ 0x800) &&
+                systemWindow->getField_0xDE0() != 2) {
+                if (systemWindow->getField_0xDE0() == 0) {
+                    if (systemWindow->fn_80152F60() == true) {
+                        mStep = 12;
+                    }
+                } else {
+                    if (systemWindow->fn_80152F50()) {
+                        mStep = 13;
+                    }
+                }
+            }
+            break;
+        }
+        case 12: {
+            if (systemWindow->fn_80152F70() == 1) {
+                mStep = 0;
+            }
+            break;
+        }
+        case 13: {
+            if (systemWindow->fn_80152F70() == 1) {
+                dCsBase_c::GetInstance()->setField704(false);
+                dDvdUnk::FontUnk::GetInstance()->fn_80052C90();
+                fileManager->setField0xA84C(1);
+                endState();
+            }
+            break;
+        }
+    }
+}
+
+void SaveMgr::beginState(SaveMgrState_e state) {
+    mCurrentState = state;
+    field_0x824 = 2;
+    mStep = 0;
+    mDelayTimer = 0;
+}
+
+void SaveMgr::endState() {
+    field_0x836 = 1;
+    FileManager::GetInstance()->setField0xA840(1);
+    field_0x83D = 0;
+    dDvdUnk::FontUnk::GetInstance()->fn_80052D00(true);
+    field_0x83B = 0;
+    field_0x83C = 0;
+    mCurrentState = STATE_MAX;
+    field_0x83E = 0;
+    field_0x83F = 0;
+}
+
+s32 SaveMgr::getFrameRate() {
+    return 60 / dSys::getFrameRate();
+}
+
+NandRequestCheckIsFile::NandRequestCheckIsFile(const char *path) : mIsFile(0) {
+    mPath = path;
+}
+
+bool NandRequestCheckIsFile::execute() {
+    u8 type = 0;
+    mStatus = NANDGetType(mPath, &type);
+    if (mStatus == NAND_RESULT_OK && type == NAND_FILE_TYPE_FILE) {
+        mIsFile = 1;
+    } else {
+        mIsFile = 0;
+    }
+    return true;
+}
+
+bool NandRequestCheckIsFileHolder::checkIsFile(const char *path) {
+    if (mpRequest != nullptr) {
+        return false;
+    }
+    NandRequestCheckIsFile *req = new NandRequestCheckIsFile(path);
+    if (req == nullptr) {
+        return false;
+    }
+    NandRequestThread::GetInstance()->enqueueRequest(req);
+    mpRequest = req;
+    return true;
+}
+
+bool NandRequestCheckIsFileHolder::getCheckResult() const {
+    return static_cast<NandRequestCheckIsFile *>(mpRequest)->mIsFile;
+}
+
+NandRequestSaveBanner::NandRequestSaveBanner(
+    const char *filePath, TPLPalette *palette, const wchar_t *title, const wchar_t *subtitle, u8 perm, u8 attr
+)
+    : NandRequestCreate(filePath, perm, attr),
+      mpPalette(palette),
+      mpTitle(title),
+      mpSubTitle(subtitle),
+      mFailed(false) {}
+
+bool NandRequestSaveBanner::execute() {
+    if (!NandRequestCreate::execute()) {
+        return true;
+    }
+
+    char homeDir[64];
+    NANDFileInfo info;
+    mStatus = NANDOpen(mFilePath, &info, NAND_ACCESS_WRITE);
+    if (mStatus != NAND_RESULT_OK) {
+        return mStatus;
+    }
+
+    if (writeBannerTpl(&info) != 0x72A0) {
+        NANDResult res = NANDClose(&info);
+        if (res != NAND_RESULT_OK) {
+            mStatus = res;
+        }
+        mFailed = true;
+        return false;
+    }
+
+    mStatus = NANDClose(&info);
+    mStatus = NANDGetHomeDir(homeDir);
+    if (mStatus != NAND_RESULT_OK) {
+        return mStatus;
+    }
+
+    mStatus = NANDMove(mFilePath, homeDir);
+    return true;
+}
+
+#define NUM_BANNER_ICONS 1
+
+u32 NandRequestSaveBanner::writeBannerTpl(NANDFileInfo *info) {
+    static NANDBanner sBanner;
+    NANDInitBanner(&sBanner, 0, getTitle(), getSubTitle());
+    TPLPalette *palette = getPalette();
+    TPLDescriptor *tpl = TPLGet(palette, 0);
+    std::memcpy(&sBanner.bannerTexture, tpl->texHeader->data, NAND_BANNER_TEXTURE_SIZE);
+    for (s32 i = 0; i < NUM_BANNER_ICONS;) {
+        TPLDescriptor *tpl = TPLGet(palette, i + 1);
+        std::memcpy(sBanner.iconTexture[0], tpl->texHeader->data, NAND_BANNER_ICON_TEXTURE_SIZE);
+        // ah yes
+        s32 idx = i++;
+        NAND_SET_ICON_SPEED(&sBanner, idx, 2);
+    }
+    NAND_SET_ICON_SPEED(&sBanner, NUM_BANNER_ICONS, 0);
+    // How is this calculated?
+    return NANDWrite(info, &sBanner, 0x72A0);
+}
+
+bool NandRequestSaveBannerHolder::saveBanner(
+    const char *filePath, TPLPalette *palette, const wchar_t *title, const wchar_t *subtitle, u8 perm, u8 attr
+) {
+    if (mpRequest != nullptr) {
+        return false;
+    }
+    NandRequestSaveBanner *req = new NandRequestSaveBanner(filePath, palette, title, subtitle, perm, attr);
+    if (req == nullptr) {
+        return false;
+    }
+    NandRequestThread::GetInstance()->enqueueRequest(req);
+    mpRequest = req;
+    return true;
+}
+
+bool NandRequestSaveBannerHolder::hasFailed() const {
+    return static_cast<NandRequestSaveBanner *>(mpRequest)->mFailed;
+}
+
+NandRequestLoadSaveFile::NandRequestLoadSaveFile(const char *path, s32 readSize, s32 mountDirection, EGG::Heap *heap)
+    : mpHeap(heap), mpBuf(nullptr), mBufLen(0), mMountDirection(mountDirection), mReadSize(readSize), mUnused(false) {
+    mPath = path;
+    if (mpHeap == nullptr) {
+        mpHeap = dHeap::work2Heap.heap;
+    }
+}
+
+bool NandRequestLoadSaveFile::execute() {
+    NANDFileInfo info;
+    mStatus = NANDOpen(mPath, &info, NAND_ACCESS_READ);
+    if (mStatus != NAND_RESULT_OK) {
+        return true;
+    }
+
+    u32 length;
+    mStatus = NANDGetLength(&info, &length);
+    if (mStatus != NAND_RESULT_OK) {
+        mStatus = NAND_RESULT_AUTHENTICATION; // ??
+        NANDResult res = NANDClose(&info);
+        if (res != NAND_RESULT_OK) {
+            mStatus = res;
+        }
+        return true;
+    }
+
+    if (length != mReadSize) {
+        mStatus = NAND_RESULT_AUTHENTICATION; // ??
+        NANDResult res = NANDClose(&info);
+        if (res != NAND_RESULT_OK) {
+            mStatus = res;
+        }
+        return true;
+    }
+    s32 align = mMountDirection == 0 ? 0x20 : -0x20;
+    mpBuf = mpHeap->alloc(length, align);
+    if (mpBuf == nullptr) {
+        mStatus = NAND_RESULT_AUTHENTICATION; // ??
+        NANDResult res = NANDClose(&info);
+        if (res != NAND_RESULT_OK) {
+            mStatus = res;
+        }
+        return false;
+    }
+
+    mBufLen = length;
+    mStatus = NANDRead(&info, mpBuf, mBufLen);
+    NANDResult res = NANDClose(&info);
+    if (mStatus != mBufLen && mStatus >= NAND_RESULT_OK) {
+        mStatus = NAND_RESULT_AUTHENTICATION; // ??
+    } else if (mStatus != NAND_RESULT_ECC_CRIT && mStatus != NAND_RESULT_AUTHENTICATION) {
+        mStatus = res;
+    }
+    return true;
+}
+
+void NandRequestLoadSaveFile::remove() {
+    if (mpBuf != nullptr) {
+        mpHeap->free(mpBuf);
+        mpBuf = nullptr;
+        mBufLen = 0;
+    }
+}
+
+bool NandRequestLoadSaveFileHolder::loadSave(const char *path, s32 readSize, s32 mountDirection, EGG::Heap *heap) {
+    if (mpRequest != nullptr) {
+        return false;
+    }
+    NandRequestLoadSaveFile *req = new NandRequestLoadSaveFile(path, readSize, mountDirection, heap);
+    if (req == nullptr) {
+        return false;
+    }
+    NandRequestThread::GetInstance()->enqueueRequest(req);
+    mpRequest = req;
+    return true;
+}
+
+void *NandRequestLoadSaveFileHolder::getBuf() const {
+    return static_cast<NandRequestLoadSaveFile *>(mpRequest)->mpBuf;
+}
+
+u32 NandRequestLoadSaveFileHolder::getLen() const {
+    return static_cast<NandRequestLoadSaveFile *>(mpRequest)->mBufLen;
+}
+
+void NandRequestLoadSaveFileHolder::remove() {
+    static_cast<NandRequestLoadSaveFile *>(mpRequest)->remove();
+}
+
+NandRequestDelete::NandRequestDelete(const char *path) {
+    mPath = path;
+}
+
+bool NandRequestDelete::execute() {
+    mStatus = NANDDelete(mPath);
+    return true;
+}
+
+bool NandRequestDeleteHolder::doDelete(const char *path) {
+    if (mpRequest != nullptr) {
+        return false;
+    }
+    NandRequestDelete *req = new NandRequestDelete(path);
+    if (req == nullptr) {
+        return false;
+    }
+    NandRequestThread::GetInstance()->enqueueRequest(req);
+    mpRequest = req;
+    return true;
+}