diff --git a/include/jaudio_NES/channel.h b/include/jaudio_NES/channel.h
index bfab8930..21d66d1d 100644
--- a/include/jaudio_NES/channel.h
+++ b/include/jaudio_NES/channel.h
@@ -22,5 +22,8 @@ extern void Nas_Release_Channel_Force(note* n);
 extern void Nas_EntryTrack(channel* chan, note* n);
 
 extern void Nas_CutList(link* l);
+extern void Nas_StopVoice(channel* chan);
 
+extern void Nas_ChannelInit(void);
+extern void Nas_InitChannelList(void);
 #endif
diff --git a/include/jaudio_NES/memory.h b/include/jaudio_NES/memory.h
index cdac9215..8b27782c 100644
--- a/include/jaudio_NES/memory.h
+++ b/include/jaudio_NES/memory.h
@@ -14,7 +14,7 @@ extern void* Nas_Alloc_Single(s32 size, s32 bank_id, u8* wave_addr, s8 medium, s
 extern void* Nas_CacheOff(u8* addr, s32 size);
 
 extern void* Nas_SzHeapAlloc(s32 table_type, s32 size, s32 cache_type, s32 id);
-extern u32 Nas_SzCacheCheck(s32 type, s32 cache_type, s32 id);
+extern void* Nas_SzCacheCheck(s32 type, s32 cache_type, s32 id);
 extern void Nas_SzStayDelete(s32 type);
 extern void Nas_SzHeapReset(u32 fix_size);
 
diff --git a/include/jaudio_NES/system.h b/include/jaudio_NES/system.h
index 1e5ba751..9162905c 100644
--- a/include/jaudio_NES/system.h
+++ b/include/jaudio_NES/system.h
@@ -55,6 +55,11 @@ extern void LpsDma(s32 reset_status);
 extern s32 Nas_CheckBgWave(s32 reset_status);
 extern void Nas_BgCopyMain(s32 reset_status);
 
+extern void EmemReload(void);
+extern void Nas_BgCopyInit(void);
+extern void MK_Init(void);
+extern void Nas_WaveDmaNew(s32 n_channels);
+
 extern BOOL AUDIO_SYSTEM_READY;
 extern Na_DmaProc NA_DMA_PROC;
 extern OSMesgQueue MK_QUEUE;
diff --git a/src/static/jaudio_NES/internal/memory.c b/src/static/jaudio_NES/internal/memory.c
index 0adebabb..690aec4f 100644
--- a/src/static/jaudio_NES/internal/memory.c
+++ b/src/static/jaudio_NES/internal/memory.c
@@ -1,13 +1,32 @@
 #include "jaudio_NES/memory.h"
 
+#include "jaudio_NES/audioconst.h"
+#include "jaudio_NES/audiowork.h"
+#include "jaudio_NES/channel.h"
+#include "jaudio_NES/track.h"
+#include "jaudio_NES/os.h"
+#include "jaudio_NES/system.h"
+#include "dolphin/os.h"
+
+void DirtyWave(s32);
+void* __Nas_SzCacheCheck_Inner(s32 a, s32 b, s32 c);
+void __RomAddrSet(SwMember*, smzwavetable*);
+SwMember* __Nas_Alloc_Single_Stay_Inner(s32 a);
+SwMember* __Nas_Alloc_Single_Auto_Inner(s32 a);
+void __ExchangeWave(s32, s32);
+void __KillSwMember(SwMember* a);
+void __Nas_MemoryReconfig();
+void Emem_KillSwMember();
+void Dirty_AllWave();
+void Nas_SetDelayLine(s32 a, fxconfig* b, s32 c);
+int Nas_Init_Single(s32, s32);
 /*
  * --INFO--
  * Address:	........
  * Size:	00001C
  */
-void __CalcRelf(f32)
-{
-	// UNUSED FUNCTION
+f32 __CalcRelf(f32 val) {
+    return (AG.audio_params.updates_per_frame_inverse_scaled * 256.f) / val;
 }
 
 /*
@@ -15,9 +34,23 @@ void __CalcRelf(f32)
  * Address:	........
  * Size:	000170
  */
-void MakeReleaseTable()
-{
-	// UNUSED FUNCTION
+void MakeReleaseTable() {
+    int i;
+    AG.adsr_decay_table[0xff] = __CalcRelf(0.25f);
+    AG.adsr_decay_table[0xfe] = __CalcRelf(0.33f);
+    AG.adsr_decay_table[0xfd] = __CalcRelf(0.5f);
+    AG.adsr_decay_table[0xfc] = __CalcRelf(0.66f);
+    AG.adsr_decay_table[0xfb] = __CalcRelf(0.75f);
+    for (i = 0x80; i < 0xfb; i++) {
+        AG.adsr_decay_table[i] = __CalcRelf(0xfb - i);
+    }
+    for (i = 0x10; i < 0x80; i++) {
+        AG.adsr_decay_table[i] = __CalcRelf((0x80 - i) * 4 + 0x3c);
+    }
+    for (i = 1; i < 0x10; i++) {
+        AG.adsr_decay_table[i] = __CalcRelf((0xf - i) * 0x3c + 0x1e0);
+    }
+    AG.adsr_decay_table[0] = 0.f;
 }
 
 /*
@@ -25,9 +58,20 @@ void MakeReleaseTable()
  * Address:	........
  * Size:	0000A0
  */
-void Nas_ResetIDtable()
-{
-	// UNUSED FUNCTION
+void Nas_ResetIDtable() {
+    int i;
+    for (i = 0; i < ARRAY_COUNT(AG.bank_load_status); i++) {
+        if (AG.bank_load_status[i] != 5)
+            AG.bank_load_status[i] = 0;
+    }
+    for (i = 0; i < ARRAY_COUNT(AG.wave_load_status); i++) {
+        if (AG.wave_load_status[i] != 5)
+            AG.wave_load_status[i] = 0;
+    }
+    for (i = 0; i < ARRAY_COUNT(AG.sequence_load_status); i++) {
+        if (AG.sequence_load_status[i] != 5)
+            AG.sequence_load_status[i] = 0;
+    }
 }
 
 /*
@@ -35,9 +79,20 @@ void Nas_ResetIDtable()
  * Address:	........
  * Size:	0000E0
  */
-void Nas_ForceStopChannel(s32)
-{
-	// UNUSED FUNCTION
+void Nas_ForceStopChannel(s32 bankID) {
+    int i;
+    for (i = 0; i < AG.num_channels; i++) {
+        channel* channel = &AG.channels[i];
+        if (channel->playback_ch.bank_id == bankID) {
+            if (channel->playback_ch.status == 0 && channel->playback_ch.priority != 0) {
+                channel->playback_ch.current_parent_note->enabled = FALSE;
+                channel->playback_ch.current_parent_note->finished = TRUE;
+            }
+            Nas_StopVoice(channel);
+            Nas_CutList(&channel->link);
+            Nas_AddList(&AG.channel_node.freeList, &channel->link);
+        }
+    }
 }
 
 /*
@@ -45,9 +100,8 @@ void Nas_ForceStopChannel(s32)
  * Address:	........
  * Size:	00006C
  */
-void Nas_ForceReleaseChannel(s32)
-{
-	// UNUSED FUNCTION
+void Nas_ForceReleaseChannel(s32 param_1) {
+    // UNUSED FUNCTION
 }
 
 /*
@@ -55,9 +109,13 @@ void Nas_ForceReleaseChannel(s32)
  * Address:	........
  * Size:	000084
  */
-void Nas_ForceStopSeq(s32)
-{
-	// UNUSED FUNCTION
+void Nas_ForceStopSeq(s32 id) {
+    int i;
+    for (i = 0; i < AG.audio_params.num_groups; i++) {
+        if (AG.groups[i].flags.enabled && AG.groups[i].seq_id == id) {
+            Nas_ReleaseGroup(AG.groups_p[i]);
+        }
+    }
 }
 
 /*
@@ -65,9 +123,9 @@ void Nas_ForceStopSeq(s32)
  * Address:	........
  * Size:	000030
  */
-void* Nas_CacheOff(u8*, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_CacheOff(u8* vaddr, s32 nbytes) {
+    osWritebackDCache2(vaddr, nbytes);
+    return vaddr;
 }
 
 /*
@@ -75,9 +133,15 @@ void* Nas_CacheOff(u8*, s32)
  * Address:	........
  * Size:	00006C
  */
-void Nas_2ndHeapAlloc_CL(ALHeap*, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_2ndHeapAlloc_CL(ALHeap* heap, s32 size) {
+    void* ret = NULL;
+    if (AG.external_heap.base != NULL) {
+        ret = Nas_HeapAlloc_CL(&AG.external_heap, size);
+    }
+    if (ret == NULL) {
+        ret = Nas_HeapAlloc_CL(heap, size);
+    }
+    return ret;
 }
 
 /*
@@ -85,9 +149,15 @@ void Nas_2ndHeapAlloc_CL(ALHeap*, s32)
  * Address:	........
  * Size:	00006C
  */
-void* Nas_2ndHeapAlloc(ALHeap*, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_2ndHeapAlloc(ALHeap* heap, s32 size) {
+    void* ret = NULL;
+    if (AG.external_heap.base != NULL) {
+        ret = Nas_HeapAlloc(&AG.external_heap, size);
+    }
+    if (ret == NULL) {
+        ret = Nas_HeapAlloc(heap, size);
+    }
+    return ret;
 }
 
 /*
@@ -95,9 +165,12 @@ void* Nas_2ndHeapAlloc(ALHeap*, s32)
  * Address:	........
  * Size:	00003C
  */
-void* Nas_NcHeapAlloc(ALHeap*, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_NcHeapAlloc(ALHeap* heap, s32 size) {
+    void* ret = Nas_HeapAlloc(heap, size);
+    if (ret != NULL) {
+        ret = Nas_CacheOff((u8*)ret, size);
+    }
+    return ret;
 }
 
 /*
@@ -105,9 +178,12 @@ void* Nas_NcHeapAlloc(ALHeap*, s32)
  * Address:	........
  * Size:	00003C
  */
-void Nas_NcHeapAlloc_CL(ALHeap*, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_NcHeapAlloc_CL(ALHeap* heap, s32 size) {
+    void* ret = Nas_HeapAlloc_CL(heap, size);
+    if (ret != NULL) {
+        ret = Nas_CacheOff((u8*)ret, size);
+    }
+    return ret;
 }
 
 /*
@@ -115,9 +191,16 @@ void Nas_NcHeapAlloc_CL(ALHeap*, s32)
  * Address:	........
  * Size:	000054
  */
-void* Nas_HeapAlloc_CL(ALHeap*, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_HeapAlloc_CL(ALHeap* heap, s32 size) {
+    // int i;
+    void* ret = Nas_HeapAlloc(heap, size);
+    if (ret != NULL) {
+        u8* i = (u8*)ret;
+        while (i < heap->current) {
+            *i++ = 0;
+        }
+    }
+    return ret;
 }
 
 /*
@@ -125,9 +208,8 @@ void* Nas_HeapAlloc_CL(ALHeap*, s32)
  * Address:	........
  * Size:	000048
  */
-void Nas_TmpAlloc(ALHeap*, s32)
-{
-	// UNUSED FUNCTION
+void Nas_TmpAlloc(ALHeap* param_1, s32 param_2) {
+    // UNUSED FUNCTION
 }
 
 /*
@@ -135,9 +217,8 @@ void Nas_TmpAlloc(ALHeap*, s32)
  * Address:	........
  * Size:	000034
  */
-void Nas_HeapFree(ALHeap*)
-{
-	// UNUSED FUNCTION
+void Nas_HeapFree(ALHeap* param_1) {
+    // UNUSED FUNCTION
 }
 
 /*
@@ -145,26 +226,26 @@ void Nas_HeapFree(ALHeap*)
  * Address:	80005640
  * Size:	00006C
  */
-void* Nas_HeapAlloc(ALHeap* heap, s32 size)
-{
-	s32* REF_size;
+void* Nas_HeapAlloc(ALHeap* heap, s32 size) {
+    s32* REF_size;
 
-	REF_size        = &size;
-	u32 roundedSize = ALIGN_NEXT(size, 32);
-	if (!heap->base) {
-		return NULL;
-	}
+    REF_size = &size;
+    u32 roundedSize = ALIGN_NEXT(size, 32);
+    if (!heap->base) {
+        OSReport("Warning: Not Allocated Heap\n");
+        return NULL;
+    }
 
-	u8* prev = heap->current;
-	if (prev + roundedSize <= heap->base + heap->length) {
-		heap->current = prev + roundedSize;
-	} else {
-		return NULL;
-	}
+    u8* prev = heap->current;
+    if (prev + roundedSize <= heap->base + heap->length) {
+        heap->current = prev + roundedSize;
+    } else {
+        return NULL;
+    }
 
-	heap->count++;
-	heap->last = prev;
-	return prev;
+    heap->count++;
+    heap->last = prev;
+    return prev;
 }
 
 /*
@@ -172,25 +253,25 @@ void* Nas_HeapAlloc(ALHeap* heap, s32 size)
  * Address:	800056C0
  * Size:	000058
  */
-void Nas_HeapInit(ALHeap* heap, u8* p2, s32 p3)
-{
-	ALHeap** REF_heap;
+void Nas_HeapInit(ALHeap* heap, u8* p2, s32 p3) {
+    ALHeap** REF_heap;
 
-	int length;
+    int length;
 
-	REF_heap    = &heap;
-	heap->count = 0;
-	if (!p2) {
-		heap->length  = 0;
-		heap->current = NULL;
-		heap->last    = NULL;
-	} else {
-		length        = p3 - ((u32)p2 & 0x1F);
-		heap->base    = (u8*)ALIGN_NEXT((u32)p2, 32);
-		heap->current = heap->base;
-		heap->length  = length;
-		heap->last    = NULL;
-	}
+    REF_heap = &heap;
+    heap->count = 0;
+    if (!p2) {
+        OSReport("Warning: 0 base heap.\n");
+        heap->length = 0;
+        heap->current = NULL;
+        heap->last = NULL;
+    } else {
+        length = p3 - ((u32)p2 & 0x1F);
+        heap->base = (u8*)ALIGN_NEXT((u32)p2, 32);
+        heap->current = heap->base;
+        heap->length = length;
+        heap->last = NULL;
+    }
 }
 
 /*
@@ -198,9 +279,10 @@ void Nas_HeapInit(ALHeap* heap, u8* p2, s32 p3)
  * Address:	........
  * Size:	000018
  */
-void Nas_SzStayClear(SZStay*)
-{
-	// UNUSED FUNCTION
+void Nas_SzStayClear(SZStay* p1) {
+    p1->heap.current = p1->heap.base;
+    p1->heap.count = NULL;
+    p1->num_entries = 0;
 }
 
 /*
@@ -208,9 +290,14 @@ void Nas_SzStayClear(SZStay*)
  * Address:	........
  * Size:	00003C
  */
-void Nas_SzAutoClear(SZAuto*)
-{
-	// UNUSED FUNCTION
+void Nas_SzAutoClear(SZAuto* p1) {
+    p1->heap.current = p1->heap.base;
+    p1->heap.count = 0;
+    p1->use_entry_idx = 0;
+    p1->entries[0].addr = p1->heap.base;
+    p1->entries[1].addr = p1->heap.base + p1->heap.length;
+    p1->entries[0].id = -1;
+    p1->entries[1].id = -1;
 }
 
 /*
@@ -228,9 +315,36 @@ void Nas_SzAutoClear(SZAuto*)
  * Address:	........
  * Size:	00010C
  */
-void Nas_SzStayDelete(s32)
-{
-	// UNUSED FUNCTION
+void Nas_SzStayDelete(s32 a) {
+    SZHeap* r31;
+    u8* r30;
+    switch (a) {
+        case SEQUENCE_TABLE: {
+            r31 = &AG.seq_heap;
+            r30 = AG.sequence_load_status;
+        } break;
+        case BANK_TABLE: {
+            r31 = &AG.bank_heap;
+            r30 = AG.bank_load_status;
+        } break;
+        case WAVE_TABLE: {
+            r31 = &AG.wave_heap;
+            r30 = AG.wave_load_status;
+        } break;
+    }
+    ALHeap* heap = &r31->stay_heap.heap;
+    if (r31->stay_heap.num_entries != 0) {
+        heap->current = r31->stay_heap.entries[r31->stay_heap.num_entries - 1].addr;
+        heap->count--;
+        if (a == 2) {
+            DirtyWave(r31->stay_heap.entries[r31->stay_heap.num_entries - 1].id);
+        }
+        if (a == 1) {
+            Nas_ForceStopChannel(r31->stay_heap.entries[r31->stay_heap.num_entries - 1].id);
+        }
+        r30[r31->stay_heap.entries[r31->stay_heap.num_entries - 1].id] = 0;
+        r31->stay_heap.num_entries--;
+    }
 }
 
 /*
@@ -238,9 +352,11 @@ void Nas_SzStayDelete(s32)
  * Address:	........
  * Size:	000068
  */
-void Nas_SzHeapReset(u32)
-{
-	// UNUSED FUNCTION
+void Nas_SzHeapReset(u32 fixSize) {
+    OSReport("FixSIZE is %x\n", fixSize);
+    Nas_HeapInit(&AG.init_heap, (u8*)AG.audio_heap_p, fixSize);
+    Nas_HeapInit(&AG.session_heap, (u8*)AG.audio_heap_p + fixSize, AG.audio_heap_size - fixSize);
+    AG.external_heap.base = NULL;
 }
 
 /*
@@ -248,9 +364,11 @@ void Nas_SzHeapReset(u32)
  * Address:	........
  * Size:	000058
  */
-void Nas_SzHeapDivide(AudioHeapstrc*)
-{
-	// UNUSED FUNCTION
+void Nas_SzHeapDivide(AudioHeapstrc* param_1) {
+    AG.session_heap.current = AG.session_heap.base;
+    Nas_HeapInit(&AG.misc_heap, (u8*)Nas_HeapAlloc(&AG.session_heap, param_1->misc_heap_size), param_1->misc_heap_size);
+    Nas_HeapInit(&AG.sz_data_heap, (u8*)Nas_HeapAlloc(&AG.session_heap, param_1->cache_heap_size),
+                 param_1->cache_heap_size);
 }
 
 /*
@@ -258,9 +376,10 @@ void Nas_SzHeapDivide(AudioHeapstrc*)
  * Address:	........
  * Size:	000014
  */
-void Nas_SzDataDivide(DataHeapstrc*)
-{
-	// UNUSED FUNCTION
+void Nas_SzDataDivide(DataHeapstrc* param_1) {
+    AG.sz_data_heap.current = AG.sz_data_heap.base;
+    Nas_HeapInit(&AG.data_heap, (u8*)Nas_HeapAlloc(&AG.sz_data_heap, param_1->data_size), param_1->data_size);
+    Nas_HeapInit(&AG.sz_auto_heap, (u8*)Nas_HeapAlloc(&AG.sz_data_heap, param_1->auto_size), param_1->auto_size);
 }
 
 /*
@@ -268,9 +387,17 @@ void Nas_SzDataDivide(DataHeapstrc*)
  * Address:	........
  * Size:	0000B4
  */
-void Nas_SzStayDivide(StayHeapstrc*)
-{
-	// UNUSED FUNCTION
+void Nas_SzStayDivide(StayHeapstrc* param_1) {
+    AG.data_heap.current = AG.data_heap.base;
+    Nas_HeapInit(&AG.seq_heap.stay_heap.heap, (u8*)Nas_HeapAlloc(&AG.data_heap, param_1->seq_heap_size),
+                 param_1->seq_heap_size);
+    Nas_HeapInit(&AG.bank_heap.stay_heap.heap, (u8*)Nas_HeapAlloc(&AG.data_heap, param_1->bank_heap_size),
+                 param_1->bank_heap_size);
+    Nas_HeapInit(&AG.wave_heap.stay_heap.heap, (u8*)Nas_HeapAlloc(&AG.data_heap, param_1->wave_heap_size),
+                 param_1->wave_heap_size);
+    Nas_SzStayClear(&AG.seq_heap.stay_heap);
+    Nas_SzStayClear(&AG.bank_heap.stay_heap);
+    Nas_SzStayClear(&AG.wave_heap.stay_heap);
 }
 
 /*
@@ -278,9 +405,16 @@ void Nas_SzStayDivide(StayHeapstrc*)
  * Address:	........
  * Size:	0000B4
  */
-void Nas_SzAutoDivide(AutoHeapstrc*)
-{
-	// UNUSED FUNCTION
+void Nas_SzAutoDivide(AutoHeapstrc* param_1) {
+    AG.sz_auto_heap.current = AG.sz_auto_heap.base;
+    Nas_HeapInit(&AG.seq_heap.auto_heap.heap, (u8*)Nas_HeapAlloc(&AG.sz_auto_heap, param_1->seqLen), param_1->seqLen);
+    Nas_HeapInit(&AG.bank_heap.auto_heap.heap, (u8*)Nas_HeapAlloc(&AG.sz_auto_heap, param_1->bankLen),
+                 param_1->bankLen);
+    Nas_HeapInit(&AG.wave_heap.auto_heap.heap, (u8*)Nas_HeapAlloc(&AG.sz_auto_heap, param_1->waveLen),
+                 param_1->waveLen);
+    Nas_SzAutoClear(&AG.seq_heap.auto_heap);
+    Nas_SzAutoClear(&AG.bank_heap.auto_heap);
+    Nas_SzAutoClear(&AG.wave_heap.auto_heap);
 }
 
 /*
@@ -288,9 +422,271 @@ void Nas_SzAutoDivide(AutoHeapstrc*)
  * Address:	........
  * Size:	0006CC
  */
-void* Nas_SzHeapAlloc(s32, s32, s32, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_SzHeapAlloc(s32 tableType, s32 size, s32 param_3, s32 id) {
+    SZAuto* auto_heap;
+    SZHeap* sound_heap;
+    void* alloc;
+    ALHeap* heap;
+    u8 status0;
+    u8 status1;
+    int end;
+    ALHeapEntry* entry;
+    int checkId;
+    u8* outStatus;
+    int idx;
+
+    switch (tableType) {
+        case SEQUENCE_TABLE: {
+            sound_heap = &AG.seq_heap;
+            outStatus = AG.sequence_load_status;
+        } break;
+        case BANK_TABLE: {
+            sound_heap = &AG.bank_heap;
+            outStatus = AG.bank_load_status;
+        } break;
+        case WAVE_TABLE: {
+            sound_heap = &AG.wave_heap;
+            outStatus = AG.wave_load_status;
+        } break;
+    }
+
+    if (param_3 == 0) {
+        auto_heap = &sound_heap->auto_heap;
+        heap = &auto_heap->heap;
+        if (auto_heap->heap.length < size) {
+            return NULL;
+        }
+
+        if (auto_heap->entries[0].id == HEAP_INVALID_INDEX) {
+            status0 = 0;
+        } else {
+            status0 = outStatus[auto_heap->entries[0].id];
+        }
+
+        if (auto_heap->entries[1].id == HEAP_INVALID_INDEX) {
+            status1 = 0;
+        } else {
+            status1 = outStatus[auto_heap->entries[1].id];
+        }
+
+        if (tableType == BANK_TABLE) {
+            if (status0 == 4) {
+                int i;
+                end = AG.num_channels;
+                checkId = auto_heap->entries[0].id;
+                for (i = 0; i < end; i++) {
+                    if (checkId == AG.channels[i].playback_ch.bank_id && AG.channels[i].common_ch.enabled) {
+                        break;
+                    }
+                }
+
+                if (i == AG.num_channels) {
+                    Nas_WriteIDbank(auto_heap->entries[0].id, 3);
+                    status0 = 3;
+                }
+            }
+
+            if (status1 == 4) {
+                int i;
+                end = AG.num_channels;
+                for (i = 0; i < end; i++) {
+                    if (auto_heap->entries[1].id == AG.channels[i].playback_ch.bank_id &&
+                        AG.channels[i].common_ch.enabled) {
+                        break;
+                    }
+                }
+
+                if (i == AG.num_channels) {
+                    Nas_WriteIDbank(auto_heap->entries[1].id, 3);
+                    status1 = 3;
+                }
+            }
+        }
+
+        if (status0 == 0) {
+            auto_heap->use_entry_idx = FALSE;
+            goto aftretnull;
+        }
+
+        if (status1 == 0) {
+            auto_heap->use_entry_idx = TRUE;
+            goto aftretnull;
+        }
+
+        if (status0 != 3 || status1 != 3) {
+            if (status0 == 3) {
+                auto_heap->use_entry_idx = FALSE;
+                goto aftretnull;
+            } else if (status1 == 3) {
+                auto_heap->use_entry_idx = TRUE;
+                goto aftretnull;
+            } else if (tableType == SEQUENCE_TABLE) {
+                if (status0 == 2) {
+                    int i;
+                    end = AG.audio_params.num_groups;
+                    for (i = 0; i < end; i++) {
+                        if (AG.groups[i].flags.enabled && AG.groups[i].seq_id == auto_heap->entries[0].id) {
+                            break;
+                        }
+                    }
+                    if (i == end) {
+                        auto_heap->use_entry_idx = FALSE;
+                        goto aftretnull;
+                    }
+                }
+                if (status1 == 2) {
+                    int i;
+                    end = AG.audio_params.num_groups;
+                    for (i = 0; i < end; i++) {
+                        if (AG.groups[i].flags.enabled && AG.groups[i].seq_id == auto_heap->entries[1].id) {
+                            break;
+                        }
+                    }
+                    if (i == end) {
+                        auto_heap->use_entry_idx = TRUE;
+                        goto aftretnull;
+                    }
+                }
+            } else if (tableType == BANK_TABLE) {
+                if (status0 == 2) {
+                    int i;
+                    end = AG.num_channels;
+                    for (i = 0; i < end; i++) {
+                        if (auto_heap->entries[0].id == AG.channels[i].playback_ch.bank_id &&
+                            AG.channels[i].common_ch.enabled) {
+                            break;
+                        }
+                    }
+                    if (i == end) {
+                        auto_heap->use_entry_idx = FALSE;
+                        goto aftretnull;
+                    }
+                }
+                if (status1 == 2) {
+                    int i;
+                    end = AG.num_channels;
+                    checkId = auto_heap->entries[1].id;
+                    for (i = 0; i < end; i++) {
+                        if (auto_heap->entries[1].id == AG.channels[i].playback_ch.bank_id &&
+                            AG.channels[i].common_ch.enabled) {
+                            break;
+                        }
+                    }
+                    if (i == end) {
+                        auto_heap->use_entry_idx = TRUE;
+                        goto aftretnull;
+                    }
+                }
+            }
+        } else {
+            goto aftretnull;
+        }
+
+        if (auto_heap->use_entry_idx == FALSE) {
+            if (status0 == 1) {
+                if (status1 == 1) {
+                    goto retnull;
+                }
+                auto_heap->use_entry_idx = TRUE;
+            }
+        } else {
+            if (status1 == 1) {
+                if (status0 == 1) {
+                    goto retnull;
+                }
+                auto_heap->use_entry_idx = FALSE;
+            }
+        }
+        goto aftretnull;
+
+    retnull:
+        return NULL;
+    aftretnull:
+
+        idx = auto_heap->use_entry_idx;
+        // entry = &auto_heap->entries[idx];
+        if (auto_heap->entries[idx].id != HEAP_INVALID_INDEX) {
+            if (tableType == WAVE_TABLE) {
+                DirtyWave(auto_heap->entries[idx].id);
+            }
+            outStatus[auto_heap->entries[idx].id] = 0;
+            if (tableType == BANK_TABLE) {
+                Nas_ForceStopChannel(auto_heap->entries[idx].id);
+            }
+        }
+
+        switch (idx) {
+            case FALSE: {
+                auto_heap->entries[0].addr = heap->base;
+                auto_heap->entries[0].id = id;
+                auto_heap->entries[0].size = size;
+                heap->current = heap->base + size;
+                if (auto_heap->entries[1].id != HEAP_INVALID_INDEX && heap->current > auto_heap->entries[1].addr) {
+                    if (tableType == WAVE_TABLE) {
+                        DirtyWave(auto_heap->entries[1].id);
+                    }
+                    outStatus[auto_heap->entries[1].id] = 0;
+                    switch (tableType) {
+                        case SEQUENCE_TABLE: {
+                            Nas_ForceStopSeq(auto_heap->entries[1].id);
+                        } break;
+                        case BANK_TABLE: {
+                            Nas_ForceStopChannel(auto_heap->entries[1].id);
+                        } break;
+                    }
+                    auto_heap->entries[1].id = -1;
+                    auto_heap->entries[1].addr = heap->base + heap->length;
+                }
+                alloc = auto_heap->entries[0].addr;
+            } break;
+            case TRUE: {
+                auto_heap->entries[1].addr = (u8*)OSRoundDown32B(heap->base + heap->length - size);
+                auto_heap->entries[1].id = id;
+                auto_heap->entries[1].size = size;
+                if (auto_heap->entries[0].id != HEAP_INVALID_INDEX && heap->current > auto_heap->entries[1].addr) {
+                    if (tableType == WAVE_TABLE) {
+                        DirtyWave(auto_heap->entries[0].id);
+                    }
+                    outStatus[auto_heap->entries[0].id] = 0;
+                    switch (tableType) {
+                        case SEQUENCE_TABLE: {
+                            Nas_ForceStopSeq(auto_heap->entries[0].id);
+                        } break;
+                        case BANK_TABLE: {
+                            Nas_ForceStopChannel(auto_heap->entries[0].id);
+                        } break;
+                    }
+                    auto_heap->entries[0].id = HEAP_INVALID_INDEX;
+                    heap->current = heap->base;
+                }
+                alloc = auto_heap->entries[1].addr;
+            } break;
+            default: {
+                return NULL;
+            } break;
+        }
+
+        // heap->use_entry_idx = !heap->use_entry_idx;
+        auto_heap->use_entry_idx ^= TRUE;
+        return alloc;
+    } else { // param_3 != 0
+        alloc = Nas_HeapAlloc(&sound_heap->stay_heap.heap, size);
+        sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries].addr = (u8*)alloc;
+        if (alloc == NULL) {
+            switch (param_3) {
+                case 2: {
+                    return Nas_SzHeapAlloc(tableType, size, 0, id);
+                } break;
+                case 0:
+                case 1: {
+                    return NULL;
+                } break;
+            }
+        }
+        sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries].id = id;
+        sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries].size = size;
+        return sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries++].addr;
+    }
 }
 
 /*
@@ -298,9 +694,15 @@ void* Nas_SzHeapAlloc(s32, s32, s32, s32)
  * Address:	........
  * Size:	000064
  */
-u32 Nas_SzCacheCheck(s32, s32, s32)
-{
-	// UNUSED FUNCTION
+void* Nas_SzCacheCheck(s32 tabletype, s32 audioCacheType, s32 id) {
+    void* v = EmemOnCheck(tabletype, id);
+    if (v) {
+        return v;
+    }
+    if (audioCacheType == CACHE_PERMANENT) {
+        return NULL;
+    }
+    return __Nas_SzCacheCheck_Inner(tabletype, audioCacheType, id);
 }
 
 /*
@@ -308,9 +710,40 @@ u32 Nas_SzCacheCheck(s32, s32, s32)
  * Address:	........
  * Size:	000114
  */
-void __Nas_SzCacheCheck_Inner(s32, s32, s32)
-{
-	// UNUSED FUNCTION
+void* __Nas_SzCacheCheck_Inner(s32 tabletype, s32 audioCacheType, s32 id) {
+    SZHeap* heap;
+    switch (tabletype) {
+        case SEQUENCE_TABLE: {
+            heap = &AG.seq_heap;
+        } break;
+        case BANK_TABLE: {
+            heap = &AG.bank_heap;
+        } break;
+        case WAVE_TABLE: {
+            heap = &AG.wave_heap;
+        } break;
+    }
+    SZAuto* autoHeap = &heap->auto_heap;
+    if (audioCacheType == 0) {
+        if (autoHeap->entries[0].id == id) {
+            autoHeap->use_entry_idx = TRUE;
+            return autoHeap->entries[0].addr;
+        }
+        if (autoHeap->entries[1].id == id) {
+            autoHeap->use_entry_idx = FALSE;
+            return autoHeap->entries[1].addr;
+        }
+        return NULL;
+    }
+    for (int i = 0; i < heap->stay_heap.num_entries; i++) {
+        if (id == heap->stay_heap.entries[i].id) {
+            return heap->stay_heap.entries[i].addr;
+        }
+    }
+    if (audioCacheType == 2) {
+        return Nas_SzCacheCheck(tabletype, 0, id);
+    }
+    return NULL;
 }
 
 /*
@@ -318,9 +751,8 @@ void __Nas_SzCacheCheck_Inner(s32, s32, s32)
  * Address:	........
  * Size:	0000D4
  */
-void Nas_InitFilterCoef(f32, f32, u16*)
-{
-	// UNUSED FUNCTION
+void Nas_InitFilterCoef(f32 param_1, f32 param_2, u16* param_3) {
+    // UNUSED FUNCTION
 }
 
 /*
@@ -328,9 +760,8 @@ void Nas_InitFilterCoef(f32, f32, u16*)
  * Address:	........
  * Size:	000020
  */
-void Nas_ClearFilter(s16*)
-{
-	// UNUSED FUNCTION
+void Nas_ClearFilter(s16* param_1) {
+    // UNUSED FUNCTION
 }
 
 /*
@@ -338,9 +769,13 @@ void Nas_ClearFilter(s16*)
  * Address:	........
  * Size:	000040
  */
-void Nas_SetLPFilter(s16*, s32)
-{
-	// UNUSED FUNCTION
+extern s16 LSF_TABLE[];
+void Nas_SetLPFilter(s16* a, s32 b) {
+    int i;
+    int c = b * 8;
+    for (i = 0; i < 8; i++) {
+        a[i] = LSF_TABLE[c + i];
+    }
 }
 
 /*
@@ -348,9 +783,13 @@ void Nas_SetLPFilter(s16*, s32)
  * Address:	........
  * Size:	000044
  */
-void Nas_SetHPFilter(s16*, s32)
-{
-	// UNUSED FUNCTION
+extern s16 HSF_TABLE[];
+void Nas_SetHPFilter(s16* a, s32 b) {
+    int i;
+    int c = (b - 1) * 8;
+    for (i = 0; i < 8; i++) {
+        a[i] = HSF_TABLE[c + i];
+    }
 }
 
 /*
@@ -358,9 +797,44 @@ void Nas_SetHPFilter(s16*, s32)
  * Address:	........
  * Size:	000134
  */
-void Nas_SetBPFilter(s16*, s32, s32)
-{
-	// UNUSED FUNCTION
+extern s16 EL_FILTER[];
+extern s16 BP_FILTER[];
+void Nas_SetBPFilter(s16* a, s32 b, s32 c) {
+    int i;
+    int k;
+    int ind;
+    int constant;
+    if (b == 0 && c == 0) {
+        Nas_SetLPFilter(a, 0);
+        return;
+    } else if (c == 0) {
+        Nas_SetLPFilter(a, b);
+        return;
+    } else if (b == 0) {
+        Nas_SetLPFilter(a, c);
+        return;
+    }
+    k = 0;
+    constant = 14;
+    if (c > b) {
+        for (i = b; i > 1; i--) {
+            k += constant;
+            constant--;
+        }
+        ind = (c - b) - 1 + k;
+        for (i = 0; i < 8; i++) {
+            a[i] = EL_FILTER[i + ind];
+        }
+    } else if (c < b) {
+        for (i = c; i > 1; i--) {
+            k += constant;
+            constant--;
+        }
+        ind = (b - c) - 1 + k;
+        for (i = 0; i < 8; i++) {
+            a[i] = BP_FILTER[i + ind];
+        }
+    }
 }
 
 /*
@@ -368,9 +842,8 @@ void Nas_SetBPFilter(s16*, s32, s32)
  * Address:	........
  * Size:	000004
  */
-void __DownDelay(delay*)
-{
-	// UNUSED FUNCTION
+void __DownDelay(delay* unused) {
+    return;
 }
 
 /*
@@ -378,9 +851,24 @@ void __DownDelay(delay*)
  * Address:	........
  * Size:	0000A0
  */
-void __Nas_DelayDown()
-{
-	// UNUSED FUNCTION
+void __Nas_DelayDown() {
+    int i;
+    int j;
+    delay* delay_p;
+    int c;
+
+    if (AG.audio_params.spec == 2) {
+        c = 2;
+    } else {
+        c = 1;
+    }
+
+    for (i = 0; i < AG.num_synth_reverbs; i++) {
+        delay_p = &AG.synth_delay[i];
+        for (j = 0; j < c; j++) {
+            __DownDelay(delay_p);
+        }
+    }
 }
 
 /*
@@ -388,9 +876,13 @@ void __Nas_DelayDown()
  * Address:	........
  * Size:	000048
  */
-void __Nas_DacClear()
-{
-	// UNUSED FUNCTION
+void __Nas_DacClear() {
+    int i;
+    int bufferIdx = AG.current_ai_buffer_idx;
+    AG.num_samples_per_frame[bufferIdx] = AG.audio_params.num_samples_per_frame_min;
+    for (i = 0; i < 0x7c0; i++) {
+        AG.ai_buffers[bufferIdx][i] = 0;
+    }
 }
 
 /*
@@ -398,9 +890,65 @@ void __Nas_DacClear()
  * Address:	........
  * Size:	000258
  */
-s32 Nas_SpecChange()
-{
-	// UNUSED FUNCTION
+s32 Nas_SpecChange() {
+    int i;
+    int j;
+    int c = AG.audio_params.spec == 2 ? 2 : 1;
+    switch (AG.reset_status) {
+        case 5: {
+            for (i = 0; i < AG.audio_params.num_groups; i++) {
+                Nas_ReleaseGroup_Force(AG.groups_p[i]);
+            }
+            AG.audio_reset_fadeout_frames_left = 2 / c;
+            AG.reset_status--;
+        } break;
+        case 4: {
+            if (AG.audio_reset_fadeout_frames_left != 0) {
+                AG.audio_reset_fadeout_frames_left--;
+                __Nas_DelayDown();
+            } else {
+                for (i = 0; i < AG.num_channels; i++) {
+                    if (AG.channels[i].common_ch.enabled && AG.channels[i].playback_ch.adsr_envp.state.flags.status) {
+                        AG.channels[i].playback_ch.adsr_envp.fadeout_velocity =
+                            AG.audio_params.updates_per_frame_inverse;
+                        AG.channels[i].playback_ch.adsr_envp.state.flags.release = TRUE;
+                    }
+                }
+                AG.audio_reset_fadeout_frames_left = 8 / c;
+                AG.reset_status--;
+            }
+        } break;
+        case 3: {
+            if (AG.audio_reset_fadeout_frames_left) {
+                AG.audio_reset_fadeout_frames_left--;
+                __Nas_DelayDown();
+            } else {
+                AG.audio_reset_fadeout_frames_left = 2 / c;
+                AG.reset_status--;
+            }
+        } break;
+        case 2: {
+            __Nas_DacClear();
+            if (AG.audio_reset_fadeout_frames_left) {
+                AG.audio_reset_fadeout_frames_left--;
+            } else {
+                AG.reset_status--;
+                Emem_KillSwMember();
+                Dirty_AllWave();
+            }
+        } break;
+        case 1: {
+            __Nas_MemoryReconfig();
+            AG.reset_status = 0;
+            for (i = 0; i < ARRAY_COUNT(AG.ai_buffers) - 1; i++) {
+                AG.num_samples_per_frame[i] = AG.audio_params.num_samples_per_frame_max;
+                for (j = 0; j < 0x7c0; j++) {
+                    AG.ai_buffers[i][j] = 0;
+                }
+            }
+        } break;
+    }
+    return AG.reset_status > 2;
 }
 
 /*
@@ -408,9 +956,133 @@ s32 Nas_SpecChange()
  * Address:	........
  * Size:	0006B4
  */
-void __Nas_MemoryReconfig()
-{
-	// UNUSED FUNCTION
+void __Nas_MemoryReconfig() {
+    s32 j;
+    s32 i;
+    s32 a;
+    s32 b;
+    s32 c;
+    s32 d;
+    na_spec_config* spec = &NA_SPEC_CONFIG[AG.spec_id];
+
+    /*0x2640*/ AG.num_waveloads = 0;
+    /*0x286E*/ AG.audio_params.sampling_frequency = spec->_00;
+    /*0x2872*/ AG.audio_params.num_samples_per_frame_target = spec->_00 / AG.refresh_rate;
+    /*0x2878*/ AG.audio_params.updates_per_frame = 4;
+    /*0x2876*/ AG.audio_params.num_samples_per_frame_min = AG.audio_params.num_samples_per_frame_target - 0x10;
+    /*0x2874*/ AG.audio_params.num_samples_per_frame_max = AG.audio_params.num_samples_per_frame_target + 0x10;
+    /*0x287A*/ AG.audio_params.num_samples_per_update =
+        (AG.audio_params.num_samples_per_frame_target / AG.audio_params.updates_per_frame) & ~7;
+    /*0x2870*/ AG.audio_params.ai_sampling_frequency = AG.audio_params.sampling_frequency;
+    OSReport("----------------------------- SFS_NORMAL = %d\n", AG.audio_params.num_samples_per_update);
+    /*
+       order is
+       287c
+       287e
+       2884
+       2898
+       289c
+       28b8
+       2888
+       2880
+       288c
+       2890
+    */
+    /*0x287C*/ AG.audio_params.num_samples_per_update_max = AG.audio_params.num_samples_per_update + 8;
+    /*0x287E*/ AG.audio_params.num_samples_per_update_min = AG.audio_params.num_samples_per_update - 8;
+    /*0x2884*/ AG.audio_params.resample_rate = 33476.156f / (s32)AG.audio_params.sampling_frequency;
+    /*0x288C*/ AG.audio_params.updates_per_frame_inverse_scaled = (1.f / 256.f) / AG.audio_params.updates_per_frame;
+    /*0x2890*/ AG.audio_params.updates_per_frame_scaled = AG.audio_params.updates_per_frame / 4.0f;
+    /*0x2888*/ AG.audio_params.updates_per_frame_inverse = 1.f / AG.audio_params.updates_per_frame;
+
+    /*0x2898*/ AG.waveload_dma_buf0_size = spec->_10;
+    /*0x289C*/ AG.waveload_dma_buf1_size = spec->_12;
+
+    /*0x28B8*/ AG.num_channels = spec->_05;
+    /*0x2880*/ AG.audio_params.num_groups = spec->_06;
+    if (AG.audio_params.num_groups > 5) {
+        /*0x2880*/ AG.audio_params.num_groups = 5;
+    }
+
+    /*0x2A18*/ AG.num_abi_cmds_max = 8;
+    /*0x0002*/ AG._0002 = spec->_14;
+
+    s32 tmp = AG.audio_params.updates_per_frame;
+    /*0x28BC*/ AG.max_tempo = ((((60.0f * 1000.0f * 48) * tmp) / AGC.timeBase) / AG._29D8) / 1.04613;
+
+    /*0x2894*/ AG._2894 = (f32)AG.refresh_rate * (f32)tmp / AG.audio_params.ai_sampling_frequency / AG.max_tempo;
+
+    /*0x286C*/ AG.audio_params.spec = spec->_04;
+    /*0x2894*/ AG._2894 = AG.refresh_rate;
+    /*0x2894*/ AG._2894 *= tmp;
+    /*0x2894*/ AG._2894 /= AG.audio_params.ai_sampling_frequency;
+    /*0x2894*/ AG._2894 /= AG.max_tempo;
+    /*0x2876*/ AG.audio_params.num_samples_per_frame_min *= AG.audio_params.spec;
+    /*0x2878*/ AG.audio_params.updates_per_frame *= AG.audio_params.spec;
+    /*0x2872*/ AG.audio_params.num_samples_per_frame_target *= AG.audio_params.spec;
+    /*0x2874*/ AG.audio_params.num_samples_per_frame_max *= AG.audio_params.spec;
+
+    if (AG.audio_params.spec > 1) {
+        /*0x2874*/ AG.audio_params.num_samples_per_frame_max -= 0x10;
+    }
+    // int c = (a + b);
+    /*0x28B4*/ AG.max_audio_cmds = (AG.num_channels * 20 * AG.audio_params.updates_per_frame) + (spec->_09 * 30) + 400;
+    a = (spec->_18 + spec->_1C + spec->_20 + 0x40);
+    b = (spec->_24 + spec->_28 + spec->_2C + 0x40);
+    c = a + b;
+    d = AG.session_heap.length - c - 0x100;
+    if (/*0x2A34*/ AG.external_heap.base != NULL) {
+        /*0x2A38*/ AG.external_heap.current = AG.external_heap.base;
+    }
+    /*0x34EC*/ AG.audio_heap_info.misc_heap_size = d;
+    /*0x34F8*/ AG.audio_heap_info.cache_heap_size = c;
+    Nas_SzHeapDivide(&AG.audio_heap_info);
+    /*0x34FC*/ AG.cache_heap.data_size = a;
+    /*0x3500*/ AG.cache_heap.auto_size = b;
+    Nas_SzDataDivide(&AG.cache_heap);
+
+    /*0x3504*/ AG.persistent_common_heap_info.seq_heap_size = spec->_18;
+    /*0x3508*/ AG.persistent_common_heap_info.bank_heap_size = spec->_1C;
+    /*0x350C*/ AG.persistent_common_heap_info.wave_heap_size = spec->_20;
+    Nas_SzStayDivide(&AG.persistent_common_heap_info);
+    AG.temporary_common_heap_info.seq_heap_size = spec->_24;
+    AG.temporary_common_heap_info.bank_heap_size = spec->_28;
+    AG.temporary_common_heap_info.wave_heap_size = spec->_2C;
+    // fake? maybe temporary_common_heap_info is wrong type?
+    Nas_SzAutoDivide((AutoHeapstrc*)&AG.temporary_common_heap_info);
+    Nas_ResetIDtable();
+    AG.channels = (channel*)Nas_HeapAlloc_CL(&AG.misc_heap, AG.num_channels * sizeof(channel));
+    Nas_ChannelInit();
+    Nas_InitChannelList();
+    AG.common_channel = (commonch*)Nas_HeapAlloc_CL(&AG.misc_heap, AG.audio_params.updates_per_frame * AG.num_channels *
+                                                                       sizeof(commonch));
+
+    for (i = 0; i < ARRAY_COUNT(AG.abi_cmd_bufs); i++) {
+        AG.abi_cmd_bufs[i] = (Acmd*)Nas_NcHeapAlloc_CL(&AG.misc_heap, AG.max_audio_cmds * sizeof(Acmd));
+    }
+    AG.adsr_decay_table = (f32*)Nas_HeapAlloc(&AG.misc_heap, sizeof(f32) * 0x100);
+    MakeReleaseTable();
+    for (i = 0; i < ARRAY_COUNT(AG.synth_delay); i++) {
+        AG.synth_delay[i].use_reverb = FALSE;
+    }
+    AG.num_synth_reverbs = spec->_09;
+    for (i = 0; i < AG.num_synth_reverbs; i++) {
+        Nas_SetDelayLine(i, &spec->_0C[i], 1);
+    }
+    Nas_InitPlayer();
+    for (j = 0; j < AG.audio_params.num_groups; j++) {
+        Nas_AssignSubTrack(j);
+        Nas_InitMySeq(AG.groups_p[j]);
+    }
+    Nas_Init_Single(spec->_30, spec->_34);
+    Nas_WaveDmaNew(AG.num_channels);
+    AG.num_requested_samples = 0;
+    LpsInit();
+    MK_Init();
+    Nas_BgCopyInit();
+    AG._0004 = 0x1000;
+    EmemReload();
+    Z_osWritebackDCacheAll();
 }
 
 /*
@@ -418,9 +1090,14 @@ void __Nas_MemoryReconfig()
  * Address:	........
  * Size:	00005C
  */
-void* EmemOnCheck(s32, s32)
-{
-	// UNUSED FUNCTION
+void* EmemOnCheck(s32 tableType, s32 id) {
+    int i;
+    for (i = 0; i < AG.emem_heap.count; i++) {
+        if (tableType == AG.emem_entries[i].table_type && id == AG.emem_entries[i].id) {
+            return AG.emem_entries[i].addr;
+        }
+    }
+    return NULL;
 }
 
 /*
@@ -428,9 +1105,17 @@ void* EmemOnCheck(s32, s32)
  * Address:	........
  * Size:	00007C
  */
-void* EmemAlloc(s32, s32, s32)
-{
-	// UNUSED FUNCTION
+void* EmemAlloc(s32 tableType, s32 id, s32 size) {
+    u32 heapCount = AG.emem_heap.count;
+    u8* p = (u8*)Nas_HeapAlloc(&AG.emem_heap, size);
+    AG.emem_entries[heapCount].addr = p;
+    if (p == NULL) {
+        return NULL;
+    }
+    AG.emem_entries[heapCount].table_type = tableType;
+    AG.emem_entries[heapCount].id = id;
+    AG.emem_entries[heapCount].size = size;
+    return p;
 }
 
 /*
@@ -438,9 +1123,23 @@ void* EmemAlloc(s32, s32, s32)
  * Address:	........
  * Size:	000064
  */
-void Nas_Alloc_Single(s32, s32, u8*, char, s32)
-{
-	// UNUSED FUNCTION
+
+void* Nas_Alloc_Single(s32 a, s32 sampleBankID, u8* sampleAddr, s8 originalMedium, s32 e) {
+    SwMember* alloc;
+    if (e == 0) {
+        alloc = __Nas_Alloc_Single_Auto_Inner(a);
+    } else {
+        alloc = __Nas_Alloc_Single_Stay_Inner(a);
+    }
+    if (alloc != NULL) {
+        SwMember* entry = (SwMember*)alloc;
+        entry->sample_bank_id = sampleBankID;
+        entry->sample_addr = sampleAddr;
+        entry->original_medium = originalMedium;
+        return entry->allocated_addr;
+    } else {
+        return NULL;
+    }
 }
 
 /*
@@ -448,9 +1147,22 @@ void Nas_Alloc_Single(s32, s32, u8*, char, s32)
  * Address:	........
  * Size:	0000C4
  */
-void Nas_Init_Single(s32, s32)
-{
-	// UNUSED FUNCTION
+int Nas_Init_Single(s32 a, s32 b) {
+    u8* alloc = (u8*)Nas_2ndHeapAlloc(&AG.misc_heap, a);
+    if (alloc == NULL) {
+        AG.emem_persistent_wave_heap.heap.length = 0;
+    } else {
+        Nas_HeapInit(&AG.emem_persistent_wave_heap.heap, alloc, a);
+    }
+
+    alloc = (u8*)Nas_2ndHeapAlloc(&AG.misc_heap, b);
+    if (alloc == NULL) {
+        AG.emem_temporary_wave_heap.heap.length = 0;
+    } else {
+        Nas_HeapInit(&AG.emem_temporary_wave_heap.heap, alloc, b);
+    }
+    AG.emem_persistent_wave_heap.num_entries = 0;
+    AG.emem_temporary_wave_heap.num_entries = 0;
 }
 
 /*
@@ -458,9 +1170,71 @@ void Nas_Init_Single(s32, s32)
  * Address:	........
  * Size:	000200
  */
-void __Nas_Alloc_Single_Auto_Inner(s32)
-{
-	// UNUSED FUNCTION
+SwMember* __Nas_Alloc_Single_Auto_Inner(s32 size) {
+    SwHeap* heap = &AG.emem_temporary_wave_heap;
+    void* alloc;
+    u8* oldCurrent = heap->heap.current;
+    u8* nowCurrent;
+    alloc = Nas_HeapAlloc(&heap->heap, size);
+    int i;
+
+    if (!alloc) {
+        u8* nowCurrent = heap->heap.current;
+        heap->heap.current = heap->heap.base;
+        alloc = Nas_HeapAlloc(&heap->heap, size);
+        if (!alloc) {
+            heap->heap.current = nowCurrent;
+            return NULL;
+        }
+        oldCurrent = heap->heap.base;
+    }
+    nowCurrent = heap->heap.current;
+
+    int s = -1;
+    for (i = 0; i < AG.num_requested_samples; i++) {
+        Bgloadreq* loadReq = &AG.requested_samples[i];
+        if (loadReq->is_free == FALSE) {
+            u8* p = loadReq->ram_addr + loadReq->sample->size - 1;
+            if ((p >= oldCurrent || loadReq->ram_addr >= oldCurrent) &&
+                (p < nowCurrent || loadReq->ram_addr < nowCurrent)) {
+                loadReq->is_free = TRUE;
+            }
+        }
+    }
+    for (i = 0; i < heap->num_entries; i++) {
+        s8 inUse = heap->entries[i].in_use;
+        if (inUse) {
+            u8* p = heap->entries[i].allocated_addr + heap->entries[i].size - 1;
+            if ((p >= oldCurrent || heap->entries[i].allocated_addr >= oldCurrent) &&
+                (p < nowCurrent || heap->entries[i].allocated_addr < nowCurrent)) {
+                __KillSwMember(&heap->entries[i]);
+                heap->entries[i].in_use = 0;
+                if (s == -1) {
+                    s = i;
+                }
+            }
+        }
+    }
+    if (s == -1) {
+        for (i = 0; i < heap->num_entries; i++) {
+            s8 inUse = heap->entries[i].in_use;
+            if (inUse == 0) {
+                break;
+            }
+        }
+        s = i;
+        if (s == heap->num_entries) {
+            if (heap->num_entries == ARRAY_COUNT(heap->entries)) {
+                return NULL;
+            }
+            heap->num_entries++;
+        }
+    }
+    SwMember* entry = &heap->entries[s];
+    entry->in_use = TRUE;
+    entry->allocated_addr = (u8*)alloc;
+    entry->size = size;
+    return entry;
 }
 
 /*
@@ -468,9 +1242,34 @@ void __Nas_Alloc_Single_Auto_Inner(s32)
  * Address:	........
  * Size:	00012C
  */
-void __SearchBank(SwMember*, s32)
-{
-	// UNUSED FUNCTION
+void __SearchBank(SwMember* entry, s32 bank) {
+    perctable* pt;
+    percvoicetable* pv;
+    voicetable* vt;
+    for (int i = 0; i < AG.voice_info[bank].num_instruments; i++) {
+        vt = ProgToVp(bank, i);
+        if (vt) {
+            if (vt->normal_range_low != 0) {
+                __RomAddrSet(entry, vt->low_pitch_tuned_sample.wavetable);
+            }
+            if (vt->normal_range_high != 0x7f) {
+                __RomAddrSet(entry, vt->high_pitch_tuned_sample.wavetable);
+            }
+            __RomAddrSet(entry, vt->normal_pitch_tuned_sample.wavetable);
+        }
+    }
+    for (int i = 0; i < AG.voice_info[bank].num_drums; i++) {
+        pt = PercToPp(bank, i);
+        if (pt) {
+            __RomAddrSet(entry, pt->tuned_sample.wavetable);
+        }
+    }
+    for (int i = 0; i < AG.voice_info[bank].num_sfx; i++) {
+        pv = VpercToVep(bank, i);
+        if (pv) {
+            __RomAddrSet(entry, pv->tuned_sample.wavetable);
+        }
+    }
 }
 
 /*
@@ -478,9 +1277,16 @@ void __SearchBank(SwMember*, s32)
  * Address:	........
  * Size:	0000EC
  */
-void __KillSwMember(SwMember*)
-{
-	// UNUSED FUNCTION
+void __KillSwMember(SwMember* a) {
+    for (int i = 0, end = AG.bank_header->numEntries; i < end; i++) {
+        int bank0 = AG.voice_info[i].wave_bank_id0;
+        int bank1 = AG.voice_info[i].wave_bank_id1;
+        if (((bank0 != 0xff && bank0 == a->sample_bank_id) || (bank1 != 0xff && bank1 == a->sample_bank_id) ||
+             (a->sample_bank_id == 0 || a->sample_bank_id == 0xfe)) &&
+            Nas_SzCacheCheck(1, 2, i) && Nas_CheckIDbank(i)) {
+            __SearchBank(a, i);
+        }
+    }
 }
 
 /*
@@ -488,9 +1294,11 @@ void __KillSwMember(SwMember*)
  * Address:	........
  * Size:	000034
  */
-void __RomAddrSet(SwMember*, smzwavetable*)
-{
-	// UNUSED FUNCTION
+void __RomAddrSet(SwMember* a, smzwavetable* b) {
+    if (b != NULL && b->sample == a->allocated_addr) {
+        b->sample = (u8*)a->sample_addr;
+        b->medium = a->original_medium;
+    }
 }
 
 /*
@@ -498,9 +1306,21 @@ void __RomAddrSet(SwMember*, smzwavetable*)
  * Address:	........
  * Size:	000094
  */
-void __Nas_Alloc_Single_Stay_Inner(s32)
-{
-	// UNUSED FUNCTION
+SwMember* __Nas_Alloc_Single_Stay_Inner(s32 a) {
+    SwHeap* heap = &AG.emem_persistent_wave_heap;
+    u8* alloc = (u8*)Nas_HeapAlloc(&heap->heap, a);
+    if (alloc == NULL) {
+        return NULL;
+    }
+    if (heap->num_entries == ARRAY_COUNT(heap->entries)) {
+        return NULL;
+    }
+    SwMember* entry = &heap->entries[heap->num_entries];
+    entry->in_use = TRUE;
+    entry->allocated_addr = (u8*)alloc;
+    entry->size = a;
+    heap->num_entries++;
+    return entry;
 }
 
 /*
@@ -508,9 +1328,10 @@ void __Nas_Alloc_Single_Stay_Inner(s32)
  * Address:	........
  * Size:	000040
  */
-void __Do_EmemKill(SwMember*, s32, s32, s32)
-{
-	// UNUSED FUNCTION
+void __Do_EmemKill(SwMember* entry, s32 id0, s32 id1, s32 bank) {
+    if (id0 == entry->sample_bank_id || id1 == entry->sample_bank_id || entry->sample_bank_id == 0) {
+        __SearchBank(entry, bank);
+    }
 }
 
 /*
@@ -518,9 +1339,20 @@ void __Do_EmemKill(SwMember*, s32, s32, s32)
  * Address:	........
  * Size:	000128
  */
-void Emem_KillSwMember()
-{
-	// UNUSED FUNCTION
+void Emem_KillSwMember() {
+    s32 i, j, end;
+    for (i = 0, end = AG.bank_header->numEntries; i < end; i++) {
+        s32 id0 = AG.voice_info[i].wave_bank_id0;
+        s32 id1 = AG.voice_info[i].wave_bank_id1;
+        if ((id0 != 0xff || id1 != 0xff) && Nas_SzCacheCheck(1, 3, i) && Nas_CheckIDbank(i)) {
+            for (j = 0; j < AG.emem_persistent_wave_heap.num_entries; j++) {
+                __Do_EmemKill(&AG.emem_persistent_wave_heap.entries[j], id0, id1, i);
+            }
+            for (j = 0; j < AG.emem_temporary_wave_heap.num_entries; j++) {
+                __Do_EmemKill(&AG.emem_temporary_wave_heap.entries[j], id0, id1, i);
+            }
+        }
+    }
 }
 
 /*
@@ -528,9 +1360,23 @@ void Emem_KillSwMember()
  * Address:	........
  * Size:	0000A0
  */
-void __RestoreAddr(Wavelookuptable*, smzwavetable*)
-{
-	// UNUSED FUNCTION
+s32 EXGTYPE;
+void __RestoreAddr(Wavelookuptable* a, smzwavetable* b) {
+    if (b != NULL && (b->medium == a->medium || EXGTYPE != 1) && (b->medium == 0 || EXGTYPE != 0)) {
+
+        u8* a_sample = a->sample;
+        u8* b_sample = b->sample;
+        u8* o = a_sample + a->_08;
+        if (b_sample >= a_sample && b_sample < o) {
+            // fakematch?
+            b->sample = (u8*)((u32)a->_04 + (b->sample - (u32)a->sample));
+            if (EXGTYPE == 0) {
+                b->medium = a->medium;
+            } else {
+                b->medium = 0;
+            }
+        }
+    }
 }
 
 /*
@@ -538,9 +1384,9 @@ void __RestoreAddr(Wavelookuptable*, smzwavetable*)
  * Address:	........
  * Size:	000030
  */
-void DirtyWave(s32)
-{
-	// UNUSED FUNCTION
+void DirtyWave(s32 id) {
+    EXGTYPE = 0;
+    __ExchangeWave(0, id);
 }
 
 /*
@@ -548,9 +1394,9 @@ void DirtyWave(s32)
  * Address:	........
  * Size:	000030
  */
-void EntryWave(s32)
-{
-	// UNUSED FUNCTION
+void EntryWave(s32 id) {
+    EXGTYPE = 1;
+    __ExchangeWave(1, id);
 }
 
 /*
@@ -558,9 +1404,63 @@ void EntryWave(s32)
  * Address:	........
  * Size:	000238
  */
-void __ExchangeWave(s32, s32)
-{
-	// UNUSED FUNCTION
+void __ExchangeWave(s32 a, s32 b) {
+    s32 i;
+    Wavelookuptable wavetable;
+    voiceinfo* voiceinfo;
+    s32 bVar1;
+    s32 bVar2;
+    ArcHeader* wave_header = AG.wave_header;
+    s16 numEntries = AG.bank_header->numEntries;
+    Wavelookuptable* pWaveTable = &wavetable;
+    u8* alloc = (u8*)Nas_SzCacheCheck(2, 2, b);
+    pWaveTable->sample = alloc;
+    if (pWaveTable->sample) {
+        pWaveTable->_08 = (s32)wave_header[b].entries[0].size;
+        pWaveTable->medium = wave_header[b].entries[0].medium;
+        pWaveTable->_04 = (u8*)wave_header[b].entries[0].addr;
+        switch (a) {
+            case 1: {
+                pWaveTable->_04 = alloc;
+                pWaveTable->sample = (u8*)wave_header[b].entries[0].addr;
+            } break;
+            case 0:
+            default:
+                break;
+        }
+        for (i = 0; i < numEntries; i++) {
+            voiceinfo = &AG.voice_info[i];
+            bVar1 = voiceinfo->wave_bank_id0;
+            bVar2 = voiceinfo->wave_bank_id1;
+            if ((bVar1 != 0xff || bVar2 != 0xff) && Nas_CheckIDbank(i) && Nas_SzCacheCheck(1, 2, i) &&
+                (bVar1 == b || bVar2 == b)) {
+                for (int j = 0; j < AG.voice_info[i].num_instruments; j++) {
+                    voicetable* voicetable = ProgToVp(i, j);
+                    if (voicetable) {
+                        if (voicetable->normal_range_low) {
+                            __RestoreAddr(pWaveTable, voicetable->low_pitch_tuned_sample.wavetable);
+                        }
+                        if (voicetable->normal_range_high != 0x7f) {
+                            __RestoreAddr(pWaveTable, voicetable->high_pitch_tuned_sample.wavetable);
+                        }
+                        __RestoreAddr(pWaveTable, voicetable->normal_pitch_tuned_sample.wavetable);
+                    }
+                }
+                for (int j = 0; j < AG.voice_info[i].num_drums; j++) {
+                    perctable* pTable = PercToPp(i, j);
+                    if (pTable) {
+                        __RestoreAddr(pWaveTable, pTable->tuned_sample.wavetable);
+                    }
+                }
+                for (int j = 0; j < AG.voice_info[i].num_sfx; j++) {
+                    percvoicetable* pTable = VpercToVep(i, j);
+                    if (pTable) {
+                        __RestoreAddr(pWaveTable, pTable->tuned_sample.wavetable);
+                    }
+                }
+            }
+        }
+    }
 }
 
 /*
@@ -568,9 +1468,18 @@ void __ExchangeWave(s32, s32)
  * Address:	........
  * Size:	000088
  */
-void Dirty_AllWave()
-{
-	// UNUSED FUNCTION
+void Dirty_AllWave() {
+    int i;
+    SZHeap* heap = &AG.wave_heap;
+    if (heap->auto_heap.entries[0].id != HEAP_INVALID_INDEX) {
+        DirtyWave(heap->auto_heap.entries[0].id);
+    }
+    if (heap->auto_heap.entries[1].id != HEAP_INVALID_INDEX) {
+        DirtyWave(heap->auto_heap.entries[1].id);
+    }
+    for (i = 0; i < heap->stay_heap.num_entries; i++) {
+        DirtyWave(heap->stay_heap.entries[i].id);
+    }
 }
 
 /*
@@ -578,9 +1487,18 @@ void Dirty_AllWave()
  * Address:	........
  * Size:	0000AC
  */
-void __Nas_GetCompressBuffer(delay*)
-{
-	// UNUSED FUNCTION
+int __Nas_GetCompressBuffer(delay* a) {
+    if (a->left_load_resample_buf != NULL && a->right_save_resample_buf != NULL) {
+        return 0;
+    }
+    a->left_load_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20);
+    a->right_load_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20);
+    a->left_save_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20);
+    a->right_save_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20);
+    if (a->right_save_resample_buf == NULL) {
+        return -1;
+    }
+    return 0;
 }
 
 /*
@@ -588,9 +1506,104 @@ void __Nas_GetCompressBuffer(delay*)
  * Address:	........
  * Size:	00028C
  */
-void Nas_SetDelayLineParam(s32, s32, s32, s32)
-{
-	// UNUSED FUNCTION
+void Nas_SetDelayLineParam(s32 a, s32 b, s32 c, s32 d) {
+    delay* delay = &AG.synth_delay[a];
+    switch (b) {
+        case 0: {
+            Nas_SetDelayLine(a, (fxconfig*)c, 0);
+        } break;
+        case 1: {
+            if (c < 4) {
+                c = 4;
+            }
+
+            int delay_num_samples = c * 0x40;
+            if (c * 0x40 < 0x100) {
+                delay_num_samples = 0x100;
+            }
+
+            delay_num_samples /= delay->downsample_rate;
+
+            if (d == 0) {
+                if (delay->delay_num_samples_after_downsampling < c / delay->downsample_rate) {
+                    return;
+                }
+                if (delay_num_samples <= delay->next_reverb_buf_pos ||
+                    delay_num_samples <= delay->delay_num_samples_unk) {
+                    delay->next_reverb_buf_pos = 0;
+                    delay->delay_num_samples_unk = 0;
+                }
+            }
+            delay->delay_num_samples = delay_num_samples;
+            if (delay->downsample_rate != 1 || delay->resample_effect_on) {
+                delay->downsample_pitch = 0x8000 / delay->downsample_rate;
+                if (__Nas_GetCompressBuffer(delay) == -1) {
+                    delay->downsample_rate = 1;
+                }
+            }
+        } break;
+        case 2: {
+            delay->decay_ratio = c;
+        } break;
+        case 3: {
+            delay->sub_volume = c;
+        } break;
+        case 4: {
+            delay->volume = c;
+        } break;
+        case 5: {
+            delay->leak_rtl = c;
+        } break;
+        case 6: {
+            delay->leak_ltl = c;
+        } break;
+        case 7: {
+            if (c) {
+                if (d || delay->filter_left_init == NULL) {
+                    delay->filter_left_state = (s16*)Nas_NcHeapAlloc_CL(&AG.misc_heap, 0x20 * sizeof(s16));
+                    delay->filter_left_init = (s16*)Nas_NcHeapAlloc(&AG.misc_heap, 0x8 * sizeof(s16));
+                }
+                delay->filter_left = delay->filter_left_init;
+                if (delay->filter_left) {
+                    Nas_SetLPFilter(delay->filter_left, c);
+                }
+            } else {
+                delay->filter_left = NULL;
+                if (d) {
+                    delay->filter_left_init = NULL;
+                }
+            }
+        } break;
+        case 8: {
+            if (c) {
+                if (d || delay->filter_right_init == NULL) {
+                    delay->filter_right_state = (s16*)Nas_NcHeapAlloc_CL(&AG.misc_heap, 0x20 * sizeof(s16));
+                    delay->filter_right_init = (s16*)Nas_NcHeapAlloc(&AG.misc_heap, 0x8 * sizeof(s16));
+                }
+                delay->filter_right = delay->filter_right_init;
+                if (delay->filter_right) {
+                    Nas_SetLPFilter(delay->filter_right, c);
+                }
+            } else {
+                delay->filter_right = NULL;
+                if (d) {
+                    delay->filter_right_init = NULL;
+                }
+            }
+        } break;
+        case 9: {
+            delay->resample_effect_extra_samples = c;
+            if (c == 0) {
+                delay->resample_effect_on = FALSE;
+            } else {
+                delay->resample_effect_on = TRUE;
+            }
+            if (__Nas_GetCompressBuffer(delay) == -1) {
+                delay->resample_effect_on = FALSE;
+                delay->resample_effect_extra_samples = FALSE;
+            }
+        } break;
+    }
 }
 
 /*
@@ -598,7 +1611,48 @@ void Nas_SetDelayLineParam(s32, s32, s32, s32)
  * Address:	........
  * Size:	0001E0
  */
-void Nas_SetDelayLine(s32, fxconfig_*, s32)
-{
-	// UNUSED FUNCTION
+void Nas_SetDelayLine(s32 a, fxconfig* b, s32 c) {
+    delay* d = &AG.synth_delay[a];
+    if (c) {
+        d->delay_num_samples_after_downsampling = b->_02 / b->downsample_rate;
+        d->left_load_resample_buf = NULL;
+    } else if (d->delay_num_samples_after_downsampling < b->_02 / b->downsample_rate) {
+        return;
+    }
+    d->downsample_rate = b->downsample_rate;
+    d->resample_effect_on = 0;
+    d->resample_effect_extra_samples = 0;
+    d->resample_effect_load_unk = 0;
+    d->resample_effect_save_unk = 0;
+    Nas_SetDelayLineParam(a, 1, b->_02, c);
+    d->decay_ratio = b->decay_ratio;
+    d->volume = b->volume;
+    d->sub_delay = b->sub_delay * 64;
+    d->sub_volume = b->sub_volume;
+    d->leak_rtl = b->leak_rtl;
+    d->leak_ltl = b->leak_ltl;
+    d->mix_reverb_idx = b->mix_reverb_idx;
+    d->mix_reverb_strength = b->mix_reverb_strength;
+    d->use_reverb = 8;
+    if (c) {
+        d->left_reverb_buf = (s16*)Nas_2ndHeapAlloc_CL(&AG.misc_heap, d->delay_num_samples * sizeof(s16));
+        d->right_reverb_buf = (s16*)Nas_2ndHeapAlloc_CL(&AG.misc_heap, d->delay_num_samples * sizeof(s16));
+        d->resample_flags = 1;
+        d->next_reverb_buf_pos = 0;
+        d->delay_num_samples_unk = 0;
+        d->cur_frame = 0;
+        d->frames_to_ignore = 2;
+    }
+    d->tuned_sample.wavetable = &d->sample;
+    d->sample.loop = &d->adpcm_loop;
+    d->tuned_sample.tuning = 1.f;
+    d->sample.codec = 4;
+    d->sample.medium = 0;
+    d->sample.size = d->delay_num_samples * sizeof(s16);
+    d->sample.sample = (u8*)d->left_reverb_buf;
+    d->adpcm_loop.loop_start = 0;
+    d->adpcm_loop.loop_end = d->delay_num_samples;
+    d->adpcm_loop.count = 1;
+    Nas_SetDelayLineParam(a, 7, b->_14, c);
+    Nas_SetDelayLineParam(a, 8, b->_16, c);
 }
diff --git a/src/static/jaudio_NES/internal/system.c b/src/static/jaudio_NES/internal/system.c
index 1536a1f5..30d667fa 100644
--- a/src/static/jaudio_NES/internal/system.c
+++ b/src/static/jaudio_NES/internal/system.c
@@ -24,8 +24,8 @@ static void* FASTDMA_BUFFER = NULL;
 Na_DmaProc NA_DMA_PROC = Z_osEPiStartDma;
 Na_SyncProc NA_SYNC_PROC = Nas_GetSyncDummy;
 
-static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr,
-    void* dram_addr, u32 size, OSMesgQueue* mq, s32 medium, s8* dma_type);
+static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr, void* dram_addr, u32 size,
+                        OSMesgQueue* mq, s32 medium, s8* dma_type);
 s32 Nas_BankOfsToAddr(s32 bank_id, u8* ctrl_p, WaveMedia* wave_media, s32 async);
 
 static s32 __Link_BankNum(s32 type, s32 id);
@@ -39,7 +39,8 @@ static u8* __Load_Bank(s32 table_type, s32 id, s32* did_alloc);
 static u32 __Load_Wave(s32 wave_id, u32* medium, s32 no_load);
 static void* __Check_Cache(s32 table_type, s32 id);
 static void __WaveTouch(wtstr* wavetouch_str, u32 ram_addr, WaveMedia* wave_media);
-static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, s32 msg);
+static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq,
+                              s32 msg);
 static Bgload* Nas_BgCopyReq(u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, s32 msg);
 static smzwavetable* __GetWaveTable(s32 bank_id, s32 inst_id);
 static void __Nas_SlowDiskCopy(u8* dev_addr, u8* ram_addr, u32 size, s32 medium);
@@ -50,7 +51,6 @@ static void __Nas_BgDiskCopy(u8* src, u8* dst, u32 size, s32 param);
 static void __Nas_ExCopy(Bgload* bgload, s32 size);
 static void __Nas_BgCopy(Bgload* bgload, s32 size);
 
-
 void Nas_WaveDmaFrameWork(void) {
     WaveLoad* wl;
     WaveLoad* wl2;
@@ -107,8 +107,10 @@ void* Nas_WaveDmaCallBack(u32 device_addr, u32 size, s32 arg2, u8* waveload_idx,
                     // Move the WAVELOAD out of the reuse queue, by swapping it with the
                     // read pos, and then incrementing the read pos.
                     if (waveload->reuse_idx != AG.waveload_dma_queue1_rpos) {
-                        AG.waveload_dma_queue1[waveload->reuse_idx] = AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos];
-                        AG.waveload_list[AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos]] .reuse_idx = waveload->reuse_idx;
+                        AG.waveload_dma_queue1[waveload->reuse_idx] =
+                            AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos];
+                        AG.waveload_list[AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos]].reuse_idx =
+                            waveload->reuse_idx;
                     }
                     AG.waveload_dma_queue1_rpos++;
                 }
@@ -130,7 +132,7 @@ void* Nas_WaveDmaCallBack(u32 device_addr, u32 size, s32 arg2, u8* waveload_idx,
             hasWaveload = TRUE;
         }
     } else {
-search_short_lived:
+    search_short_lived:
         waveload = AG.waveload_list + *waveload_idx;
         for (i = 0; i <= AG.waveload_count; waveload = AG.waveload_list + i++) {
             bufferPos = device_addr - waveload->device_addr;
@@ -140,8 +142,10 @@ search_short_lived:
                     // Move the WAVELOAD out of the reuse queue, by swapping it with the
                     // read pos, and then incrementing the read pos.
                     if (waveload->reuse_idx != AG.waveload_dma_queue0_rpos) {
-                        AG.waveload_dma_queue0[waveload->reuse_idx] = AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos];
-                        AG.waveload_list[AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos]].reuse_idx = waveload->reuse_idx;
+                        AG.waveload_dma_queue0[waveload->reuse_idx] =
+                            AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos];
+                        AG.waveload_list[AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos]].reuse_idx =
+                            waveload->reuse_idx;
                     }
                     AG.waveload_dma_queue0_rpos++;
                 }
@@ -168,8 +172,9 @@ search_short_lived:
     waveload->time_to_live = 3;
     waveload->device_addr = waveloadDevAddr;
     waveload->size_unused = transfer;
-    Nas_StartDma(&AG.cur_adio_frame_dma_io_mesg_buf[AG.current_frame_dma_count++], 0 /* OS_MESG_PRI_NORMAL */, 0 /* OS_READ */,
-                  waveloadDevAddr, waveload->ram_addr, transfer, &AG.cur_audio_frame_dma_queue, medium, (s8*)"SUPERDMA");
+    Nas_StartDma(&AG.cur_adio_frame_dma_io_mesg_buf[AG.current_frame_dma_count++], 0 /* OS_MESG_PRI_NORMAL */,
+                 0 /* OS_READ */, waveloadDevAddr, waveload->ram_addr, transfer, &AG.cur_audio_frame_dma_queue, medium,
+                 (s8*)"SUPERDMA");
     *waveload_idx = waveloadIndex;
     return (device_addr - waveloadDevAddr) + waveload->ram_addr;
 }
@@ -180,7 +185,8 @@ void Nas_WaveDmaNew(s32 n_channels) {
     s32 t2;
 
     AG.waveload_dma_cur_buf_size = AG.waveload_dma_buf0_size;
-    AG.waveload_list = (WaveLoad*)Nas_HeapAlloc(&AG.misc_heap, 4 * AG.num_channels * sizeof(WaveLoad) * AG.audio_params.spec);
+    AG.waveload_list =
+        (WaveLoad*)Nas_HeapAlloc(&AG.misc_heap, 4 * AG.num_channels * sizeof(WaveLoad) * AG.audio_params.spec);
     t2 = 3 * AG.num_channels * AG.audio_params.spec;
     for (i = 0; i < t2; i++) {
         waveload = &AG.waveload_list[AG.num_waveloads];
@@ -371,7 +377,8 @@ static s32 __Nas_LoadVoice_Inner(smzwavetable* wavetable, s32 bank_id) {
 
     if (wavetable->is_relocated == TRUE) {
         if (wavetable->medium != MEDIUM_RAM) {
-            sample_addr = (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT);
+            sample_addr =
+                (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT);
             if (sample_addr == NULL) {
                 return -1;
             }
@@ -390,7 +397,6 @@ static s32 __Nas_LoadVoice_Inner(smzwavetable* wavetable, s32 bank_id) {
     return 0;
 }
 
-
 s32 Nas_LoadVoice(s32 bank_id, s32 instId, s32 drumId) {
     if (instId < 0x7F) {
         voicetable* voice = ProgToVp(bank_id, instId);
@@ -551,7 +557,7 @@ static s32 __Nas_StartSeq(s32 group_idx, s32 seq_id, s32 param) {
 
     Nas_InitMySeq(group);
     group->seq_id = seq_id;
-    
+
     if (bank_id != 0xFF) {
         bank_id = __Link_BankNum(BANK_TABLE, bank_id);
         group->bank_id = bank_id;
@@ -600,12 +606,12 @@ static u32 __Load_Wave(s32 wave_id, u32* medium, s32 no_load) {
         *medium = MEDIUM_RAM;
         return (u32)ram_p;
     }
-    
+
     if (header->entries[wave_id].cacheType == CACHE_LOAD_EITHER_NOSYNC || no_load == TRUE) {
         *medium = header->entries[wave_id].medium;
         return header->entries[link_id].addr;
     }
-    
+
     ram_p = __Load_Bank(WAVE_TABLE, wave_id, &no_load);
     if (ram_p != NULL) {
         *medium = MEDIUM_RAM;
@@ -633,7 +639,7 @@ static u8* __Load_Ctrl(s32 bank_id) {
 
     wave_media.wave0_bank_id = wave_id0;
     wave_media.wave1_bank_id = wave_id1;
-    
+
     if (wave_id0 != 0xFF) {
         wave_media.wave0_p = (void*)__Load_Wave(wave_id0, &wave_media.wave0_media, FALSE);
     } else {
@@ -719,7 +725,7 @@ static u8* __Load_Bank(s32 table_type, s32 id, s32* did_alloc) {
             if (rom_addr == NULL) {
                 return NULL;
             }
-            
+
             if (table_type == BANK_TABLE) {
                 size -= sizeof(ArcEntry);
                 vinfo = &AG.voice_info[link_id];
@@ -781,7 +787,7 @@ static void* __Check_Cache(s32 table_type, s32 id) {
         return ram_p;
     }
 
-    ram_p = (void*)Nas_SzCacheCheck(table_type, CACHE_EITHER, id);
+    ram_p = Nas_SzCacheCheck(table_type, CACHE_EITHER, id);
     if (ram_p) {
         return ram_p;
     }
@@ -828,7 +834,7 @@ static void Nas_BankOfsToAddr_Inner(s32 bank_id, u8* ctrl_p, WaveMedia* wave_med
                 continue; // empty percussion/drum entry
             }
 
-            inst_ofs += (u32)ctrl_p;//OFS2RAM(ctrl_p, ofs);
+            inst_ofs += (u32)ctrl_p; // OFS2RAM(ctrl_p, ofs);
             percvt = (perctable*)inst_ofs;
             ((perctable**)*BANK_ENTRY(ctrl_p, 0))[i] = percvt;
 
@@ -920,7 +926,7 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) {
     if ((((u32)SrcAddr) & 0x1F) != 0) {
         OSReport("DMA Warning: SrcAddr %d is not align32\n", SrcAddr);
     }
-    
+
     if ((((u32)DestAdd) & 0x1F) != 0) {
         OSReport("DMA Warning: DestAdd %d is not align32\n", DestAdd);
     }
@@ -930,16 +936,18 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) {
 
         // DMA the first non-align32 bytes
         // @BUG - FASTDMA_BUFFER is always NULL
-        Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr - (((u32)SrcAddr) & 0x1F), FASTDMA_BUFFER, 0x20, &AG.sync_dma_queue, medium, (s8*)"FastCopy");
+        Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr - (((u32)SrcAddr) & 0x1F), FASTDMA_BUFFER, 0x20,
+                     &AG.sync_dma_queue, medium, (s8*)"FastCopy");
         Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK);
         unalign_copy_len = 32 - (((u32)SrcAddr) & 0x1F);
         Z_bcopy(unalign_src_copy + (((u32)SrcAddr) & 0x1F), DestAdd, 32 - (((u32)SrcAddr) & 0x1F));
         SrcAddr += unalign_copy_len;
         DestAdd += unalign_copy_len;
         Length -= unalign_copy_len;
-        
+
         while (Length != 0) {
-            Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, unalign_src_copy, 0x400, &AG.sync_dma_queue, medium, (s8*)"FastCopy");
+            Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, unalign_src_copy, 0x400, &AG.sync_dma_queue, medium,
+                         (s8*)"FastCopy");
             Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK);
 
             if (Length < 0x400) {
@@ -959,7 +967,8 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) {
                 break;
             }
 
-            Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, 0x400, &AG.sync_dma_queue, medium, (s8*)"FastCopy");
+            Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, 0x400, &AG.sync_dma_queue, medium,
+                         (s8*)"FastCopy");
             Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK);
             Length -= 0x400;
             SrcAddr += 0x400;
@@ -967,7 +976,8 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) {
         }
 
         if (Length != 0) {
-            Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, Length, &AG.sync_dma_queue, medium, (s8*)"FastCopy");
+            Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, Length, &AG.sync_dma_queue, medium,
+                         (s8*)"FastCopy");
             Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK);
         }
     }
@@ -977,11 +987,11 @@ extern void Nas_FastDiskCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium
     // empty
 }
 
-static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr,
-    void* dram_addr, u32 size, OSMesgQueue* mq, s32 medium, s8* dma_type) {
+static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr, void* dram_addr, u32 size,
+                        OSMesgQueue* mq, s32 medium, s8* dma_type) {
     OSPiHandle* handle;
-    
-        osInvalDCache2(dram_addr, size);
+
+    osInvalDCache2(dram_addr, size);
     if (AG.reset_timer > 16) {
         return -1;
     }
@@ -1055,7 +1065,8 @@ static u8* __Load_Bank_BG(s32 table_type, s32 id, s32 n_chunks, s32 ret_data, OS
     ramAddr = (u8*)__Check_Cache(table_type, link_id);
     if (ramAddr != NULL) {
         loadStatus = LOAD_STATUS_COMPLETE;
-        Z_osSendMesg(ret_queue, (OSMesg)MK_BGLOAD_MSG(ret_data, SEQUENCE_TABLE, 0, LOAD_STATUS_NOT_LOADED), OS_MESG_NOBLOCK);
+        Z_osSendMesg(ret_queue, (OSMesg)MK_BGLOAD_MSG(ret_data, SEQUENCE_TABLE, 0, LOAD_STATUS_NOT_LOADED),
+                     OS_MESG_NOBLOCK);
     } else {
         header = __Get_ArcHeader(table_type);
         size = header->entries[link_id].size;
@@ -1101,7 +1112,7 @@ static u8* __Load_Bank_BG(s32 table_type, s32 id, s32 n_chunks, s32 ret_data, OS
             if (devAddr == 0) {
                 return NULL;
             }
-            
+
             if (table_type == BANK_TABLE) {
                 size -= 0x10;
                 vinfo = &AG.voice_info[link_id];
@@ -1113,11 +1124,11 @@ static u8* __Load_Bank_BG(s32 table_type, s32 id, s32 n_chunks, s32 ret_data, OS
         }
 
         if (medium == MEDIUM_DISK) {
-            Nas_BgCopyDisk(header->medium, (u8*)devAddr, ramAddr, size, medium,
-                                              n_chunks, ret_queue, MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus));
+            Nas_BgCopyDisk(header->medium, (u8*)devAddr, ramAddr, size, medium, n_chunks, ret_queue,
+                           MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus));
         } else {
             Nas_BgCopyReq((u8*)devAddr, ramAddr, size, medium, n_chunks, ret_queue,
-                                     MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus));
+                          MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus));
         }
         loadStatus = LOAD_STATUS_IN_PROGRESS;
     }
@@ -1200,12 +1211,13 @@ void Nas_InitAudio(u64* heap_p, s32 heap_size) {
     *(u32*)&AG.unused_rsp_tasks[0][56] = 0; // OSTask.t.data_size = 0;
     *(u32*)&AG.unused_rsp_tasks[1][56] = 0; // OSTask.t.data_size = 0;
     Z_osCreateMesgQueue(&AG.sync_dma_queue, AG.sync_dma_queue_msg, ARRAY_COUNT(AG.sync_dma_queue_msg));
-    Z_osCreateMesgQueue(&AG.cur_audio_frame_dma_queue, AG.cur_audio_frame_dma_mesg_buf, ARRAY_COUNT(AG.cur_audio_frame_dma_mesg_buf));
+    Z_osCreateMesgQueue(&AG.cur_audio_frame_dma_queue, AG.cur_audio_frame_dma_mesg_buf,
+                        ARRAY_COUNT(AG.cur_audio_frame_dma_mesg_buf));
     Z_osCreateMesgQueue(&AG.external_load_queue, AG.external_load_mesg_buf, ARRAY_COUNT(AG.external_load_mesg_buf));
     Z_osCreateMesgQueue(&AG.preload_sample_queue, AG.preload_sample_mesg_buf, ARRAY_COUNT(AG.preload_sample_mesg_buf));
     AG.current_frame_dma_count = 0;
     AG.num_waveloads = 0;
-    
+
     AG.audio_heap_p = heap_p;
     AG.audio_heap_size = heap_size;
     OSReport("AUDIOHEAP SET ADDR %xh (SIZE %xh) \n", (u32)heap_p, heap_size);
@@ -1293,7 +1305,8 @@ s32 VoiceLoad(s32 bank_id, u32 inst_id, s8* done_p) {
 
     cache->sample = *wavetable;
     cache->is_done = done_p;
-    cache->current_ram_addr = (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY);
+    cache->current_ram_addr =
+        (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY);
 
     if (cache->current_ram_addr == NULL) {
         if (wavetable->medium == MEDIUM_DISK || wavetable->codec == CODEC_S16_INMEMORY) {
@@ -1386,7 +1399,8 @@ void LpsDma(s32 reset_status) {
                     *cache->is_done = TRUE;
                 } else if (cache->bytes_remaining < 0x400) {
                     if (cache->medium == MEDIUM_DISK) {
-                        __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr, cache->bytes_remaining, cache->unk_medium_param);
+                        __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr,
+                                           cache->bytes_remaining, cache->unk_medium_param);
                     } else {
                         __Nas_SlowCopy(cache, cache->bytes_remaining);
                     }
@@ -1394,7 +1408,8 @@ void LpsDma(s32 reset_status) {
                     cache->bytes_remaining = 0;
                 } else {
                     if (cache->medium == MEDIUM_DISK) {
-                        __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr, 0x400, cache->unk_medium_param);
+                        __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr, 0x400,
+                                           cache->unk_medium_param);
                     } else {
                         __Nas_SlowCopy(cache, 0x400);
                     }
@@ -1412,7 +1427,8 @@ void LpsDma(s32 reset_status) {
 static void __Nas_SlowCopy(lpscache* cache, s32 size) {
     osInvalDCache2(cache->current_ram_addr, size);
     Z_osCreateMesgQueue(&cache->mq, cache->msg, ARRAY_COUNT(cache->msg));
-    Nas_StartDma(&cache->io_mesg, 0, 0, cache->current_device_addr, cache->current_ram_addr, size, &cache->mq, cache->medium, (s8*)"SLOWCOPY");
+    Nas_StartDma(&cache->io_mesg, 0, 0, cache->current_device_addr, cache->current_ram_addr, size, &cache->mq,
+                 cache->medium, (s8*)"SLOWCOPY");
 }
 
 static void __Nas_SlowDiskCopy(u8* dev_addr, u8* ram_addr, u32 size, s32 medium) {
@@ -1431,7 +1447,7 @@ s32 SeqLoad(s32 seq_id, u8* ram_addr, s8* is_done) {
 
     cache->sample.sample = NULL;
     cache->is_done = is_done;
-    
+
     size = header->entries[link_id].size;
     size = ALIGN_NEXT(size, 32);
 
@@ -1459,7 +1475,8 @@ void Nas_BgCopyInit(void) {
     }
 }
 
-static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, s32 msg) {
+static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq,
+                              s32 msg) {
     Bgload* bgload = Nas_BgCopyReq(src, dst, size, medium, n_chunks, mq, msg);
 
     if (bgload == NULL) {
@@ -1491,7 +1508,7 @@ static Bgload* Nas_BgCopyReq(u8* src, u8* dst, u32 size, s32 medium, s32 n_chunk
     bgload->ram_addr = dst;
     bgload->current_ram_addr = dst;
     bgload->bytes_remaining = size;
-    
+
     if (n_chunks == 0) {
         bgload->chunk_size = 0x1000;
     } else if (n_chunks == 1) {
@@ -1562,7 +1579,7 @@ static void __BgCopyFinishProcess(Bgload* bgload) {
     s32 wave0;
     s32 wave1;
     WaveMedia wavemedia;
-    
+
     type = BGLOAD_TBLTYPE(msg);
     status = BGLOAD_LOAD_STATUS(msg);
     id = BGLOAD_ID(msg);
@@ -1591,7 +1608,7 @@ static void __BgCopyFinishProcess(Bgload* bgload) {
             } else {
                 wavemedia.wave1_p = NULL;
             }
-            
+
             Nas_WriteIDbank(id, status);
             Nas_BankOfsToAddr(id, bgload->ram_addr, &wavemedia, TRUE);
             break;
@@ -1627,7 +1644,8 @@ static void __BgCopySub(Bgload* bgload, s32 reset_status) {
 
     if (bgload->bytes_remaining < bgload->chunk_size) {
         if (bgload->medium == MEDIUM_DISK) {
-            __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->bytes_remaining, header->medium);
+            __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->bytes_remaining,
+                             header->medium);
         } else if (bgload->medium == MEDIUM_RAM_UNLOADED) {
             __Nas_ExCopy(bgload, bgload->bytes_remaining);
         } else {
@@ -1637,7 +1655,8 @@ static void __BgCopySub(Bgload* bgload, s32 reset_status) {
         bgload->bytes_remaining = 0;
     } else {
         if (bgload->medium == MEDIUM_DISK) {
-            __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->chunk_size, header->medium);
+            __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->chunk_size,
+                             header->medium);
         } else if (bgload->medium == MEDIUM_RAM_UNLOADED) {
             __Nas_ExCopy(bgload, bgload->chunk_size);
         } else {
@@ -1654,7 +1673,8 @@ static void __Nas_BgCopy(Bgload* bgload, s32 size) {
     size = ALIGN_NEXT(size, 32);
     osInvalDCache2(bgload->current_ram_addr, size);
     Z_osCreateMesgQueue(&bgload->mq, bgload->msg, ARRAY_COUNT(bgload->msg));
-    Nas_StartDma(&bgload->io_mesg, 0, 0, bgload->current_device_addr, bgload->current_ram_addr, size, &bgload->mq, bgload->medium, (s8*)"BGCOPY");
+    Nas_StartDma(&bgload->io_mesg, 0, 0, bgload->current_device_addr, bgload->current_ram_addr, size, &bgload->mq,
+                 bgload->medium, (s8*)"BGCOPY");
 }
 
 static void __Nas_ExCopy(Bgload* bgload, s32 size) {
@@ -1672,7 +1692,7 @@ static void __Nas_BgDiskCopy(u8* src, u8* dst, u32 size, s32 param) {
 static void __WaveTouch(wtstr* wavetouch_str, u32 ram_addr, WaveMedia* wave_media) {
     smzwavetable* wavetable;
     void* reloc;
-    
+
     if ((u32)wavetouch_str->wavetable <= OS_BASE_CACHED) {
         // wave is not relocated
         reloc = (void*)((u32)wavetouch_str->wavetable + ram_addr);
@@ -1703,7 +1723,8 @@ static void __WaveTouch(wtstr* wavetouch_str, u32 ram_addr, WaveMedia* wave_medi
             }
 
             wavetable->is_relocated = TRUE;
-            if (wavetable->bit26 && wavetable->medium != MEDIUM_RAM && AG.num_used_samples < ARRAY_COUNT(AG.used_samples)) {
+            if (wavetable->bit26 && wavetable->medium != MEDIUM_RAM &&
+                AG.num_used_samples < ARRAY_COUNT(AG.used_samples)) {
                 AG.used_samples[AG.num_used_samples++] = wavetable;
             }
         }
@@ -1744,24 +1765,30 @@ s32 Nas_BankOfsToAddr(s32 bank_id, u8* ctrl_p, WaveMedia* wave_media, s32 async)
 
         wavetable = AG.used_samples[i];
         wave_ram_p = NULL;
-        
+
         switch (async) {
             case FALSE:
                 if (wavetable->medium == wave_media->wave0_media) {
-                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT);
+                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample,
+                                                       wavetable->medium, CACHE_PERSISTENT);
                 } else if (wavetable->medium == wave_media->wave1_media) {
-                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT);
+                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample,
+                                                       wavetable->medium, CACHE_PERSISTENT);
                 } else if (wavetable->medium == MEDIUM_DISK_DRIVE) {
-                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium, CACHE_PERSISTENT);
+                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium,
+                                                       CACHE_PERSISTENT);
                 }
                 break;
             case TRUE:
                 if (wavetable->medium == wave_media->wave0_media) {
-                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY);
+                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample,
+                                                       wavetable->medium, CACHE_TEMPORARY);
                 } else if (wavetable->medium == wave_media->wave1_media) {
-                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY);
+                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample,
+                                                       wavetable->medium, CACHE_TEMPORARY);
                 } else if (wavetable->medium == MEDIUM_DISK_DRIVE) {
-                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium, CACHE_TEMPORARY);
+                    wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium,
+                                                       CACHE_TEMPORARY);
                 }
                 break;
         }
@@ -1800,7 +1827,8 @@ s32 Nas_BankOfsToAddr(s32 bank_id, u8* ctrl_p, WaveMedia* wave_media, s32 async)
         wavetable = top_preload->sample;
         n_chunks = 1;
         n_chunks += (wavetable->size / 0x1000);
-        Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, &AG.preload_sample_queue, top_preload->encoded_info);
+        Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks,
+                      &AG.preload_sample_queue, top_preload->encoded_info);
     }
 
     // @BUG - this function clearly has no return value
@@ -1814,7 +1842,7 @@ s32 Nas_CheckBgWave(s32 reset_status) {
     u32 preload_idx;
     s32 key;
     s32 n_chunks;
-    
+
     if (AG.num_requested_samples > 0) {
         if (reset_status != 0) {
             Z_osRecvMesg(&AG.preload_sample_queue, (OSMesg*)&preload_idx, OS_MESG_NOBLOCK);
@@ -1860,7 +1888,8 @@ s32 Nas_CheckBgWave(s32 reset_status) {
                 preload->is_free = TRUE;
                 AG.num_requested_samples--;
             } else {
-                Nas_BgCopyReq(wavetable->sample, preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, &AG.preload_sample_queue, preload->encoded_info);
+                Nas_BgCopyReq(wavetable->sample, preload->ram_addr, wavetable->size, wavetable->medium, n_chunks,
+                              &AG.preload_sample_queue, preload->encoded_info);
                 break;
             }
         }
@@ -1925,7 +1954,7 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) {
 
     for (i = 0; i < n_drums; i++) {
         percussion = PercToPp(bank_id, i);
-        
+
         if (percussion != NULL) {
             __Reload(&percussion->tuned_sample);
         }
@@ -1933,7 +1962,7 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) {
 
     for (i = 0; i < n_sfx; i++) {
         sfx = VpercToVep(bank_id, i);
-        
+
         if (sfx != NULL) {
             __Reload(&sfx->tuned_sample);
         }
@@ -1961,16 +1990,20 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) {
         switch (async) {
             case FALSE:
                 if (wavetable->medium == wavemedia->wave0_media) {
-                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT);
+                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample,
+                                                 wavetable->medium, CACHE_PERSISTENT);
                 } else if (wavetable->medium == wavemedia->wave1_media) {
-                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT);
+                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample,
+                                                 wavetable->medium, CACHE_PERSISTENT);
                 }
                 break;
             case TRUE:
                 if (wavetable->medium == wavemedia->wave0_media) {
-                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY);
+                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample,
+                                                 wavetable->medium, CACHE_TEMPORARY);
                 } else if (wavetable->medium == wavemedia->wave1_media) {
-                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY);
+                    addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample,
+                                                 wavetable->medium, CACHE_TEMPORARY);
                 }
                 break;
         }
@@ -2009,7 +2042,8 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) {
         wavetable = top_preload->sample;
         n_chunks = 1;
         n_chunks += (wavetable->size / 0x1000);
-        Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, &AG.preload_sample_queue, top_preload->encoded_info);
+        Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks,
+                      &AG.preload_sample_queue, top_preload->encoded_info);
     }
 }
 
@@ -2056,7 +2090,7 @@ u8* MK_RMES[MK_ENTRIES];
 
 void MK_load(s32 table_type, s32 id, u8* done_p) {
     static s32 use = 0;
-    
+
     MK_RMES[use] = done_p;
     Nas_PreLoad_BG(table_type, id, 0, use, &MK_QUEUE);
     use++;