diff --git a/include/functions.h b/include/functions.h
index 14226efa71..e39524223f 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -839,7 +839,7 @@ void func_800B9EF4(GlobalContext* ctxt, int numActors, Actor** actors); // func_
 s32 func_800BA2D8(GlobalContext* ctxt, Actor* actor); // func_800BA2D8
 s32 func_800BA2FC(GlobalContext* ctxt, Actor* actor, Vec3f* param_3, f32 param_4); // func_800BA2FC
 void Actor_DrawAll(GlobalContext* ctxt, ActorContext* aCtxt); // func_800BA42C
-void func_800BA6FC(void); // func_800BA6FC
+void func_800BA6FC(GlobalContext* ctxt, ActorContext* aCtxt); // func_800BA6FC
 void func_800BA798(GlobalContext* ctxt, ActorContext* aCtxt); // func_800BA798
 void func_800BA8B8(GlobalContext* ctxt, ActorContext* actCtxt); // func_800BA8B8
 void func_800BA9B4(void); // func_800BA9B4
@@ -2431,7 +2431,7 @@ void Scene_ReloadUnloadedObjects(SceneContext* sceneCtxt); // func_8012F4FC
 s32 Scene_FindSceneObjectIndex(SceneContext* sceneCtxt, s16 id); // func_8012F608
 s32 Scene_IsObjectLoaded(SceneContext* iParm1, s32 index); // func_8012F668
 void Scene_DmaAllObjects(SceneContext* sceneCtxt); // func_8012F698
-u32 func_8012F73C(SceneContext* sceneCtxt, s32 iParm2, s16 id); // func_8012F73C
+void* func_8012F73C(SceneContext* sceneCtxt, s32 iParm2, s16 id); // func_8012F73C
 void Scene_HeaderCommand00(GlobalContext* ctxt, SceneCmd* entry); // func_8012F79C
 void Scene_HeaderCommand01(GlobalContext* ctxt, SceneCmd* entry); // func_8012F90C
 void Scene_HeaderCommand02(GlobalContext* ctxt, SceneCmd* entry); // func_8012F954
@@ -2467,7 +2467,7 @@ void Scene_HeaderCommand1A(GlobalContext* ctxt, SceneCmd* entry); // func_801306
 void func_801306A4(GlobalContext* ctxt); // func_801306A4
 s32 Scene_ProcessHeader(GlobalContext* ctxt, SceneCmd* header); // func_801306E8
 u32 Scene_CreateEntrance(u32 sceneIndex, u32 spawnIndex, u32 offset); // func_80130768
-void func_80130784(void); // func_80130784
+void func_80130784(u32 spawnIndex); // func_80130784
 void SceneProc_DrawCurrentSceneAnimatedTextures(GlobalContext* ctxt); // func_801307C0
 void SceneProc_DrawSceneConfig0(GlobalContext* ctxt); // func_801307F4
 Gfx* SceneProc_SetTile1Layer(GlobalContext* ctxt, ScrollingTextureParams* params); // func_80130834
@@ -2508,7 +2508,7 @@ EntranceRecord* SceneTable_LookupEntrance(u32 entrance); // func_801322C0
 s32 SceneTable_LookupEntranceScene(u32 entrance); // func_8013230C
 s32 SceneTable_LookupEntranceAbsoluteScene(u32 entrance); // func_80132338
 void func_80132374(void); // func_80132374
-void func_801323A0(void); // func_801323A0
+s16 func_801323A0(u32 entrance); // func_801323A0
 void func_801323D0(void); // func_801323D0
 void func_80132428(void); // func_80132428
 void func_80132494(void); // func_80132494
diff --git a/include/structs.h b/include/structs.h
index 586cc10d1a..61f409c396 100644
--- a/include/structs.h
+++ b/include/structs.h
@@ -837,7 +837,11 @@ typedef struct {
 /* 0x282 */ u16 unk282;
 /* 0x284 */ UNK_TYPE1 pad284[0x28];
 /* 0x2AC */ u8 cutsceneTrigger;
-/* 0x2AD */ UNK_TYPE1 pad2AD[0x17];
+/* 0x2AD */ UNK_TYPE1 pad2AD[0x5];
+/* 0x2B2 */ u16 environmentTime;
+/* 0x2B4 */ UNK_TYPE1 pad2B4[0x4];
+/* 0x2B8 */ s16 unk2b8;
+/* 0x2BA */ UNK_TYPE1 pad2BA[0xA];
 /* 0x2C4 */ f32 unk2C4;
 /* 0x2C8 */ CycleSceneFlags cycleSceneFlags[120];
 } SaveContextExtra; // size = 0xC28
@@ -915,7 +919,7 @@ typedef struct {
 } SceneEntranceTableEnty; // size = 0xC
 
 typedef struct {
-/* 0x00 */ s16 scenes[27];
+/* 0x00 */ u16 scenes[27];
 } SceneIdList; // size = 0x36
 
 typedef struct {
@@ -923,8 +927,8 @@ typedef struct {
 /* 0x02 */ UNK_TYPE1 pad2[0x2];
 /* 0x04 */ void* vramAddr;
 /* 0x08 */ DmaRequest dmaReq;
-/* 0x28 */ OSMesgQueue unk28;
-/* 0x40 */ UNK_TYPE1 pad40[0x4];
+/* 0x28 */ OSMesgQueue loadQueue;
+/* 0x40 */ OSMesg loadMsg;
 } SceneObject; // size = 0x44
 
 typedef struct {
@@ -1433,7 +1437,7 @@ typedef struct {
 typedef struct {
 /* 0x0000 */ u32 entranceIndex; // bits 0-3 : offset; 4-8: spawn index; 9-15: scene index
 /* 0x0004 */ UNK_TYPE1 pad4[0x4];
-/* 0x0008 */ u32 cutscene;
+/* 0x0008 */ s32 cutscene;
 /* 0x000C */ u16 time;
 /* 0x000E */ UNK_TYPE1 padE[0xA];
 /* 0x0018 */ u32 day;
@@ -1461,8 +1465,8 @@ typedef struct {
 /* 0x000 */ void* objectVramStart;
 /* 0x004 */ void* objectVramEnd;
 /* 0x008 */ u8 objectCount;
-/* 0x009 */ u8 unk9;
-/* 0x00A */ u8 unkA;
+/* 0x009 */ u8 spawnedObjectCount;
+/* 0x00A */ u8 mainKeepIndex;
 /* 0x00B */ u8 keepObjectId;
 /* 0x00C */ SceneObject objects[35];
 } SceneContext; // size = 0x958
@@ -1646,8 +1650,7 @@ typedef struct {
 typedef struct {
 /* 0x00 */ UNK_TYPE1 unk0;
 /* 0x01 */ UNK_TYPE1 unk1;
-/* 0x02 */ UNK_TYPE1 unk2;
-/* 0x03 */ UNK_TYPE1 unk3;
+/* 0x02 */ u16 unk2;
 /* 0x04 */ f32 unk4;
 /* 0x08 */ f32 unk8;
 /* 0x0C */ f32 unkC;
@@ -2828,7 +2831,9 @@ struct GlobalContext {
 /* 0x18876 */ UNK_TYPE1 pad18876[0x4];
 /* 0x1887A */ u16 unk1887A;
 /* 0x1887C */ s8 unk1887C;
-/* 0x1887D */ UNK_TYPE1 pad1887D[0x7];
+/* 0x1887D */ UNK_TYPE1 pad1887D[0x2];
+/* 0x1887F */ u8 unk1887F;
+/* 0x18880 */ UNK_TYPE1 pad18880[0x4];
 /* 0x18884 */ CollisionCheckContext colCheckCtx;
 /* 0x18B20 */ UNK_TYPE1 pad18B20[0x28];
 /* 0x18B48 */ u8 curSpawn;
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index efb91567ce..b2e688e5b3 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -1,11 +1,108 @@
 #include <ultra64.h>
 #include <global.h>
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_LoadObject.asm")
+/* 
+TODO: There are a few issues left with this file, but rely on larger structural project changes.
+I am avoiding these in the mean time in order to not break the Ghidra project structures.
+We need a header file for just z_scene. Including OBJECT_EXCHANGE_BANK_MAX and relevant structs, Scene, and Object enums.
+We need a macro header file for ALIGN16, PHYSICAL_TO_VIRTUAL and other global macros.
+We need to convert a lot of u32 struct members to void* to avoid UB.
+u32 -> void*: gRspSegmentPhysAddrs, Lib_PtrSegToVirt, DmaMgr_SendRequest0, DmaMgr_SendRequestImpl
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_Init.asm")
+Additionally, the .data, .bss, and .rodata sections are not migrated to this file yet.
+*/
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_ReloadUnloadedObjects.asm")
+s32 Scene_LoadObject(SceneContext* sceneCtxt, s16 id) {
+    u32 size;
+    
+    sceneCtxt->objects[sceneCtxt->objectCount].id = id;
+    size = objectFileTable[id].vromEnd - objectFileTable[id].vromStart;
+    
+    if (sceneCtxt) {}
+    
+    if (size) {
+        // TODO: UB to convert vramAddr to u32
+        DmaMgr_SendRequest0((u32)sceneCtxt->objects[sceneCtxt->objectCount].vramAddr,
+                            objectFileTable[id].vromStart, size);
+    }
+        
+    // TODO: This 0x22 is OBJECT_EXCHANGE_BANK_MAX - 1 in OOT
+    if (sceneCtxt->objectCount < 0x22) {
+        sceneCtxt->objects[sceneCtxt->objectCount + 1].vramAddr = 
+            // TODO: ALIGN16 macro here
+            (void*)((((u32)sceneCtxt->objects[sceneCtxt->objectCount].vramAddr + size) + 0xF) & ~0xF);
+    }
+    
+    sceneCtxt->objectCount++;
+    sceneCtxt->spawnedObjectCount = sceneCtxt->objectCount;
+    
+    return sceneCtxt->objectCount - 1;
+}
+
+void Scene_Init(GlobalContext* ctxt, SceneContext* sceneCtxt) {
+    GlobalContext* global = ctxt; // Needs to be a new variable to match (possibly a sub struct?)
+    u32 unused;
+    u32 spaceSize;
+    s32 i;
+    
+    // TODO: Needs scene enums!
+    if (global->sceneNum == 0x6F || global->sceneNum == 0x6C || global->sceneNum == 0x6E || global->sceneNum == 0x6D) {
+        spaceSize = 1566720;
+    } else if (global->sceneNum == 0x15) {
+        spaceSize = 1617920;
+    } else if (global->sceneNum == 0x2D) {
+        spaceSize = 1505280;
+    } else {
+        spaceSize = 1413120;
+    }
+    
+    sceneCtxt->objectCount = 0;
+    sceneCtxt->spawnedObjectCount = 0;
+    sceneCtxt->mainKeepIndex = 0;
+    sceneCtxt->keepObjectId = 0;
+    
+    // TODO: 0x23 is OBJECT_EXCHANGE_BANK_MAX in OOT 
+    for (i = 0; i < 0x23; i++) sceneCtxt->objects[i].id = 0;
+    
+    sceneCtxt->objectVramStart = sceneCtxt->objects[0].vramAddr = GameStateHeap_AllocFromEnd(&ctxt->state.heap, spaceSize);
+    // UB to cast sceneCtxt->objectVramStart to s32
+    sceneCtxt->objectVramEnd = (void*)((u32)sceneCtxt->objectVramStart + spaceSize);
+    // TODO: Second argument here is an object enum
+    sceneCtxt->mainKeepIndex = Scene_LoadObject(sceneCtxt, 1);
+    // TODO: PHYSICAL_TO_VIRTUAL macro
+    // TODO: Segment number enum
+    gRspSegmentPhysAddrs[4] = (u32)sceneCtxt->objects[sceneCtxt->mainKeepIndex].vramAddr + 0x80000000;
+}
+
+void Scene_ReloadUnloadedObjects(SceneContext* sceneCtxt) {
+    s32 i;
+    SceneObject* status;
+    ObjectFileTableEntry* objectFile;
+    u32 size;
+    
+    status = &sceneCtxt->objects[0];
+    for (i = 0; i < sceneCtxt->objectCount; i++) {
+        if (status->id < 0) {
+            s32 id = -status->id;
+            if (status->dmaReq.vromStart == 0) {
+                objectFile = &objectFileTable[id];
+                size = objectFile->vromEnd - objectFile->vromStart;
+                
+                if (size == 0) {
+                    status->id = 0;
+                } else {
+                    osCreateMesgQueue(&status->loadQueue, &status->loadMsg, 1);
+                    // TODO: UB to cast pointer to u32
+                    DmaMgr_SendRequestImpl(&status->dmaReq, (u32)status->vramAddr, objectFile->vromStart,
+                                            size, 0, &status->loadQueue, NULL);
+                }
+            } else if (!osRecvMesg(&status->loadQueue, NULL, OS_MESG_NOBLOCK)) {
+                status->id = id;
+            }
+        }
+        status++;
+    }
+}
 
 s32 Scene_FindSceneObjectIndex(SceneContext* sceneCtxt, s16 objectId) {
     s32 i;
@@ -25,42 +122,78 @@ s32 Scene_IsObjectLoaded(SceneContext* iParm1, s32 index) {
     }
 }
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_DmaAllObjects.asm")
+void Scene_DmaAllObjects(SceneContext* sceneCtxt) {
+    s32 i;
+    s32 id;
+    u32 vromSize;
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/func_8012F73C.asm")
+    for (i = 0; i < sceneCtxt->objectCount; i++) {
+        id = sceneCtxt->objects[i].id;
+        vromSize = objectFileTable[id].vromEnd - objectFileTable[id].vromStart;
+        
+        if (vromSize == 0) {
+            continue;
+        }
+        
+        // TODO: UB to cast void* to u32
+        DmaMgr_SendRequest0((u32)sceneCtxt->objects[i].vramAddr, objectFileTable[id].vromStart, vromSize);
+    }
+}
+
+void* func_8012F73C(SceneContext* sceneCtxt, s32 iParm2, s16 id) {
+    u32 addr;
+    u32 vromSize;
+    ObjectFileTableEntry* fileTableEntry;
+    
+    sceneCtxt->objects[iParm2].id = -id;
+    sceneCtxt->objects[iParm2].dmaReq.vromStart = 0;
+    
+    fileTableEntry = &objectFileTable[id];
+    vromSize = fileTableEntry->vromEnd - fileTableEntry->vromStart;
+    // TODO: UB to cast void to u32
+    addr = ((u32)sceneCtxt->objects[iParm2].vramAddr) + vromSize;
+    // TODO: This is ALIGN16 macro from OOT. Seems to be aligning an address to DMA
+    addr = (addr + 0xF) & ~0xF;
+    // UB to cast u32 to pointer
+    return (void*)addr;
+}
 
 // Scene Command 0x00: Link Spawn List
 void Scene_HeaderCommand00(GlobalContext* ctxt, SceneCmd* entry) {
-    GlobalContext* global;
-    s32 loadReturn;
+    GlobalContext* global = ctxt; // Needs to be a new variable to match (possibly a sub struct?)
+    s32 loadedCount;
     void* objectVramAddr;
     s16 temp16;
     u8 unk20;
+    
+    // TODO: UB to cast a u32 to pointer
     ctxt->linkActorEntry = (ActorEntry*)Lib_PtrSegToVirt(entry->spawnList.segment) +
                     ctxt->setupEntranceList[ctxt->curSpawn].spawn;
     if ( (ctxt->linkActorEntry->params & 0x0F00) >> 8 == 0x0C ||
          (gSaveContext.extra.unk10 == 0x02 && gSaveContext.extra.unk42 == 0x0CFF)
     ) {
+        // TODO: 0x192 is an object enum
         Scene_LoadObject(&ctxt->sceneContext, 0x192);
         return;
     }
 
-    loadReturn = Scene_LoadObject(&ctxt->sceneContext, 0x11);
-    global = ctxt;
+    // TODO: 0x11 is an object enum
+    loadedCount = Scene_LoadObject(&ctxt->sceneContext, 0x11);
     objectVramAddr = global->sceneContext.objects[global->sceneContext.objectCount].vramAddr;
-    ctxt->sceneContext.objectCount = loadReturn;
-    ctxt->sceneContext.unk9 = loadReturn;
+    ctxt->sceneContext.objectCount = loadedCount;
+    ctxt->sceneContext.spawnedObjectCount = loadedCount;
     unk20 = gSaveContext.perm.unk20;
     temp16 = D_801C2730[unk20];
     actorOverlayTable[0].initInfo->objectId = temp16;
     Scene_LoadObject(&ctxt->sceneContext, temp16);
 
+    // TODO: UB to cast pointer to u32
     ctxt->sceneContext.objects[ctxt->sceneContext.objectCount].vramAddr = objectVramAddr;
 }
 
 // Scene Command 0x01: Actor List
 void Scene_HeaderCommand01(GlobalContext* ctxt, SceneCmd* entry) {
-    ctxt->sceneNumActorsToLoad = (u16) entry->actorList.num;
+    ctxt->sceneNumActorsToLoad = (u16)entry->actorList.num;
     ctxt->setupActorList = (ActorEntry*)Lib_PtrSegToVirt(entry->actorList.segment);
     ctxt->actorCtx.unkC = (u16)0;
 }
@@ -108,6 +241,8 @@ void Scene_HeaderCommand07(GlobalContext* ctxt, SceneCmd* entry) {
     if (entry->specialFiles.keepObjectId != 0) {
         ctxt->sceneContext.keepObjectId = Scene_LoadObject(&ctxt->sceneContext, 
                                                            entry->specialFiles.keepObjectId);
+        // TODO: PHYSICAL_TO_VIRTUAL macro
+        // TODO: Segment number enum
         gRspSegmentPhysAddrs[5] = (u32)(ctxt->sceneContext.objects[ctxt->sceneContext.keepObjectId].vramAddr)
                                     + 0x80000000;
     }
@@ -132,7 +267,55 @@ void Scene_HeaderCommand0A(GlobalContext* ctxt, SceneCmd* entry) {
     ctxt->roomContext.currRoom.mesh = (RoomMesh*)Lib_PtrSegToVirt(entry->mesh.segment);
 }
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_HeaderCommand0B.asm")
+// Scene Command 0x0B: Object List
+void Scene_HeaderCommand0B(GlobalContext *ctxt, SceneCmd *entry) {
+    s32 i, j, k;
+    SceneObject* firstObject;
+    SceneObject* status;
+    SceneObject* status2;
+    s16* objectEntry;
+    void* nextPtr;
+    
+    objectEntry = (s16*)Lib_PtrSegToVirt(entry->objectList.segment);
+    k = 0;
+    i = ctxt->sceneContext.spawnedObjectCount;
+    status = &ctxt->sceneContext.objects[i];
+    firstObject = ctxt->sceneContext.objects;
+
+    while (i < ctxt->sceneContext.objectCount) {
+        if (status->id != *objectEntry) {
+            status2 = &ctxt->sceneContext.objects[i];
+            for (j = i; j < ctxt->sceneContext.objectCount; j++) {
+                status2->id = 0;
+                status2++;
+            }
+            ctxt->sceneContext.objectCount = i;
+            func_800BA6FC(ctxt, &ctxt->actorCtx);
+            
+            continue;
+        }
+        
+        i++;
+        k++;
+        objectEntry++;
+        status++;
+    }
+
+    while (k < entry->objectList.num) {
+        nextPtr = func_8012F73C(&ctxt->sceneContext, i, *objectEntry);
+        
+        // TODO: This 0x22 is OBJECT_EXCHANGE_BANK_MAX - 1 in OOT
+        if (i < 0x22) {
+            // TODO: UB to cast pointer to u32
+            firstObject[i + 1].vramAddr = nextPtr;
+        }
+        i++;
+        k++;
+        objectEntry++;
+    }
+    
+    ctxt->sceneContext.objectCount = i;
+}
 
 // Scene Command 0x0C: Light List
 void Scene_HeaderCommand0C(GlobalContext* ctxt, SceneCmd* entry) {
@@ -170,12 +353,13 @@ void Scene_HeaderCommand0F(GlobalContext* ctxt, SceneCmd* entry) {
 }
 
 s32 func_8012FF10(GlobalContext* ctxt, s32 fileIndex) {
-    s32 vromStart = D_801C2660[fileIndex].vromStart;
-    s32 fileSize = D_801C2660[fileIndex].vromEnd - vromStart;
+    u32 vromStart = D_801C2660[fileIndex].vromStart;
+    u32 fileSize = D_801C2660[fileIndex].vromEnd - vromStart;
     
     if (fileSize) {
         ctxt->roomContext.unk74 = GameStateHeap_AllocFromEnd(&ctxt->state.heap, fileSize);
-        return DmaMgr_SendRequest0((s32)ctxt->roomContext.unk74, vromStart, fileSize);
+        // TODO: UB to cast pointer to u32
+        return DmaMgr_SendRequest0((u32)ctxt->roomContext.unk74, vromStart, fileSize);
     }
     
     // UB: Undefined behaviour to not have a return statement here, but it breaks matching to add one.
@@ -195,7 +379,53 @@ void Scene_HeaderCommand12(GlobalContext* ctxt, SceneCmd* entry) {
     ctxt->kankyoContext.unk16 = entry->skyboxDisables.unk5;
 }
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_HeaderCommand10.asm")
+// Scene Command 0x10: Time Settings
+void Scene_HeaderCommand10(GlobalContext *ctxt, SceneCmd *entry) {
+    u32 dayTime;
+    
+    if (entry->timeSettings.hour != 0xFF && entry->timeSettings.min != 0xFF) {
+        gSaveContext.extra.environmentTime = gSaveContext.perm.time = 
+            (u16)(((entry->timeSettings.hour + (entry->timeSettings.min / 60.0f)) * 60.0f) / 0.021972656f);
+    }
+    
+    if (entry->timeSettings.unk6 != 0xFF) {
+        ctxt->kankyoContext.unk2 = entry->timeSettings.unk6;
+    } else {
+        ctxt->kankyoContext.unk2 = 0;
+    }
+    
+    if (gSaveContext.perm.inv.items[0] == 0xFF) {
+        if (ctxt->kankyoContext.unk2 != 0) {
+            ctxt->kankyoContext.unk2 = 5;
+        }
+    }
+    
+    if (gSaveContext.extra.unk2b8 == 0) {
+        // TODO: Needs REG macro
+        gStaticContext->data[0x0F] = ctxt->kankyoContext.unk2;
+    }
+    
+    dayTime = gSaveContext.perm.time;
+    ctxt->kankyoContext.unk4 = -(Math_Sins(dayTime - 0x8000) * 120.0f) * 25.0f;
+    dayTime = gSaveContext.perm.time;
+    ctxt->kankyoContext.unk8 = (Math_Coss(dayTime - 0x8000) * 120.0f) * 25.0f;
+    dayTime = gSaveContext.perm.time;
+    ctxt->kankyoContext.unkC = (Math_Coss(dayTime - 0x8000) * 20.0f) * 25.0f;
+    
+    if (ctxt->kankyoContext.unk2 == 0 && gSaveContext.perm.cutscene < 0xFFF0) {
+        gSaveContext.extra.environmentTime = gSaveContext.perm.time;
+        
+        if (gSaveContext.extra.environmentTime >= 0x2AAA && gSaveContext.extra.environmentTime < 0x4555) {
+            gSaveContext.extra.environmentTime = 0x3555;
+        } else if (gSaveContext.extra.environmentTime >= 0x4555 && gSaveContext.extra.environmentTime < 0x5555) {
+            gSaveContext.extra.environmentTime = 0x5555;
+        } else if (gSaveContext.extra.environmentTime >= 0xAAAA && gSaveContext.extra.environmentTime < 0xB555) {
+            gSaveContext.extra.environmentTime = 0xB555;
+        } else if (gSaveContext.extra.environmentTime >= 0xC000 && gSaveContext.extra.environmentTime < 0xCAAA) {
+            gSaveContext.extra.environmentTime = 0xCAAA;
+        }
+    }
+}
 
 // Scene Command 0x05: Wind Settings
 void Scene_HeaderCommand05(GlobalContext* ctxt, SceneCmd* entry) {
@@ -273,19 +503,71 @@ void Scene_HeaderCommand1E(GlobalContext* ctxt, SceneCmd* entry) {
     func_8010565C(ctxt, entry->minimapChests.num, entry->minimapChests.segment);
 }
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_HeaderCommand19.asm")
+// Scene Command 0x19: Misc. Settings (Camera & World Map Area)
+void Scene_HeaderCommand19(GlobalContext *ctxt, SceneCmd *entry) {
+    s16 j;
+    s16 i;
+    
+    j = 0;
+    i = 0;
+    while (1) {
+        if (scenesPerMapArea[i].scenes[j] == 0xFFFF) {
+            i++;
+            j=0;
+            
+            // 0x0B is sizeof(scenesPerMapArea) / sizeof(SceneIdList) ... but does not match calculated
+            if (i == 0x0B) {
+                break;
+            }
+        }
+        
+        if (ctxt->sceneNum == scenesPerMapArea[i].scenes[j]) {
+            break;
+        }
+        
+        j++;
+    }
+   
+    // 0x0B is sizeof(scenesPerMapArea) / sizeof(SceneIdList) ... but does not match calculated
+    if (i < 0x0B) {
+        // This bitwise OR could be a macro, but all sane looking versions break matching.
+        gSaveContext.perm.mapsVisited = (gBitFlags[i] | gSaveContext.perm.mapsVisited) | gSaveContext.perm.mapsVisited;
+    }
+}
 
 // Scene Command 0x1A: Texture Animations
 void Scene_HeaderCommand1A(GlobalContext* ctxt, SceneCmd* entry) {
     ctxt->sceneTextureAnimations = (AnimatedTexture*)Lib_PtrSegToVirt(entry->textureAnimations.segment);
 }
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/func_801306A4.asm")
+void func_801306A4(GlobalContext *ctxt) {
+    ctxt->unk1887F = func_801323A0(ctxt->unk1887A) & 0x7F;
+}
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_ProcessHeader.asm")
+s32 Scene_ProcessHeader(GlobalContext* ctxt, SceneCmd* header) {
+    u32 cmdCode;
+
+    while (1) {
+        cmdCode = header->base.code;
+        
+        if (cmdCode == 0x14) {
+            break;
+        }
+
+        if (cmdCode < 0x1F) {
+            sceneHeaderFuncTable[cmdCode](ctxt, header);
+        }
+
+        header++;
+    }
+
+    return 0;
+}
 
 u32 Scene_CreateEntrance(u32 sceneIndex, u32 spawnIndex, u32 offset) {
     return (((sceneIndex << 9) | (spawnIndex << 4)) | offset) & 0xFFFF;
 }
 
-GLOBAL_ASM("./asm/non_matchings/z_scene/func_80130784.asm")
+void func_80130784(u32 spawnIndex) {
+    Scene_CreateEntrance(gSaveContext.perm.entranceIndex >> 9, spawnIndex, 0);
+}
\ No newline at end of file