diff --git a/data/uking_functions.csv b/data/uking_functions.csv
index a3aea111..75adf6ac 100644
--- a/data/uking_functions.csv
+++ b/data/uking_functions.csv
@@ -241,7 +241,7 @@
 0x0000007100004194,DamageMgrBow::m52,8,
 0x000000710000419c,DamageMgrBow::m53,8,
 0x00000071000041a4,nullsub_40,4,
-0x00000071000041a8,_ZN4sead19FixedSafeStringBaseIcLi64EED0Ev,8,
+0x00000071000041a8,x,8,
 0x00000071000041b0,sub_71000041B0,372,
 0x0000007100004324,_ZNK4sead15RuntimeTypeInfo6DeriveINS_13ControlDeviceEE9isDerivedEPKNS0_9InterfaceE,140,
 0x00000071000043b0,sub_71000043B0,140,
@@ -395,10 +395,10 @@
 0x000000710000a9dc,sub_710000A9DC,40,
 0x000000710000aa04,sub_710000AA04,8,
 0x000000710000aa0c,_ZThn8_N3agl6detail20GPUMemBlockMgrHeapExD0Ev,40,
-0x000000710000aa34,j__ZdlPv_1,4,
-0x000000710000aa38,sead::SafeStringX::assign,240,
-0x000000710000ab28,j__ZdlPv_2,4,
-0x000000710000ab2c,_ZN4sead15FixedSafeStringILi64EEaSERKNS_14SafeStringBaseIcEE,240,
+0x000000710000aa34,j__ZdlPv_1,4,_ZN4sead15FixedSafeStringILi64EED0Ev
+0x000000710000aa38,sead::SafeStringX::assign,240,_ZN4sead15FixedSafeStringILi64EEaSERKNS_14SafeStringBaseIcEE
+0x000000710000ab28,j__ZdlPv_2,4,_ZN4sead19FixedSafeStringBaseIcLi64EED0Ev
+0x000000710000ab2c,_ZN4sead19FixedSafeStringBaseIcLi64EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead19FixedSafeStringBaseIcLi64EEaSERKNS_14SafeStringBaseIcEE
 0x000000710000ac1c,j__ZdlPv_3,4,
 0x000000710000ac20,sub_710000AC20,140,
 0x000000710000acac,sub_710000ACAC,372,
@@ -437,7 +437,7 @@
 0x000000710000ded8,sub_710000DED8,1412,
 0x000000710000e45c,Dragon::m78,164,
 0x000000710000e500,sub_710000E500,756,
-0x000000710000e7f4,_ZN4sead15FixedSafeStringILi128EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi16EEaSERKNS_14SafeStringBaseIcEE
+0x000000710000e7f4,xxx,240,_ZN4sead15FixedSafeStringILi16EEaSERKNS_14SafeStringBaseIcEE
 0x000000710000e8e4,sub_710000E8E4,420,
 0x000000710000ea88,sub_710000EA88,456,
 0x000000710000ec50,sub_710000EC50,84,
@@ -490,8 +490,8 @@
 0x0000007100011f30,sub_7100011F30,200,
 0x0000007100011ff8,sub_7100011FF8,192,
 0x00000071000120b8,sub_71000120B8,200,
-0x0000007100012180,j__ZdlPv_4,4,
-0x0000007100012184,_ZN4sead15FixedSafeStringILi20EEaSERKNS_14SafeStringBaseIcEE_0,240,
+0x0000007100012180,j__ZdlPv_4,4,_ZN4sead15FixedSafeStringILi32EED0Ev
+0x0000007100012184,_ZN4sead15FixedSafeStringILi32EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi32EEaSERKNS_14SafeStringBaseIcEE
 0x0000007100012274,sub_7100012274,20,
 0x0000007100012288,j__ZdlPv_5,4,
 0x000000710001228c,sub_710001228C,8,
@@ -504,8 +504,8 @@
 0x000000710001260c,j__ZdlPv_6,4,_ZN4sead15FixedSafeStringILi16EED0Ev
 0x0000007100012610,_ZNK4sead14SafeStringBaseIcE9findIndexERKS1_,468,_ZNK4sead14SafeStringBaseIcE9findIndexERKS1_
 0x00000071000127e4,_ZN4sead18Matrix34CalcCommonIfE7inverseERNS_9BaseMtx34IfEERKS3_,336,
-0x0000007100012934,j__ZdlPv_7,4,
-0x0000007100012938,xxxx,240,
+0x0000007100012934,j__ZdlPv_7,4,_ZN4sead21FormatFixedSafeStringILi128EED0Ev
+0x0000007100012938,_ZN4sead15FixedSafeStringILi128EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi128EEaSERKNS_14SafeStringBaseIcEE
 0x0000007100012a28,sub_7100012A28,600,
 0x0000007100012c80,Enemy::construct,68,
 0x0000007100012cc4,sub_7100012CC4,44,
@@ -619,7 +619,7 @@
 0x000000710001b1b8,nullsub_53,4,
 0x000000710001b1bc,_ZNK4sead15RuntimeTypeInfo6DeriveINS_6CameraEE9isDerivedEPKNS0_9InterfaceE,140,
 0x000000710001b248,j__ZdlPv_11,4,
-0x000000710001b24c,_ZN4sead19FixedSafeStringBaseIcLi64EEaSERKNS_14SafeStringBaseIcEE,240,
+0x000000710001b24c,x,240,
 0x000000710001b33c,sub_710001B33C,88,
 0x000000710001b394,sub_710001B394,96,
 0x000000710001b3f4,sub_710001B3F4,40,
@@ -2393,10 +2393,10 @@
 0x000000710007fd84,_ZN4sead10FileHandleD0Ev,64,_ZN4sead10FileHandleD0Ev
 0x000000710007fdc4,sub_710007FDC4,140,
 0x000000710007fe50,sub_710007FE50,372,
-0x000000710007ffc4,j__ZdlPv_29,4,
-0x000000710007ffc8,_ZN4sead19FixedSafeStringBaseIcLi128EEaSERKNS_14SafeStringBaseIcEE,240,
-0x00000071000800b8,j__ZdlPv_30,4,
-0x00000071000800bc,_ZN4sead15FixedSafeStringILi256EEaSERKNS_14SafeStringBaseIcEE,240,
+0x000000710007ffc4,j__ZdlPv_29,4,_ZN4sead15FixedSafeStringILi256EED0Ev
+0x000000710007ffc8,_ZN4sead15FixedSafeStringIcLi256EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi256EEaSERKNS_14SafeStringBaseIcEE
+0x00000071000800b8,j__ZdlPv_30,4,_ZN4sead19FixedSafeStringBaseIcLi256EED0Ev
+0x00000071000800bc,_ZN4sead19FixedSafeStringBaseIcLi256EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead19FixedSafeStringBaseIcLi256EEaSERKNS_14SafeStringBaseIcEE
 0x00000071000801ac,_ZN4sead18HeapSafeStringBaseIcED0Ev,60,
 0x00000071000801e8,j__ZdlPv_31,4,
 0x00000071000801ec,_ZN4sead15FixedSafeStringILi32EEaSERKNS_14SafeStringBaseIcEE,240,
@@ -6792,8 +6792,8 @@
 0x000000710011ffbc,_ZNK5uking6action28EventPlayUiOneTimeAnimAction27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE,288,_ZNK5uking6action28EventPlayUiOneTimeAnimAction27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
 0x00000071001200dc,_ZNK5uking6action28EventPlayUiOneTimeAnimAction18getRuntimeTypeInfoEv,92,_ZNK5uking6action28EventPlayUiOneTimeAnimAction18getRuntimeTypeInfoEv
 0x0000007100120138,j__ZdlPv_46,4,
-0x000000710012013c,j__ZdlPv_47,4,
-0x0000007100120140,_ZN4sead19FixedSafeStringBaseIcLi155EEaSERKNS_14SafeStringBaseIcEE,240,
+0x000000710012013c,j__ZdlPv_47,4,_ZN4sead19FixedSafeStringBaseIcLi32EED0Ev
+0x0000007100120140,_ZN4sead19FixedSafeStringBaseIcLi32EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead19FixedSafeStringBaseIcLi32EEaSERKNS_14SafeStringBaseIcEE
 0x0000007100120230,AI_Action_EventPlayUiOPTextAction::ctor,56,
 0x0000007100120268,_ZN5uking6action23EventPlayUiOPTextActionD1Ev,20,_ZN5uking6action23EventPlayUiOPTextActionD1Ev
 0x000000710012027c,_ZN5uking6action23EventPlayUiOPTextActionD0Ev,52,_ZN5uking6action23EventPlayUiOPTextActionD0Ev
@@ -28503,7 +28503,7 @@
 0x0000007100480840,j__ZdlPv_112,4,
 0x0000007100480844,_ZN4sead15FixedSafeStringILi512EEaSERKNS_14SafeStringBaseIcEE,240,
 0x0000007100480934,j__ZdlPv_113,4,
-0x0000007100480938,_ZN4sead19FixedSafeStringBaseIcLi256EEaSERKNS_14SafeStringBaseIcEE,240,
+0x0000007100480938,x,240,
 0x0000007100480a28,AI_AI_LeaveFromTarget::ctor,52,_ZN5uking2ai15LeaveFromTargetC1ERKN4ksys3act2ai10ActionBase7InitArgE
 0x0000007100480a5c,_ZN5uking2ai15LeaveFromTargetD1Ev,4,_ZN5uking2ai15LeaveFromTargetD1Ev
 0x0000007100480a60,_ZN5uking2ai15LeaveFromTargetD0Ev,36,_ZN5uking2ai15LeaveFromTargetD0Ev
@@ -76059,37 +76059,37 @@
 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,
-0x0000007100dd2f00,getShopInfoByHash,140,
+0x0000007100dd2d20,GameDataMgr::copyParamToParam1,28,_ZN4ksys3gdt7Manager17copyParamToParam1Ev
+0x0000007100dd2d3c,GameDataMgr::getBoolIdxForMapUnitObject,272,_ZN4ksys3gdt7Manager20getRevivalFlagHandleERKN4sead14SafeStringBaseIcEERKNS_3map9MubinIterE
+0x0000007100dd2e4c,GameDataMgr::allocParam1,180,_ZN4ksys3gdt7Manager11allocParam1Ev
+0x0000007100dd2f00,getShopInfoByHash,140,_ZN4ksys3gdt7Manager15getShopInfoIterEjPN2al9ByamlIterERKS3_PKj
 0x0000007100dd2f8c,GameDataMgr::resetBoolFlagForRadarMgr,208,
-0x0000007100dd305c,allocRetryBuffer,176,
-0x0000007100dd310c,GameDataMgr::destroyTriggerParamC08IfNeeded,52,
-0x0000007100dd3140,GameDataMgr::syncData,368,
-0x0000007100dd32b0,GameDataMgr::syncStart,1084,
-0x0000007100dd36ec,GameDataMgr::syncDataX,8392,
-0x0000007100dd57b4,sub_7100DD57B4,8,
-0x0000007100dd57bc,GameDataMgr::syncStartOnLoadEnd,136,
-0x0000007100dd5844,sub_7100DD5844,752,
-0x0000007100dd5b34,GameDataMgr::doSyncDataBool,368,
-0x0000007100dd5ca4,GameDataMgr::doSyncDataS32,368,
-0x0000007100dd5e14,GameDataMgr::doSyncDataF32,368,
-0x0000007100dd5f84,GameDataMgr::doSyncDataString,616,
-0x0000007100dd61ec,GameDataMgr::doSyncDataString64,616,
-0x0000007100dd6454,GameDataMgr::doSyncDataString256,616,
-0x0000007100dd66bc,GameDataMgr::doSyncDataVec2f,568,
-0x0000007100dd68f4,GameDataMgr::doSyncDataVec3f,568,
-0x0000007100dd6b2c,GameDataMgr::doSyncDataVec4f,568,
-0x0000007100dd6d64,GameDataMgr::doSyncDataBoolArray,388,
-0x0000007100dd6ee8,GameDataMgr::doSyncDataS32Array,352,
-0x0000007100dd7048,GameDataMgr::doSyncDataF32Array,352,
-0x0000007100dd71a8,GameDataMgr::doSyncDataStringArray,584,
-0x0000007100dd73f0,GameDataMgr::doSyncDataString64Array,584,
-0x0000007100dd7638,GameDataMgr::doSyncDataString256Array,584,
-0x0000007100dd7880,GameDataMgr::doSyncDataVec2fArray,528,
-0x0000007100dd7a90,GameDataMgr::doSyncDataVec3fArray,528,
-0x0000007100dd7ca0,GameDataMgr::doSyncDataVec4fArray,528,
+0x0000007100dd305c,allocRetryBuffer,176,_ZN4ksys3gdt7Manager16allocRetryBufferEPN4sead4HeapE
+0x0000007100dd310c,GameDataMgr::destroyTriggerParamC08IfNeeded,52,_ZN4ksys3gdt7Manager18destroyRetryBufferEv
+0x0000007100dd3140,GameDataMgr::syncData,368,_ZN4ksys3gdt7Manager8syncDataEPKc
+0x0000007100dd32b0,GameDataMgr::syncStart,1084,_ZN4ksys3gdt7Manager9syncStartEv
+0x0000007100dd36ec,GameDataMgr::syncDataX,8392,_ZN4ksys3gdt7Manager10syncUpdateEPKc!
+0x0000007100dd57b4,sub_7100DD57B4,8,_ZThn8_N4ksys3gdt7Manager8syncDataEPKc
+0x0000007100dd57bc,GameDataMgr::syncStartOnLoadEnd,136,_ZN4ksys3gdt7Manager18startSyncOnLoadEndEv
+0x0000007100dd5844,sub_7100DD5844,752,_ZN4ksys3gdt7Manager11parseFloatsERKN4sead14SafeStringBaseIcEEPfj
+0x0000007100dd5b34,GameDataMgr::doSyncDataBool,368,_ZN4ksys3gdt7Manager11doSyncArrayIbEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKc
+0x0000007100dd5ca4,GameDataMgr::doSyncDataS32,368,_ZN4ksys3gdt7Manager11doSyncArrayIiEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKc
+0x0000007100dd5e14,GameDataMgr::doSyncDataF32,368,_ZN4ksys3gdt7Manager11doSyncArrayIfEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKc
+0x0000007100dd5f84,GameDataMgr::doSyncDataString,616,_ZN4ksys3gdt7Manager14doSyncArrayStrILi32EEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKcj
+0x0000007100dd61ec,GameDataMgr::doSyncDataString64,616,_ZN4ksys3gdt7Manager14doSyncArrayStrILi64EEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKcj
+0x0000007100dd6454,GameDataMgr::doSyncDataString256,616,_ZN4ksys3gdt7Manager14doSyncArrayStrILi256EEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKcj
+0x0000007100dd66bc,GameDataMgr::doSyncDataVec2f,568,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector2IfEEEEvRKNS3_8PtrArrayINS0_8FlagBaseEEEPhPKcj
+0x0000007100dd68f4,GameDataMgr::doSyncDataVec3f,568,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector3IfEEEEvRKNS3_8PtrArrayINS0_8FlagBaseEEEPhPKcj
+0x0000007100dd6b2c,GameDataMgr::doSyncDataVec4f,568,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector4IfEEEEvRKNS3_8PtrArrayINS0_8FlagBaseEEEPhPKcj
+0x0000007100dd6d64,GameDataMgr::doSyncDataBoolArray,388,_ZN4ksys3gdt7Manager11doSyncArrayIbEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKc
+0x0000007100dd6ee8,GameDataMgr::doSyncDataS32Array,352,_ZN4ksys3gdt7Manager11doSyncArrayIiEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKc
+0x0000007100dd7048,GameDataMgr::doSyncDataF32Array,352,_ZN4ksys3gdt7Manager11doSyncArrayIfEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKc
+0x0000007100dd71a8,GameDataMgr::doSyncDataStringArray,584,_ZN4ksys3gdt7Manager14doSyncArrayStrILi32EEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKcj
+0x0000007100dd73f0,GameDataMgr::doSyncDataString64Array,584,_ZN4ksys3gdt7Manager14doSyncArrayStrILi64EEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKcj
+0x0000007100dd7638,GameDataMgr::doSyncDataString256Array,584,_ZN4ksys3gdt7Manager14doSyncArrayStrILi256EEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKcj
+0x0000007100dd7880,GameDataMgr::doSyncDataVec2fArray,528,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector2IfEEEEvRKNS3_8PtrArrayINS6_INS0_8FlagBaseEEEEEPhPKcj
+0x0000007100dd7a90,GameDataMgr::doSyncDataVec3fArray,528,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector3IfEEEEvRKNS3_8PtrArrayINS6_INS0_8FlagBaseEEEEEPhPKcj
+0x0000007100dd7ca0,GameDataMgr::doSyncDataVec4fArray,528,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector4IfEEEEvRKNS3_8PtrArrayINS6_INS0_8FlagBaseEEEEEPhPKcj
 0x0000007100dd7eb0,GameDataMgr::getName,12,_ZNK4ksys3gdt7Manager7getNameEv
 0x0000007100dd7ebc,sub_7100DD7EBC,12,_ZThn8_NK4ksys3gdt7Manager7getNameEv
 0x0000007100dd7ec8,j__ZdlPv_893,4,_ZN4ksys3gdt15TriggerParamRefD0Ev
@@ -79185,7 +79185,7 @@
 0x0000007100e8de68,sub_7100E8DE68,40,
 0x0000007100e8de90,sub_7100E8DE90,40,
 0x0000007100e8deb8,MapConst::m1,64,
-0x0000007100e8def8,_ZN4sead15FixedSafeStringILi64EED0Ev,68,
+0x0000007100e8def8,x,68,
 0x0000007100e8df3c,sub_7100E8DF3C,68,
 0x0000007100e8df80,MapConst::m18,8,
 0x0000007100e8df88,nullsub_4002,4,
diff --git a/lib/sead b/lib/sead
index dfbcf903..9ac7ac68 160000
--- a/lib/sead
+++ b/lib/sead
@@ -1 +1 @@
-Subproject commit dfbcf903b8543c5f85fe166eaf8d4bc92c9c93ba
+Subproject commit 9ac7ac68fb0cd1adbb62fb2bfb52d56db3c5cc90
diff --git a/src/KingSystem/GameData/gdtManager.cpp b/src/KingSystem/GameData/gdtManager.cpp
index d46b0745..7597cc49 100644
--- a/src/KingSystem/GameData/gdtManager.cpp
+++ b/src/KingSystem/GameData/gdtManager.cpp
@@ -1,18 +1,24 @@
 #include "KingSystem/GameData/gdtManager.h"
 #include <algorithm>
+#include <cstring>
 #include <devenv/seadEnvUtil.h>
 #include <framework/seadFramework.h>
 #include <mc/seadCoreInfo.h>
+#include <prim/seadStringUtil.h>
 #include <thread/seadThreadUtil.h>
 #include <time/seadTickTime.h>
+#include <type_traits>
 #include "Game/DLC/aocManager.h"
 #include "KingSystem/GameData/gdtSaveMgr.h"
 #include "KingSystem/GameData/gdtTriggerParam.h"
+#include "KingSystem/Map/mapMubinIter.h"
 #include "KingSystem/Resource/resEntryFactory.h"
 #include "KingSystem/Resource/resResourceGameData.h"
 #include "KingSystem/Resource/resSystem.h"
+#include "KingSystem/System/OverlayArenaSystem.h"
 #include "KingSystem/Utils/HeapUtil.h"
 #include "KingSystem/Utils/InitTimeInfo.h"
+#include "KingSystem/Utils/SafeDelete.h"
 
 namespace ksys::gdt {
 
@@ -554,4 +560,673 @@ bool Manager::wasFlagNotCopied(const sead::SafeString& name) {
     return getParam().get().getBuffer()->getBoolIfCopied(&value, name, false, true) && !value;
 }
 
+void Manager::copyParamToParam1() {
+    mFlagBuffer1->copyChangedFlags(*mFlagBuffer, true, false, false);
+}
+
+FlagHandle Manager::getRevivalFlagHandle(const sead::SafeString& object_name,
+                                         const map::MubinIter& iter) {
+    if (mBitFlags.isOn(BitFlag::_40000))
+        return InvalidHandle;
+
+    const sead::SafeString& map_name =
+        mGetMapNameDelegate ? mGetMapNameDelegate->invoke() : sead::SafeString::cEmptyString;
+
+    u32 hash_id = 0;
+    iter.tryGetParamUIntByKey(&hash_id, "HashId");
+
+    sead::FormatFixedSafeString<128> flag_name("%s_%s_%u", map_name.cstr(), object_name.cstr(),
+                                               hash_id);
+    if (mBitFlags.isOn(BitFlag::_2000))
+        return InvalidHandle;
+    return getBoolHandle(flag_name);
+}
+
+void Manager::allocParam1() {
+    auto* parent_heap = OverlayArenaSystem::instance()->getGameDataWorkHeap();
+    auto* heap = util::tryCreateDualHeap(0, "param1", parent_heap, nullptr,
+                                         sead::Heap::cHeapDirection_Forward, false);
+    mFlagBuffer1 = new (heap) TriggerParam;
+    mFlagBuffer1->copyAllFlags(*mFlagBuffer, heap, true);
+    heap->adjust();
+}
+
+bool Manager::getShopInfoIter(u32 hash, al::ByamlIter* out, const al::ByamlIter& iter,
+                              const u32* hashes) {
+    int a = 0;
+    int b = iter.getSize();
+    while (a < b) {
+        const auto m = (a + b) / 2;
+        if (hashes[m] == hash)
+            return iter.tryGetIterByIndex(out, m);
+        if (hashes[m] < hash)
+            a = m + 1;
+        else
+            b = m;
+    }
+    return false;
+}
+
+void Manager::allocRetryBuffer(sead::Heap* heap) {
+    if (mRetryBuffer)
+        return;
+
+    auto* buffer_heap = util::tryCreateDualHeap(0x100000, "RetryBuffer", heap, nullptr,
+                                                sead::Heap::cHeapDirection_Reverse, false);
+    mRetryBuffer = new (buffer_heap) TriggerParam;
+    mRetryBuffer->copyPermanentFlags(*mFlagBuffer1, buffer_heap);
+    buffer_heap->adjust();
+}
+
+void Manager::destroyRetryBuffer() {
+    if (mBitFlags.isOn(BitFlag::_80000))
+        return;
+
+    if (mRetryBuffer) {
+        mRetryBuffer->destroyHeap();
+        mRetryBuffer = nullptr;
+    }
+}
+
+void Manager::syncData(const char* data) {
+    const sead::SafeString cmd = data;
+    if (cmd.compare("SyncStart") == 0) {
+        if (util::getDebugHeap()) {
+            if (mBitFlags.testAndClear(BitFlag::_100)) {
+                mSyncStep = 0;
+            }
+            mBitFlags.set(BitFlag::_200);
+            syncStart();
+        }
+    } else if (cmd.compare("SyncEnd") == 0) {
+        mSyncStep = 0;
+        mBitFlags.reset(BitFlag::_100);
+        mBitFlags.reset(BitFlag::_200);
+    } else {
+        syncUpdate(data);
+        onChangedByDebug();
+    }
+}
+
+constexpr size_t ComBufferSize = 0x1a000;
+
+void Manager::syncStart() {
+    if (KingEditor::instance()->get88() == 0 || util::getDebugHeap() == nullptr)
+        return;
+
+    if (mGameDataComHeap) {
+        if (mGameDataComHeap->getFreeSize() < ComBufferSize)
+            return;
+    } else {
+        mGameDataComHeap =
+            sead::ExpHeap::tryCreate(ComBufferSize + 0x400, "GameDataCom", util::getDebugHeap(),
+                                     sizeof(void*), sead::Heap::cHeapDirection_Forward, false);
+        if (!mGameDataComHeap)
+            return;
+    }
+
+    u8* buffer = new (mGameDataComHeap) u8[ComBufferSize];
+    auto* flag_buffer = mFlagBuffer;
+    const int step = mSyncStep;
+    switch (mSyncStep) {
+    case 0:
+        doSyncArray<bool>(flag_buffer->mBoolFlags, buffer, "[SyncData][AllData][bool]");
+        mSyncStep = step + 1;
+        break;
+    case 1:
+        doSyncArray<s32>(flag_buffer->mS32Flags, buffer, "[SyncData][AllData][s32]");
+        mSyncStep = step + 1;
+        break;
+    case 2:
+        doSyncArray<f32>(flag_buffer->mF32Flags, buffer, "[SyncData][AllData][f32]");
+        mSyncStep = step + 1;
+        break;
+    case 3:
+        doSyncArrayStr<32>(flag_buffer->mStringFlags, buffer, "[SyncData][AllData][string]");
+        mSyncStep = step + 1;
+        break;
+    case 4:
+        doSyncArrayStr<64>(flag_buffer->mString64Flags, buffer, "[SyncData][AllData][string64]");
+        mSyncStep = step + 1;
+        break;
+    case 5:
+        doSyncArrayStr<256>(flag_buffer->mString256Flags, buffer, "[SyncData][AllData][string256]");
+        mSyncStep = step + 1;
+        break;
+    case 6:
+        doSyncArrayVec<sead::Vector2f>(flag_buffer->mVector2fFlags, buffer,
+                                       "[SyncData][AllData][vector2f]", 2);
+        mSyncStep = step + 1;
+        break;
+    case 7:
+        doSyncArrayVec<sead::Vector3f>(flag_buffer->mVector3fFlags, buffer,
+                                       "[SyncData][AllData][vector3f]", 3);
+        mSyncStep = step + 1;
+        break;
+    case 8:
+        doSyncArrayVec<sead::Vector4f>(flag_buffer->mVector4fFlags, buffer,
+                                       "[SyncData][AllData][vector4f]", 4);
+        mSyncStep = step + 1;
+        break;
+    case 9:
+        doSyncArray<bool>(flag_buffer->mBoolArrayFlags, buffer, "[SyncData][AllData][boolarray]");
+        mSyncStep = step + 1;
+        break;
+    case 10:
+        doSyncArray<s32>(flag_buffer->mS32ArrayFlags, buffer, "[SyncData][AllData][s32array]");
+        mSyncStep = step + 1;
+        break;
+    case 11:
+        doSyncArray<f32>(flag_buffer->mF32ArrayFlags, buffer, "[SyncData][AllData][f32array]");
+        mSyncStep = step + 1;
+        break;
+    case 12:
+        doSyncArrayStr<32>(flag_buffer->mStringArrayFlags, buffer,
+                           "[SyncData][AllData][stringarray]");
+        mSyncStep = step + 1;
+        break;
+    case 13:
+        doSyncArrayStr<64>(flag_buffer->mString64ArrayFlags, buffer,
+                           "[SyncData][AllData][string64array]");
+        mSyncStep = step + 1;
+        break;
+    case 14:
+        doSyncArrayStr<256>(flag_buffer->mString256ArrayFlags, buffer,
+                            "[SyncData][AllData][string256array]");
+        mSyncStep = step + 1;
+        break;
+    case 15:
+        doSyncArrayVec<sead::Vector2f>(flag_buffer->mVector2fArrayFlags, buffer,
+                                       "[SyncData][AllData][vector2farray]", 2);
+        mSyncStep = step + 1;
+        break;
+    case 16:
+        doSyncArrayVec<sead::Vector3f>(flag_buffer->mVector3fArrayFlags, buffer,
+                                       "[SyncData][AllData][vector3farray]", 3);
+        mSyncStep = step + 1;
+        break;
+    case 17:
+        doSyncArrayVec<sead::Vector4f>(flag_buffer->mVector4fArrayFlags, buffer,
+                                       "[SyncData][AllData][vector4farray]", 4);
+        mSyncStep = step + 1;
+        break;
+    default:
+        KingEditor::instance()->log(getName(), "[SendAllData]");
+        mBitFlags.reset(BitFlag::SyncFlags);
+        mBitFlags.set(BitFlag::_100);
+        break;
+    }
+    util::safeDeleteArray(buffer);
+}
+
+// NON_MATCHING: recordFlagChange calls not being merged, or merged in the wrong way
+void Manager::syncUpdate(const char* data) {
+    const sead::SafeString cmd = data;
+    auto it = cmd.tokenBegin("|");
+    const auto end = cmd.tokenEnd("|");
+    if (it == end)
+        return;
+
+    sead::FixedSafeString<256> name;
+    it.getAndForward(&name);
+
+    sead::FixedSafeString<256> type;
+    it.getAndForward(&type);
+
+    sead::FixedSafeString<256> value;
+    it.getAndForward(&value);
+
+    auto* tparam = mFlagBuffer1;
+    int idx = -1;
+    const u32 pl_core_id = sead::CoreInfo::getPlatformCoreId(sead::CoreInfo::getCurrentCoreId());
+
+    const auto calc_hash = [&] { return sead::HashCRC32::calcStringHash(name); };
+
+    if (type.compare("bool") == 0) {
+        auto* flag = tparam->getBoolFlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        bool v = false;
+        if (value == "true")
+            v = true;
+
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("s32") == 0) {
+        auto* flag = tparam->getS32FlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        s32 v = 0;
+        sead::StringUtil::tryParseS32(&v, value, sead::StringUtil::CardinalNumber::BaseAuto);
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("f32") == 0) {
+        auto* flag = tparam->getF32FlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        f32 v = 0;
+        sead::StringUtil::tryParseF32(&v, value);
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("string") == 0) {
+        auto* flag = tparam->getStrFlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        flag->setValue(value);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("string64") == 0) {
+        auto* flag = tparam->getStr64FlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        flag->setValue(value);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("string256") == 0) {
+        auto* flag = tparam->getStr256FlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        flag->setValue(value);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("vector2f") == 0) {
+        auto* flag = tparam->getVec2fFlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        sead::Vector2f v;
+        parseFloats(value, v.e.data(), v.e.size());
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("vector3f") == 0) {
+        auto* flag = tparam->getVec3fFlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        sead::Vector3f v;
+        parseFloats(value, v.e.data(), v.e.size());
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    if (type.compare("vector4f") == 0) {
+        auto* flag = tparam->getVec4fFlagAndIdx(&idx, calc_hash());
+        if (!flag)
+            return;
+
+        sead::Vector4f v;
+        parseFloats(value, v.e.data(), v.e.size());
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
+        return;
+    }
+
+    sead::FixedSafeString<64> sub_idx_str{"-1"};
+    if (it != end)
+        it.getAndForward(&sub_idx_str);
+    const int sub_idx =
+        sead::StringUtil::parseS32(sub_idx_str, sead::StringUtil::CardinalNumber::BaseAuto);
+
+    if (type.compare("boolarray") == 0) {
+        auto* flag = tparam->getBoolFlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        bool v = false;
+        if (value == "true")
+            v = true;
+
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("s32array") == 0) {
+        auto* flag = tparam->getS32FlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        s32 v = 0;
+        sead::StringUtil::tryParseS32(&v, value, sead::StringUtil::CardinalNumber::BaseAuto);
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("f32array") == 0) {
+        auto* flag = tparam->getF32FlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        f32 v = 0;
+        sead::StringUtil::tryParseF32(&v, value);
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("stringarray") == 0) {
+        auto* flag = tparam->getStrFlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        flag->setValue(value);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("string64array") == 0) {
+        auto* flag = tparam->getStr64FlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        flag->setValue(value);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("string256array") == 0) {
+        auto* flag = tparam->getStr256FlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        flag->setValue(value);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("vector2farray") == 0) {
+        auto* flag = tparam->getVec2fFlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        sead::Vector2f v;
+        parseFloats(value, v.e.data(), v.e.size());
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("vector3farray") == 0) {
+        auto* flag = tparam->getVec3fFlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        sead::Vector3f v;
+        parseFloats(value, v.e.data(), v.e.size());
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+
+    if (type.compare("vector4farray") == 0) {
+        auto* flag = tparam->getVec4fFlagAndIdx(&idx, calc_hash(), sub_idx);
+        if (!flag)
+            return;
+
+        sead::Vector4f v;
+        parseFloats(value, v.e.data(), v.e.size());
+        flag->setValue(v);
+        recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
+        return;
+    }
+}
+
+void Manager::recordFlagChange(u32 platform_core_id, TriggerParam* tparam, u8 type, const s32& idx,
+                               const s32& sub_idx) {
+    auto& buffer = tparam->mFlagChangeRecords[platform_core_id].ref();
+    buffer[tparam->mFlagChangeRecordIndices[platform_core_id]].type.mValue = type;
+    buffer[tparam->mFlagChangeRecordIndices[platform_core_id]].index = idx;
+    buffer[tparam->mFlagChangeRecordIndices[platform_core_id]].sub_index = sub_idx;
+    ++tparam->mFlagChangeRecordIndices[platform_core_id];
+}
+
+void Manager::startSyncOnLoadEnd() {
+    if (!mBitFlags.isOn(BitFlag::_100) || mBitFlags.isOn(BitFlag::_200))
+        return;
+
+    KingEditor::instance()->log(getName(), "[LoadEnd]");
+    mBitFlags.reset(BitFlag::SyncFlags);
+    mBitFlags.set(BitFlag::_200);
+    mSyncStep = 0;
+    syncStart();
+}
+
+void Manager::parseFloats(const sead::SafeString& str, f32* values, u32 n) {
+    auto it = str.tokenBegin(" ");
+    const auto end = str.tokenEnd(" ");
+    u32 i = 0;
+    while (end != it) {
+        sead::FixedSafeString<256> part;
+        it.getAndForward(&part);
+
+        f32 value;
+        if (!sead::StringUtil::tryParseF32(&value, part))
+            value = 0.0;
+
+        values[i++] = value;
+        if (i == n)
+            break;
+    }
+}
+
+namespace {
+template <typename T>
+void writeToBuffer(u8* buffer, u32* written, const T& value) {
+    static_assert(std::is_trivially_copyable<T>());
+    std::memcpy(buffer + *written, &value, sizeof(value));
+    *written += u32(sizeof(value));
+}
+}  // namespace
+
+template <typename T>
+void Manager::doSyncArray(const sead::PtrArray<FlagBase>& array, u8* buffer,
+                          const char* description) {
+    KingEditor::instance()->log(getName(), "[ArrayStart]");
+
+    u32 offset = 0;
+    const auto flush = [&] {
+        KingEditor::instance()->log(getName(), description, buffer, offset);
+        offset = 0;
+    };
+    for (FlagBase& flag : array) {
+        u32 written = 0;
+        writeToBuffer(buffer + offset, &written, flag.getHash());
+        if constexpr (std::is_same<bool, T>()) {
+            writeToBuffer(buffer + offset, &written, static_cast<Flag<T>&>(flag).getValue());
+        } else {
+            writeToBuffer(buffer + offset, &written, static_cast<Flag<T>&>(flag).getValueRef());
+        }
+        offset += written;
+        if (offset >= ComBufferSize - written)
+            flush();
+    }
+
+    if (offset != 0)
+        flush();
+
+    KingEditor::instance()->log(getName(), "[ArrayEnd]");
+}
+
+template <int N>
+void Manager::doSyncArrayStr(const sead::PtrArray<FlagBase>& array, u8* buffer,
+                             const char* description, u32 n) {
+    KingEditor::instance()->log(getName(), "[ArrayStart]");
+
+    u32 offset = 0;
+    const auto flush = [&] {
+        KingEditor::instance()->log(getName(), description, buffer, offset);
+        offset = 0;
+    };
+    for (FlagBase& flag : array) {
+        const auto& flag_ = static_cast<const Flag<sead::FixedSafeString<N>>&>(flag);
+        u8* entry = buffer + offset;
+
+        const u32 hash = flag.getHash();
+        std::memcpy(entry, &hash, sizeof(hash));
+
+        const auto len = flag_.getValueRef().calcLength();
+        sead::MemUtil::copy(entry + sizeof(hash), flag_.getValueRef().cstr(), len);
+        sead::MemUtil::fillZero(entry + u32(sizeof(hash) + len), n - len);
+
+        offset += u32(sizeof(hash) + n);
+        if (offset >= ComBufferSize - sizeof(hash) - n)
+            flush();
+    }
+
+    if (offset != 0)
+        flush();
+
+    KingEditor::instance()->log(getName(), "[ArrayEnd]");
+}
+
+template <typename T>
+void Manager::doSyncArrayVec(const sead::PtrArray<FlagBase>& array, u8* buffer,
+                             const char* description, u32 n) {
+    KingEditor::instance()->log(getName(), "[ArrayStart]");
+
+    u32 offset = 0;
+    const auto flush = [&] {
+        KingEditor::instance()->log(getName(), description, buffer, offset);
+        offset = 0;
+    };
+    for (FlagBase& flag : array) {
+        const auto& flag_ = static_cast<const Flag<T>&>(flag);
+        u32 written = 0;
+        writeToBuffer(buffer + offset, &written, flag.getHash());
+
+        for (u32 i = 0; i != n; ++i)
+            writeToBuffer(buffer + offset, &written, flag_.getValueRef().e[i]);
+
+        offset += written;
+        /// @bug "n" should be "sizeof(f32) * n" instead.
+        if (offset >= ComBufferSize - sizeof(u32) - n)
+            flush();
+    }
+
+    if (offset != 0)
+        flush();
+
+    KingEditor::instance()->log(getName(), "[ArrayEnd]");
+}
+
+template <typename T>
+void Manager::doSyncArray(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
+                          const char* description) {
+    KingEditor::instance()->log(getName(), "[ArrayStart]");
+
+    for (auto& flags : array) {
+        u32 written = [&] {
+            u32 offset = 0;
+
+            auto it = flags.begin();
+            const auto end = flags.end();
+            writeToBuffer(buffer, &offset, flags[0]->getHash());
+
+            for (; it != end; ++it) {
+                writeToBuffer(buffer, &offset, static_cast<Flag<T>&>(*it).getValueRef());
+                if (offset >= ComBufferSize - sizeof(T))
+                    break;
+            }
+            return offset;
+        }();
+
+        if (written != 0)
+            KingEditor::instance()->log(getName(), description, buffer, written);
+    }
+
+    KingEditor::instance()->log(getName(), "[ArrayEnd]");
+}
+
+template <int N>
+void Manager::doSyncArrayStr(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
+                             const char* description, u32 n) {
+    KingEditor::instance()->log(getName(), "[ArrayStart]");
+
+    for (auto& flags : array) {
+        u32 written = [&] {
+            u32 offset = 0;
+
+            auto it = flags.begin();
+            const auto end = flags.end();
+            writeToBuffer(buffer, &offset, flags[0]->getHash());
+
+            for (; it != end; ++it) {
+                const auto& flag = static_cast<const Flag<sead::FixedSafeString<N>>&>(*it);
+
+                const auto len = flag.getValueRef().calcLength();
+                sead::MemUtil::copy(buffer + offset, flag.getValueRef().cstr(), len);
+                sead::MemUtil::fillZero(buffer + u32(offset + len), n - len);
+                offset += n;
+
+                if (offset >= u32(ComBufferSize) - n)
+                    break;
+            }
+            return offset;
+        }();
+
+        if (written != 0)
+            KingEditor::instance()->log(getName(), description, buffer, written);
+    }
+
+    KingEditor::instance()->log(getName(), "[ArrayEnd]");
+}
+
+template <typename T>
+static u32 syncOneVec(Manager*, u8* buffer, const sead::PtrArray<FlagBase>& flags, u32 n) {
+    u32 offset = 0;
+
+    auto it = flags.begin();
+    const auto end = flags.end();
+    writeToBuffer(buffer, &offset, flags[0]->getHash());
+
+    for (; it != end; ++it) {
+        for (u32 i = 0; i < n; ++i)
+            writeToBuffer(buffer, &offset, static_cast<const Flag<T>&>(*it).getValueRef().e[i]);
+
+        if (offset >= u32(ComBufferSize) - n)
+            break;
+    }
+    return offset;
+}
+
+template <typename T>
+void Manager::doSyncArrayVec(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
+                             const char* description, u32 n) {
+    KingEditor::instance()->log(getName(), "[ArrayStart]");
+
+    for (auto& flags : array) {
+        u32 written = syncOneVec<T>(this, buffer, flags, n);
+        if (written != 0)
+            KingEditor::instance()->log(getName(), description, buffer, written);
+    }
+
+    KingEditor::instance()->log(getName(), "[ArrayEnd]");
+}
+
 }  // namespace ksys::gdt
diff --git a/src/KingSystem/GameData/gdtManager.h b/src/KingSystem/GameData/gdtManager.h
index 81077df0..01a80926 100644
--- a/src/KingSystem/GameData/gdtManager.h
+++ b/src/KingSystem/GameData/gdtManager.h
@@ -20,6 +20,10 @@ class Framework;
 class MethodTreeMgr;
 }  // namespace sead
 
+namespace ksys::map {
+class MubinIter;
+}
+
 namespace ksys::gdt {
 
 namespace detail {
@@ -230,6 +234,7 @@ public:
     using ReinitSignal = sead::DelegateEvent<ReinitEvent*>;
 
     void init(sead::Heap* heap, sead::Framework* framework);
+    void calc();
 
     void addReinitCallback(ReinitSignal::Slot& slot);
     void removeReinitCallback(ReinitSignal::Slot& slot);
@@ -485,6 +490,20 @@ public:
     bool wasFlagCopied(const sead::SafeString& name);
     bool wasFlagNotCopied(const sead::SafeString& name);
 
+    void copyParamToParam1();
+    void allocParam1();
+
+    FlagHandle getRevivalFlagHandle(const sead::SafeString& object_name,
+                                    const map::MubinIter& iter);
+    static bool getShopInfoIter(u32 hash, al::ByamlIter* out, const al::ByamlIter& iter,
+                                const u32* hashes);
+    void resetBoolFlagForRadarMgr(FlagBool& flag);
+
+    void allocRetryBuffer(sead::Heap* heap);
+    void destroyRetryBuffer();
+
+    void startSyncOnLoadEnd();
+
 private:
     enum class BitFlag {
         _1 = 0x1,
@@ -497,6 +516,7 @@ private:
         _80 = 0x80,
         _100 = 0x100,
         _200 = 0x200,
+        SyncFlags = _100 | _200,
         _400 = 0x400,
         _800 = 0x800,
         _1000 = 0x1000,
@@ -506,6 +526,7 @@ private:
         _10000 = 0x10000,
         _20000 = 0x20000,
         _40000 = 0x40000,
+        _80000 = 0x80000,
     };
 
     enum class ResetFlag {
@@ -569,6 +590,31 @@ private:
     void loadShopGameDataInfo(const sead::SafeString& path);
     void unloadResources();
 
+    void syncStart();
+    void syncUpdate(const char* data);
+    static void parseFloats(const sead::SafeString& str, f32* values, u32 n);
+    static inline void recordFlagChange(u32 platform_core_id, TriggerParam* tparam, u8 type,
+                                        const s32& idx, const s32& sub_idx = -1);
+
+    template <typename T>
+    void doSyncArray(const sead::PtrArray<FlagBase>& array, u8* buffer, const char* description);
+    template <int N>
+    void doSyncArrayStr(const sead::PtrArray<FlagBase>& array, u8* buffer, const char* description,
+                        u32 n = N);
+    template <typename T>
+    void doSyncArrayVec(const sead::PtrArray<FlagBase>& array, u8* buffer, const char* description,
+                        u32 n);
+
+    template <typename T>
+    void doSyncArray(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
+                     const char* description);
+    template <int N>
+    void doSyncArrayStr(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
+                        const char* description, u32 n = N);
+    template <typename T>
+    void doSyncArrayVec(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
+                        const char* description, u32 n);
+
     sead::Heap* mGameDataHeap = nullptr;
     sead::Heap* mSaveAreaHeap = nullptr;
     sead::Heap* mGameDataComHeap = nullptr;
diff --git a/src/KingSystem/GameData/gdtTriggerParam.h b/src/KingSystem/GameData/gdtTriggerParam.h
index 0264e919..d5012205 100644
--- a/src/KingSystem/GameData/gdtTriggerParam.h
+++ b/src/KingSystem/GameData/gdtTriggerParam.h
@@ -24,6 +24,7 @@ public:
     struct ResetEntry {
         sead::SizedEnum<FlagType::ValueType, u8> type;
         sead::SizedEnum<ResetType, u8> reset_type;
+        s16 sub_index;
         s32 index;
     };
     KSYS_CHECK_SIZE_NX150(ResetEntry, 0x8);
@@ -453,6 +454,8 @@ public:
                           bool ignore_temp_flags);
 
 private:
+    friend class Manager;
+
     enum class BitFlag : u8 {
         _1 = 1,
         _2 = 2,
diff --git a/src/KingSystem/System/KingEditor.h b/src/KingSystem/System/KingEditor.h
index e2a3afca..ec310f3c 100644
--- a/src/KingSystem/System/KingEditor.h
+++ b/src/KingSystem/System/KingEditor.h
@@ -31,6 +31,8 @@ public:
     void registerComponent(KingEditorComponent* component);
     void log(const char* system, const char* message, void* = {}, int = {});
 
+    u32 get88() const { return _88; }
+
 private:
     sead::OffsetList<KingEditorComponent> mComponents;
     sead::ListNode mListNode;
diff --git a/src/KingSystem/System/OverlayArenaSystem.h b/src/KingSystem/System/OverlayArenaSystem.h
index 46dc9b88..73d55373 100644
--- a/src/KingSystem/System/OverlayArenaSystem.h
+++ b/src/KingSystem/System/OverlayArenaSystem.h
@@ -45,6 +45,16 @@ public:
     OverlayArena* getAudioArena() const;
     OverlayArena* getUnknownArena() const;
 
+    sead::Heap* getFixedHeap() const { return mFixedHeap; }
+    sead::Heap* getMovableMemoryHeap() const { return mMovableMemoryHeap; }
+    sead::Heap* getGameDataWorkHeap() const { return mGameDataWorkHeap; }
+    sead::Heap* getMovieHeap() const { return mMovieHeap; }
+    sead::Heap* getPlacementTreeHeap() const { return mPlacementTreeHeap; }
+    sead::Heap* getTeraWorkHeap() const { return mTeraWorkHeap; }
+    sead::Heap* getSzsDecompressorInstHeap() const { return mSzsDecompressorInstHeap; }
+    sead::Heap* getSzsHeap() const { return mSzsHeap; }
+    sead::Heap* getTexArcWorkHeap() const { return mTexArcWorkHeap; }
+
     void createTeraWorkHeap();
     void createStubbed();
     void createMovieHeap();