From 72c850b0fbfaef3f2972e5e6356b218f4f05f411 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Mon, 25 Dec 2023 16:26:49 -0600
Subject: [PATCH] Clean up armem.c

---
 include/game/armem.h |  23 +--
 include/game/data.h  |   5 -
 include/game/perf.h  |   2 +-
 src/game/armem.c     | 431 +++++++++++++++++++++----------------------
 src/game/data.c      |   7 +-
 src/game/window.c    |   2 +-
 6 files changed, 232 insertions(+), 238 deletions(-)

diff --git a/include/game/armem.h b/include/game/armem.h
index 06ca3762..df62b322 100644
--- a/include/game/armem.h
+++ b/include/game/armem.h
@@ -3,19 +3,20 @@
 
 #include "common.h"
 #include "game/memory.h"
+#include "game/data.h"
 
 void HuARInit(void);
-void *HuARMalloc(u32 arg0);
-void HuARFree(void *arg0);
+u32 HuARMalloc(u32 size);
+void HuARFree(u32 amemptr);
 void HuAMemDump(void);
-void *HuAR_DVDtoARAM(u32 arg0);
-void HuAR_MRAMtoARAM(s32 arg0);
-void *HuAR_MRAMtoARAM2(void *arg0);
-void HuAR_ARAMtoMRAM(void *dst);
-void *HuAR_ARAMtoMRAMNum(void *dst, s32 num);
-BOOL HuARDMACheck(void);
-void *HuARDirCheck(u32 dir);
-void HuARDirFree(u32 arg0);
-void *HuAR_ARAMtoMRAMFileRead(u32 arg0, u32 arg1, HeapID arg2);
+u32 HuAR_DVDtoARAM(u32 dir);
+u32 HuAR_MRAMtoARAM(s32 dir);
+u32 HuAR_MRAMtoARAM2(void *dir_ptr);
+void HuAR_ARAMtoMRAM(u32 amemptr);
+void *HuAR_ARAMtoMRAMNum(u32 amemptr, s32 num);
+s32 HuARDMACheck(void);
+u32 HuARDirCheck(u32 dir);
+void HuARDirFree(u32 dir);
+void *HuAR_ARAMtoMRAMFileRead(u32 dir, u32 num, HeapID heap);
 
 #endif
diff --git a/include/game/data.h b/include/game/data.h
index 123c50de..36791bf4 100644
--- a/include/game/data.h
+++ b/include/game/data.h
@@ -63,10 +63,5 @@ void *HuDataReadNumHeapShortForce(s32 data_id, s32 num, HeapID heap);
 
 void HuDecodeData(void *src, void *dst, u32 size, int decode_type);
 
-void *HuARDirCheck(u32 dir);
-void HuAR_ARAMtoMRAM(void *dst);
-void *HuAR_ARAMtoMRAMNum(void *dst, s32 num);
-BOOL HuARDMACheck();
-
 
 #endif
\ No newline at end of file
diff --git a/include/game/perf.h b/include/game/perf.h
index 6061a5dd..08d804dc 100644
--- a/include/game/perf.h
+++ b/include/game/perf.h
@@ -1,7 +1,7 @@
 #ifndef _GAME_PERF_H
 #define _GAME_PERF_H
 
-#include "common.h"
+#include "dolphin.h"
 
 void HuPerfInit(void);
 s32 HuPerfCreate(char *arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4);
diff --git a/src/game/armem.c b/src/game/armem.c
index dd989cdc..ec2be64c 100644
--- a/src/game/armem.c
+++ b/src/game/armem.c
@@ -1,36 +1,35 @@
 #include "game/armem.h"
 #include "game/data.h"
 
-typedef struct some_armem_struct0 {
-    /* 0x00 */ u8 unk00;
-    /* 0x01 */ char unk01[1];
-    /* 0x02 */ u16 unk02;
-    /* 0x04 */ void *unk04;
-    /* 0x08 */ u32 unk08;
-    /* 0x0C */ struct some_armem_struct0 *unk0C;
-} SomeArmemStruct0; // Size 0x10
+typedef struct armem_block {
+    /* 0x00 */ u8 flag;
+    /* 0x02 */ u16 dir;
+    /* 0x04 */ u32 amemptr;
+    /* 0x08 */ u32 size;
+    /* 0x0C */ struct armem_block *next;
+} ARMemBlock; // Size 0x10
 
-typedef struct {
-    /* 0x00 */ ARQRequest unk00;
-    /* 0x20 */ s32 unk20;
-    /* 0x24 */ void *unk24;
-} SomeArmemStruct1; // Size 0x28
+typedef struct ar_que_req {
+    /* 0x00 */ ARQRequest req;
+    /* 0x20 */ s32 dir;
+    /* 0x24 */ void *dst;
+} ARQueReq; // Size 0x28
 
 static void ArqCallBack(u32 pointerToARQRequest);
 static void ArqCallBackAM(u32 pointerToARQRequest);
 static void ArqCallBackAMFileRead(u32 pointerToARQRequest);
 
 static s32 ATTRIBUTE_ALIGN(32) preLoadBuf[16];
-static SomeArmemStruct1 ARQueBuf[16];
+static ARQueReq ARQueBuf[16];
 static ARQRequest arqReq;
-static SomeArmemStruct0 ARInfo[64];
+static ARMemBlock ARInfo[64];
 
 static s32 ARBase;
 static s32 arqCnt;
 static s16 arqIdx;
 
 void HuARInit(void) {
-    s32 temp_r30;
+    s32 size;
     s16 i;
 
     if (!ARCheckInit()) {
@@ -38,185 +37,183 @@ void HuARInit(void) {
         ARQInit();
     }
     for (i = 0; i < 64; i++) {
-        ARInfo[i].unk04 = 0;
+        ARInfo[i].amemptr = 0;
     }
-    temp_r30 = ARGetSize() - 0x808000;
+    size = ARGetSize() - 0x808000;
     ARBase = 0x808000;
-    ARInfo[0].unk04 = (void*) ARBase;
-    ARInfo[0].unk08 = temp_r30;
-    ARInfo[0].unk00 = 0;
-    ARInfo[0].unk0C = &ARInfo[1];
-    ARInfo[0].unk02 = 0xFFFF;
-    ARInfo[1].unk04 = (void*) -1;
-    ARInfo[1].unk08 = 0;
-    ARInfo[1].unk00 = 1;
-    ARInfo[1].unk0C = 0;
-    ARInfo[1].unk02 = 0xFFFF;
+    ARInfo[0].amemptr = ARBase;
+    ARInfo[0].size = size;
+    ARInfo[0].flag = 0;
+    ARInfo[0].next = &ARInfo[1];
+    ARInfo[0].dir = 0xFFFF;
+    ARInfo[1].amemptr = -1;
+    ARInfo[1].size = 0;
+    ARInfo[1].flag = 1;
+    ARInfo[1].next = 0;
+    ARInfo[1].dir = 0xFFFF;
     arqCnt = 0;
 }
 
-void *HuARMalloc(u32 arg0) {
-    SomeArmemStruct0 *var_r27;
-    SomeArmemStruct0 *var_r30;
-    SomeArmemStruct0 *var_r31;
+u32 HuARMalloc(u32 size) {
+    ARMemBlock *prev;
+    ARMemBlock *next;
+    ARMemBlock *curr;
     s16 i;
 
-    arg0 = (arg0 + 0x1F) & ~0x1F;
-    var_r31 = var_r27 = ARInfo;
-    while (var_r31->unk0C != 0) {
-        if (var_r31->unk00 == 0 && var_r31->unk08 >= arg0) {
+    size = OSRoundUp32B(size);
+    curr = prev = ARInfo;
+    while (curr->next != 0) {
+        if (curr->flag == 0 && curr->size >= size) {
             break;
         }
-        var_r27 = var_r31;
-        var_r31 = var_r31->unk0C;
+        prev = curr;
+        curr = curr->next;
     }
-    if (var_r31->unk0C == 0) {
-        OSReport("Can't ARAM Allocated %x\n", arg0);
+    if (curr->next == 0) {
+        OSReport("Can't ARAM Allocated %x\n", size);
         HuAMemDump();
         return 0;
     }
-    var_r31->unk00 = 1;
-    if (var_r31->unk08 == arg0 && var_r27 != var_r31) {
-        var_r31->unk02 = 0xFFFF;
+    curr->flag = 1;
+    if (curr->size == size && prev != curr) {
+        curr->dir = 0xFFFF;
     } else {
-        var_r30 = &ARInfo[1];
-        for (i = 0; i < 63; i++, var_r30++) {
-            if (var_r30->unk04 == 0) {
+        next = &ARInfo[1];
+        for (i = 0; i < 63; i++, next++) {
+            if (!next->amemptr) {
                 break;
             }
         }
         if (i == 63) {
-            OSReport("Can't ARAM Allocated %x\n", arg0);
+            OSReport("Can't ARAM Allocated %x\n", size);
             return 0;
         }
-        var_r30->unk0C = var_r31->unk0C;
-        var_r31->unk0C = var_r30;
-        var_r30->unk08 = var_r31->unk08 - arg0;
-        var_r30->unk04 = (u8*) var_r31->unk04 + arg0;
-        var_r31->unk08 = arg0;
-        var_r31->unk02 = var_r30->unk02 = 0xFFFF;
-        var_r30->unk00 = 0;
+        next->next = curr->next;
+        curr->next = next;
+        next->size = curr->size - size;
+        next->amemptr = curr->amemptr + size;
+        curr->size = size;
+        curr->dir = next->dir = 0xFFFF;
+        next->flag = 0;
     }
-    return var_r31->unk04;
+    return curr->amemptr;
 }
 
-void HuARFree(void *arg0) {
-    SomeArmemStruct0 *var_r30;
-    SomeArmemStruct0 *temp_r29;
-    SomeArmemStruct0 *var_r31;
+void HuARFree(u32 amemptr) {
+    ARMemBlock *prev;
+    ARMemBlock *next;
+    ARMemBlock *curr;
 
-    var_r31 = var_r30 = ARInfo;
-    while (var_r31->unk0C != 0) {
-        if (var_r31->unk04 == arg0) {
+    curr = prev = ARInfo;
+    while (curr->next) {
+        if (curr->amemptr == amemptr) {
             break;
         }
-        var_r30 = var_r31;
-        var_r31 = var_r31->unk0C;
+        prev = curr;
+        curr = curr->next;
     }
-    if (var_r31->unk00 != 0) {
-        if (var_r31->unk0C == 0 && var_r31->unk04 != arg0) {
-            OSReport("Can't ARAM Free %x\n", arg0);
+    if (curr->flag != 0) {
+        if (!curr->next && curr->amemptr != amemptr) {
+            OSReport("Can't ARAM Free %x\n", amemptr);
             return;
         }
-        temp_r29 = var_r31->unk0C;
-        if (temp_r29->unk0C != 0 && temp_r29->unk00 == 0) {
-            if (var_r31->unk04 > temp_r29->unk04) {
-                var_r31->unk04 = temp_r29->unk04;
+        next = curr->next;
+        if (next->next && next->flag == 0) {
+            if (curr->amemptr > next->amemptr) {
+                curr->amemptr = next->amemptr;
             }
-            var_r31->unk08 += temp_r29->unk08;
-            var_r31->unk0C = temp_r29->unk0C;
-            temp_r29->unk04 = 0;
+            curr->size += next->size;
+            curr->next = next->next;
+            next->amemptr = 0;
         }
-        if (var_r30 != var_r31 && var_r30->unk0C != 0 && var_r30->unk00 == 0) {
-            if (var_r30->unk04 > var_r31->unk04) {
-                var_r30->unk04 = var_r31->unk04;
+        if (prev != curr && prev->next != 0 && prev->flag == 0) {
+            if (prev->amemptr > curr->amemptr) {
+                prev->amemptr = curr->amemptr;
             }
-            var_r30->unk08 += var_r31->unk08;
-            var_r30->unk0C = var_r31->unk0C;
-            var_r31->unk04 = 0;
+            prev->size += curr->size;
+            prev->next = curr->next;
+            curr->amemptr = 0;
         }
-        var_r31->unk00 = 0;
-        var_r31->unk02 = 0xFFFF;
+        curr->flag = 0;
+        curr->dir = 0xFFFF;
     }
 }
 
-static char lbl_80130705[] = "Can't Find ARAM %x\n";
+static u32 HuARSizeGet(u32 amemptr) {
+    ARMemBlock *curr;
+    ARMemBlock *prev;
 
-static inline SomeArmemStruct0 *ArmemInlineFunc1(void *arg0) {
-    SomeArmemStruct0 *temp_var1;
-    SomeArmemStruct0 *temp_var2;
-
-    temp_var1 = temp_var2 = ARInfo;
-    while (temp_var1->unk0C != 0) {
-        if (temp_var1->unk04 == arg0) {
+    curr = prev = ARInfo;
+    while (curr->next != 0) {
+        if (curr->amemptr == amemptr) {
             break;
         }
-        temp_var2 = temp_var1;
-        temp_var1 = temp_var1->unk0C;
+        prev = curr;
+        curr = curr->next;
     }
-    if (temp_var1->unk0C == 0 && temp_var1->unk04 != arg0) {
-        OSReport(lbl_80130705, arg0);
-        return NULL;
-    } else {
-        return temp_var1;
-    }
-}
-
-static inline u32 ArmemInlineFunc2(void *arg0) {
-    SomeArmemStruct0 *temp_var1;
-    SomeArmemStruct0 *temp_var2;
-
-    temp_var1 = temp_var2 = ARInfo;
-    while (temp_var1->unk0C != 0) {
-        if (temp_var1->unk04 == arg0) {
-            break;
-        }
-        temp_var2 = temp_var1;
-        temp_var1 = temp_var1->unk0C;
-    }
-    if (temp_var1->unk0C == 0 && temp_var1->unk04 != arg0) {
-        OSReport(lbl_80130705, arg0);
+    if (curr->next == 0 && curr->amemptr != amemptr) {
+        OSReport("Can't Find ARAM %x\n", amemptr);
         return 0;
     } else {
-        return temp_var1->unk08;
+        return curr->size;
+    }
+}
+
+static ARMemBlock *HuARInfoGet(u32 amemptr) {
+    ARMemBlock *curr;
+    ARMemBlock *prev;
+
+    curr = prev = ARInfo;
+    while (curr->next != 0) {
+        if (curr->amemptr == amemptr) {
+            break;
+        }
+        prev = curr;
+        curr = curr->next;
+    }
+    if (curr->next == 0 && curr->amemptr != amemptr) {
+        OSReport("Can't Find ARAM %x\n", amemptr);
+        return NULL;
+    } else {
+        return curr;
     }
 }
 
 void HuAMemDump(void) {
-    SomeArmemStruct0 *var_r31;
+    ARMemBlock *curr;
 
     OSReport("ARAM DUMP ======================\n");
     OSReport("AMemPtr  Stat Length\n");
-    for (var_r31 = ARInfo; var_r31->unk0C != 0; var_r31 = var_r31->unk0C) {
-        OSReport("%08x:%04x,%08x,%08x\n", var_r31->unk04, var_r31->unk00, var_r31->unk08, var_r31->unk02);
+    for (curr = ARInfo; curr->next; curr = curr->next) {
+        OSReport("%08x:%04x,%08x,%08x\n", curr->amemptr, curr->flag, curr->size, curr->dir);
     }
-    OSReport("%08x:%04x,%08x\n", var_r31->unk04, var_r31->unk00, var_r31->unk08);
+    OSReport("%08x:%04x,%08x\n", curr->amemptr, curr->flag, curr->size);
     OSReport("================================\n");
 }
 
-void *HuAR_DVDtoARAM(u32 arg0) {
-    DataReadStat *temp_r28;
-    SomeArmemStruct0 *var_r27;
-    void *temp_r3;
+u32 HuAR_DVDtoARAM(u32 dir) {
+    DataReadStat *stat;
+    ARMemBlock *block;
+    u32 amemptr;
 
-    temp_r3 = HuARDirCheck(arg0);
-    if (temp_r3 != 0) {
-        return temp_r3;
+    amemptr = HuARDirCheck(dir);
+    if (amemptr) {
+        return amemptr;
     }
-    temp_r28 = HuDataDirRead(arg0);
-    DirDataSize = (DirDataSize + 0x1F) & ~0x1F;
-    temp_r3 = HuARMalloc(DirDataSize);
-    if (temp_r3 == 0) {
+    stat = HuDataDirRead(dir);
+    DirDataSize = OSRoundUp32B(DirDataSize);
+    amemptr = HuARMalloc(DirDataSize);
+    if (!amemptr) {
         return 0;
     }
-    var_r27 = ArmemInlineFunc1(temp_r3);
-    var_r27->unk02 = (arg0 >> 16);
+    block = HuARInfoGet(amemptr);
+    block->dir = (dir >> 16);
     arqCnt++;
-    ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32) temp_r28->dir, (u32) temp_r3, DirDataSize, ArqCallBack);
-    OSReport("ARAM Trans %x\n", temp_r3);
+    ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32) stat->dir, amemptr, DirDataSize, ArqCallBack);
+    OSReport("ARAM Trans %x\n", amemptr);
     while (HuARDMACheck());
-    HuDataDirClose(arg0);
-    return temp_r3;
+    HuDataDirClose(dir);
+    return amemptr;
 }
 
 static void ArqCallBack(u32 pointerToARQRequest) {
@@ -224,151 +221,151 @@ static void ArqCallBack(u32 pointerToARQRequest) {
     (void)pointerToARQRequest; // required to match (return?)
 }
 
-void HuAR_MRAMtoARAM(s32 arg0) {
-    HuAR_MRAMtoARAM2(HuDataGetDirPtr(arg0));
+u32 HuAR_MRAMtoARAM(s32 dir) {
+    return HuAR_MRAMtoARAM2(HuDataGetDirPtr(dir));
 }
 
-void *HuAR_MRAMtoARAM2(void *arg0) {
-    SomeArmemStruct0 *var_r27;
-    DataReadStat *temp_r3_3;
-    u32 temp_r28;
-    void *temp_r3;
+u32 HuAR_MRAMtoARAM2(void *dir_ptr) {
+    ARMemBlock *block;
+    DataReadStat *status;
+    u32 size;
+    u32 amemptr;
 
-    temp_r3_3 = HuDataGetStatus(arg0);
-    temp_r3 = HuARDirCheck(temp_r3_3->dir_id << 16);
-    if (temp_r3 != 0) {
-        return temp_r3;
+    status = HuDataGetStatus(dir_ptr);
+    amemptr = HuARDirCheck(status->dir_id << 16);
+    if (amemptr) {
+        return amemptr;
     }
-    temp_r28 = HuMemMemorySizeGet(arg0);
-    temp_r28 = (temp_r28 + 0x1F) & ~0x1F;
-    temp_r3 = HuARMalloc(temp_r28);
-    if (temp_r3 == 0) {
+    size = HuMemMemorySizeGet(dir_ptr);
+    size = OSRoundUp32B(size);
+    amemptr = HuARMalloc(size);
+    if (!amemptr) {
         return 0;
     }
-    var_r27 = ArmemInlineFunc1(temp_r3);
-    var_r27->unk02 = temp_r3_3->dir_id;
+    block = HuARInfoGet(amemptr);
+    block->dir = status->dir_id;
     arqCnt++;
-    ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32) arg0, (u32) temp_r3, temp_r28, ArqCallBack);
-    return temp_r3;
+    ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32)dir_ptr, amemptr, size, ArqCallBack);
+    return amemptr;
 }
 
-void HuAR_ARAMtoMRAM(void *dst) {
-    HuAR_ARAMtoMRAMNum(dst, 0);
+void HuAR_ARAMtoMRAM(u32 src) {
+    HuAR_ARAMtoMRAMNum(src, 0);
 }
 
-void *HuAR_ARAMtoMRAMNum(void *dst, s32 num) {
-    SomeArmemStruct0 *var_r25;
-    s32 var_r26;
-    void *temp_r3;
+void *HuAR_ARAMtoMRAMNum(u32 src, s32 num) {
+    ARMemBlock *block;
+    s32 size;
+    void *dst;
 
-    var_r25 = ArmemInlineFunc1(dst);
-    if (HuDataReadChk(var_r25->unk02 << 16) >= 0) {
+    block = HuARInfoGet(src);
+    if (HuDataReadChk(block->dir << 16) >= 0) {
         return;
     }
-    var_r26 = ArmemInlineFunc2(dst);
-    temp_r3 = HuMemDirectMallocNum(HEAP_DVD, var_r26, num);
-    if (temp_r3 == 0) {
+    size = HuARSizeGet(src);
+    dst = HuMemDirectMallocNum(HEAP_DVD, size, num);
+    if (!dst) {
         return 0;
     }
-    DCFlushRangeNoSync(temp_r3, var_r26);
-    ARQueBuf[arqIdx].unk20 = (var_r25->unk02 << 16);
-    ARQueBuf[arqIdx].unk24 = temp_r3;
+    DCFlushRangeNoSync(dst, size);
+    ARQueBuf[arqIdx].dir = (block->dir << 16);
+    ARQueBuf[arqIdx].dst = dst;
     arqCnt++;
     PPCSync();
-    ARQPostRequest(&ARQueBuf[arqIdx].unk00, 0x1234, 1, 0, (u32) dst, (u32) temp_r3, var_r26, ArqCallBackAM);
+    ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, src, (u32) dst, size, ArqCallBackAM);
     arqIdx++;
     arqIdx &= 0xF;
-    return temp_r3;
+    return dst;
 }
 
 static void ArqCallBackAM(u32 pointerToARQRequest) {
-    SomeArmemStruct1 *sp8 = (SomeArmemStruct1*) pointerToARQRequest;
+    ARQueReq *req_ptr = (ARQueReq*) pointerToARQRequest;
 
     arqCnt--;
-    HuDataDirSet(sp8->unk24, sp8->unk20);
+    HuDataDirSet(req_ptr->dst, req_ptr->dir);
 }
 
-BOOL HuARDMACheck(void) {
+s32 HuARDMACheck(void) {
     return arqCnt;
 }
 
-void *HuARDirCheck(u32 dir) {
-    SomeArmemStruct0 *var_r31;
+u32 HuARDirCheck(u32 dir) {
+    ARMemBlock *curr;
 
-    var_r31 = ARInfo;
+    curr = ARInfo;
     dir >>= 16;
-    while (var_r31->unk0C != 0) {
-        if (var_r31->unk00 == 1 && var_r31->unk02 == dir) {
-            return var_r31->unk04;
+    while (curr->next != 0) {
+        if (curr->flag == 1 && curr->dir == dir) {
+            return curr->amemptr;
         }
-        var_r31 = var_r31->unk0C;
+        curr = curr->next;
     }
 
     return 0;
 }
 
-void HuARDirFree(u32 arg0) {
-    SomeArmemStruct0 *var_r31;
+void HuARDirFree(u32 dir) {
+    ARMemBlock *curr;
 
-    var_r31 = ARInfo;
-    arg0 >>= 16;
-    while (var_r31->unk0C != 0) {
-        if (var_r31->unk02 == arg0) {
-            HuARFree(var_r31->unk04);
+    curr = ARInfo;
+    dir >>= 16;
+    while (curr->next != 0) {
+        if (curr->dir == dir) {
+            HuARFree(curr->amemptr);
             break;
         }
-        var_r31 = var_r31->unk0C;
+        curr = curr->next;
     }
 }
 
-void *HuAR_ARAMtoMRAMFileRead(u32 arg0, u32 arg1, HeapID arg2) {
-    s32 *temp_r29;
-    void *temp_r3;
-    void *temp_r3_2;
-    void *var_r20;
-    s32 temp_r24;
-    s32 var_r22;
-    u8 *var_r17;
+void *HuAR_ARAMtoMRAMFileRead(u32 dir, u32 num, HeapID heap) {
+    s32 *dir_data;
+    void *dst;
+    void *dvd_data;
+    u32 amem_src;
+    s32 count;
+    s32 size;
+    u32 amemptr;
 
-    if ((var_r17 = HuARDirCheck(arg0)) == 0) {
-        OSReport("Error: data none on ARAM %0x\n", arg0);
+    if ((amemptr = HuARDirCheck(dir)) == 0) {
+        OSReport("Error: data none on ARAM %0x\n", dir);
         HuAMemDump();
         return 0;
     }
     DCInvalidateRange(&preLoadBuf, sizeof(preLoadBuf));
-    var_r20 = var_r17 + ((u32) (((u16) arg0 + 1) * 4) & 0xFFFFFFFE0);
+    amem_src = amemptr + (u32)((u32)(((u16)dir + 1) * 4) & 0xFFFFFFFE0);
     arqCnt++;
-    ARQPostRequest(&ARQueBuf[arqIdx].unk00, 0x1234, 1, 0, (u32) var_r20, (u32) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
+    ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (u32) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
     arqIdx++;
     arqIdx &= 0xF;
     while (HuARDMACheck());
-    temp_r29 = &preLoadBuf[(arg0 + 1) & 7];
-    temp_r24 = temp_r29[0];
-    var_r20 = var_r17 + (temp_r24 & 0xFFFFFFFE0);
-    if (temp_r29[1] - temp_r24 < 0) {
-        var_r22 = (ArmemInlineFunc2(var_r17) - temp_r24 + 0x3F) & 0xFFFFFFFE0;
+    dir_data = &preLoadBuf[(dir + 1) & 7];
+    count = dir_data[0];
+    amem_src = amemptr + (u32)(count & 0xFFFFFFFE0);
+    if (dir_data[1] - count < 0) {
+        size = (HuARSizeGet(amemptr) - count + 0x3F) & 0xFFFFFFFE0;
     } else {
-        var_r22 = (temp_r29[1] - temp_r24 + 0x3F) & 0xFFFFFFFE0;
+        size = (dir_data[1] - count + 0x3F) & 0xFFFFFFFE0;
     }
-    temp_r3_2 = HuMemDirectMalloc(HEAP_DVD, var_r22);
-    if (temp_r3_2 == 0) {
+    dvd_data = HuMemDirectMalloc(HEAP_DVD, size);
+    if (!dvd_data) {
         return 0;
     }
-    DCFlushRangeNoSync(temp_r3_2, var_r22);
+    DCFlushRangeNoSync(dvd_data, size);
     arqCnt++;
     PPCSync();
-    ARQPostRequest(&ARQueBuf[arqIdx].unk00, 0x1234, 1, 0, (u32) var_r20, (u32) temp_r3_2, (u32) var_r22, ArqCallBackAMFileRead);
+    ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (u32) dvd_data, (u32) size, ArqCallBackAMFileRead);
     arqIdx++;
     arqIdx &= 0xF;
     while (HuARDMACheck());
-    temp_r29 = (s32*) ((u8*) temp_r3_2 + (temp_r24 & 0x1F));
-    temp_r3 = HuMemDirectMallocNum(arg2, (temp_r29[0] + 1) & ~1, arg1);
-    if (temp_r3 == 0) {
+    dir_data = (s32*) ((u8*) dvd_data + (count & 0x1F));
+    dst = HuMemDirectMallocNum(heap, (dir_data[0] + 1) & ~1, num);
+    if (!dst) {
         return 0;
     }
-    HuDecodeData(&temp_r29[2], temp_r3, temp_r29[0], temp_r29[1]);
-    HuMemDirectFree(temp_r3_2);
-    return temp_r3;
+    HuDecodeData(&dir_data[2], dst, dir_data[0], dir_data[1]);
+    HuMemDirectFree(dvd_data);
+    return dst;
 }
 
 static void ArqCallBackAMFileRead(u32 pointerToARQRequest) {
diff --git a/src/game/data.c b/src/game/data.c
index b69447fc..7048bdc1 100644
--- a/src/game/data.c
+++ b/src/game/data.c
@@ -1,5 +1,6 @@
 #include "common.h"
 #include "game/data.h"
+#include "game/armem.h"
 #include "dolphin/dvd.h"
 
 #define PTR_OFFSET(ptr, offset) (void *)(((u8 *)(ptr)+(u32)(offset)))
@@ -108,7 +109,7 @@ DataReadStat *HuDataDirRead(s32 data_num)
     }
     
     if((status = HuDataReadChk(data_num)) < 0) {
-        void *dir_aram;
+        u32 dir_aram;
         if(dir_aram = HuARDirCheck(data_num)) {
             HuAR_ARAMtoMRAM(dir_aram);
             while(HuARDMACheck());
@@ -144,7 +145,7 @@ DataReadStat *HuDataDirReadNum(s32 data_num, s32 num)
     }
     
     if((status = HuDataReadChk(data_num)) < 0) {
-        void *dir_aram;
+        u32 dir_aram;
         if((dir_aram = HuARDirCheck(data_num))) {
             OSReport("ARAM data num %x\n", data_num);
             HuAR_ARAMtoMRAMNum(dir_aram, num);
@@ -220,7 +221,7 @@ s32 HuDataDirReadAsync(s32 data_num)
         return -1;
     }
     if((status = HuDataReadChk(data_num)) < 0) {
-        void *dir_aram;
+        u32 dir_aram;
         if(dir_aram = HuARDirCheck(data_num)) {
             OSReport("ARAM data num %x\n", data_num);
             HuAR_ARAMtoMRAM(dir_aram);
diff --git a/src/game/window.c b/src/game/window.c
index bf925243..5fdb5680 100644
--- a/src/game/window.c
+++ b/src/game/window.c
@@ -59,7 +59,7 @@ static s16 winMaxHeight;
 static u8 mesWInsert[8];
 static u8 winTabSize;
 static u8 winInsertF;
-static void *winAMemP;
+static u32 winAMemP;
 static u8 *fontWidthP;
 static s32 cancelCRF;
 static s16 mesCharCnt;