Added Makefile command to generate the context file

Decompiled more code
Before I do something stupid...

Makefile

@@ -109,6 +109,8 @@ split:
 	$(V)$(SPLAT)
 	@touch $(SPLAT_TIMESTAMP)
 
+context: 
+	$(V)$(PYTHON) tools/m2ctx.py include/common.h
 
 $(BUILD_DIR)/src/boot.c.o: OPTFLAGS = -O0
 
@@ -176,4 +178,4 @@ endif
 .PHONY: all clean distclean test setup split
 
 # Print target for debugging
-print-% : ; $(info $* is a $(flavor $*) variable set to [$($*)]) @true
+print-% : ; $(info $* is a $(flavor $*) variable set to [$($*)]) @true

include/common.h

@@ -224,9 +224,69 @@ extern u8 D_801951A1;
 extern u8 D_80197AE7[8];
 
 extern void func_80186160(void);
+extern void func_80186178(void);
+extern void func_80186190(s32 arg0, s32 arg1);
+extern s32 func_80186210(s32 arg0);
 extern s32 func_80186240(s32 arg0);
 extern void func_80186284(s32 arg0);
 extern void func_80186290(void);
 extern void func_801862A8(void);
 
+extern const char STR_CREATING_NEW_DATA[];
+extern const char STR_CREATING_A_NEW_FILE[];
+extern const char STR_ADDING_NEW_DATA[];
+extern const char STR_buSave_SAVING[];
+extern const char STR_UNUSEDMALLOCNO_INSUFFICIENT_MEMORY[];
+
+extern const char STR_LHa___s_s__s[];
+extern const char STR_Error[];
+extern const char STR_Fatal_error[];
+extern const char STR_Invalid_header_LHarc_file_[];
+extern const char STR_rb[];
+extern const char STR_wb[];
+extern const char STR_Unknown_method_skiped[];
+
+extern void AddHeap(void* start, u32 length);
+extern void __some_logging(const char* format, ...); 
+
+
+extern void main_(void*);
+extern void __idle_start_4_threads(s32, s32);
+extern void (*D_800E7A18)();
+
+extern void boot(void);
+extern void idle(void* arg);
+
+extern OSThread THREAD_FIRST_DMA_LOAD;
+extern u8 SP_THREAD_FIRST_DMA_LOAD[];
+extern OSThread THREAD_IDLE;
+extern u8 SP_THREAD_IDLE[];
+
+extern void* __GLOBAL_WITH__inc_menu_timer[];
+extern void* D_8018FB0C[];
+extern void* D_8018FAF8[];
+extern void* D_8018FAE4[];
+
+extern s32 __inc_menu_timer();                             
+extern void func_801707F4();                                  
+extern void func_8017223C(s32);                                 
+extern void func_80172368();                                  
+extern void func_80172394();     
+extern void func_8019B2E0(void);                             
+extern u16 D_800C4C26;
+extern u16 D_8018F1A2;
+extern s32 D_8018FB34;
+
+extern void func_801D0840(void);
+
+extern void func_80198080(s32);
+extern void func_80173610(void);
+extern void func_801B00B0(void);
+extern void func_8016C814(void);
+extern void func_801C889C(s32 arg0);
+extern void func_8007337C(void);
+extern void func_801C8864(void);
+
+extern u8 D_800A872C;
+
 #endif

splat.yaml

@@ -100,7 +100,7 @@ segments:
       - [0x18F80, asm]
       - [0x19050, c]
       - [0x19DD0, c]
-      - [0x19E10, asm]
+      - [0x19E10, c]
       - [0x19E30, c]
       - [0x19EB0, asm]
       - [0x19FC0, c, "black"]
@@ -380,7 +380,7 @@ segments:
       - [0x495E0, asm]
       - [0x49820, asm]
       - [0x49A30, asm]
-      - [0x4D5C0, asm]
+      - [0x4D5C0, c]
       - [0x4EF10, asm]
       - [0x514B0, asm]
       - [0x5AC70, asm]
@@ -419,13 +419,15 @@ segments:
 
       - { start: 0x66E10, type: bss, vram: 0x80190F10 }
       
-  # - [0x66E10, bin]
+  - [0x66E10, bin]
 
   - type: code
     dir: overlays/overlay_table_0
     start: 0x66E10
     vram: 0x80197B70
     bss_size: 0x10
+    # symbol_name_format: $VRAM_0_$ROM
+    # exclusive_ram_id: test_overlapping
     subsegments:
       - [0x66E10, asm]
       - [0x67570, asm]
@@ -445,26 +447,22 @@ segments:
   #   start: 0x6E660
   #   vram: 0x80197B70
   #   bss_size: 0x10
-  #   exclusive_overlay_id: overlay_table_1
+  #   # symbol_name_format: unique_1_$ROM
+  #   # exclusive_overlay_id: test_overlapping
   #   subsegments:
   #     - [0x6E660, asm]
 
-  #     - [0x70E70, rodata]      
-  #     - [0x71060, rodata]
-  #     - [0x71080, rodata]
-
   #     - { start: 0x71280, type: bss, vram: 0x8019A790 }
 
-  # - [0x71280, bin]
+  - [0x71280, bin]
-
 
   # - type: code
   #   dir: overlays/overlay_table_2
   #   start: 0xE48F0
   #   vram: 0x80197B70
   #   bss_size: 0x20
-  #   exclusive_overlay_id: overlay_table_2
+  #   symbol_name_format: $VRAM_2_$ROM
-  #   symbol_name_format: overlay_table_2_$ROM
+  #   exclusive_ram_id: test_overlapping
   #   subsegments:
   #     - [0xE48F0, asm]      
   #     - [0xE4BE0, asm]
@@ -475,6 +473,106 @@ segments:
 
   #     - { start: 0xEBBB0, type: bss, vram: 0x8019EE30 }
 
+  - [0xEBBB0, bin]
+
+  - type: code
+    dir: overlays/overlay_EBBB0
+    start: 0xEBBB0
+    vram: 0x8019EE50
+    bss_size: 0x310
+    subsegments:
+      - [0xEBBB0, asm]
+      - [0xED530, asm]
+      - [0xF6340, asm]
+
+      - [0xF8550, rodata]
+      - [0xF86A0, rodata]
+      - [0xF87A0, rodata]
+      - [0xF8A10, rodata]
+      - [0xF8F00, rodata]
+      - [0xF9760, rodata]
+      - [0xF9B40, rodata]
+      - [0xF9E60, rodata]
+      - [0xF9E70, rodata]
+      - [0xF9EA0, rodata]
+      - [0xF9F90, rodata]
+
+      - { start: 0xF9FF0, type: bss, vram: 0x801AD290 }
+
+  - [0xF9FF0, bin]
+
+  # - type: code
+  #   dir: overlays/overlay_FA5E0
+  #   start: 0xFA5E0
+  #   vram: 0x801AD5A0
+  #   bss_size: 0xA0
+  #   subsegments:
+  #     - [0xFA5E0, asm]
+
+  #     - [0x1003D0, rodata]      
+  #     - [0x1006D0, rodata]
+  #     - [0x101390, rodata]
+  #     - [0x1018D0, rodata]
+  #     - [0x101A10, rodata]
+  #     - [0x101A40, rodata]
+
+  #     - { start: 0x101CE0, type: bss, vram: 0x801B4CA0 }
+
+  - [0x101CE0, bin]
+
+  - type: code
+    dir: overlays/overlay_14EBE0
+    start: 0x14EBE0
+    vram: 0x801FDA70
+    bss_size: 0x130
+    subsegments:
+      - [0x14EBE0, asm]      
+      - [0x151F40, asm]
+      - [0x15DF10, asm]
+      - [0x15DF70, asm]
+      - [0x15E670, asm]
+      
+      - [0x15FBF0, rodata]
+      - [0x161940, rodata]
+      - [0x161B90, rodata]
+      - [0x161C40, rodata]
+      - [0x163580, rodata]
+      - [0x1636D0, rodata]
+      - [0x1647E0, rodata]
+      - [0x1647F0, rodata]
+      - [0x164940, rodata]
+      - [0x1649F0, rodata]
+      - [0x164D60, rodata]
+      - [0x165DA0, rodata]
+      - [0x165E00, rodata]
+      - [0x165E80, rodata]
+      - [0x165FB0, rodata]
+
+      - { start: 0x165FC0, type: bss, vram: 0x80214E50 }
+
+  - [0x165FC0, bin]
+
+  - type: code
+    dir: overlays/overlay_1BA050
+    start: 0x1BA050
+    vram: 0x80220F40
+    bss_size: 0x650
+    subsegments:
+      - [0x1BA050, asm]
+      - [0x1BBFB0, asm]
+
+      - [0x1C2DC0, rodata]      
+      - [0x1C3010, rodata]
+      - [0x1C3130, rodata]
+      - [0x1C3140, rodata]
+      - [0x1C31C0, rodata]
+      - [0x1C31E0, rodata]
+      - [0x1C32F0, rodata]
+
+      - { start: 0x1C3300, type: bss, vram: 0x8022A1F0 }
+
+  - [0x1C3300, bin]
+  
   # - type: code
   #   dir: overlays/unknown
   #   start: 0x1CE070
@@ -538,9 +636,8 @@ segments:
   #     - [0x241610, asm]
   #     - [0x243F20, asm]
 
-  # - [0x2447A0, bin]
+  - [0x2447A0, bin]
   
-
   # - type: code
   #   dir: overlays/overlay99
   #   start: 0x002AE3C0

src/19E10.c

@@ -0,0 +1,10 @@
+#include "common.h"
+
+INCLUDE_ASM(const s32, "19E10", func_80089A10);
+
+/* 19E10 80089A10 */
+// void func_80089A10(void) {
+//     if(D_800E79A4 != 0) {
+//         func_80089A10();
+//     }
+// }

src/1A050.c

@@ -5,19 +5,15 @@ void func_80089C50(void) {
     __SCREEN_IS_NOT_BLACK = 0x80;
 }
 
-
-// INCLUDE_ASM(const s32, "1A050", __init_controllers);
-
 /* 1A060 80089C60 */
-u8 __init_controllers(void) {
+u8 obInitControllers(void) {
     u8 pattern;
-    OSContStatus data;
+    OSContStatus data[3];
-    s32 pad[2];
 
     osCreateMesgQueue(&MQ_CONTROLLER, D_800BBE60, 8);
     osSetEventMesg(OS_EVENT_SI, &MQ_CONTROLLER, NULL);
     
-    osContInit(&MQ_CONTROLLER, &pattern, &data);
+    osContInit(&MQ_CONTROLLER, &pattern, data);
     
     osCreateThread(&THREAD_CONTROLLER, 5, __controller_thread_80089D9C, NULL, &MQ_800BE030, 0x73);
     osStartThread(&THREAD_CONTROLLER);

src/5FC0.c

@@ -4,13 +4,11 @@ INCLUDE_ASM(const s32, "5FC0", __calls_loads_overlay_array);
 
 INCLUDE_ASM(const s32, "5FC0", func_80076150);
 
-extern u8 D_800A872C;
 /* 6588 80076188 */
 u8* func_80076188(void) {
     return &D_800A872C;
 }
 
-extern u16 D_800C4C26;
 /* 6594 80076194 */
 void func_80076194(void) {
     D_800C4C26 = 0xFFFE;

src/A370.c

@@ -22,7 +22,6 @@ INCLUDE_ASM(const s32, "A370", func_8007AB7C);
 
 INCLUDE_ASM(const s32, "A370", func_8007ABAC);
 
-extern void __some_logging(unsigned char*, ...);
 extern char D_800AE038;
 extern OSMesgQueue MQ_800AF320;
 
@@ -72,18 +71,22 @@ INCLUDE_ASM(const s32, "A370", func_8007BA98);
 
 INCLUDE_ASM(const s32, "A370", func_8007BB48);
 
-// INCLUDE_ASM(const s32, "A370", func_8007BB90);
-extern unsigned char STR_Error;
-extern unsigned char STR_LHa___s_s__s;
-
 /* BF90 8007BB90 */
 void __log_lha_error(unsigned char* arg0, unsigned char* arg1) {
-    __some_logging(&STR_LHa___s_s__s, &STR_Error, arg0, arg1);
+    __some_logging(STR_LHa___s_s__s, STR_Error, arg0, arg1);
 }
 
-INCLUDE_ASM(const s32, "A370", func_8007BBC0);
+extern u8 D_800AE334;
 
-INCLUDE_ASM(const s32, "A370", func_8007BBF4);
+/* BFC0 8007BBC0 */
+void __log_fatal_error_desc(char* arg0) {
+    __some_logging(STR_LHa___s_s__s, STR_Fatal_error, &D_800AE334, arg0);
+}
+
+/* BFF4 8007BBF4 */
+void __log_fatal_error(char* arg0, char* arg1) {
+    __some_logging(STR_LHa___s_s__s, STR_Fatal_error, arg0, arg1);
+}
 
 INCLUDE_ASM(const s32, "A370", func_8007BC24);
 

src/boot.c

@@ -1,26 +1,12 @@
 #include "common.h"
 
-void boot(void);
-void idle(void* arg);
-
 void boot(void) {
-    extern OSThread THREAD_IDLE;
-    extern u8 SP_THREAD_IDLE[1];
-
     osInitialize();
     osCreateThread(&THREAD_IDLE, 1, idle, NULL, SP_THREAD_IDLE, 0xA);
     osStartThread(&THREAD_IDLE);
 }
 
 void idle(void* arg) {
-    extern void main_(void*);
-    extern void __idle_start_4_threads(s32, s32);
-    extern void (*D_800E7A18)();
-
-    extern u8 SP_THREAD_FIRST_DMA_LOAD[1];
-    extern OSThread THREAD_FIRST_DMA_LOAD;
-    extern OSThread THREAD_IDLE;
-
     D_800E7A18 = NULL;
 
     obInitializePi();

src/main.c

@@ -237,8 +237,6 @@ INCLUDE_ASM(const s32, "main", func_80073ED8);
 
 INCLUDE_ASM(const s32, "main", func_80073F58);
 
-// INCLUDE_ASM(const s32, "main", func_80073FD4);
-
 /* 43D4 80073FD4 */
 void __initialize_song_mem(void) {
     s32 mask;

src/overlays/overlay1/4D5C0.c

@@ -0,0 +1,228 @@
+#include "common.h"
+
+/* 4D5C0 801776C0 */
+void** func_801776C0(void) {
+    return D_8018FAE4;
+}
+
+/* 4D5CC 801776CC */
+void func_801776CC(void) {
+    func_80198080(-1);
+    D_800C4C26 = 0x800E;
+}
+
+/* 4D5F4 801776F4 */
+void** func_801776F4(void) {
+    return D_8018FAF8;
+}
+
+/* 4D600 80177700 */
+void func_80177700(void) {
+    func_80198080(0x29);
+    D_800C4C26 = 0x8014;
+}
+
+/* 4D628 80177728 */
+void** func_80177728(void) {
+    return D_8018FB0C;
+}
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177734);
+
+/* 4D88C 8017798C */
+void func_8017798C(void) {
+    func_8007337C();
+    func_801C8864();
+}
+
+/* 4D8B0 801779B0 */
+void func_801779B0(s32 arg0) {
+    func_8016C814();
+    func_801C889C(arg0);
+}
+
+/* 4D8DC 801779DC */
+void func_801779DC(void) {
+    func_801B00B0();
+}
+
+/* 4D8F8 801779F8 */
+void** func_801779F8(void) {
+    func_80173610();
+    return __GLOBAL_WITH__inc_menu_timer;
+}
+
+/* 4D91C 80177A1C */
+void func_80177A1C(void) {
+    func_8019B2E0();
+}
+
+/* 4D938 80177A38 */
+void __calls_inc_menu_timer(void) {
+    switch (__inc_menu_timer()) 
+    {
+    case 1:
+        func_80172368();
+        func_80172394();
+        func_8017223C(1);
+        func_801707F4();
+        D_800C4C26 = D_8018F1A2;
+        break;
+    case 2:
+        D_800C4C26 = 0x8012;
+        break;
+    case 3:
+        D_800C4C26 = 0x17;
+        break;
+    case 4:
+        switch(D_8018FB34) {
+        case 0:
+            D_800C4C26 = 0xB;
+            break;
+
+        case 1:
+            D_800C4C26 = 0xC;
+            break;                     
+        }
+
+        D_8018FB34 =  (D_8018FB34 + 1) % 2;        
+        break;
+    }
+}
+
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177B40);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177B5C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177B78);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177B84);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177CC0);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177D04);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177D20);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177D74);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177D80);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177DAC);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177DE8);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177E20);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177E4C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177E58);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177E74);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177EA0);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177EBC);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177ED8);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177EE4);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177F00);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177F1C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177F38);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177F54);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177F60);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177F7C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177FB4);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80177FD0);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178014);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178038);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178054);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178060);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_8017806C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_8017809C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801780CC);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801780E8);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178104);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178110);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178250);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178280);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_8017829C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801782B8);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801782C4);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801783A8);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801783D8);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801783F4);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178410);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178444);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178460);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_8017846C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_801784BC);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_8017850C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178534);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178548);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178898);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178900);
+
+void func_8017892C(void) { }
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178934);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178B20);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178B5C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178BF4);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178C64);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178C90);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178CCC);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178D10);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178D3C);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178DFC);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178E30);
+
+INCLUDE_ASM(const s32, "overlays/overlay1/4D5C0", func_80178E60);

src/overlays/overlay1/5C060.c

@@ -10,22 +10,24 @@ void func_80186178(void) {
     D_80197168[0] &= 0xFE;
 }
 
-INCLUDE_ASM(const s32, "overlays/overlay1/5C060", func_80186190);
+/* 5C090 80186190 */
+void func_80186190(s32 arg0, s32 arg1) {
+    if (arg1 != 0) {
+        s32 var_a1 = ((arg0 >= 0) ? arg0 : arg0 + 7);
+        D_80197168[(var_a1 >> 3)] = D_80197168[(var_a1 >> 3)] | (1 << (arg0 - ((var_a1 >> 3) * 8)));
+    } else {
+        s32 var_a1_3 = (arg0 >= 0) ? arg0 : arg0 + 7;
+        D_80197168[(var_a1_3 >> 3)] = D_80197168[(var_a1_3 >> 3)] & ~(1 << (arg0 - ((var_a1_3 >> 3) * 8)));
+    }
+}
 
 /* 5C110 80186210 */
 s32 func_80186210(s32 arg0) {
-    s32 temp_v1;
+    s32 var_v1 = (arg0 >= 0 ? arg0 : arg0 + 7);
-    s32 var_v1;
 
-    var_v1 = arg0;
+    return (D_80197168[(var_v1 >> 3)] >> (arg0 - ((var_v1 >> 3) * 8))) & 1;
-    if (arg0 < 0) {
-        var_v1 = arg0 + 7;
-    }
-    temp_v1 = var_v1 >> 3;
-    return (D_80197168[temp_v1] >> (arg0 - (temp_v1 * 8))) & 1;
 }
 
-
 /* 5C140 80186240 */
 s32 func_80186240(s32 arg0) {
     s32 temp_v1;

symbol_addrs.txt

@@ -6,9 +6,33 @@ __SOME_OVERLAY_TABLE_3 = 0x800A8438; // size:0x28
 __SOME_OVERLAY_TABLE_4 = 0x800A8460; // size:0x28
 __SOME_OVERLAY_TABLE_5 = 0x800A8488; // size:0x28
 __SOME_OVERLAY_TABLE_6 = 0x800A84B0; // size:0x28
+__SOME_OVERLAY_TABLE_7 = 0x800A84D8; // size:0x28
+__SOME_OVERLAY_TABLE_8 = 0x800A8500; // size:0x28
+__SOME_OVERLAY_TABLE_9 = 0x800A8528; // size:0x28
+__SOME_OVERLAY_TABLE_10 = 0x800A8550; // size:0x28
+__SOME_OVERLAY_TABLE_11 = 0x800A8578; // size:0x28
+__SOME_OVERLAY_TABLE_12 = 0x800A85A0; // size:0x28
+__SOME_OVERLAY_TABLE_13 = 0x800A85C8; // size:0x28
+__SOME_OVERLAY_TABLE_14 = 0x800A85F0; // size:0x28
+__SOME_OVERLAY_TABLE_15 = 0x800A8618; // size:0x28
+__SOME_OVERLAY_TABLE_16 = 0x800A8640; // size:0x28
+__SOME_OVERLAY_TABLE_17 = 0x800A8668; // size:0x28
+__SOME_OVERLAY_TABLE_18 = 0x800A8690; // size:0x28
 
 __SOME_OVERLAY_ID_ARRAY = 0x800A86FC; // size:0x2c
 
+UnusedMallocNo = 0x80077368;
+// The string at 0x800ADF08 translates to: "buSave: Saving...". It only appears in this function.
+buSave = 0x8007485C;
+
+// These strings are translated...
+STR_CREATING_NEW_DATA = 0x800ADEE8;
+STR_CREATING_A_NEW_FILE = 0x800ADEC8;
+STR_ADDING_NEW_DATA = 0x800ADEA4;
+STR_buSave_SAVING = 0x800ADF08;
+STR_UNUSEDMALLOCNO_INSUFFICIENT_MEMORY = 0x800ADF88;
+STR_FILE_NOT_FOUND = 0x800AE2AC;
+
 D_800A86B8 = 0x800A86B8; // size:0x3 type:u8
 D_800A86BC = 0x800A86BC; // size:0x6 type:u8
 D_800A86C4 = 0x800A86C4; // size:0x8 type:u8
@@ -20,6 +44,9 @@ D_800A86E4 = 0x800A86E4; // size:0x8 type:u8
 D_800A86EC = 0x800A86EC; // size:0x3 type:u8
 D_800A86F0 = 0x800A86F0; // size:0x7 type:u8
 D_800A86F8 = 0x800A86F8; // size:0x4 type:u8
+D_800AEFE0 = 0x800AEFE0; // size:0x8
+
+D_800AF028 = 0x800AF028; // size:0x64 type:u32
 
 __loads_overlay_array = 0x800761E4;
 __get_overlay_index = 0x80076430;
@@ -56,6 +83,9 @@ STR_rb = 0x800AE0A8; // type:asciz
 STR_wb = 0x800AE27C; // type:asciz
 STR_Unknown_method_skiped = 0x800AE284; // type:asciz
 
+__log_fatal_error = 0x8007BBF4;
+__log_fatal_error_desc = 0x8007BBC0;
+
 __set_vi_mode = 0x80072738;
 __calls_osViSwapBuffer_8007307C = 0x8007307C;
 __osViSwapBuffer_3 = 0x8008B110;
@@ -105,6 +135,8 @@ __inc_menu_timer = 0x8019BCEC; // type:func rom:0x1D21EC
 __calls_inc_menu_timer = 0x80177A38; // rom:0x4D938
 __MENU_INDEX = 0x801BA94C;
 
+__GLOBAL_WITH__inc_menu_timer = 0x8018FB20;
+
 __GLOBAL_CONT_STATUS = 0x800C4B38;
 
 __set_fp_8008A660 = 0x8008A660;
@@ -232,7 +264,7 @@ osViModePalLan1 = 0x800ABBE0;
 osViModeMpalLan1 = 0x800ABA00;
 osViModeNtscLan1 = 0x800AB960;
 
-__init_controllers = 0x80089C60;
+obInitControllers = 0x80089C60;
 
 MusFxBankInitialize = 0x80081F7C; // rom:0x1237C