diff --git a/.clang-tidy b/.clang-tidy
index c39746ed..0784981f 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -6,7 +6,6 @@ bugprone-*,
 -bugprone-easily-swappable-parameters,
 clang-analyzer-*,
 -clang-analyzer-apiModeling.Errno,
-cppcoreguidelines-pro-type-member-init,
 cppcoreguidelines-slicing,
 cppcoreguidelines-interfaces-global-init,
 cppcoreguidelines-narrowing-conversions,
diff --git a/src/KingSystem/ActorSystem/actActorParamMgr.cpp b/src/KingSystem/ActorSystem/actActorParamMgr.cpp
index e2ace0d4..fdf9c870 100644
--- a/src/KingSystem/ActorSystem/actActorParamMgr.cpp
+++ b/src/KingSystem/ActorSystem/actActorParamMgr.cpp
@@ -131,8 +131,7 @@ void ActorParamMgr::init(sead::Heap* heap, sead::Heap* debug_heap) {
         req.mEntryFactory = dummy_gparam_factory;
         getDummyResHandle(ResType::GParamList)
             .load("Actor/GeneralParamList/Dummy.bgparamlist", &req);
-        if (dummy_gparam_factory)
-            delete dummy_gparam_factory;
+        delete dummy_gparam_factory;
 
         auto* modellist = static_cast<res::ModelList*>(
             getDummyResHandle(ResType::ModelList).getResourceUnchecked());
@@ -191,12 +190,12 @@ ActorParam* ActorParamMgr::getParam(const char* actor_name, ActorParam** out_fre
 }
 
 ActorParam* ActorParamMgr::loadParam(const char* actor_name, res::Handle* pack_handle, void* x,
-                                     u32 load_req_c) {
+                                     u32 lane_id) {
     bool allocated_new = false;
     ActorParam* param = allocParam(actor_name, &allocated_new);
 
     if (allocated_new) {
-        loadFiles(param, mTempHeap, pack_handle, x, load_req_c);
+        loadFiles(param, mTempHeap, pack_handle, x, lane_id);
         param->setEventSignal();
     } else {
         param->waitForEvent();
@@ -206,14 +205,14 @@ ActorParam* ActorParamMgr::loadParam(const char* actor_name, res::Handle* pack_h
 }
 
 void ActorParamMgr::loadFiles(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle,
-                              void* x, u32 load_req_c) {
+                              void* x, u32 lane_id) {
     param->deleteResHandles();
     param->allocResHandles(heap, 0, ActorParam::NumResourceTypes + 1);
     param->mActiveBufferIdx = 0;
 
     const auto* link =
         loadFile<res::ActorLink>(param, Type::ActorLink, "Actor/ActorLink", "xml",
-                                 param->getActorName().cstr(), pack_handle, x, load_req_c);
+                                 param->getActorName().cstr(), pack_handle, x, lane_id);
 
     if (link)
         param->setProfileAndPriority(link->getUserName(User::Profile), link->getPriority().cstr());
@@ -225,20 +224,20 @@ void ActorParamMgr::loadFiles(ActorParam* param, sead::Heap* heap, res::Handle*
     param->mActiveBufferIdx = 0;
 
     loadFile<res::ModelList>(param, Type::ModelList, "Actor/ModelList", "modellist",
-                             actor_link->getUserName(User::Model), pack_handle, x, load_req_c);
+                             actor_link->getUserName(User::Model), pack_handle, x, lane_id);
 
     loadFile<res::UMii>(param, Type::UMii, "Actor/UMii", "umii",
-                        actor_link->getUserName(User::UMii), pack_handle, x, load_req_c);
+                        actor_link->getUserName(User::UMii), pack_handle, x, lane_id);
 
     loadFile<res::ASList>(param, Type::ASList, "Actor/ASList", "aslist",
                           actor_link->getUserName(res::ActorLink::User::AS), pack_handle, x,
-                          load_req_c);
+                          lane_id);
 
-    loadFilesStep2(param, heap, pack_handle, x, load_req_c);
+    loadFilesStep2(param, heap, pack_handle, x, lane_id);
 }
 
 bool ActorParamMgr::requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
-                                         u32 load_req_c) {
+                                         u32 lane_id) {
     sead::FixedSafeString<128> path;
     res::LoadRequest req;
 
@@ -247,14 +246,14 @@ bool ActorParamMgr::requestLoadActorPack(res::Handle* handle, const sead::SafeSt
 
     path.format("Actor/Pack/%s.bactorpack", actor_name.cstr());
     req.mRequester = actor_name;
-    req._c = load_req_c;
+    req.mLaneId = lane_id;
     req._8 = true;
     req._28 = false;
     return handle->requestLoad(path, &req);
 }
 
 ActorParam* ActorParamMgr::loadParamAsync(const char* actor_name, res::Handle* pack_handle,
-                                          bool* allocated_new, void* x, u32 load_req_c) {
+                                          bool* allocated_new, void* x, u32 lane_id) {
     auto* param = allocParam(actor_name, allocated_new);
     if (!*allocated_new)
         return param;
@@ -264,7 +263,7 @@ ActorParam* ActorParamMgr::loadParamAsync(const char* actor_name, res::Handle* p
     param->mActiveBufferIdx = 0;
 
     loadFileAsync<res::ActorLink>(param, Type::ActorLink, "Actor/ActorLink", "xml",
-                                  param->getActorName().cstr(), pack_handle, x, load_req_c);
+                                  param->getActorName().cstr(), pack_handle, x, lane_id);
     return param;
 }
 
@@ -272,19 +271,19 @@ template <typename T>
 bool ActorParamMgr::loadFileAsync(ActorParam* param, ActorParam::ResourceType type,
                                   const sead::SafeString& dir_name,
                                   const sead::SafeString& extension, const sead::SafeString& name,
-                                  res::Handle* pack_handle, void* x, u32 load_req_c) {
+                                  res::Handle* pack_handle, void* x, u32 lane_id) {
     auto* handle = param->allocHandle();
 
     if (name != "Dummy" && !name.isEmpty()) {
         sead::FixedSafeString<128> path;
         res::LoadRequest req;
-        prepareLoadFromActorPack(&path, &req, x, dir_name, extension, name, pack_handle, load_req_c,
+        prepareLoadFromActorPack(&path, &req, x, dir_name, extension, name, pack_handle, lane_id,
                                  param->getActorName());
         return handle->requestLoad(path, &req);
     }
 
     if (ActorParam::isValidType(type)) {
-        auto* res = sead::DynamicCast<T>(mDummyResources[u32(type)].getResource());
+        auto* res = sead::DynamicCast<T>(mDummyResources[s32(type)].getResource());
         param->setResource(type, res);
     }
 
@@ -300,7 +299,7 @@ T* ActorParamMgr::handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::R
     *idx = current_idx + 1;
 
     if (ActorParam::isValidType(type)) {
-        if (auto* res = static_cast<T*>(param->getRes().mArray[u32(type)]))
+        if (auto* res = static_cast<T*>(param->getRes().mArray[s32(type)]))
             return res;
     }
 
@@ -313,7 +312,7 @@ T* ActorParamMgr::handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::R
     handle.parseResource(nullptr);
 
     if (handle.checkLoadStatus() && type != Type::EventFlow)
-        param->_a = 1;
+        param->_a = true;
 
     auto* res = sead::DynamicCast<T>(handle.getResource());
     if (res) {
@@ -344,72 +343,71 @@ bool ActorParamMgr::finishLoadingActorLink(ActorParam* param, void* x) {
 }
 
 void ActorParamMgr::loadParamAsyncStep2(ActorParam* param, res::Handle* pack_handle, void* x,
-                                        u32 load_req_c) {
+                                        u32 lane_id) {
     const auto* link = param->getRes().mActorLink;
 
     loadFileAsync<res::ModelList>(param, Type::ModelList, "Actor/ModelList", "modellist",
-                                  link->getUsers().getModel(), pack_handle, x, load_req_c);
+                                  link->getUsers().getModel(), pack_handle, x, lane_id);
 
     loadFileAsync<res::UMii>(param, Type::UMii, "Actor/UMii", "umii", link->getUsers().getUMii(),
-                             pack_handle, x, load_req_c);
+                             pack_handle, x, lane_id);
 
     loadFileAsync<res::ASList>(param, Type::ASList, "Actor/ASList", "aslist",
-                               link->getUsers().getAS(), pack_handle, x, load_req_c);
+                               link->getUsers().getAS(), pack_handle, x, lane_id);
 
     loadFileAsync<res::AttClientList>(param, Type::AttClientList, "Actor/AttClientList", "atcllist",
-                                      link->getUserName(User::Attention), pack_handle, x,
-                                      load_req_c);
+                                      link->getUserName(User::Attention), pack_handle, x, lane_id);
 
     loadFileAsync<res::RagdollConfigList>(param, Type::RagdollConfigList, "Actor/RagdollConfigList",
                                           "rgconfiglist", link->getUserName(User::RgConfigList),
-                                          pack_handle, x, load_req_c);
+                                          pack_handle, x, lane_id);
 
     loadFileAsync<res::AIProgram>(param, Type::AIProgram, "Actor/AIProgram", "aiprog",
-                                  link->getUsers().getAIProgram(), pack_handle, x, load_req_c);
+                                  link->getUsers().getAIProgram(), pack_handle, x, lane_id);
 
     loadFileAsync<res::GParamList>(param, Type::GParamList, "Actor/GeneralParamList", "gparamlist",
-                                   link->getUsers().getGParam(), pack_handle, x, load_req_c);
+                                   link->getUsers().getGParam(), pack_handle, x, lane_id);
 
     loadFileAsync<res::Physics>(param, Type::Physics, "Actor/Physics", "physics",
-                                link->getUsers().getPhysics(), pack_handle, x, load_req_c);
+                                link->getUsers().getPhysics(), pack_handle, x, lane_id);
 
     loadFileAsync<res::Chemical>(param, Type::Chemical, "Actor/Chemical", "chemical",
-                                 link->getUsers().getChemical(), pack_handle, x, load_req_c);
+                                 link->getUsers().getChemical(), pack_handle, x, lane_id);
 
     loadFileAsync<res::DamageParam>(param, Type::DamageParam, "Actor/DamageParam", "dmgparam",
-                                    link->getUsers().getDamageParam(), pack_handle, x, load_req_c);
+                                    link->getUsers().getDamageParam(), pack_handle, x, lane_id);
 
     loadFileAsync<res::RagdollBlendWeight>(
         param, Type::RagdollBlendWeight, "Actor/RagdollBlendWeight", "rgbw",
-        link->getUsers().getRgBlendWeight(), pack_handle, x, load_req_c);
+        link->getUsers().getRgBlendWeight(), pack_handle, x, lane_id);
 
     loadFileAsync<res::Awareness>(param, Type::Awareness, "Actor/Awareness", "awareness",
-                                  link->getUsers().getAwareness(), pack_handle, x, load_req_c);
+                                  link->getUsers().getAwareness(), pack_handle, x, lane_id);
 
     loadFileAsync<res::Drop>(param, Type::DropTable, "Actor/DropTable", "drop",
-                             link->getUsers().getDropTable(), pack_handle, x, load_req_c);
+                             link->getUsers().getDropTable(), pack_handle, x, lane_id);
 
     loadFileAsync<res::Shop>(param, Type::ShopData, "Actor/ShopData", "shop",
-                             link->getUsers().getShopData(), pack_handle, x, load_req_c);
+                             link->getUsers().getShopData(), pack_handle, x, lane_id);
 
     loadFileAsync<res::Recipe>(param, Type::Recipe, "Actor/Recipe", "recipe",
-                               link->getUsers().getRecipe(), pack_handle, x, load_req_c);
+                               link->getUsers().getRecipe(), pack_handle, x, lane_id);
 
     loadFileAsync<res::Lod>(param, Type::Lod, "Actor/LOD", "lod", link->getUsers().getLOD(),
-                            pack_handle, x, load_req_c);
+                            pack_handle, x, lane_id);
 
     loadFileAsync<res::AISchedule>(param, Type::AISchedule, "Actor/AISchedule", "aischedule",
-                                   link->getUsers().getAISchedule(), pack_handle, x, load_req_c);
+                                   link->getUsers().getAISchedule(), pack_handle, x, lane_id);
 
     loadFileAsync<res::BoneControl>(param, Type::BoneControl, "Actor/BoneControl", "bonectrl",
-                                    link->getUsers().getBoneControl(), pack_handle, x, load_req_c);
+                                    link->getUsers().getBoneControl(), pack_handle, x, lane_id);
 
     loadFileAsync<res::LifeCondition>(param, Type::LifeCondition, "Actor/LifeCondition",
                                       "lifecondition", link->getUsers().getLifeCondition(),
-                                      pack_handle, x, load_req_c);
+                                      pack_handle, x, lane_id);
 
     loadFileAsync<res::AnimInfo>(param, Type::AnimationInfo, "Actor/AnimationInfo", "animinfo",
-                                 link->getUsers().getAnimationInfo(), pack_handle, x, load_req_c);
+                                 link->getUsers().getAnimationInfo(), pack_handle, x, lane_id);
 }
 
 bool ActorParamMgr::finishLoadingStep2(ActorParam* param, void* x) {
@@ -479,7 +477,7 @@ bool ActorParamMgr::finishLoadingStep2(ActorParam* param, void* x) {
 }
 
 void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handle, void* x,
-                                      u32 load_req_c) {
+                                      u32 lane_id) {
     const auto* aslist = param->getRes().mASList;
     const auto* atcllist = param->getRes().mAttClientList;
     const auto* rgconfiglist = param->getRes().mRagdollConfigList;
@@ -495,7 +493,7 @@ void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handl
         for (s32 i = 0; i < num_as; ++i) {
             loadFileAsync<res::AS>(param, Type::AS, "Actor/AS", "as",
                                    aslist->getASDefines()[i].getFileName(), pack_handle, x,
-                                   load_req_c);
+                                   lane_id);
         }
     }
 
@@ -503,7 +501,7 @@ void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handl
         for (s32 i = 0; i < num_att; ++i) {
             loadFileAsync<res::AttClient>(param, Type::AttClient, "Actor/AttClient", "atcl",
                                           atcllist->getClients()[i].getFileName(), pack_handle, x,
-                                          load_req_c);
+                                          lane_id);
         }
     }
 
@@ -511,7 +509,7 @@ void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handl
         for (s32 i = 0; i < num_rg; ++i) {
             loadFileAsync<res::RagdollConfig>(
                 param, Type::RagdollConfig, "Actor/RagdollConfig", "rgconfig",
-                rgconfiglist->getImpulseParams()[i].getFileName(), pack_handle, x, load_req_c);
+                rgconfiglist->getImpulseParams()[i].getFileName(), pack_handle, x, lane_id);
         }
     }
 }
@@ -627,16 +625,16 @@ void ActorParamMgr::allocExtraResHandles(ActorParam* param, sead::Heap* heap) co
 }
 
 void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle,
-                                   void* x, u32 load_req_c) {
+                                   void* x, u32 lane_id) {
     const auto* link = param->getRes().mActorLink;
     param->mActiveBufferIdx = 0;
 
     loadFile<res::AttClientList>(param, Type::AttClientList, "Actor/AttClientList", "atcllist",
-                                 link->getUserName(User::Attention), pack_handle, x, load_req_c);
+                                 link->getUserName(User::Attention), pack_handle, x, lane_id);
 
     loadFile<res::RagdollConfigList>(param, Type::RagdollConfigList, "Actor/RagdollConfigList",
                                      "rgconfiglist", link->getUserName(User::RgConfigList),
-                                     pack_handle, x, load_req_c);
+                                     pack_handle, x, lane_id);
 
     // Start loading the extra ActorParam files.
     allocExtraResHandles(param, heap);
@@ -644,9 +642,9 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
 
     if (auto* aslist = param->getRes().mASList) {
         for (s32 i = 0; i < aslist->getASDefines().size(); ++i) {
-            auto* as = loadFile<res::AS>(param, Type::AS, "Actor/AS", "as",
-                                         aslist->getASDefines()[i].getFileName(), pack_handle, x,
-                                         load_req_c);
+            auto* as =
+                loadFile<res::AS>(param, Type::AS, "Actor/AS", "as",
+                                  aslist->getASDefines()[i].getFileName(), pack_handle, x, lane_id);
             if (as) {
                 as->setIndex(u32(Type::AS));
                 aslist->addAS_(i, as);
@@ -658,7 +656,7 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
         for (s32 i = 0; i < list->getClients().size(); ++i) {
             auto* client = loadFile<res::AttClient>(param, Type::AttClient, "Actor/AttClient",
                                                     "atcl", list->getClients()[i].getFileName(),
-                                                    pack_handle, x, load_req_c);
+                                                    pack_handle, x, lane_id);
             if (client) {
                 client->setIndex(u32(Type::AttClient));
                 list->addClient_(i, client);
@@ -670,7 +668,7 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
         for (s32 i = 0; i < list->getImpulseParams().size(); ++i) {
             auto* config = loadFile<res::RagdollConfig>(
                 param, Type::RagdollConfig, "Actor/RagdollConfig", "rgconfig",
-                list->getImpulseParams()[i].getFileName(), pack_handle, x, load_req_c);
+                list->getImpulseParams()[i].getFileName(), pack_handle, x, lane_id);
             if (config) {
                 config->setIndex(u32(Type::RagdollConfig));
                 list->addImpulseParamConfig_(i, config);
@@ -683,50 +681,50 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
     param->mActiveBufferIdx = 0;
 
     loadFile<res::AIProgram>(param, Type::AIProgram, "Actor/AIProgram", "aiprog",
-                             link->getUsers().getAIProgram(), pack_handle, x, load_req_c);
+                             link->getUsers().getAIProgram(), pack_handle, x, lane_id);
 
     loadFile<res::GParamList>(param, Type::GParamList, "Actor/GeneralParamList", "gparamlist",
-                              link->getUsers().getGParam(), pack_handle, x, load_req_c);
+                              link->getUsers().getGParam(), pack_handle, x, lane_id);
 
     loadFile<res::Physics>(param, Type::Physics, "Actor/Physics", "physics",
-                           link->getUsers().getPhysics(), pack_handle, x, load_req_c);
+                           link->getUsers().getPhysics(), pack_handle, x, lane_id);
 
     loadFile<res::Chemical>(param, Type::Chemical, "Actor/Chemical", "chemical",
-                            link->getUsers().getChemical(), pack_handle, x, load_req_c);
+                            link->getUsers().getChemical(), pack_handle, x, lane_id);
 
     loadFile<res::DamageParam>(param, Type::DamageParam, "Actor/DamageParam", "dmgparam",
-                               link->getUsers().getDamageParam(), pack_handle, x, load_req_c);
+                               link->getUsers().getDamageParam(), pack_handle, x, lane_id);
 
     loadFile<res::RagdollBlendWeight>(param, Type::RagdollBlendWeight, "Actor/RagdollBlendWeight",
                                       "rgbw", link->getUsers().getRgBlendWeight(), pack_handle, x,
-                                      load_req_c);
+                                      lane_id);
 
     loadFile<res::Awareness>(param, Type::Awareness, "Actor/Awareness", "awareness",
-                             link->getUsers().getAwareness(), pack_handle, x, load_req_c);
+                             link->getUsers().getAwareness(), pack_handle, x, lane_id);
 
     loadFile<res::Drop>(param, Type::DropTable, "Actor/DropTable", "drop",
-                        link->getUsers().getDropTable(), pack_handle, x, load_req_c);
+                        link->getUsers().getDropTable(), pack_handle, x, lane_id);
 
     loadFile<res::Shop>(param, Type::ShopData, "Actor/ShopData", "shop",
-                        link->getUsers().getShopData(), pack_handle, x, load_req_c);
+                        link->getUsers().getShopData(), pack_handle, x, lane_id);
 
     loadFile<res::Recipe>(param, Type::Recipe, "Actor/Recipe", "recipe",
-                          link->getUsers().getRecipe(), pack_handle, x, load_req_c);
+                          link->getUsers().getRecipe(), pack_handle, x, lane_id);
 
     loadFile<res::Lod>(param, Type::Lod, "Actor/LOD", "lod", link->getUsers().getLOD(), pack_handle,
-                       x, load_req_c);
+                       x, lane_id);
 
     loadFile<res::AISchedule>(param, Type::AISchedule, "Actor/AISchedule", "aischedule",
-                              link->getUsers().getAISchedule(), pack_handle, x, load_req_c);
+                              link->getUsers().getAISchedule(), pack_handle, x, lane_id);
 
     loadFile<res::BoneControl>(param, Type::BoneControl, "Actor/BoneControl", "bonectrl",
-                               link->getUsers().getBoneControl(), pack_handle, x, load_req_c);
+                               link->getUsers().getBoneControl(), pack_handle, x, lane_id);
 
     loadFile<res::LifeCondition>(param, Type::LifeCondition, "Actor/LifeCondition", "lifecondition",
-                                 link->getUsers().getLifeCondition(), pack_handle, x, load_req_c);
+                                 link->getUsers().getLifeCondition(), pack_handle, x, lane_id);
 
     loadFile<res::AnimInfo>(param, Type::AnimationInfo, "Actor/AnimationInfo", "animinfo",
-                            link->getUsers().getAnimationInfo(), pack_handle, x, load_req_c);
+                            link->getUsers().getAnimationInfo(), pack_handle, x, lane_id);
 
     param->_9 = 0;
     param->onLoadFinished(this);
@@ -741,7 +739,7 @@ bool ActorParamMgr::prepareLoadFromActorPack(sead::BufferedSafeString* path, res
                                              void*, const sead::SafeString& dir_name,
                                              const sead::SafeString& extension,
                                              const sead::SafeString& file_name,
-                                             res::Handle* pack_handle, u32 load_req_c,
+                                             res::Handle* pack_handle, u32 lane_id,
                                              const sead::SafeString& requester) {
     path->format("%s/%s.b%s", dir_name.cstr(), file_name.cstr(), extension.cstr());
 
@@ -764,14 +762,14 @@ bool ActorParamMgr::prepareLoadFromActorPack(sead::BufferedSafeString* path, res
         req->_24 = false;
     }
 
-    req->_c = load_req_c;
+    req->mLaneId = lane_id;
     req->mRequester = requester;
     req->_8 = true;
     return ret;
 }
 
 res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
-                                           u32 load_req_c) {
+                                           u32 lane_id) {
     sead::FixedSafeString<128> path;
     res::TempResourceLoader::LoadArg arg;
     arg.retry_on_failure = true;
@@ -782,7 +780,7 @@ res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::Safe
 
     path.format("Actor/Pack/%s.bactorpack", actor_name.cstr());
     arg.load_req.mRequester = actor_name;
-    arg.load_req._c = load_req_c;
+    arg.load_req.mLaneId = lane_id;
     arg.load_req._8 = true;
     arg.load_req._28 = false;
     arg.load_req.mPath = path;
@@ -797,14 +795,14 @@ res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::Safe
     res::SimpleLoadRequest req;
     req.mRequester = "tap::ActorParamMgr";
     req.mPath = path;
-    req._c = 2;
+    req.mLaneId = 2;
     return sead::DynamicCast<res::Archive>(handle->load(path, &req));
 }
 
 template <typename T>
 T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, const char* dir_name_c,
                            const char* extension_c, const char* name_c, res::Handle* pack_handle,
-                           void* x, u32 load_req_c) {
+                           void* x, u32 lane_id) {
     const sead::SafeString name = name_c;
     const sead::SafeString extension = extension_c;
     sead::FixedSafeString<128> path;
@@ -821,18 +819,18 @@ T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, con
             actor_name = &param->getActorName();
             req.mRequester = *actor_name;
             req.mPath = path;
-            req._c = 2;
+            req.mLaneId = 2;
             res = sead::DynamicCast<T>(temp_handle->load(path, &req));
         }
 
         // If loading the resource from the RomFS has failed, try to load it from the actor pack.
         if (!res) {
             if (!pack_handle->isSuccess())
-                loadActorPack(pack_handle, *actor_name, load_req_c);
+                loadActorPack(pack_handle, *actor_name, lane_id);
 
             res::LoadRequest req;
             prepareLoadFromActorPack(&path, &req, x, dir_name_c, extension_c, name_c, pack_handle,
-                                     load_req_c, *actor_name);
+                                     lane_id, *actor_name);
             res = sead::DynamicCast<T>(temp_handle->load(path, &req));
 
             if (!res) {
@@ -868,7 +866,7 @@ T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, con
     }
 
     if (extension != "fevfl")
-        param->_a = 1;
+        param->_a = true;
 
     // Fall back to using the dummy resource.
     res = sead::DynamicCast<T>(mDummyResources[s32(type)].getResource());
diff --git a/src/KingSystem/ActorSystem/actActorParamMgr.h b/src/KingSystem/ActorSystem/actActorParamMgr.h
index 3704dce3..8f69b9b3 100644
--- a/src/KingSystem/ActorSystem/actActorParamMgr.h
+++ b/src/KingSystem/ActorSystem/actActorParamMgr.h
@@ -42,19 +42,17 @@ public:
 
     ActorParam* allocParam(const char* actor_name, bool* allocated_new);
     ActorParam* getParam(const char* actor_name, ActorParam** out_free_param) const;
-    ActorParam* loadParam(const char* actor_name, res::Handle* pack_handle, void* x,
-                          u32 load_req_c);
+    ActorParam* loadParam(const char* actor_name, res::Handle* pack_handle, void* x, u32 lane_id);
     void unloadParam(ActorParam* param);
 
-    bool requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
-                              u32 load_req_c);
+    bool requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name, u32 lane_id);
 
     ActorParam* loadParamAsync(const char* actor_name, res::Handle* pack_handle,
-                               bool* allocated_new, void* x, u32 load_req_c);
+                               bool* allocated_new, void* x, u32 lane_id);
     bool finishLoadingActorLink(ActorParam* param, void* x);
-    void loadParamAsyncStep2(ActorParam* param, res::Handle* pack_handle, void* x, u32 load_req_c);
+    void loadParamAsyncStep2(ActorParam* param, res::Handle* pack_handle, void* x, u32 lane_id);
     bool finishLoadingStep2(ActorParam* param, void* x);
-    void loadExtraResAsync(ActorParam* param, res::Handle* pack_handle, void* x, u32 load_req_c);
+    void loadExtraResAsync(ActorParam* param, res::Handle* pack_handle, void* x, u32 lane_id);
     bool finishLoadingExtraRes(ActorParam* param, void* x);
     res::GParamList* getDummyGParamList() const;
 
@@ -67,31 +65,31 @@ private:
     };
 
     void loadFiles(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void* x,
-                   u32 load_req_c);
+                   u32 lane_id);
     bool prepareLoadFromActorPack(sead::BufferedSafeString* path, res::LoadRequest* req, void* x,
                                   const sead::SafeString& dir_name,
                                   const sead::SafeString& extension,
                                   const sead::SafeString& file_name, res::Handle* pack_handle,
-                                  u32 load_req_c, const sead::SafeString& requester);
+                                  u32 lane_id, const sead::SafeString& requester);
     res::Archive* loadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
-                                u32 load_req_c);
+                                u32 lane_id);
 
     template <typename T>
     T* loadFile(ActorParam* param, ActorParam::ResourceType type, const char* dir_name_c,
                 const char* extension_c, const char* name_c, res::Handle* pack_handle, void* x,
-                u32 load_req_c);
+                u32 lane_id);
 
     template <typename T>
     bool loadFileAsync(ActorParam* param, ActorParam::ResourceType type,
                        const sead::SafeString& dir_name, const sead::SafeString& extension,
                        const sead::SafeString& name, res::Handle* pack_handle, void* x,
-                       u32 load_req_c);
+                       u32 lane_id);
 
     template <typename T>
     T* handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::ResourceType type, void* x);
 
     void loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void* x,
-                        u32 load_req_c);
+                        u32 lane_id);
 
     void allocExtraResHandles(ActorParam* param, sead::Heap* heap) const;
 
@@ -101,7 +99,7 @@ private:
 
     static constexpr s32 NumParams = 0x400;
 
-    sead::TypedBitFlag<Flag> mFlags{};
+    sead::TypedBitFlag<Flag> mFlags;
     ActorParam* mParams = nullptr;
     DebugMessage mDebugMessage{"アクタパラメータ"};
     void* _e0 = nullptr;
diff --git a/src/KingSystem/Resource/resCache.cpp b/src/KingSystem/Resource/resCache.cpp
index d59ab29e..d3e3195c 100644
--- a/src/KingSystem/Resource/resCache.cpp
+++ b/src/KingSystem/Resource/resCache.cpp
@@ -118,7 +118,7 @@ Handle::Status Cache::loadResource(const ControlTaskData& data) {
     }
 
     u8 lane_id = 0xff;
-    if (data.mResLoadReq._c <= 2) {
+    if (data.mResLoadReq.mLaneId <= 2) {
         const bool x = result->mStatusFlags.isOn(ResourceUnit::StatusFlag::LoadFromArchive);
 #ifdef MATCHING_HACK_NX_CLANG
         // This makes absolutely no sense at all, but this prevents InstCombine from
@@ -127,7 +127,7 @@ Handle::Status Cache::loadResource(const ControlTaskData& data) {
         // so the conditional still works fine.
         __builtin_assume(x);
 #endif
-        lane_id = 2 * data.mResLoadReq._c + (x ? 1 : 2);
+        lane_id = 2 * data.mResLoadReq.mLaneId + (x ? 1 : 2);
     }
 
     ResourceUnit::RequestInitLoadArg load_arg;
diff --git a/src/KingSystem/Resource/resHandle.cpp b/src/KingSystem/Resource/resHandle.cpp
index e47cb65e..c620ee25 100644
--- a/src/KingSystem/Resource/resHandle.cpp
+++ b/src/KingSystem/Resource/resHandle.cpp
@@ -49,9 +49,9 @@ ILoadRequest::~ILoadRequest() {
 
 LoadRequest::LoadRequest() = default;
 
-LoadRequest::LoadRequest(s32 load_data_alignment, u32 arg_c, bool arg_20)
+LoadRequest::LoadRequest(s32 load_data_alignment, u32 lane_id, bool arg_20)
     : _20(arg_20), mLoadDataAlignment(load_data_alignment) {
-    _c = arg_c;
+    mLaneId = lane_id;
 }
 
 SimpleLoadRequest::SimpleLoadRequest() = default;
diff --git a/src/KingSystem/Resource/resInfoContainer.cpp b/src/KingSystem/Resource/resInfoContainer.cpp
index 14795e56..dfecf413 100644
--- a/src/KingSystem/Resource/resInfoContainer.cpp
+++ b/src/KingSystem/Resource/resInfoContainer.cpp
@@ -33,7 +33,7 @@ bool ResourceInfoContainer::loadResourceSizeTable() {
         req._34 = 0;
         req.mRequester = "ResourceInfoContainer";
         req.mPath = "System/Resource/ResourceSizeTable.product.rsizetable";
-        req._c = 1;
+        req.mLaneId = 1;
         return sead::DynamicCast<Resource>(mRstbHandle.load(req.mPath, &req));
     };
 
@@ -48,8 +48,7 @@ bool ResourceInfoContainer::loadResourceSizeTable() {
         const auto num_entries = sead::BitUtil::bitCastPtr<s32>(data, 0x4);
         const auto num_string_entries = sead::BitUtil::bitCastPtr<s32>(data, 0x8);
 
-        auto* entries_data =
-            reinterpret_cast<const ResEntry*>(reinterpret_cast<const u8*>(data) + 0xc);
+        auto* entries_data = reinterpret_cast<const ResEntry*>(data + 0xc);
 
         if (num_entries >= 1) {
             mEntries = {num_entries, entries_data};
@@ -68,7 +67,7 @@ bool ResourceInfoContainer::loadResourceSizeTable() {
         stubbedLogFunction();
         if (resource->getRawSize() != 0) {
             const u32 num_entries = resource->getRawSize() / sizeof(ResEntry);
-            mEntries.setBuffer(num_entries,
+            mEntries.setBuffer(s32(num_entries),
                                reinterpret_cast<const ResEntry*>(resource->getRawData()));
         }
     }
diff --git a/src/KingSystem/Resource/resLoadRequest.h b/src/KingSystem/Resource/resLoadRequest.h
index 13892170..b23f0e55 100644
--- a/src/KingSystem/Resource/resLoadRequest.h
+++ b/src/KingSystem/Resource/resLoadRequest.h
@@ -29,7 +29,7 @@ public:
     virtual ~ILoadRequest();
 
     bool _8 = false;
-    u32 _c = 1;
+    u32 mLaneId = 1;
     sead::SafeString mRequester;
 };
 KSYS_CHECK_SIZE_NX150(ILoadRequest, 0x20);
@@ -38,7 +38,7 @@ class LoadRequest : public ILoadRequest {
     SEAD_RTTI_OVERRIDE(LoadRequest, ILoadRequest)
 public:
     LoadRequest();
-    LoadRequest(s32 load_data_alignment, u32 arg_c, bool arg_20);
+    LoadRequest(s32 load_data_alignment, u32 lane_id, bool arg_20);
     LoadRequest(const LoadRequest&) = default;
     LoadRequest& operator=(const LoadRequest&) = default;
     ~LoadRequest() override = default;
diff --git a/src/KingSystem/Resource/resUnit.cpp b/src/KingSystem/Resource/resUnit.cpp
index ee252d84..186cffb2 100644
--- a/src/KingSystem/Resource/resUnit.cpp
+++ b/src/KingSystem/Resource/resUnit.cpp
@@ -48,7 +48,7 @@ bool ResourceUnit::init(const ResourceUnit::InitArg& arg) {
         SimplePackedLoadRequest request;
         request._8 = true;
         request.mRequester = "ResourceUnit";
-        request._c = 2;
+        request.mLaneId = 2;
         request.mPack = arg.load_req->mPackHandle;
         mArchiveRes = sead::DynamicCast<sead::ArchiveRes>(mArchiveResHandle.load("", &request));
     }
diff --git a/src/KingSystem/System/UI/LayoutResourceMgr.cpp b/src/KingSystem/System/UI/LayoutResourceMgr.cpp
index fa1d9dc2..a016d633 100644
--- a/src/KingSystem/System/UI/LayoutResourceMgr.cpp
+++ b/src/KingSystem/System/UI/LayoutResourceMgr.cpp
@@ -179,7 +179,7 @@ void LayoutResourceMgr::loadTitleLayout(sead::Heap* heap) {
     req.mLoadDataAlignment = 0x1000;
     req._22 = false;
     req._26 = false;
-    req._c = 2;
+    req.mLaneId = 2;
 
     res::Handle::Status status = res::Handle::Status::NoFile;
     mTitleLayout.getHandle()->requestLoad("Layout/Title.blarc", &req, &status);
@@ -207,7 +207,7 @@ bool LayoutResourceMgr::loadHorseLayout(sead::Heap* heap) {
     req.mLoadDataAlignment = 0x1000;
     req._22 = false;
     req._26 = true;
-    req._c = 2;
+    req.mLaneId = 2;
 
     res::Handle::Status status = res::Handle::Status::NoFile;
     mHorseLayout.getHandle()->requestLoad("Layout/Horse.blarc", &req, &status);