diff --git a/data/uking_functions.csv b/data/uking_functions.csv
index 528a66bc..a23558fe 100644
--- a/data/uking_functions.csv
+++ b/data/uking_functions.csv
@@ -76027,38 +76027,38 @@
 0x0000007100dd0974,GameDataMgr::calc1,240,
 0x0000007100dd0a64,GameDataMgr::setCallback_stubbed,4,_ZN4ksys3gdt7Manager17addReinitCallbackERN4sead13DelegateEventIPNS1_11ReinitEventEE4SlotE
 0x0000007100dd0a68,nullsub_3858,4,_ZN4ksys3gdt7Manager20removeReinitCallbackERN4sead13DelegateEventIPNS1_11ReinitEventEE4SlotE
-0x0000007100dd0a6c,GameDataMgr::setCurrentRupeeFlagName,12,
-0x0000007100dd0a78,GameDataMgr::requestResetAllToInitial,16,
-0x0000007100dd0a88,GameDataMgr::getAndSetShrineQuestAndKassFlags,3628,
+0x0000007100dd0a6c,GameDataMgr::setCurrentRupeeFlagName,12,_ZN4ksys3gdt7Manager23setCurrentRupeeFlagNameERKN4sead14SafeStringBaseIcEE
+0x0000007100dd0a78,GameDataMgr::requestResetAllToInitial,16,_ZN4ksys3gdt7Manager29requestResetAllFlagsToInitialEv
+0x0000007100dd0a88,GameDataMgr::getAndSetShrineQuestAndKassFlags,3628,_ZN4ksys3gdt7Manager13fixQuestFlagsEv
 0x0000007100dd18b4,GameDataMgr::setBoolByKey,164,_ZN4ksys3gdt7Manager7setBoolEbRKN4sead14SafeStringBaseIcEE
-0x0000007100dd1958,GameDataMgr::getAndSetShrineQuestFlagsAndKassDlc2,1416,
-0x0000007100dd1ee0,GameDataMgr::setStringInArrayByKey,184,
-0x0000007100dd1f98,GameDataMgr::setBoolByKeyB,164,
-0x0000007100dd203c,sub_7100DD203C,164,
-0x0000007100dd20e0,GameDataMgr::__auto4,164,
-0x0000007100dd2184,sub_7100DD2184,172,
-0x0000007100dd2230,sub_7100DD2230,164,
-0x0000007100dd22d4,sub_7100DD22D4,184,
+0x0000007100dd1958,GameDataMgr::getAndSetShrineQuestFlagsAndKassDlc2,1416,_ZN4ksys3gdt7Manager17fixQuestFlagsDlc2Ev
+0x0000007100dd1ee0,GameDataMgr::setStringInArrayByKey,184,_ZN4ksys3gdt7Manager8setStr64EPKcRKN4sead14SafeStringBaseIcEEi
+0x0000007100dd1f98,GameDataMgr::setBoolByKeyB,164,_ZN4ksys3gdt7Manager14setBoolNoCheckEbRKN4sead14SafeStringBaseIcEE
+0x0000007100dd203c,sub_7100DD203C,164,_ZN4ksys3gdt7Manager15setBoolNoCheck_EbRKN4sead14SafeStringBaseIcEE
+0x0000007100dd20e0,GameDataMgr::__auto4,164,_ZN4ksys3gdt7Manager13setS32NoCheckEiRKN4sead14SafeStringBaseIcEE
+0x0000007100dd2184,sub_7100DD2184,172,_ZN4ksys3gdt7Manager13setF32NoCheckEfRKN4sead14SafeStringBaseIcEE
+0x0000007100dd2230,sub_7100DD2230,164,_ZN4ksys3gdt7Manager13setStrNoCheckEPKcRKN4sead14SafeStringBaseIcEE
+0x0000007100dd22d4,sub_7100DD22D4,184,_ZN4ksys3gdt7Manager13setS32NoCheckEiRKN4sead14SafeStringBaseIcEEi
 0x0000007100dd238c,GameDataMgr::setIntByKey,164,_ZN4ksys3gdt7Manager6setS32EiRKN4sead14SafeStringBaseIcEE
 0x0000007100dd2430,GameDataMgr::setFloatByKey,172,_ZN4ksys3gdt7Manager6setF32EfRKN4sead14SafeStringBaseIcEE
 0x0000007100dd24dc,GameDataMgr::setString32ByKey,164,_ZN4ksys3gdt7Manager6setStrEPKcRKN4sead14SafeStringBaseIcEE
-0x0000007100dd2580,GameDataMgr::setString64ByKey,164,
+0x0000007100dd2580,GameDataMgr::setString64ByKey,164,_ZN4ksys3gdt7Manager8setStr64EPKcRKN4sead14SafeStringBaseIcEE
 0x0000007100dd2624,GameDataMgr::setVec3ByKey,164,_ZN4ksys3gdt7Manager8setVec3fERKN4sead7Vector3IfEERKNS2_14SafeStringBaseIcEE
-0x0000007100dd26c8,GameDataMgr::setBoolInArrayByKey,184,
-0x0000007100dd2780,GameDataMgr::__auto3,184,
-0x0000007100dd2838,sub_7100DD2838,184,
-0x0000007100dd28f0,GameDataMgr::x_1,184,
-0x0000007100dd29a8,sub_7100DD29A8,40,
-0x0000007100dd29d0,sub_7100DD29D0,40,
-0x0000007100dd29f8,GameDataMgr::resetBoolByKeyMaybe,40,
-0x0000007100dd2a20,GameDataMgr::resetIntByKeyMaybe,40,
-0x0000007100dd2a48,GameDataMgr::resetStrByKeyMaybe,40,
-0x0000007100dd2a70,GameDataMgr::resetVec3ByKeyMaybe,40,
-0x0000007100dd2a98,GameDataMgr::resetIntInArrayByKeyMaybe,40,
-0x0000007100dd2ac0,GameDataMgr::increaseGameDataInt,232,
-0x0000007100dd2ba8,GameDataMgr::increaseInt,232,
-0x0000007100dd2c90,GameDataMgr::__auto1,72,
-0x0000007100dd2cd8,GameDataMgr::__auto6,72,
+0x0000007100dd26c8,GameDataMgr::setBoolInArrayByKey,184,_ZN4ksys3gdt7Manager7setBoolEbRKN4sead14SafeStringBaseIcEEi
+0x0000007100dd2780,GameDataMgr::__auto3,184,_ZN4ksys3gdt7Manager6setS32EiRKN4sead14SafeStringBaseIcEEi
+0x0000007100dd2838,sub_7100DD2838,184,_ZN4ksys3gdt7Manager6setF32EfRKN4sead14SafeStringBaseIcEEi
+0x0000007100dd28f0,GameDataMgr::x_1,184,_ZN4ksys3gdt7Manager9setStr64_EPKcRKN4sead14SafeStringBaseIcEEi
+0x0000007100dd29a8,sub_7100DD29A8,40,_ZN4ksys3gdt7Manager10resetBool_ERKN4sead14SafeStringBaseIcEE
+0x0000007100dd29d0,sub_7100DD29D0,40,_ZN4ksys3gdt7Manager9resetS32_ERKN4sead14SafeStringBaseIcEE
+0x0000007100dd29f8,GameDataMgr::resetBoolByKeyMaybe,40,_ZN4ksys3gdt7Manager9resetBoolERKN4sead14SafeStringBaseIcEE
+0x0000007100dd2a20,GameDataMgr::resetIntByKeyMaybe,40,_ZN4ksys3gdt7Manager8resetS32ERKN4sead14SafeStringBaseIcEE
+0x0000007100dd2a48,GameDataMgr::resetStrByKeyMaybe,40,_ZN4ksys3gdt7Manager10resetStr64ERKN4sead14SafeStringBaseIcEE
+0x0000007100dd2a70,GameDataMgr::resetVec3ByKeyMaybe,40,_ZN4ksys3gdt7Manager10resetVec3fERKN4sead14SafeStringBaseIcEE
+0x0000007100dd2a98,GameDataMgr::resetIntInArrayByKeyMaybe,40,_ZN4ksys3gdt7Manager8resetS32ERKN4sead14SafeStringBaseIcEEi
+0x0000007100dd2ac0,GameDataMgr::increaseGameDataInt,232,_ZN4ksys3gdt7Manager19incrementS32NoCheckEiRKN4sead14SafeStringBaseIcEE
+0x0000007100dd2ba8,GameDataMgr::increaseInt,232,_ZN4ksys3gdt7Manager12incrementS32EiRKN4sead14SafeStringBaseIcEE
+0x0000007100dd2c90,GameDataMgr::__auto1,72,_ZN4ksys3gdt7Manager13wasFlagCopiedERKN4sead14SafeStringBaseIcEE
+0x0000007100dd2cd8,GameDataMgr::__auto6,72,_ZN4ksys3gdt7Manager16wasFlagNotCopiedERKN4sead14SafeStringBaseIcEE
 0x0000007100dd2d20,GameDataMgr::copyParamToParam1,28,
 0x0000007100dd2d3c,GameDataMgr::getBoolIdxForMapUnitObject,272,
 0x0000007100dd2e4c,GameDataMgr::allocParam1,180,
@@ -76227,10 +76227,10 @@
 0x0000007100de70ec,TriggerParam::resetF32,232,_ZN4ksys3gdt12TriggerParam8resetF32Eib
 0x0000007100de71d4,TriggerParam::resetString64,232,_ZN4ksys3gdt12TriggerParam10resetStr64Eib
 0x0000007100de72bc,_ZN4ksys3gdt12TriggerParam10resetVec3fEib,232,_ZN4ksys3gdt12TriggerParam10resetVec3fEib
-0x0000007100de73a4,resetBoolByKey,0x110,_ZN4ksys3gdt12TriggerParam9resetBoolERKN4sead14SafeStringBaseIcEEb
-0x0000007100de74b4,TriggerParam::resetS32ByKey,272,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEb
-0x0000007100de75c4,_ZN4ksys3gdt12TriggerParam10resetStr64ERKN4sead14SafeStringBaseIcEEb,0x110,_ZN4ksys3gdt12TriggerParam10resetStr64ERKN4sead14SafeStringBaseIcEEb
-0x0000007100de76d4,_ZN4ksys3gdt12TriggerParam10resetVec3fERKN4sead14SafeStringBaseIcEEb,0x110,_ZN4ksys3gdt12TriggerParam10resetVec3fERKN4sead14SafeStringBaseIcEEb
+0x0000007100de73a4,resetBoolByKey,0x110,_ZN4ksys3gdt12TriggerParam9resetBoolERKN4sead14SafeStringBaseIcEEbb
+0x0000007100de74b4,TriggerParam::resetS32ByKey,272,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEbb
+0x0000007100de75c4,_ZN4ksys3gdt12TriggerParam10resetStr64ERKN4sead14SafeStringBaseIcEEb,0x110,_ZN4ksys3gdt12TriggerParam10resetStr64ERKN4sead14SafeStringBaseIcEEbb
+0x0000007100de76d4,_ZN4ksys3gdt12TriggerParam10resetVec3fERKN4sead14SafeStringBaseIcEEb,0x110,_ZN4ksys3gdt12TriggerParam10resetVec3fERKN4sead14SafeStringBaseIcEEbb
 0x0000007100de77e4,TriggerParam::resetBoolArray,284,_ZN4ksys3gdt12TriggerParam9resetBoolEiib
 0x0000007100de7900,TriggerParam::resetS32Array,284,_ZN4ksys3gdt12TriggerParam8resetS32Eiib
 0x0000007100de7a1c,TriggerParam::resetF32Array,284,_ZN4ksys3gdt12TriggerParam8resetF32Eiib
@@ -76240,7 +76240,7 @@
 0x0000007100de7e8c,TriggerParam::resetVec2fArray,284,_ZN4ksys3gdt12TriggerParam10resetVec2fEiib
 0x0000007100de7fa8,TriggerParam::resetVec3fArray,284,_ZN4ksys3gdt12TriggerParam10resetVec3fEiib
 0x0000007100de80c4,TriggerParam::resetVec4fArray,284,_ZN4ksys3gdt12TriggerParam10resetVec4fEiib
-0x0000007100de81e0,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEib,0xEC,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEib
+0x0000007100de81e0,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEib,0xEC,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEibb
 0x0000007100de82cc,TriggerParam::getArray158Flag,364,_ZNK4ksys3gdt12TriggerParam15getBoolIfCopiedEPbRKN4sead14SafeStringBaseIcEEbb
 0x0000007100de8438,TriggerParam::getHorseIntByKeyMaybe,360,_ZNK4ksys3gdt12TriggerParam14getS32IfCopiedEPiRKN4sead14SafeStringBaseIcEEbb
 0x0000007100de85a0,sub_7100DE85A0,360,_ZNK4ksys3gdt12TriggerParam14getF32IfCopiedEPfRKN4sead14SafeStringBaseIcEEbb
diff --git a/src/KingSystem/GameData/gdtManager.cpp b/src/KingSystem/GameData/gdtManager.cpp
index c3cd8c6d..d46b0745 100644
--- a/src/KingSystem/GameData/gdtManager.cpp
+++ b/src/KingSystem/GameData/gdtManager.cpp
@@ -1,9 +1,11 @@
 #include "KingSystem/GameData/gdtManager.h"
+#include <algorithm>
 #include <devenv/seadEnvUtil.h>
 #include <framework/seadFramework.h>
 #include <mc/seadCoreInfo.h>
 #include <thread/seadThreadUtil.h>
 #include <time/seadTickTime.h>
+#include "Game/DLC/aocManager.h"
 #include "KingSystem/GameData/gdtSaveMgr.h"
 #include "KingSystem/GameData/gdtTriggerParam.h"
 #include "KingSystem/Resource/resEntryFactory.h"
@@ -141,6 +143,393 @@ void Manager::removeReinitCallback(sead::DelegateEvent<Manager::ReinitEvent*>::S
     // Stubbed in release builds.
 }
 
+void Manager::setCurrentRupeeFlagName(const sead::SafeString& name) {
+    getParam().get1().getBuffer()->setCurrentRupeeFlagName(name);
+}
+
+void Manager::requestResetAllFlagsToInitial() {
+    mBitFlags.set(BitFlag::RequestResetAllFlagsToInitial);
+}
+
+namespace {
+
+template <int N>
+bool loadAllFlags(Manager* mgr, sead::SafeArray<bool, N>* flags,
+                  const sead::SafeString (&names)[N]) {
+#ifdef MATCHING_HACK_NX_CLANG
+#pragma clang loop unroll(full)
+#endif
+    for (int i = 0; i < N; ++i) {
+        if (!mgr->getParam().get1().getBool(&(*flags)[i], names[i]))
+            return false;
+    }
+    return true;
+}
+
+void fixDarkWoodsFlags(Manager* mgr) {
+    enum {
+        DarkWoods_Giant_Clear,
+        DarkWoods_Finish,
+    };
+    sead::SafeString names[] = {
+        "DarkWoods_Giant_Clear",
+        "DarkWoods_Finish",
+    };
+    sead::SafeArray<bool, std::size(names)> flags;
+    if (!loadAllFlags(mgr, &flags, names))
+        return;
+    if (flags[DarkWoods_Giant_Clear] && !flags[DarkWoods_Finish])
+        mgr->getParamBypassPerm().get1().setBool(false, names[DarkWoods_Giant_Clear], true);
+}
+
+void fixGiantQuestFlags(Manager* mgr) {
+    enum {
+        giant_ball1,
+        giant_ball2,
+        giant_ball3,
+        giant_dungeon,
+        MainField_DgnObj_RemainsLithogragh_A_02_789666109,
+        MainField_DgnObj_RemainsLithogragh_A_02_2456751716,
+        MainField_DgnObj_RemainsLithogragh_A_02_1822262999,
+    };
+    sead::SafeString names[] = {
+        "giant_ball1",
+        "giant_ball2",
+        "giant_ball3",
+        "giant_dungeon",
+        "MainField_DgnObj_RemainsLithogragh_A_02_789666109",
+        "MainField_DgnObj_RemainsLithogragh_A_02_2456751716",
+        "MainField_DgnObj_RemainsLithogragh_A_02_1822262999",
+    };
+    sead::SafeArray<bool, std::size(names)> flags;
+    if (!loadAllFlags(mgr, &flags, names))
+        return;
+
+    if (flags[giant_ball1] && !flags[MainField_DgnObj_RemainsLithogragh_A_02_789666109])
+        mgr->setBool(true, names[MainField_DgnObj_RemainsLithogragh_A_02_789666109]);
+    if (flags[giant_ball2] && !flags[MainField_DgnObj_RemainsLithogragh_A_02_2456751716])
+        mgr->setBool(true, names[MainField_DgnObj_RemainsLithogragh_A_02_2456751716]);
+    if (flags[giant_ball3] && !flags[MainField_DgnObj_RemainsLithogragh_A_02_1822262999])
+        mgr->setBool(true, names[MainField_DgnObj_RemainsLithogragh_A_02_1822262999]);
+
+    if (flags[giant_ball1] && flags[giant_ball2] && flags[giant_ball3] && !flags[giant_dungeon])
+        mgr->getParamBypassPerm().get1().setBool(true, names[giant_dungeon], true);
+}
+
+void fixBowOfLightFlag(Manager* mgr) {
+    enum { MainField_Weapon_Bow_071_2178255681 };
+    sead::SafeString names[] = {"MainField_Weapon_Bow_071_2178255681"};
+    sead::SafeArray<bool, std::size(names)> flags;
+    if (loadAllFlags(mgr, &flags, names) && flags[MainField_Weapon_Bow_071_2178255681])
+        mgr->setBool(false, names[MainField_Weapon_Bow_071_2178255681]);
+}
+
+void fixBalladOfHeroesFlags(Manager* mgr) {
+    enum {
+        BalladOfHeroes_Step02,
+        BalladOfHeroes_Step03,
+        Defeat_OneHitDungeon001,
+        Defeat_OneHitDungeon002,
+        Defeat_OneHitDungeon003,
+        Defeat_OneHitDungeon004,
+        Lock_OneHitDungeon001,
+        Lock_OneHitDungeon002,
+        Lock_OneHitDungeon003,
+        Lock_OneHitDungeon004,
+        BalladOfHeroes_Step02_Dungeon01,
+        BalladOfHeroes_Step02_Dungeon02,
+        BalladOfHeroes_Step02_Dungeon03,
+        BalladOfHeroes_Step2_Dungeon4,
+    };
+    sead::SafeString names[] = {
+        "BalladOfHeroes_Step02",
+        "BalladOfHeroes_Step03",
+        //
+        "Defeat_OneHitDungeon001",
+        "Defeat_OneHitDungeon002",
+        "Defeat_OneHitDungeon003",
+        "Defeat_OneHitDungeon004",
+        //
+        "Lock_OneHitDungeon001",
+        "Lock_OneHitDungeon002",
+        "Lock_OneHitDungeon003",
+        "Lock_OneHitDungeon004",
+        //
+        "BalladOfHeroes_Step02_Dungeon01",
+        "BalladOfHeroes_Step02_Dungeon02",
+        "BalladOfHeroes_Step02_Dungeon03",
+        "BalladOfHeroes_Step2_Dungeon4",
+    };
+    sead::SafeArray<bool, std::size(names)> flags;
+    if (!loadAllFlags(mgr, &flags, names))
+        return;
+
+    if (!flags[BalladOfHeroes_Step02] || flags[BalladOfHeroes_Step03])
+        return;
+
+    s8 count = 0;
+    bool not_locked = false;
+
+    if (flags[Defeat_OneHitDungeon001]) {
+        ++count;
+        if (!flags[Lock_OneHitDungeon001])
+            not_locked = true;
+    }
+    if (flags[Defeat_OneHitDungeon002]) {
+        ++count;
+        if (!flags[Lock_OneHitDungeon002])
+            not_locked = true;
+    }
+    if (flags[Defeat_OneHitDungeon003]) {
+        ++count;
+        if (!flags[Lock_OneHitDungeon003])
+            not_locked = true;
+    }
+    if (flags[Defeat_OneHitDungeon004]) {
+        ++count;
+        if (!flags[Lock_OneHitDungeon004])
+            not_locked = true;
+    }
+
+    if (not_locked) {
+        if (count >= 1 && !flags[BalladOfHeroes_Step02_Dungeon01])
+            mgr->setBool(true, names[BalladOfHeroes_Step02_Dungeon01]);
+        if (count >= 2 && !flags[BalladOfHeroes_Step02_Dungeon02])
+            mgr->setBool(true, names[BalladOfHeroes_Step02_Dungeon02]);
+        if (count >= 3 && !flags[BalladOfHeroes_Step02_Dungeon03])
+            mgr->setBool(true, names[BalladOfHeroes_Step02_Dungeon03]);
+        if (count >= 4 && !flags[BalladOfHeroes_Step2_Dungeon4])
+            mgr->setBool(true, names[BalladOfHeroes_Step2_Dungeon4]);
+    }
+}
+
+void fixAllShrinesFlags(Manager* mgr) {
+    enum {
+        IsGet_Armor_005_Head,
+        IsGet_Armor_005_Upper,
+        IsGet_Armor_005_Lower,
+        CompleteDungeon_Finish,
+    };
+    sead::SafeString names[] = {
+        "IsGet_Armor_005_Head",
+        "IsGet_Armor_005_Upper",
+        "IsGet_Armor_005_Lower",
+        "CompleteDungeon_Finish",
+    };
+    sead::SafeArray<bool, std::size(names)> flags;
+    if (!loadAllFlags(mgr, &flags, names))
+        return;
+
+    if (flags[IsGet_Armor_005_Head] && flags[IsGet_Armor_005_Upper] &&
+        flags[IsGet_Armor_005_Lower] && !flags[CompleteDungeon_Finish]) {
+        mgr->setBool(true, names[CompleteDungeon_Finish]);
+    }
+}
+
+}  // namespace
+
+void Manager::fixQuestFlags() {
+    fixDarkWoodsFlags(this);
+    fixGiantQuestFlags(this);
+    fixBowOfLightFlag(this);
+    fixBalladOfHeroesFlags(this);
+    fixAllShrinesFlags(this);
+
+    {
+        enum {
+            NightStoneBreak,
+            NightStoneDungeonAppear,
+        };
+        sead::SafeString names[] = {
+            "NightStoneBreak",
+            "NightStoneDungeonAppear",
+        };
+        sead::SafeArray<bool, std::size(names)> flags;
+        if (loadAllFlags(this, &flags, names)) {
+            if (flags[NightStoneBreak] && !flags[NightStoneDungeonAppear])
+                getParamBypassPerm().get().setBool(false, names[NightStoneBreak], true);
+        }
+    }
+
+    {
+        enum {
+            Animal_Forest_Finish,
+            HateeluMini_Treasure_Finish,
+            Thunder_Sword_Finish,
+            Relief_Landing_Finish,
+            Shadow_Sign_Finish,
+            MouthofDragon_Finish,
+            TwoWheels_Finish,
+            BloodyMoonRelief_Finish,
+            Rito_BrosRock_Finish,
+        };
+        sead::SafeString names[] = {
+            "Animal_Forest_Finish",
+            "HateeluMini_Treasure_Finish",
+            "Thunder_Sword_Finish",
+            "Relief_Landing_Finish",
+            "Shadow_Sign_Finish",
+            "MouthofDragon_Finish",
+            "TwoWheels_Finish",
+            "BloodyMoonRelief_Finish",
+            // Not a shrine quest
+            "Rito_BrosRock_Finish",
+        };
+        sead::SafeArray<bool, std::size(names)> flags;
+        if (loadAllFlags(this, &flags, names)) {
+            if (std::all_of(flags.begin(), flags.end(), [](bool b) { return b; }))
+                getParamBypassPerm().get().setBool(true, "Npc_Musician_Come", true);
+        }
+    }
+}
+
+void Manager::fixQuestFlagsDlc2() {
+    if (uking::aoc::Manager::instance()->hasAoc3())
+        return;
+
+    enum {
+        Ichigeki_Sword_Appear,
+        BalladOfHeroes_Retire_Dungeon04,
+        BalladOfHeroes_Step02,
+        BalladOfHeroes_Step02_Dungeon01,
+        BalladOfHeroes_Step02_Dungeon02,
+        BalladOfHeroes_Step02_Dungeon03,
+        BalladOfHeroes_Step2_Dungeon4,
+        BalladOfHeroes_Step03,
+    };
+    sead::SafeString names[] = {
+        "Ichigeki_Sword_Appear",
+        "BalladOfHeroes_Retire_Dungeon04",
+        // OhO plateau phase
+        "BalladOfHeroes_Step02",
+        "BalladOfHeroes_Step02_Dungeon01",
+        "BalladOfHeroes_Step02_Dungeon02",
+        "BalladOfHeroes_Step02_Dungeon03",
+        "BalladOfHeroes_Step2_Dungeon4",
+        "BalladOfHeroes_Step03",
+    };
+    sead::SafeArray<bool, std::size(names)> flags;
+    if (!loadAllFlags(this, &flags, names))
+        return;
+
+    const bool value_BalladOfHeroes_Step2_Dungeon4 = flags[BalladOfHeroes_Step2_Dungeon4];
+
+    if (!flags[BalladOfHeroes_Step02] || flags[BalladOfHeroes_Step03])
+        return;
+
+    setBool(false, names[BalladOfHeroes_Step2_Dungeon4]);
+    setBool(false, names[BalladOfHeroes_Step02_Dungeon03]);
+    setBool(false, names[BalladOfHeroes_Step02_Dungeon02]);
+    setBool(false, names[BalladOfHeroes_Step02_Dungeon01]);
+    setBool(false, names[BalladOfHeroes_Step02]);
+    if (!value_BalladOfHeroes_Step2_Dungeon4)
+        setBool(false, names[BalladOfHeroes_Retire_Dungeon04]);
+    setBool(true, names[Ichigeki_Sword_Appear]);
+
+    const char* temp_horse;
+    if (getParam().get().getStr64(&temp_horse, "Horse_ActorName", 5) &&
+        sead::SafeString(temp_horse) == "GameRomHorseBone_AllDay") {
+        setStr64("", "Horse_ActorName", 5);
+    }
+}
+
+#define GDT_SET_IMPL_(NAME, TRAITS)                                                                \
+    /* Setters (by name) */                                                                        \
+    bool Manager::NAME(TRAITS::ArgType value, const sead::SafeString& name) {                      \
+        return NAME(value, name, false, false);                                                    \
+    }                                                                                              \
+    bool Manager::NAME##_(TRAITS::ArgType value, const sead::SafeString& name) {                   \
+        return NAME(value, name, false, false);                                                    \
+    }                                                                                              \
+    bool Manager::NAME##NoCheck(TRAITS::ArgType value, const sead::SafeString& name) {             \
+        return NAME(value, name, true, false);                                                     \
+    }                                                                                              \
+    bool Manager::NAME##NoCheck_(TRAITS::ArgType value, const sead::SafeString& name) {            \
+        return NAME(value, name, true, false);                                                     \
+    }                                                                                              \
+    bool Manager::NAME##NoCheckForce(TRAITS::NoCheckForceArgType value,                            \
+                                     const sead::SafeString& name) {                               \
+        return NAME(value, name, true, true);                                                      \
+    }                                                                                              \
+    /* Setters for arrays (by name) */                                                             \
+    bool Manager::NAME(TRAITS::ArgType value, const sead::SafeString& name, s32 sub_idx) {         \
+        return NAME(value, name, false, false, sub_idx);                                           \
+    }                                                                                              \
+    bool Manager::NAME##_(TRAITS::ArgType value, const sead::SafeString& name, s32 sub_idx) {      \
+        return NAME(value, name, false, false, sub_idx);                                           \
+    }                                                                                              \
+    bool Manager::NAME##NoCheck(TRAITS::ArgType value, const sead::SafeString& name,               \
+                                s32 sub_idx) {                                                     \
+        return NAME(value, name, true, false, sub_idx);                                            \
+    }                                                                                              \
+    bool Manager::NAME##NoCheckForce(TRAITS::NoCheckForceArgType value,                            \
+                                     const sead::SafeString& name, s32 sub_idx) {                  \
+        return NAME(value, name, true, true, sub_idx);                                             \
+    }
+
+GDT_SET_IMPL_(setBool, detail::SetterTraits<bool>)
+GDT_SET_IMPL_(setS32, detail::SetterTraits<s32>)
+GDT_SET_IMPL_(setF32, detail::SetterTraits<f32>)
+GDT_SET_IMPL_(setStr, detail::SetterTraits<const char*>)
+GDT_SET_IMPL_(setStr64, detail::SetterTraits<const char*>)
+GDT_SET_IMPL_(setStr256, detail::SetterTraits<const char*>)
+GDT_SET_IMPL_(setVec2f, detail::SetterTraits<sead::Vector2f>)
+GDT_SET_IMPL_(setVec3f, detail::SetterTraits<sead::Vector3f>)
+GDT_SET_IMPL_(setVec4f, detail::SetterTraits<sead::Vector4f>)
+
+#undef GDT_SET_IMPL_
+
+#define GDT_RESET_IMPL_(NAME)                                                                      \
+    bool Manager::NAME(const sead::SafeString& name) {                                             \
+        if (mBitFlags.isOn(BitFlag::_40000))                                                       \
+            return false;                                                                          \
+        return getParam().get1().NAME(name);                                                       \
+    }                                                                                              \
+    bool Manager::NAME##_(const sead::SafeString& name) { return NAME(name); }                     \
+    bool Manager::NAME(const sead::SafeString& name, int sub_idx) {                                \
+        if (mBitFlags.isOn(BitFlag::_40000))                                                       \
+            return false;                                                                          \
+        return getParam().get1().NAME(name, sub_idx);                                              \
+    }
+
+GDT_RESET_IMPL_(resetBool)
+GDT_RESET_IMPL_(resetS32)
+GDT_RESET_IMPL_(resetF32)
+GDT_RESET_IMPL_(resetStr)
+GDT_RESET_IMPL_(resetStr64)
+GDT_RESET_IMPL_(resetStr256)
+GDT_RESET_IMPL_(resetVec2f)
+GDT_RESET_IMPL_(resetVec3f)
+GDT_RESET_IMPL_(resetVec4f)
+
+#undef GDT_RESET_IMPL_
+
+void Manager::incrementS32NoCheck(s32 value, const sead::SafeString& name) {
+    if (mBitFlags.isOn(BitFlag::_40000))
+        return;
+
+    if (mBitFlags.isOn(BitFlag::_10000)) {
+        s32 current = 0;
+        if (getParamBypassPerm().get().getS32(&current, name))
+            setS32NoCheck(current + value, name);
+    } else if (mIncreaseLogger) {
+        mIncreaseLogger->addRecord(value, name, -1, true);
+    }
+}
+
+void Manager::incrementS32(s32 value, const sead::SafeString& name) {
+    if (mBitFlags.isOn(BitFlag::_40000))
+        return;
+
+    if (mBitFlags.isOn(BitFlag::_10000)) {
+        s32 current = 0;
+        if (getParam().get().getS32(&current, name))
+            setS32(current + value, name);
+    } else if (mIncreaseLogger) {
+        mIncreaseLogger->addRecord(value, name, -1, false);
+    }
+}
+
 void Manager::IncreaseLogger::addRecord(s32 value, const sead::SafeString& name, s32 sub_idx,
                                         bool debug) {
     const u32 name_hash = sead::HashCRC32::calcStringHash(name);
@@ -155,4 +544,14 @@ void Manager::IncreaseLogger::addRecord(s32 value, const sead::SafeString& name,
     ring_buffers[0][platform_core_id].pushBack(record);
 }
 
+bool Manager::wasFlagCopied(const sead::SafeString& name) {
+    bool value;
+    return getParam().get().getBuffer()->getBoolIfCopied(&value, name, false, true) && value != 0;
+}
+
+bool Manager::wasFlagNotCopied(const sead::SafeString& name) {
+    bool value;
+    return getParam().get().getBuffer()->getBoolIfCopied(&value, name, false, true) && !value;
+}
+
 }  // namespace ksys::gdt
diff --git a/src/KingSystem/GameData/gdtManager.h b/src/KingSystem/GameData/gdtManager.h
index 24f9841e..8fb83661 100644
--- a/src/KingSystem/GameData/gdtManager.h
+++ b/src/KingSystem/GameData/gdtManager.h
@@ -334,16 +334,11 @@ public:
         auto& ref = debug ? getParamBypassPerm() : getParam();                                     \
         return ref.get().NAME(value, name, force);                                                 \
     }                                                                                              \
-    [[gnu::noinline]] bool NAME(TRAITS::ArgType value, const sead::SafeString& name) {             \
-        return NAME(value, name, false, false);                                                    \
-    }                                                                                              \
-    [[gnu::noinline]] bool NAME##NoCheck(TRAITS::ArgType value, const sead::SafeString& name) {    \
-        return NAME(value, name, true, false);                                                     \
-    }                                                                                              \
-    [[gnu::noinline]] bool NAME##NoCheckForce(TRAITS::NoCheckForceArgType value,                   \
-                                              const sead::SafeString& name) {                      \
-        return NAME(value, name, true, true);                                                      \
-    }                                                                                              \
+    bool NAME(TRAITS::ArgType value, const sead::SafeString& name);                                \
+    bool NAME##_(TRAITS::ArgType value, const sead::SafeString& name);                             \
+    bool NAME##NoCheck(TRAITS::ArgType value, const sead::SafeString& name);                       \
+    bool NAME##NoCheck_(TRAITS::ArgType value, const sead::SafeString& name);                      \
+    bool NAME##NoCheckForce(TRAITS::NoCheckForceArgType value, const sead::SafeString& name);      \
     /* Setters for arrays (by name) */                                                             \
     KSYS_ALWAYS_INLINE bool NAME(TRAITS::ArgType value, const sead::SafeString& name, bool debug,  \
                                  bool force, s32 sub_idx) {                                        \
@@ -352,18 +347,11 @@ public:
         auto& ref = debug ? getParamBypassPerm() : getParam();                                     \
         return ref.get().NAME(value, name, sub_idx, force);                                        \
     }                                                                                              \
-    [[gnu::noinline]] bool NAME(TRAITS::ArgType value, const sead::SafeString& name,               \
-                                s32 sub_idx) {                                                     \
-        return NAME(value, name, false, false, sub_idx);                                           \
-    }                                                                                              \
-    [[gnu::noinline]] bool NAME##NoCheck(TRAITS::ArgType value, const sead::SafeString& name,      \
-                                         s32 sub_idx) {                                            \
-        return NAME(value, name, true, false, sub_idx);                                            \
-    }                                                                                              \
-    [[gnu::noinline]] bool NAME##NoCheckForce(TRAITS::NoCheckForceArgType value,                   \
-                                              const sead::SafeString& name, s32 sub_idx) {         \
-        return NAME(value, name, true, true, sub_idx);                                             \
-    }                                                                                              \
+    bool NAME(TRAITS::ArgType value, const sead::SafeString& name, s32 sub_idx);                   \
+    bool NAME##_(TRAITS::ArgType value, const sead::SafeString& name, s32 sub_idx);                \
+    bool NAME##NoCheck(TRAITS::ArgType value, const sead::SafeString& name, s32 sub_idx);          \
+    bool NAME##NoCheckForce(TRAITS::NoCheckForceArgType value, const sead::SafeString& name,       \
+                            s32 sub_idx);                                                          \
                                                                                                    \
     bool NAME(TRAITS::WrapperArgType value, FlagHandle handle, bool debug) {                       \
         if (debug) {                                                                               \
@@ -418,6 +406,9 @@ public:
 #undef GDT_SET_
 
 #define GDT_RESET_(NAME)                                                                           \
+    bool NAME(const sead::SafeString& name);                                                       \
+    bool NAME##_(const sead::SafeString& name);                                                    \
+    bool NAME(const sead::SafeString& name, int sub_idx);                                          \
     KSYS_ALWAYS_INLINE bool NAME##_(FlagHandle handle, bool debug) {                               \
         if (mBitFlags.isOn(BitFlag::_40000))                                                       \
             return false;                                                                          \
@@ -466,6 +457,9 @@ public:
 
 #undef GDT_RESET_
 
+    void incrementS32NoCheck(s32 value, const sead::SafeString& name);
+    void incrementS32(s32 value, const sead::SafeString& name);
+
     void increaseS32CommonFlag(s32 value, const sead::SafeString& name, s32 sub_idx, bool debug) {
         if (!mIncreaseLogger)
             return;
@@ -475,16 +469,27 @@ public:
             onChangedByDebug();
     }
 
+    bool wasFlagCopied(const sead::SafeString& name);
+    bool wasFlagNotCopied(const sead::SafeString& name);
+
     void init(sead::Heap* heap, sead::Framework* framework);
 
     void addReinitCallback(ReinitSignal::Slot& slot);
     void removeReinitCallback(ReinitSignal::Slot& slot);
 
+    void setCurrentRupeeFlagName(const sead::SafeString& name);
+    void requestResetAllFlagsToInitial();
+
+    /// Checks whether quest flags (e.g. Kass shrine quest flags) are set or cleared properly
+    /// and takes any action necessary to fix them.
+    void fixQuestFlags();
+    void fixQuestFlagsDlc2();
+
 private:
     enum class BitFlag {
         _1 = 0x1,
         _2 = 0x2,
-        _4 = 0x4,
+        RequestResetAllFlagsToInitial = 0x4,
         _8 = 0x8,
         _10 = 0x10,
         _20 = 0x20,
diff --git a/src/KingSystem/GameData/gdtTriggerParam.cpp b/src/KingSystem/GameData/gdtTriggerParam.cpp
index 2c6ba5a2..951031ee 100644
--- a/src/KingSystem/GameData/gdtTriggerParam.cpp
+++ b/src/KingSystem/GameData/gdtTriggerParam.cpp
@@ -1459,7 +1459,7 @@ SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec4f, getVec4fArrayIdx, cons
     }
 
 #define RESET_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, FLAGS, GET_IDX_FN)                            \
-    bool FUNCTION_NAME(const sead::SafeString& name, bool check_permissions) {                     \
+    bool FUNCTION_NAME(const sead::SafeString& name, bool check_permissions, bool) {               \
         return FUNCTION_NAME(GET_IDX_FN(name), check_permissions);                                 \
     }
 
@@ -1491,7 +1491,7 @@ SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec4f, getVec4fArrayIdx, cons
     }
 
 #define RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, FLAGS, GET_IDX_FN)                      \
-    bool FUNCTION_NAME(const sead::SafeString& name, s32 sub_idx, bool check_permissions) {        \
+    bool FUNCTION_NAME(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool) {  \
         return FUNCTION_NAME(GET_IDX_FN(name), sub_idx, check_permissions);                        \
     }
 
diff --git a/src/KingSystem/GameData/gdtTriggerParam.h b/src/KingSystem/GameData/gdtTriggerParam.h
index 9a4c6fd3..0264e919 100644
--- a/src/KingSystem/GameData/gdtTriggerParam.h
+++ b/src/KingSystem/GameData/gdtTriggerParam.h
@@ -346,15 +346,15 @@ public:
     bool resetVec3f(s32 idx, bool check_permissions);
     bool resetVec4f(s32 idx, bool check_permissions);
 
-    bool resetBool(const sead::SafeString& name, bool check_permissions);
-    bool resetS32(const sead::SafeString& name, bool check_permissions);
-    bool resetF32(const sead::SafeString& name, bool check_permissions);
-    bool resetStr(const sead::SafeString& name, bool check_permissions);
-    bool resetStr64(const sead::SafeString& name, bool check_permissions);
-    bool resetStr256(const sead::SafeString& name, bool check_permissions);
-    bool resetVec2f(const sead::SafeString& name, bool check_permissions);
-    bool resetVec3f(const sead::SafeString& name, bool check_permissions);
-    bool resetVec4f(const sead::SafeString& name, bool check_permissions);
+    bool resetBool(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetS32(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetF32(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetStr(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetStr64(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetStr256(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetVec2f(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetVec3f(const sead::SafeString& name, bool check_permissions, bool = true);
+    bool resetVec4f(const sead::SafeString& name, bool check_permissions, bool = true);
 
     // endregion
 
@@ -370,15 +370,16 @@ public:
     bool resetVec3f(s32 idx, s32 sub_idx, bool check_permissions);
     bool resetVec4f(s32 idx, s32 sub_idx, bool check_permissions);
 
-    bool resetBool(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetS32(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetF32(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetStr(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetStr64(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetStr256(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetVec2f(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetVec3f(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
-    bool resetVec4f(const sead::SafeString& name, s32 sub_idx, bool check_permissions);
+    bool resetBool(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
+    bool resetS32(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
+    bool resetF32(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
+    bool resetStr(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
+    bool resetStr64(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
+    bool resetStr256(const sead::SafeString& name, s32 sub_idx, bool check_permissions,
+                     bool = true);
+    bool resetVec2f(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
+    bool resetVec3f(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
+    bool resetVec4f(const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool = true);
 
     // endregion