diff --git a/include/functions.h b/include/functions.h
index 33962eb58d..d3521cfc97 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -2816,16 +2816,16 @@ void AudioEffects_NotePortamentoInit(Note* note);
 void AudioEffects_AdsrInit(AdsrState* adsr, EnvelopePoint* envelope, s16* volOut);
 f32 AudioEffects_AdsrUpdate(AdsrState* adsr);
 
-void AudioSeq_SequenceChannelDisable(SequenceChannel* channel);
-void AudioSeq_SequencePlayerDisableAsFinished(SequencePlayer* seqPlayer);
-void AudioSeq_SequencePlayerDisable(SequencePlayer* seqPlayer);
-void AudioSeq_AudioListPushBack(AudioListItem* list, AudioListItem* item);
-void* AudioSeq_AudioListPopBack(AudioListItem* list);
-void AudioSeq_ProcessSequences(s32 arg0);
-void AudioSeq_SkipForwardSequence(SequencePlayer* seqPlayer);
-void AudioSeq_ResetSequencePlayer(SequencePlayer* seqPlayer);
-void AudioSeq_InitSequencePlayerChannels(s32 seqPlayerIndex);
-void AudioSeq_InitSequencePlayers(void);
+void AudioScript_SequenceChannelDisable(SequenceChannel* channel);
+void AudioScript_SequencePlayerDisableAsFinished(SequencePlayer* seqPlayer);
+void AudioScript_SequencePlayerDisable(SequencePlayer* seqPlayer);
+void AudioScript_AudioListPushBack(AudioListItem* list, AudioListItem* item);
+void* AudioScript_AudioListPopBack(AudioListItem* list);
+void AudioScript_ProcessSequences(s32 arg0);
+void AudioScript_SkipForwardSequence(SequencePlayer* seqPlayer);
+void AudioScript_ResetSequencePlayer(SequencePlayer* seqPlayer);
+void AudioScript_InitSequencePlayerChannels(s32 seqPlayerIndex);
+void AudioScript_InitSequencePlayers(void);
 
 void func_8019AE40(s32 param_1, s32 param_2, u32 param_3, s32 param_4);
 void func_8019AEC0(UNK_PTR param_1, UNK_PTR param_2);
diff --git a/src/audio/lib/effects.c b/src/audio/lib/effects.c
index 0dcdcda88f..feddf73caf 100644
--- a/src/audio/lib/effects.c
+++ b/src/audio/lib/effects.c
@@ -64,7 +64,7 @@ void AudioEffects_SequencePlayerProcessSound(SequencePlayer* seqPlayer) {
 
         seqPlayer->fadeTimer--;
         if ((seqPlayer->fadeTimer == 0) && (seqPlayer->state == SEQPLAYER_STATE_FADE_OUT)) {
-            AudioSeq_SequencePlayerDisable(seqPlayer);
+            AudioScript_SequencePlayerDisable(seqPlayer);
             return;
         }
     }
diff --git a/src/audio/lib/heap.c b/src/audio/lib/heap.c
index d767f7de36..0a64c0d1b4 100644
--- a/src/audio/lib/heap.c
+++ b/src/audio/lib/heap.c
@@ -86,7 +86,7 @@ void AudioHeap_DiscardFont(s32 fontId) {
 
             AudioPlayback_NoteDisable(note);
             AudioPlayback_AudioListRemove(&note->listItem);
-            AudioSeq_AudioListPushBack(&gAudioCtx.noteFreeLists.disabled, &note->listItem);
+            AudioScript_AudioListPushBack(&gAudioCtx.noteFreeLists.disabled, &note->listItem);
         }
     }
 }
@@ -113,7 +113,7 @@ void AudioHeap_DiscardSequence(s32 seqId) {
 
     for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) {
         if (gAudioCtx.seqPlayers[i].enabled && gAudioCtx.seqPlayers[i].seqId == seqId) {
-            AudioSeq_SequencePlayerDisable(&gAudioCtx.seqPlayers[i]);
+            AudioScript_SequencePlayerDisable(&gAudioCtx.seqPlayers[i]);
         }
     }
 }
@@ -857,7 +857,7 @@ s32 AudioHeap_ResetStep(void) {
     switch (gAudioCtx.resetStatus) {
         case 5:
             for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) {
-                AudioSeq_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[i]);
+                AudioScript_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[i]);
             }
             gAudioCtx.audioResetFadeOutFramesLeft = 2 / count;
             gAudioCtx.resetStatus--;
@@ -1059,10 +1059,10 @@ void AudioHeap_Init(void) {
     }
 
     // Initialize sequence players
-    AudioSeq_InitSequencePlayers();
+    AudioScript_InitSequencePlayers();
     for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) {
-        AudioSeq_InitSequencePlayerChannels(i);
-        AudioSeq_ResetSequencePlayer(&gAudioCtx.seqPlayers[i]);
+        AudioScript_InitSequencePlayerChannels(i);
+        AudioScript_ResetSequencePlayer(&gAudioCtx.seqPlayers[i]);
     }
 
     // Initialize two additional caches on the audio heap to store individual audio samples
diff --git a/src/audio/lib/load.c b/src/audio/lib/load.c
index 6584b0a50f..3a4f1c1e0d 100644
--- a/src/audio/lib/load.c
+++ b/src/audio/lib/load.c
@@ -584,7 +584,7 @@ s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIndex, s32 seqId, s32 arg2) {
         return 0;
     }
 
-    AudioSeq_SequencePlayerDisable(seqPlayer);
+    AudioScript_SequencePlayerDisable(seqPlayer);
 
     if (1) {}
     fontId = 0xFF;
@@ -602,7 +602,7 @@ s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIndex, s32 seqId, s32 arg2) {
         return 0;
     }
 
-    AudioSeq_ResetSequencePlayer(seqPlayer);
+    AudioScript_ResetSequencePlayer(seqPlayer);
     seqPlayer->seqId = seqId;
 
     if (fontId != 0xFF) {
diff --git a/src/audio/lib/playback.c b/src/audio/lib/playback.c
index 9f3c6f8ed8..deb6e82b99 100644
--- a/src/audio/lib/playback.c
+++ b/src/audio/lib/playback.c
@@ -189,7 +189,7 @@ void AudioPlayback_ProcessNotes(void) {
                        (playbackState->priority >= 1)) {
                 // do nothing
             } else if (playbackState->parentLayer->channel->seqPlayer == NULL) {
-                AudioSeq_SequenceChannelDisable(playbackState->parentLayer->channel);
+                AudioScript_SequenceChannelDisable(playbackState->parentLayer->channel);
                 playbackState->priority = 1;
                 playbackState->status = PLAYBACK_STATUS_1;
                 continue;
@@ -224,13 +224,13 @@ void AudioPlayback_ProcessNotes(void) {
                             AudioEffects_NoteVibratoInit(note);
                             AudioEffects_NotePortamentoInit(note);
                             AudioPlayback_AudioListRemove(&note->listItem);
-                            AudioSeq_AudioListPushBack(&note->listItem.pool->active, &note->listItem);
+                            AudioScript_AudioListPushBack(&note->listItem.pool->active, &note->listItem);
                             playbackState->wantedParentLayer = NO_LAYER;
                             // don't skip
                         } else {
                             AudioPlayback_NoteDisable(note);
                             AudioPlayback_AudioListRemove(&note->listItem);
-                            AudioSeq_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
+                            AudioScript_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
                             playbackState->wantedParentLayer = NO_LAYER;
                             goto skip;
                         }
@@ -240,7 +240,7 @@ void AudioPlayback_ProcessNotes(void) {
                         }
                         AudioPlayback_NoteDisable(note);
                         AudioPlayback_AudioListRemove(&note->listItem);
-                        AudioSeq_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
+                        AudioScript_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
                         continue;
                     }
                 }
@@ -250,7 +250,7 @@ void AudioPlayback_ProcessNotes(void) {
                 }
                 AudioPlayback_NoteDisable(note);
                 AudioPlayback_AudioListRemove(&note->listItem);
-                AudioSeq_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
+                AudioScript_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
                 continue;
             }
 
@@ -669,7 +669,7 @@ void AudioPlayback_InitNoteFreeList(void) {
     for (i = 0; i < gAudioCtx.numNotes; i++) {
         gAudioCtx.notes[i].listItem.u.value = &gAudioCtx.notes[i];
         gAudioCtx.notes[i].listItem.prev = NULL;
-        AudioSeq_AudioListPushBack(&gAudioCtx.noteFreeLists.disabled, &gAudioCtx.notes[i].listItem);
+        AudioScript_AudioListPushBack(&gAudioCtx.noteFreeLists.disabled, &gAudioCtx.notes[i].listItem);
     }
 }
 
@@ -708,7 +708,7 @@ void AudioPlayback_NotePoolClear(NotePool* pool) {
                 break;
             }
             AudioPlayback_AudioListRemove(cur);
-            AudioSeq_AudioListPushBack(dest, cur);
+            AudioScript_AudioListPushBack(dest, cur);
         }
     }
 }
@@ -750,11 +750,11 @@ void AudioPlayback_NotePoolFill(NotePool* pool, s32 count) {
         }
 
         while (j < count) {
-            note = AudioSeq_AudioListPopBack(source);
+            note = AudioScript_AudioListPopBack(source);
             if (note == NULL) {
                 break;
             }
-            AudioSeq_AudioListPushBack(dest, &note->listItem);
+            AudioScript_AudioListPushBack(dest, &note->listItem);
             j++;
         }
     }
@@ -867,7 +867,8 @@ void AudioPlayback_NoteReleaseAndTakeOwnership(Note* note, SequenceLayer* layer)
 }
 
 Note* AudioPlayback_AllocNoteFromDisabled(NotePool* pool, SequenceLayer* layer) {
-    Note* note = AudioSeq_AudioListPopBack(&pool->disabled);
+    Note* note = AudioScript_AudioListPopBack(&pool->disabled);
+
     if (note != NULL) {
         AudioPlayback_NoteInitForLayer(note, layer);
         AudioPlayback_AudioListPushFront(&pool->active, &note->listItem);
@@ -881,7 +882,7 @@ Note* AudioPlayback_AllocNoteFromDecaying(NotePool* pool, SequenceLayer* layer)
     if (note != NULL) {
         AudioPlayback_NoteReleaseAndTakeOwnership(note, layer);
         AudioPlayback_AudioListRemove(&note->listItem);
-        AudioSeq_AudioListPushBack(&pool->releasing, &note->listItem);
+        AudioScript_AudioListPushBack(&pool->releasing, &note->listItem);
     }
     return note;
 }
@@ -912,7 +913,7 @@ Note* AudioPlayback_AllocNoteFromActive(NotePool* pool, SequenceLayer* layer) {
     if (aPriority < rPriority) {
         AudioPlayback_AudioListRemove(&aNote->listItem);
         func_801963E8(aNote, layer);
-        AudioSeq_AudioListPushBack(&pool->releasing, &aNote->listItem);
+        AudioScript_AudioListPushBack(&pool->releasing, &aNote->listItem);
         aNote->playbackState.priority = layer->channel->notePriority;
         return aNote;
     }
@@ -931,7 +932,7 @@ Note* AudioPlayback_AllocNote(SequenceLayer* layer) {
             note->playbackState.wantedParentLayer == NO_LAYER) {
             AudioPlayback_NoteReleaseAndTakeOwnership(note, layer);
             AudioPlayback_AudioListRemove(&note->listItem);
-            AudioSeq_AudioListPushBack(&note->listItem.pool->releasing, &note->listItem);
+            AudioScript_AudioListPushBack(&note->listItem.pool->releasing, &note->listItem);
             return note;
         }
     }
diff --git a/src/audio/lib/seqplayer.c b/src/audio/lib/seqplayer.c
index a8c54420a1..270164972e 100644
--- a/src/audio/lib/seqplayer.c
+++ b/src/audio/lib/seqplayer.c
@@ -29,15 +29,15 @@ typedef enum {
     /* 5 */ PORTAMENTO_MODE_5
 } PortamentoMode;
 
-u8 AudioSeq_ScriptReadU8(SeqScriptState* state);
-s16 AudioSeq_ScriptReadS16(SeqScriptState* state);
-u16 AudioSeq_ScriptReadCompressedU16(SeqScriptState* state);
-void AudioSeq_SeqLayerProcessScriptStep1(SequenceLayer* layer);
-s32 AudioSeq_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameTunedSample);
-s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer);
-s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd);
-s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd);
-u8 AudioSeq_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** instOut, AdsrSettings* adsr);
+u8 AudioScript_ScriptReadU8(SeqScriptState* state);
+s16 AudioScript_ScriptReadS16(SeqScriptState* state);
+u16 AudioScript_ScriptReadCompressedU16(SeqScriptState* state);
+void AudioScript_SeqLayerProcessScriptStep1(SequenceLayer* layer);
+s32 AudioScript_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameTunedSample);
+s32 AudioScript_SeqLayerProcessScriptStep2(SequenceLayer* layer);
+s32 AudioScript_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd);
+s32 AudioScript_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd);
+u8 AudioScript_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** instOut, AdsrSettings* adsr);
 
 /**
  * sSeqInstructionArgsTable is a table for each sequence instruction
@@ -172,7 +172,7 @@ u8 sSeqInstructionArgsTable[] = {
  *
  * @return the argument value for a control flow instruction, or 0 if there is no argument
  */
-u16 AudioSeq_GetScriptControlFlowArgument(SeqScriptState* state, u8 cmd) {
+u16 AudioScript_GetScriptControlFlowArgument(SeqScriptState* state, u8 cmd) {
     u8 highBits = sSeqInstructionArgsTable[cmd - 0xA0];
     u8 lowBits = highBits & 3;
     u16 cmdArg = 0;
@@ -180,9 +180,9 @@ u16 AudioSeq_GetScriptControlFlowArgument(SeqScriptState* state, u8 cmd) {
     // only 1 argument
     if (lowBits == 1) {
         if (!(highBits & 0x80)) {
-            cmdArg = AudioSeq_ScriptReadU8(state);
+            cmdArg = AudioScript_ScriptReadU8(state);
         } else {
-            cmdArg = AudioSeq_ScriptReadS16(state);
+            cmdArg = AudioScript_ScriptReadS16(state);
         }
     }
 
@@ -194,7 +194,7 @@ u16 AudioSeq_GetScriptControlFlowArgument(SeqScriptState* state, u8 cmd) {
  *
  * @return number of frames until next instruction. -1 signals termination
  */
-s32 AudioSeq_HandleScriptFlowControl(SequencePlayer* seqPlayer, SeqScriptState* state, s32 cmd, s32 cmdArg) {
+s32 AudioScript_HandleScriptFlowControl(SequencePlayer* seqPlayer, SeqScriptState* state, s32 cmd, s32 cmdArg) {
     u32 depth;
 
     switch (cmd) {
@@ -206,7 +206,7 @@ s32 AudioSeq_HandleScriptFlowControl(SequencePlayer* seqPlayer, SeqScriptState*
             break;
 
         case 0xFD: // delay n frames
-            return AudioSeq_ScriptReadCompressedU16(state);
+            return AudioScript_ScriptReadCompressedU16(state);
 
         case 0xFE: // delay 1 frame
             return 1;
@@ -266,7 +266,7 @@ s32 AudioSeq_HandleScriptFlowControl(SequencePlayer* seqPlayer, SeqScriptState*
     return 0;
 }
 
-void AudioSeq_InitSequenceChannel(SequenceChannel* channel) {
+void AudioScript_InitSequenceChannel(SequenceChannel* channel) {
     s32 i;
 
     if (channel == &gAudioCtx.sequenceChannelNone) {
@@ -325,12 +325,12 @@ void AudioSeq_InitSequenceChannel(SequenceChannel* channel) {
     channel->sfxState = NULL;
 }
 
-s32 AudioSeq_SeqChannelSetLayer(SequenceChannel* channel, s32 layerIndex) {
+s32 AudioScript_SeqChannelSetLayer(SequenceChannel* channel, s32 layerIndex) {
     SequenceLayer* layer;
     s32 pad;
 
     if (channel->layers[layerIndex] == NULL) {
-        layer = AudioSeq_AudioListPopBack(&gAudioCtx.layerFreeList);
+        layer = AudioScript_AudioListPopBack(&gAudioCtx.layerFreeList);
         channel->layers[layerIndex] = layer;
         if (layer == NULL) {
             channel->layers[layerIndex] = NULL;
@@ -382,7 +382,7 @@ s32 AudioSeq_SeqChannelSetLayer(SequenceChannel* channel, s32 layerIndex) {
     return 0;
 }
 
-void AudioSeq_SeqLayerDisable(SequenceLayer* layer) {
+void AudioScript_SeqLayerDisable(SequenceLayer* layer) {
     if (layer != NULL) {
         if ((layer->channel != &gAudioCtx.sequenceChannelNone) && (layer->channel->seqPlayer->finished == true)) {
             AudioPlayback_SeqLayerNoteRelease(layer);
@@ -394,30 +394,30 @@ void AudioSeq_SeqLayerDisable(SequenceLayer* layer) {
     }
 }
 
-void AudioSeq_SeqLayerFree(SequenceChannel* channel, s32 layerIndex) {
+void AudioScript_SeqLayerFree(SequenceChannel* channel, s32 layerIndex) {
     SequenceLayer* layer = channel->layers[layerIndex];
 
     if (layer != NULL) {
-        AudioSeq_AudioListPushBack(&gAudioCtx.layerFreeList, &layer->listItem);
-        AudioSeq_SeqLayerDisable(layer);
+        AudioScript_AudioListPushBack(&gAudioCtx.layerFreeList, &layer->listItem);
+        AudioScript_SeqLayerDisable(layer);
         channel->layers[layerIndex] = NULL;
     }
 }
 
-void AudioSeq_SequenceChannelDisable(SequenceChannel* channel) {
+void AudioScript_SequenceChannelDisable(SequenceChannel* channel) {
     s32 i;
 
     channel->finished = true;
 
     for (i = 0; i < 4; i++) {
-        AudioSeq_SeqLayerFree(channel, i);
+        AudioScript_SeqLayerFree(channel, i);
     }
 
     AudioPlayback_NotePoolClear(&channel->notePool);
     channel->enabled = false;
 }
 
-void AudioSeq_SequencePlayerSetupChannels(SequencePlayer* seqPlayer, u16 channelBits) {
+void AudioScript_SequencePlayerSetupChannels(SequencePlayer* seqPlayer, u16 channelBits) {
     SequenceChannel* channel;
     s32 i;
 
@@ -432,19 +432,19 @@ void AudioSeq_SequencePlayerSetupChannels(SequencePlayer* seqPlayer, u16 channel
     }
 }
 
-void AudioSeq_SequencePlayerDisableChannels(SequencePlayer* seqPlayer, u16 channelBitsUnused) {
+void AudioScript_SequencePlayerDisableChannels(SequencePlayer* seqPlayer, u16 channelBitsUnused) {
     SequenceChannel* channel;
     s32 i;
 
     for (i = 0; i < SEQ_NUM_CHANNELS; i++) {
         channel = seqPlayer->channels[i];
         if (IS_SEQUENCE_CHANNEL_VALID(channel) == 1) {
-            AudioSeq_SequenceChannelDisable(channel);
+            AudioScript_SequenceChannelDisable(channel);
         }
     }
 }
 
-void AudioSeq_SequenceChannelEnable(SequencePlayer* seqPlayer, u8 channelIndex, void* script) {
+void AudioScript_SequenceChannelEnable(SequencePlayer* seqPlayer, u8 channelIndex, void* script) {
     SequenceChannel* channel = seqPlayer->channels[channelIndex];
     s32 i;
 
@@ -456,18 +456,18 @@ void AudioSeq_SequenceChannelEnable(SequencePlayer* seqPlayer, u8 channelIndex,
 
     for (i = 0; i < ARRAY_COUNT(channel->layers); i++) {
         if (channel->layers[i] != NULL) {
-            AudioSeq_SeqLayerFree(channel, i);
+            AudioScript_SeqLayerFree(channel, i);
         }
     }
 }
 
-void AudioSeq_SequencePlayerDisableAsFinished(SequencePlayer* seqPlayer) {
+void AudioScript_SequencePlayerDisableAsFinished(SequencePlayer* seqPlayer) {
     seqPlayer->finished = true;
-    AudioSeq_SequencePlayerDisable(seqPlayer);
+    AudioScript_SequencePlayerDisable(seqPlayer);
 }
 
-void AudioSeq_SequencePlayerDisable(SequencePlayer* seqPlayer) {
-    AudioSeq_SequencePlayerDisableChannels(seqPlayer, 0xFFFF);
+void AudioScript_SequencePlayerDisable(SequencePlayer* seqPlayer) {
+    AudioScript_SequencePlayerDisableChannels(seqPlayer, 0xFFFF);
     AudioPlayback_NotePoolClear(&seqPlayer->notePool);
     if (!seqPlayer->enabled) {
         return;
@@ -491,7 +491,7 @@ void AudioSeq_SequencePlayerDisable(SequencePlayer* seqPlayer) {
     }
 }
 
-void AudioSeq_AudioListPushBack(AudioListItem* list, AudioListItem* item) {
+void AudioScript_AudioListPushBack(AudioListItem* list, AudioListItem* item) {
     if (item->prev == NULL) {
         list->prev->next = item;
         item->prev = list->prev;
@@ -502,7 +502,7 @@ void AudioSeq_AudioListPushBack(AudioListItem* list, AudioListItem* item) {
     }
 }
 
-void* AudioSeq_AudioListPopBack(AudioListItem* list) {
+void* AudioScript_AudioListPopBack(AudioListItem* list) {
     AudioListItem* item = list->prev;
 
     if (item == list) {
@@ -517,7 +517,7 @@ void* AudioSeq_AudioListPopBack(AudioListItem* list) {
     return item->u.value;
 }
 
-void AudioSeq_InitLayerFreelist(void) {
+void AudioScript_InitLayerFreelist(void) {
     s32 i;
 
     gAudioCtx.layerFreeList.prev = &gAudioCtx.layerFreeList;
@@ -528,22 +528,22 @@ void AudioSeq_InitLayerFreelist(void) {
     for (i = 0; i < ARRAY_COUNT(gAudioCtx.sequenceLayers); i++) {
         gAudioCtx.sequenceLayers[i].listItem.u.value = &gAudioCtx.sequenceLayers[i];
         gAudioCtx.sequenceLayers[i].listItem.prev = NULL;
-        AudioSeq_AudioListPushBack(&gAudioCtx.layerFreeList, &gAudioCtx.sequenceLayers[i].listItem);
+        AudioScript_AudioListPushBack(&gAudioCtx.layerFreeList, &gAudioCtx.sequenceLayers[i].listItem);
     }
 }
 
-u8 AudioSeq_ScriptReadU8(SeqScriptState* state) {
+u8 AudioScript_ScriptReadU8(SeqScriptState* state) {
     return *(state->pc++);
 }
 
-s16 AudioSeq_ScriptReadS16(SeqScriptState* state) {
+s16 AudioScript_ScriptReadS16(SeqScriptState* state) {
     s16 ret = *(state->pc++) << 8;
 
     ret = *(state->pc++) | ret;
     return ret;
 }
 
-u16 AudioSeq_ScriptReadCompressedU16(SeqScriptState* state) {
+u16 AudioScript_ScriptReadCompressedU16(SeqScriptState* state) {
     u16 ret = *(state->pc++);
 
     if (ret & 0x80) {
@@ -553,7 +553,7 @@ u16 AudioSeq_ScriptReadCompressedU16(SeqScriptState* state) {
     return ret;
 }
 
-void AudioSeq_SeqLayerProcessScript(SequenceLayer* layer) {
+void AudioScript_SeqLayerProcessScript(SequenceLayer* layer) {
     s32 cmd;
 
     if (!layer->enabled) {
@@ -569,25 +569,25 @@ void AudioSeq_SeqLayerProcessScript(SequenceLayer* layer) {
         return;
     }
 
-    AudioSeq_SeqLayerProcessScriptStep1(layer);
+    AudioScript_SeqLayerProcessScriptStep1(layer);
 
     do {
-        cmd = AudioSeq_SeqLayerProcessScriptStep2(layer);
+        cmd = AudioScript_SeqLayerProcessScriptStep2(layer);
         if (cmd == PROCESS_SCRIPT_END) {
             return;
         }
 
-        cmd = AudioSeq_SeqLayerProcessScriptStep3(layer, cmd);
+        cmd = AudioScript_SeqLayerProcessScriptStep3(layer, cmd);
 
     } while ((cmd == -1) && (layer->delay == 0));
 
     if (cmd != PROCESS_SCRIPT_END) {
         // returns `sameTunedSample` instead of a command
-        cmd = AudioSeq_SeqLayerProcessScriptStep4(layer, cmd);
+        cmd = AudioScript_SeqLayerProcessScriptStep4(layer, cmd);
     }
 
     if (cmd != PROCESS_SCRIPT_END) {
-        AudioSeq_SeqLayerProcessScriptStep5(layer, cmd);
+        AudioScript_SeqLayerProcessScriptStep5(layer, cmd);
     }
 
     if (layer->muted == true) {
@@ -597,7 +597,7 @@ void AudioSeq_SeqLayerProcessScript(SequenceLayer* layer) {
     }
 }
 
-void AudioSeq_SeqLayerProcessScriptStep1(SequenceLayer* layer) {
+void AudioScript_SeqLayerProcessScriptStep1(SequenceLayer* layer) {
     if (!layer->continuousNotes) {
         AudioPlayback_SeqLayerNoteDecay(layer);
     } else if ((layer->note != NULL) && (layer->note->playbackState.wantedParentLayer == layer)) {
@@ -611,7 +611,7 @@ void AudioSeq_SeqLayerProcessScriptStep1(SequenceLayer* layer) {
     layer->notePropertiesNeedInit = true;
 }
 
-s32 AudioSeq_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameTunedSample) {
+s32 AudioScript_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameTunedSample) {
     Note* note;
 
     if ((layer->continuousNotes == true) && (layer->bit1 == true)) {
@@ -648,7 +648,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameTunedSampl
     return 0;
 }
 
-s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
+s32 AudioScript_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
     SequenceChannel* channel = layer->channel;
     SeqScriptState* state = &layer->scriptState;
     SequencePlayer* seqPlayer = channel->seqPlayer;
@@ -658,22 +658,22 @@ s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
     u16 velocity;
 
     while (true) {
-        cmd = AudioSeq_ScriptReadU8(state);
+        cmd = AudioScript_ScriptReadU8(state);
 
         // Note Commands
-        // To be processed in AudioSeq_SeqLayerProcessScriptStep3
+        // To be processed in AudioScript_SeqLayerProcessScriptStep3
         if (cmd <= 0xC0) {
             return cmd;
         }
 
         // Control Flow Commands
         if (cmd >= 0xF2) {
-            cmdArg16 = AudioSeq_GetScriptControlFlowArgument(state, cmd);
+            cmdArg16 = AudioScript_GetScriptControlFlowArgument(state, cmd);
 
-            if (AudioSeq_HandleScriptFlowControl(seqPlayer, state, cmd, cmdArg16) == 0) {
+            if (AudioScript_HandleScriptFlowControl(seqPlayer, state, cmd, cmdArg16) == 0) {
                 continue;
             }
-            AudioSeq_SeqLayerDisable(layer);
+            AudioScript_SeqLayerDisable(layer);
             return PROCESS_SCRIPT_END;
         }
 
@@ -710,12 +710,12 @@ s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
                 break;
 
             case 0xC3: // layer: set short note default delay
-                cmdArg16 = AudioSeq_ScriptReadCompressedU16(state);
+                cmdArg16 = AudioScript_ScriptReadCompressedU16(state);
                 layer->shortNoteDefaultDelay = cmdArg16;
                 break;
 
             case 0xC6: // layer: set instrument
-                cmd = AudioSeq_ScriptReadU8(state);
+                cmd = AudioScript_ScriptReadU8(state);
                 if (cmd >= 0x7E) {
                     if (cmd == 0x7E) {
                         // Sfxs
@@ -734,17 +734,17 @@ s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
                     }
                 } else {
                     // Instrument
-                    if ((layer->instOrWave = AudioSeq_GetInstrument(channel, cmd, &layer->instrument, &layer->adsr)) ==
-                        0) {
+                    if ((layer->instOrWave =
+                             AudioScript_GetInstrument(channel, cmd, &layer->instrument, &layer->adsr)) == 0) {
                         layer->instOrWave = 0xFF;
                     }
                 }
                 break;
 
             case 0xC7: // layer: enable portamento
-                layer->portamento.mode = AudioSeq_ScriptReadU8(state);
+                layer->portamento.mode = AudioScript_ScriptReadU8(state);
 
-                cmd = AudioSeq_ScriptReadU8(state);
+                cmd = AudioScript_ScriptReadU8(state);
                 cmd += channel->transposition;
                 cmd += layer->transposition;
                 cmd += seqPlayer->transposition;
@@ -761,7 +761,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
                     break;
                 }
 
-                cmdArg16 = AudioSeq_ScriptReadCompressedU16(state);
+                cmdArg16 = AudioScript_ScriptReadCompressedU16(state);
                 layer->portamentoTime = cmdArg16;
                 break;
 
@@ -770,11 +770,11 @@ s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
                 break;
 
             case 0xCB: // layer: set envelope and decay index
-                cmdArg16 = AudioSeq_ScriptReadS16(state);
+                cmdArg16 = AudioScript_ScriptReadS16(state);
                 layer->adsr.envelope = (EnvelopePoint*)(seqPlayer->seqData + cmdArg16);
                 // fallthrough
             case 0xCF: // layer: set decay index
-                layer->adsr.decayIndex = AudioSeq_ScriptReadU8(state);
+                layer->adsr.decayIndex = AudioScript_ScriptReadU8(state);
                 break;
 
             case 0xCC: // layer: ignore drum pan
@@ -782,21 +782,21 @@ s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
                 break;
 
             case 0xCD: // layer: stereo effects
-                layer->stereoData.asByte = AudioSeq_ScriptReadU8(state);
+                layer->stereoData.asByte = AudioScript_ScriptReadU8(state);
                 break;
 
             case 0xCE: // layer: bend pitch
-                cmdArg8 = AudioSeq_ScriptReadU8(state);
+                cmdArg8 = AudioScript_ScriptReadU8(state);
                 layer->bend = gBendPitchTwoSemitonesFrequencies[(u8)(cmdArg8 + 0x80)];
                 break;
 
             case 0xF0: // layer:
-                cmdArg16 = AudioSeq_ScriptReadS16(state);
+                cmdArg16 = AudioScript_ScriptReadS16(state);
                 layer->unk_0A.asByte &= (cmdArg16 ^ 0xFFFF);
                 break;
 
             case 0xF1: // layer:
-                layer->surroundEffectIndex = AudioSeq_ScriptReadU8(state);
+                layer->surroundEffectIndex = AudioScript_ScriptReadU8(state);
                 break;
 
             default:
@@ -814,7 +814,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
     }
 }
 
-s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) {
+s32 AudioScript_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) {
     s32 sameTunedSample = true;
     s32 instOrWave;
     s32 speed;
@@ -1025,7 +1025,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) {
     return sameTunedSample;
 }
 
-s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) {
+s32 AudioScript_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) {
     SeqScriptState* state = &layer->scriptState;
     u16 delay;
     s32 velocity;
@@ -1035,7 +1035,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) {
     f32 floatDelta;
 
     if (cmd == 0xC0) { // layer: delay
-        layer->delay = AudioSeq_ScriptReadCompressedU16(state);
+        layer->delay = AudioScript_ScriptReadCompressedU16(state);
         layer->muted = true;
         layer->bit1 = false;
         return PROCESS_SCRIPT_END;
@@ -1046,14 +1046,14 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) {
     if (channel->largeNotes == true) {
         switch (cmd & 0xC0) {
             case 0x00: // layer: large note 0
-                delay = AudioSeq_ScriptReadCompressedU16(state);
+                delay = AudioScript_ScriptReadCompressedU16(state);
                 velocity = *(state->pc++);
                 layer->gateTime = *(state->pc++);
                 layer->lastDelay = delay;
                 break;
 
             case 0x40: // layer: large note 1
-                delay = AudioSeq_ScriptReadCompressedU16(state);
+                delay = AudioScript_ScriptReadCompressedU16(state);
                 velocity = *(state->pc++);
                 layer->gateTime = 0;
                 layer->lastDelay = delay;
@@ -1074,7 +1074,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) {
     } else {
         switch (cmd & 0xC0) {
             case 0x00: // layer: small note 0
-                delay = AudioSeq_ScriptReadCompressedU16(state);
+                delay = AudioScript_ScriptReadCompressedU16(state);
                 layer->lastDelay = delay;
                 break;
 
@@ -1138,7 +1138,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) {
     return cmd;
 }
 
-void AudioSeq_SetChannelPriorities(SequenceChannel* channel, u8 priority) {
+void AudioScript_SetChannelPriorities(SequenceChannel* channel, u8 priority) {
     if ((priority & 0xF) != 0) {
         channel->notePriority = priority & 0xF;
     }
@@ -1149,7 +1149,7 @@ void AudioSeq_SetChannelPriorities(SequenceChannel* channel, u8 priority) {
     }
 }
 
-u8 AudioSeq_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** instOut, AdsrSettings* adsr) {
+u8 AudioScript_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** instOut, AdsrSettings* adsr) {
     Instrument* inst = AudioPlayback_GetInstrumentInner(channel->fontId, instId);
 
     if (inst == NULL) {
@@ -1169,7 +1169,7 @@ u8 AudioSeq_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** inst
     return instId;
 }
 
-void AudioSeq_SetInstrument(SequenceChannel* channel, u8 instId) {
+void AudioScript_SetInstrument(SequenceChannel* channel, u8 instId) {
     if (instId >= 0x80) {
         // Synthetic Waves
         channel->instOrWave = instId;
@@ -1184,7 +1184,7 @@ void AudioSeq_SetInstrument(SequenceChannel* channel, u8 instId) {
         channel->instrument = (Instrument*)2; // invalid pointer, never dereferenced
     } else {
         // Instruments
-        if ((channel->instOrWave = AudioSeq_GetInstrument(channel, instId, &channel->instrument, &channel->adsr)) ==
+        if ((channel->instOrWave = AudioScript_GetInstrument(channel, instId, &channel->instrument, &channel->adsr)) ==
             0) {
             channel->hasInstrument = false;
             return;
@@ -1194,11 +1194,11 @@ void AudioSeq_SetInstrument(SequenceChannel* channel, u8 instId) {
     channel->hasInstrument = true;
 }
 
-void AudioSeq_SequenceChannelSetVolume(SequenceChannel* channel, u8 volume) {
+void AudioScript_SequenceChannelSetVolume(SequenceChannel* channel, u8 volume) {
     channel->volume = (s32)volume / 127.0f;
 }
 
-void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
+void AudioScript_SequenceChannelProcessScript(SequenceChannel* channel) {
     s32 i;
     u8* data;
     u32 rand;
@@ -1225,7 +1225,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
         u16 cmdArgU16;
         u32 cmdArgs[3];
         s8 cmdArgS8;
-        u8 cmd = AudioSeq_ScriptReadU8(scriptState);
+        u8 cmd = AudioScript_ScriptReadU8(scriptState);
         u8 lowBits;
         u8 highBits;
         s32 delay;
@@ -1244,19 +1244,19 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
             // read in arguments for the instruction
             for (i = 0; i < lowBits; i++, highBits <<= 1) {
                 if (!(highBits & 0x80)) {
-                    cmdArgs[i] = AudioSeq_ScriptReadU8(scriptState);
+                    cmdArgs[i] = AudioScript_ScriptReadU8(scriptState);
                 } else {
-                    cmdArgs[i] = AudioSeq_ScriptReadS16(scriptState);
+                    cmdArgs[i] = AudioScript_ScriptReadS16(scriptState);
                 }
             }
 
             // Control Flow Commands
             if (cmd >= 0xF2) {
-                delay = AudioSeq_HandleScriptFlowControl(seqPlayer, scriptState, cmd, cmdArgs[0]);
+                delay = AudioScript_HandleScriptFlowControl(seqPlayer, scriptState, cmd, cmdArgs[0]);
 
                 if (delay != 0) {
                     if (delay == PROCESS_SCRIPT_END) {
-                        AudioSeq_SequenceChannelDisable(channel);
+                        AudioScript_SequenceChannelDisable(channel);
                     } else {
                         channel->delay = delay;
                     }
@@ -1310,7 +1310,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
                     // fallthrough
                 case 0xC1: // channel: set instrument
                     cmd = (u8)cmdArgs[0];
-                    AudioSeq_SetInstrument(channel, cmd);
+                    AudioScript_SetInstrument(channel, cmd);
                     break;
 
                 case 0xC3: // channel: large notes off
@@ -1323,7 +1323,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
 
                 case 0xDF: // channel: set volume
                     cmd = (u8)cmdArgs[0];
-                    AudioSeq_SequenceChannelSetVolume(channel, cmd);
+                    AudioScript_SequenceChannelSetVolume(channel, cmd);
                     channel->changes.s.volume = true;
                     break;
 
@@ -1459,7 +1459,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
 
                 case 0xCD: // channel: disable channel
                     cmd = (u8)cmdArgs[0];
-                    AudioSeq_SequenceChannelDisable(seqPlayer->channels[cmd]);
+                    AudioScript_SequenceChannelDisable(seqPlayer->channels[cmd]);
                     break;
 
                 case 0xCA: // channel: set mute behavior
@@ -1533,7 +1533,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
                     channel->muteFlags = data[0];
                     data += 3;
                     channel->noteAllocPolicy = data[-2];
-                    AudioSeq_SetChannelPriorities(channel, data[-1]);
+                    AudioScript_SetChannelPriorities(channel, data[-1]);
                     channel->transposition = (s8)data[0];
                     data += 4;
                     channel->newPan = data[-3];
@@ -1548,12 +1548,12 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
                     channel->muteFlags = cmdArgs[0];
                     channel->noteAllocPolicy = cmdArgs[1];
                     cmd = (u8)cmdArgs[2];
-                    AudioSeq_SetChannelPriorities(channel, cmd);
-                    channel->transposition = (s8)AudioSeq_ScriptReadU8(scriptState);
-                    channel->newPan = AudioSeq_ScriptReadU8(scriptState);
-                    channel->panChannelWeight = AudioSeq_ScriptReadU8(scriptState);
-                    channel->targetReverbVol = AudioSeq_ScriptReadU8(scriptState);
-                    channel->reverbIndex = AudioSeq_ScriptReadU8(scriptState);
+                    AudioScript_SetChannelPriorities(channel, cmd);
+                    channel->transposition = (s8)AudioScript_ScriptReadU8(scriptState);
+                    channel->newPan = AudioScript_ScriptReadU8(scriptState);
+                    channel->panChannelWeight = AudioScript_ScriptReadU8(scriptState);
+                    channel->targetReverbVol = AudioScript_ScriptReadU8(scriptState);
+                    channel->reverbIndex = AudioScript_ScriptReadU8(scriptState);
                     //! @bug: Not marking reverb state as changed
                     channel->changes.s.pan = true;
                     break;
@@ -1579,7 +1579,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
                     break;
 
                 case 0xE9: // channel: set note priority
-                    AudioSeq_SetChannelPriorities(channel, (u8)cmdArgs[0]);
+                    AudioScript_SetChannelPriorities(channel, (u8)cmdArgs[0]);
                     break;
 
                 case 0xED: // channel: set hilo gain
@@ -1747,18 +1747,18 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
                     break;
 
                 case 0x88: // channel: set layer
-                    cmdArgU16 = AudioSeq_ScriptReadS16(scriptState);
-                    if (!AudioSeq_SeqChannelSetLayer(channel, lowBits)) {
+                    cmdArgU16 = AudioScript_ScriptReadS16(scriptState);
+                    if (!AudioScript_SeqChannelSetLayer(channel, lowBits)) {
                         channel->layers[lowBits]->scriptState.pc = &seqPlayer->seqData[cmdArgU16];
                     }
                     break;
 
                 case 0x90: // channel: free layer
-                    AudioSeq_SeqLayerFree(channel, lowBits);
+                    AudioScript_SeqLayerFree(channel, lowBits);
                     break;
 
                 case 0x98: // channel: dynset layer
-                    if ((scriptState->value != -1) && (AudioSeq_SeqChannelSetLayer(channel, lowBits) != -1)) {
+                    if ((scriptState->value != -1) && (AudioScript_SeqChannelSetLayer(channel, lowBits) != -1)) {
                         data = (*channel->dynTable)[scriptState->value];
                         cmdArgU16 = (data[0] << 8) + data[1];
                         channel->layers[lowBits]->scriptState.pc = &seqPlayer->seqData[cmdArgU16];
@@ -1770,8 +1770,8 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
                     break;
 
                 case 0x78: // channel: set layer relative
-                    temp1 = AudioSeq_ScriptReadS16(scriptState);
-                    if (!AudioSeq_SeqChannelSetLayer(channel, lowBits)) {
+                    temp1 = AudioScript_ScriptReadS16(scriptState);
+                    if (!AudioScript_SeqChannelSetLayer(channel, lowBits)) {
                         channel->layers[lowBits]->scriptState.pc = &scriptState->pc[temp1];
                     }
                     break;
@@ -1815,17 +1815,17 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
                 break;
 
             case 0x20: // channel: start channel
-                cmdArgU16 = AudioSeq_ScriptReadS16(scriptState);
-                AudioSeq_SequenceChannelEnable(seqPlayer, lowBits, &seqPlayer->seqData[cmdArgU16]);
+                cmdArgU16 = AudioScript_ScriptReadS16(scriptState);
+                AudioScript_SequenceChannelEnable(seqPlayer, lowBits, &seqPlayer->seqData[cmdArgU16]);
                 break;
 
             case 0x30: // channel: io write value 2
-                cmd = AudioSeq_ScriptReadU8(scriptState);
+                cmd = AudioScript_ScriptReadU8(scriptState);
                 seqPlayer->channels[lowBits]->seqScriptIO[cmd] = scriptState->value;
                 break;
 
             case 0x40: // channel: io read value 2
-                cmd = AudioSeq_ScriptReadU8(scriptState);
+                cmd = AudioScript_ScriptReadU8(scriptState);
                 scriptState->value = seqPlayer->channels[lowBits]->seqScriptIO[cmd];
                 break;
         }
@@ -1834,12 +1834,12 @@ exit_loop:
 
     for (i = 0; i < ARRAY_COUNT(channel->layers); i++) {
         if (channel->layers[i] != NULL) {
-            AudioSeq_SeqLayerProcessScript(channel->layers[i]);
+            AudioScript_SeqLayerProcessScript(channel->layers[i]);
         }
     }
 }
 
-void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
+void AudioScript_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
     u8 cmd;
     u8 cmdLowBits;
     SeqScriptState* seqScript = &seqPlayer->scriptState;
@@ -1866,7 +1866,7 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
         if (AudioLoad_IsSeqLoadComplete(seqPlayer->seqId)) {}
         if (AudioLoad_IsSeqLoadComplete(seqPlayer->defaultFont)) {}
 
-        AudioSeq_SequencePlayerDisable(seqPlayer);
+        AudioScript_SequencePlayerDisable(seqPlayer);
         return;
     }
 
@@ -1903,16 +1903,16 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
         seqPlayer->recalculateVolume = true;
 
         while (true) {
-            cmd = AudioSeq_ScriptReadU8(seqScript);
+            cmd = AudioScript_ScriptReadU8(seqScript);
 
             // 0xF2 and above are "flow control" commands, including termination.
             if (cmd >= 0xF2) {
-                delay = AudioSeq_HandleScriptFlowControl(
-                    seqPlayer, seqScript, cmd, AudioSeq_GetScriptControlFlowArgument(&seqPlayer->scriptState, cmd));
+                delay = AudioScript_HandleScriptFlowControl(
+                    seqPlayer, seqScript, cmd, AudioScript_GetScriptControlFlowArgument(&seqPlayer->scriptState, cmd));
 
                 if (delay != 0) {
                     if (delay == -1) {
-                        AudioSeq_SequencePlayerDisable(seqPlayer);
+                        AudioScript_SequencePlayerDisable(seqPlayer);
                     } else {
                         seqPlayer->delay = delay;
                     }
@@ -1926,7 +1926,7 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                 switch (cmd) {
                     case 0xF1: // seqPlayer: reserve notes
                         AudioPlayback_NotePoolClear(&seqPlayer->notePool);
-                        cmd = AudioSeq_ScriptReadU8(seqScript);
+                        cmd = AudioScript_ScriptReadU8(seqScript);
                         AudioPlayback_NotePoolFill(&seqPlayer->notePool, cmd);
                         break;
 
@@ -1938,11 +1938,11 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         seqPlayer->transposition = 0;
                         // fallthrough
                     case 0xDE: // seqPlayer: transpose relative
-                        seqPlayer->transposition += (s8)AudioSeq_ScriptReadU8(seqScript);
+                        seqPlayer->transposition += (s8)AudioScript_ScriptReadU8(seqScript);
                         break;
 
                     case 0xDD: // seqPlayer: set tempo
-                        seqPlayer->tempo = AudioSeq_ScriptReadU8(seqScript) * TATUMS_PER_BEAT;
+                        seqPlayer->tempo = AudioScript_ScriptReadU8(seqScript) * TATUMS_PER_BEAT;
                         if (seqPlayer->tempo > gAudioCtx.maxTempo) {
                             seqPlayer->tempo = gAudioCtx.maxTempo;
                         }
@@ -1953,12 +1953,12 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xDC: // seqPlayer: add tempo
-                        seqPlayer->tempoChange = (s8)AudioSeq_ScriptReadU8(seqScript) * TATUMS_PER_BEAT;
+                        seqPlayer->tempoChange = (s8)AudioScript_ScriptReadU8(seqScript) * TATUMS_PER_BEAT;
                         break;
 
                     case 0xDA: // seqPlayer: change volume
-                        cmd = AudioSeq_ScriptReadU8(seqScript);
-                        temp = AudioSeq_ScriptReadS16(seqScript);
+                        cmd = AudioScript_ScriptReadU8(seqScript);
+                        temp = AudioScript_ScriptReadS16(seqScript);
                         switch (cmd) {
                             case SEQPLAYER_STATE_0:
                             case SEQPLAYER_STATE_FADE_IN:
@@ -1977,7 +1977,7 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xDB: // seqPlayer: set volume
-                        value = AudioSeq_ScriptReadU8(seqScript);
+                        value = AudioScript_ScriptReadU8(seqScript);
                         switch (seqPlayer->state) {
                             case SEQPLAYER_STATE_FADE_IN:
                                 seqPlayer->state = SEQPLAYER_STATE_0;
@@ -1999,20 +1999,20 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xD9: // seqPlayer: set volume scale
-                        seqPlayer->fadeVolumeScale = (s8)AudioSeq_ScriptReadU8(seqScript) / 127.0f;
+                        seqPlayer->fadeVolumeScale = (s8)AudioScript_ScriptReadU8(seqScript) / 127.0f;
                         break;
 
                     case 0xD7: // seqPlayer: initialize channels
-                        temp = AudioSeq_ScriptReadS16(seqScript);
-                        AudioSeq_SequencePlayerSetupChannels(seqPlayer, temp);
+                        temp = AudioScript_ScriptReadS16(seqScript);
+                        AudioScript_SequencePlayerSetupChannels(seqPlayer, temp);
                         break;
 
                     case 0xD6: // seqPlayer: disable channels
-                        AudioSeq_ScriptReadS16(seqScript);
+                        AudioScript_ScriptReadS16(seqScript);
                         break;
 
                     case 0xD5: // seqPlayer: set mute scale
-                        seqPlayer->muteVolumeScale = (s8)AudioSeq_ScriptReadU8(seqScript) / 127.0f;
+                        seqPlayer->muteVolumeScale = (s8)AudioScript_ScriptReadU8(seqScript) / 127.0f;
                         break;
 
                     case 0xD4: // seqPlayer: mute
@@ -2020,12 +2020,12 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xD3: // seqPlayer: set mute behavior
-                        seqPlayer->muteFlags = AudioSeq_ScriptReadU8(seqScript);
+                        seqPlayer->muteFlags = AudioScript_ScriptReadU8(seqScript);
                         break;
 
                     case 0xD1: // seqPlayer: set short note gatetime table
                     case 0xD2: // seqPlayer: set short note velocity table
-                        temp = AudioSeq_ScriptReadS16(seqScript);
+                        temp = AudioScript_ScriptReadS16(seqScript);
                         data3 = &seqPlayer->seqData[temp];
                         if (cmd == 0xD2) {
                             seqPlayer->shortNoteVelocityTable = data3;
@@ -2035,11 +2035,11 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xD0: // seqPlayer: set note allocation policy
-                        seqPlayer->noteAllocPolicy = AudioSeq_ScriptReadU8(seqScript);
+                        seqPlayer->noteAllocPolicy = AudioScript_ScriptReadU8(seqScript);
                         break;
 
                     case 0xCE: // seqPlayer: random value
-                        cmd = AudioSeq_ScriptReadU8(seqScript);
+                        cmd = AudioScript_ScriptReadU8(seqScript);
                         if (cmd == 0) {
                             seqScript->value = (gAudioCtx.audioRandom >> 2) & 0xFF;
                         } else {
@@ -2048,7 +2048,7 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xCD: // seqPlayer: dyncall
-                        temp = AudioSeq_ScriptReadS16(seqScript);
+                        temp = AudioScript_ScriptReadS16(seqScript);
                         if ((seqScript->value != -1) && (seqScript->depth != 3)) {
                             data1 = seqPlayer->seqData + (u32)(temp + (seqScript->value << 1));
                             seqScript->stack[seqScript->depth] = seqScript->pc;
@@ -2059,26 +2059,26 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xCC: // seqPlayer: set value
-                        seqScript->value = AudioSeq_ScriptReadU8(seqScript);
+                        seqScript->value = AudioScript_ScriptReadU8(seqScript);
                         break;
 
                     case 0xC9: // seqPlayer: `bit and` -> set value
-                        seqScript->value &= AudioSeq_ScriptReadU8(seqScript);
+                        seqScript->value &= AudioScript_ScriptReadU8(seqScript);
                         break;
 
                     case 0xC8: // seqPlayer: subtract -> set value
-                        seqScript->value -= AudioSeq_ScriptReadU8(seqScript);
+                        seqScript->value -= AudioScript_ScriptReadU8(seqScript);
                         break;
 
                     case 0xC7: // seqPlayer: write into sequence script
-                        cmd = AudioSeq_ScriptReadU8(seqScript);
-                        temp = AudioSeq_ScriptReadS16(seqScript);
+                        cmd = AudioScript_ScriptReadU8(seqScript);
+                        temp = AudioScript_ScriptReadS16(seqScript);
                         data2 = &seqPlayer->seqData[temp];
                         *data2 = (u8)seqScript->value + cmd;
                         break;
 
                     case 0xC2: // seqPlayer:
-                        temp = AudioSeq_ScriptReadS16(seqScript);
+                        temp = AudioScript_ScriptReadS16(seqScript);
                         if (seqScript->value != -1) {
                             data4 = seqPlayer->seqData + (u32)(temp + (seqScript->value << 1));
 
@@ -2092,16 +2092,16 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         return;
 
                     case 0xC5: // seqPlayer:
-                        seqPlayer->unk_16 = AudioSeq_ScriptReadS16(seqScript);
+                        seqPlayer->unk_16 = AudioScript_ScriptReadS16(seqScript);
                         break;
 
                     case 0xEF: // seqPlayer:
-                        AudioSeq_ScriptReadS16(seqScript);
-                        AudioSeq_ScriptReadU8(seqScript);
+                        AudioScript_ScriptReadS16(seqScript);
+                        AudioScript_ScriptReadU8(seqScript);
                         break;
 
                     case 0xC4: // seqPlayer: start sequence
-                        cmd = AudioSeq_ScriptReadU8(seqScript);
+                        cmd = AudioScript_ScriptReadU8(seqScript);
                         if (cmd == 0xFF) {
                             cmd = seqPlayer->playerIndex;
                             if (seqPlayer->state == SEQPLAYER_STATE_FADE_OUT) {
@@ -2109,7 +2109,7 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                             }
                         }
 
-                        cmdLowBits = AudioSeq_ScriptReadU8(seqScript);
+                        cmdLowBits = AudioScript_ScriptReadU8(seqScript);
                         AudioLoad_SyncInitSeqPlayer(cmd, cmdLowBits, 0);
                         if (cmd == (u8)seqPlayer->playerIndex) {
                             return;
@@ -2117,7 +2117,7 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                         break;
 
                     case 0xC3: // seqPlayer:
-                        temp = AudioSeq_ScriptReadS16(seqScript);
+                        temp = AudioScript_ScriptReadS16(seqScript);
                         if (seqScript->value != -1) {
                             new_var = (u16*)(seqPlayer->seqData + (u32)(temp + seqScript->value * 2));
                             temp = *new_var;
@@ -2156,30 +2156,30 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
                     break;
 
                 case 0x40: // seqPlayer: disable channel
-                    AudioSeq_SequenceChannelDisable(seqPlayer->channels[cmdLowBits]);
+                    AudioScript_SequenceChannelDisable(seqPlayer->channels[cmdLowBits]);
                     break;
 
                 case 0x90: // seqPlayer: start channel
-                    temp = AudioSeq_ScriptReadS16(seqScript);
-                    AudioSeq_SequenceChannelEnable(seqPlayer, cmdLowBits, (void*)&seqPlayer->seqData[temp]);
+                    temp = AudioScript_ScriptReadS16(seqScript);
+                    AudioScript_SequenceChannelEnable(seqPlayer, cmdLowBits, (void*)&seqPlayer->seqData[temp]);
                     break;
 
                 case 0xA0: // seqPlayer: start channel relative
-                    tempS = AudioSeq_ScriptReadS16(seqScript);
-                    AudioSeq_SequenceChannelEnable(seqPlayer, cmdLowBits, (void*)&seqScript->pc[tempS]);
+                    tempS = AudioScript_ScriptReadS16(seqScript);
+                    AudioScript_SequenceChannelEnable(seqPlayer, cmdLowBits, (void*)&seqScript->pc[tempS]);
                     break;
 
                 case 0xB0: // seqPlayer: load sequence
-                    cmd = AudioSeq_ScriptReadU8(seqScript);
-                    temp = AudioSeq_ScriptReadS16(seqScript);
+                    cmd = AudioScript_ScriptReadU8(seqScript);
+                    temp = AudioScript_ScriptReadS16(seqScript);
                     data2 = &seqPlayer->seqData[temp];
                     AudioLoad_SlowLoadSeq(cmd, data2, &seqPlayer->seqScriptIO[cmdLowBits]);
                     break;
 
                 case 0x60: // seqPlayer: async load
-                    cmd = AudioSeq_ScriptReadU8(seqScript);
+                    cmd = AudioScript_ScriptReadU8(seqScript);
                     value = cmd;
-                    temp = AudioSeq_ScriptReadU8(seqScript);
+                    temp = AudioScript_ScriptReadU8(seqScript);
                     AudioLoad_ScriptLoad(value, temp, &seqPlayer->seqScriptIO[cmdLowBits]);
                     break;
             }
@@ -2189,12 +2189,12 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
     for (j = 0; j < SEQ_NUM_CHANNELS; j++) {
         channel = seqPlayer->channels[j];
         if (channel->enabled) {
-            AudioSeq_SequenceChannelProcessScript(channel);
+            AudioScript_SequenceChannelProcessScript(channel);
         }
     }
 }
 
-void AudioSeq_ProcessSequences(s32 arg0) {
+void AudioScript_ProcessSequences(s32 arg0) {
     SequencePlayer* seqPlayer;
     u32 i;
 
@@ -2203,7 +2203,7 @@ void AudioSeq_ProcessSequences(s32 arg0) {
     for (i = 0; i < (u32)gAudioCtx.audioBufferParameters.numSequencePlayers; i++) {
         seqPlayer = &gAudioCtx.seqPlayers[i];
         if (seqPlayer->enabled == true) {
-            AudioSeq_SequencePlayerProcessSequence(seqPlayer);
+            AudioScript_SequencePlayerProcessSequence(seqPlayer);
             AudioEffects_SequencePlayerProcessSound(seqPlayer);
         }
     }
@@ -2211,18 +2211,18 @@ void AudioSeq_ProcessSequences(s32 arg0) {
     AudioPlayback_ProcessNotes();
 }
 
-void AudioSeq_SkipForwardSequence(SequencePlayer* seqPlayer) {
+void AudioScript_SkipForwardSequence(SequencePlayer* seqPlayer) {
     while (seqPlayer->skipTicks > 0) {
-        AudioSeq_SequencePlayerProcessSequence(seqPlayer);
+        AudioScript_SequencePlayerProcessSequence(seqPlayer);
         AudioEffects_SequencePlayerProcessSound(seqPlayer);
         seqPlayer->skipTicks--;
     }
 }
 
-void AudioSeq_ResetSequencePlayer(SequencePlayer* seqPlayer) {
+void AudioScript_ResetSequencePlayer(SequencePlayer* seqPlayer) {
     s32 channelIndex;
 
-    AudioSeq_SequencePlayerDisable(seqPlayer);
+    AudioScript_SequencePlayerDisable(seqPlayer);
     seqPlayer->stopScript = false;
     seqPlayer->delay = 0;
     seqPlayer->state = SEQPLAYER_STATE_FADE_IN;
@@ -2243,11 +2243,11 @@ void AudioSeq_ResetSequencePlayer(SequencePlayer* seqPlayer) {
     seqPlayer->muteVolumeScale = 0.5f;
 
     for (channelIndex = 0; channelIndex < SEQ_NUM_CHANNELS; channelIndex++) {
-        AudioSeq_InitSequenceChannel(seqPlayer->channels[channelIndex]);
+        AudioScript_InitSequenceChannel(seqPlayer->channels[channelIndex]);
     }
 }
 
-void AudioSeq_InitSequencePlayerChannels(s32 seqPlayerIndex) {
+void AudioScript_InitSequencePlayerChannels(s32 seqPlayerIndex) {
     SequenceChannel* channel;
     SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[seqPlayerIndex];
     s32 channelIndex;
@@ -2267,11 +2267,11 @@ void AudioSeq_InitSequencePlayerChannels(s32 seqPlayerIndex) {
             }
         }
 
-        AudioSeq_InitSequenceChannel(seqPlayer->channels[channelIndex]);
+        AudioScript_InitSequenceChannel(seqPlayer->channels[channelIndex]);
     }
 }
 
-void AudioSeq_InitSequencePlayer(SequencePlayer* seqPlayer) {
+void AudioScript_InitSequencePlayer(SequencePlayer* seqPlayer) {
     s32 i;
     s32 j;
 
@@ -2294,13 +2294,13 @@ void AudioSeq_InitSequencePlayer(SequencePlayer* seqPlayer) {
     seqPlayer->bend = 1.0f;
 
     AudioPlayback_InitNoteLists(&seqPlayer->notePool);
-    AudioSeq_ResetSequencePlayer(seqPlayer);
+    AudioScript_ResetSequencePlayer(seqPlayer);
 }
 
-void AudioSeq_InitSequencePlayers(void) {
+void AudioScript_InitSequencePlayers(void) {
     s32 i;
 
-    AudioSeq_InitLayerFreelist();
+    AudioScript_InitLayerFreelist();
 
     for (i = 0; i < ARRAY_COUNT(gAudioCtx.sequenceLayers); i++) {
         gAudioCtx.sequenceLayers[i].channel = NULL;
@@ -2308,6 +2308,6 @@ void AudioSeq_InitSequencePlayers(void) {
     }
 
     for (i = 0; i < ARRAY_COUNT(gAudioCtx.seqPlayers); i++) {
-        AudioSeq_InitSequencePlayer(&gAudioCtx.seqPlayers[i]);
+        AudioScript_InitSequencePlayer(&gAudioCtx.seqPlayers[i]);
     }
 }
diff --git a/src/audio/lib/synthesis.c b/src/audio/lib/synthesis.c
index 057668f373..71b6a2212b 100644
--- a/src/audio/lib/synthesis.c
+++ b/src/audio/lib/synthesis.c
@@ -223,7 +223,7 @@ Acmd* AudioSynth_Update(Acmd* abiCmdStart, s32* numAbiCmds, s16* aiBufStart, s32
 
     for (reverseUpdateIndex = gAudioCtx.audioBufferParameters.updatesPerFrame; reverseUpdateIndex > 0;
          reverseUpdateIndex--) {
-        AudioSeq_ProcessSequences(reverseUpdateIndex - 1);
+        AudioScript_ProcessSequences(reverseUpdateIndex - 1);
         AudioSynth_SyncSampleStates(gAudioCtx.audioBufferParameters.updatesPerFrame - reverseUpdateIndex);
     }
 
diff --git a/src/audio/lib/thread.c b/src/audio/lib/thread.c
index 2b06281cce..082e77a67d 100644
--- a/src/audio/lib/thread.c
+++ b/src/audio/lib/thread.c
@@ -212,13 +212,13 @@ void AudioThread_ProcessGlobalCmd(AudioCmd* cmd) {
         case AUDIOCMD_OP_GLOBAL_INIT_SEQPLAYER_SKIP_TICKS:
             AudioLoad_SyncInitSeqPlayerSkipTicks(cmd->arg0, cmd->arg1, cmd->asInt);
             AudioThread_SetFadeInTimer(cmd->arg0, 500);
-            AudioSeq_SkipForwardSequence(&gAudioCtx.seqPlayers[cmd->arg0]);
+            AudioScript_SkipForwardSequence(&gAudioCtx.seqPlayers[cmd->arg0]);
             break;
 
         case AUDIOCMD_OP_GLOBAL_DISABLE_SEQPLAYER:
             if (gAudioCtx.seqPlayers[cmd->arg0].enabled) {
                 if (cmd->asInt == 0) {
-                    AudioSeq_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[cmd->arg0]);
+                    AudioScript_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[cmd->arg0]);
                 } else {
                     AudioThread_SetFadeOutTimer(cmd->arg0, cmd->asInt);
                 }
@@ -322,7 +322,7 @@ void AudioThread_ProcessGlobalCmd(AudioCmd* cmd) {
             if (flags == AUDIO_NOTE_RELEASE) {
                 for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) {
                     if (gAudioCtx.seqPlayers[i].enabled) {
-                        AudioSeq_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[i]);
+                        AudioScript_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[i]);
                     }
                 }
             }
diff --git a/tools/disasm/functions.txt b/tools/disasm/functions.txt
index a7a1347df6..4aca60126a 100644
--- a/tools/disasm/functions.txt
+++ b/tools/disasm/functions.txt
@@ -3767,42 +3767,42 @@
     0x80197138:("AudioEffects_NotePortamentoInit",),
     0x80197164:("AudioEffects_AdsrInit",),
     0x80197188:("AudioEffects_AdsrUpdate",),
-    0x801974D0:("AudioSeq_GetScriptControlFlowArgument",),
-    0x80197538:("AudioSeq_HandleScriptFlowControl",),
-    0x80197714:("AudioSeq_InitSequenceChannel",),
-    0x80197880:("AudioSeq_SeqChannelSetLayer",),
-    0x801979D8:("AudioSeq_SeqLayerDisable",),
-    0x80197A54:("AudioSeq_SeqLayerFree",),
-    0x80197AA4:("AudioSeq_SequenceChannelDisable",),
-    0x80197B14:("AudioSeq_SequencePlayerSetupChannels",),
-    0x80197C0C:("AudioSeq_SequencePlayerDisableChannels",),
-    0x80197C8C:("AudioSeq_SequenceChannelEnable",),
-    0x80197D24:("AudioSeq_SequencePlayerDisableAsFinished",),
-    0x80197D4C:("AudioSeq_SequencePlayerDisable",),
-    0x80197E08:("AudioSeq_AudioListPushBack",),
-    0x80197E48:("AudioSeq_AudioListPopBack",),
-    0x80197E88:("AudioSeq_InitLayerFreelist",),
-    0x80197F28:("AudioSeq_ScriptReadU8",),
-    0x80197F3C:("AudioSeq_ScriptReadS16",),
-    0x80197F74:("AudioSeq_ScriptReadCompressedU16",),
-    0x80197FB4:("AudioSeq_SeqLayerProcessScript",),
-    0x801980D0:("AudioSeq_SeqLayerProcessScriptStep1",),
-    0x8019815C:("AudioSeq_SeqLayerProcessScriptStep5",),
-    0x8019825C:("AudioSeq_SeqLayerProcessScriptStep2",),
-    0x80198640:("AudioSeq_SeqLayerProcessScriptStep4",),
-    0x80198CE0:("AudioSeq_SeqLayerProcessScriptStep3",),
-    0x801990F4:("AudioSeq_SetChannelPriorities",),
-    0x80199124:("AudioSeq_GetInstrument",),
-    0x80199198:("AudioSeq_SetInstrument",),
-    0x80199244:("AudioSeq_SequenceChannelSetVolume",),
-    0x80199268:("AudioSeq_SequenceChannelProcessScript",),
-    0x8019A0BC:("AudioSeq_SequencePlayerProcessSequence",),
-    0x8019AA3C:("AudioSeq_ProcessSequences",),
-    0x8019AAF0:("AudioSeq_SkipForwardSequence",),
-    0x8019AB40:("AudioSeq_ResetSequencePlayer",),
-    0x8019AC10:("AudioSeq_InitSequencePlayerChannels",),
-    0x8019ACEC:("AudioSeq_InitSequencePlayer",),
-    0x8019ADBC:("AudioSeq_InitSequencePlayers",),
+    0x801974D0:("AudioScript_GetScriptControlFlowArgument",),
+    0x80197538:("AudioScript_HandleScriptFlowControl",),
+    0x80197714:("AudioScript_InitSequenceChannel",),
+    0x80197880:("AudioScript_SeqChannelSetLayer",),
+    0x801979D8:("AudioScript_SeqLayerDisable",),
+    0x80197A54:("AudioScript_SeqLayerFree",),
+    0x80197AA4:("AudioScript_SequenceChannelDisable",),
+    0x80197B14:("AudioScript_SequencePlayerSetupChannels",),
+    0x80197C0C:("AudioScript_SequencePlayerDisableChannels",),
+    0x80197C8C:("AudioScript_SequenceChannelEnable",),
+    0x80197D24:("AudioScript_SequencePlayerDisableAsFinished",),
+    0x80197D4C:("AudioScript_SequencePlayerDisable",),
+    0x80197E08:("AudioScript_AudioListPushBack",),
+    0x80197E48:("AudioScript_AudioListPopBack",),
+    0x80197E88:("AudioScript_InitLayerFreelist",),
+    0x80197F28:("AudioScript_ScriptReadU8",),
+    0x80197F3C:("AudioScript_ScriptReadS16",),
+    0x80197F74:("AudioScript_ScriptReadCompressedU16",),
+    0x80197FB4:("AudioScript_SeqLayerProcessScript",),
+    0x801980D0:("AudioScript_SeqLayerProcessScriptStep1",),
+    0x8019815C:("AudioScript_SeqLayerProcessScriptStep5",),
+    0x8019825C:("AudioScript_SeqLayerProcessScriptStep2",),
+    0x80198640:("AudioScript_SeqLayerProcessScriptStep4",),
+    0x80198CE0:("AudioScript_SeqLayerProcessScriptStep3",),
+    0x801990F4:("AudioScript_SetChannelPriorities",),
+    0x80199124:("AudioScript_GetInstrument",),
+    0x80199198:("AudioScript_SetInstrument",),
+    0x80199244:("AudioScript_SequenceChannelSetVolume",),
+    0x80199268:("AudioScript_SequenceChannelProcessScript",),
+    0x8019A0BC:("AudioScript_SequencePlayerProcessSequence",),
+    0x8019AA3C:("AudioScript_ProcessSequences",),
+    0x8019AAF0:("AudioScript_SkipForwardSequence",),
+    0x8019AB40:("AudioScript_ResetSequencePlayer",),
+    0x8019AC10:("AudioScript_InitSequencePlayerChannels",),
+    0x8019ACEC:("AudioScript_InitSequencePlayer",),
+    0x8019ADBC:("AudioScript_InitSequencePlayers",),
     0x8019AE40:("func_8019AE40",),
     0x8019AEC0:("func_8019AEC0",),
     0x8019AF00:("AudioOcarina_ReadControllerInput",),
diff --git a/tools/sizes/code_functions.csv b/tools/sizes/code_functions.csv
index e7e1737e3f..121ba52556 100644
--- a/tools/sizes/code_functions.csv
+++ b/tools/sizes/code_functions.csv
@@ -3283,42 +3283,42 @@ asm/non_matchings/code/audio_effects/AudioEffects_NoteVibratoInit.s,AudioEffects
 asm/non_matchings/code/audio_effects/AudioEffects_NotePortamentoInit.s,AudioEffects_NotePortamentoInit,0x80197138,0xB
 asm/non_matchings/code/audio_effects/AudioEffects_AdsrInit.s,AudioEffects_AdsrInit,0x80197164,0x9
 asm/non_matchings/code/audio_effects/AudioEffects_AdsrUpdate.s,AudioEffects_AdsrUpdate,0x80197188,0xD2
-asm/non_matchings/code/audio_seqplayer/AudioSeq_GetScriptControlFlowArgument.s,AudioSeq_GetScriptControlFlowArgument,0x801974D0,0x1A
-asm/non_matchings/code/audio_seqplayer/AudioSeq_HandleScriptFlowControl.s,AudioSeq_HandleScriptFlowControl,0x80197538,0x77
-asm/non_matchings/code/audio_seqplayer/AudioSeq_InitSequenceChannel.s,AudioSeq_InitSequenceChannel,0x80197714,0x5B
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqChannelSetLayer.s,AudioSeq_SeqChannelSetLayer,0x80197880,0x56
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerDisable.s,AudioSeq_SeqLayerDisable,0x801979D8,0x1F
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerFree.s,AudioSeq_SeqLayerFree,0x80197A54,0x14
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequenceChannelDisable.s,AudioSeq_SequenceChannelDisable,0x80197AA4,0x1C
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequencePlayerSetupChannels.s,AudioSeq_SequencePlayerSetupChannels,0x80197B14,0x3E
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequencePlayerDisableChannels.s,AudioSeq_SequencePlayerDisableChannels,0x80197C0C,0x20
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequenceChannelEnable.s,AudioSeq_SequenceChannelEnable,0x80197C8C,0x26
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequencePlayerDisableAsFinished.s,AudioSeq_SequencePlayerDisableAsFinished,0x80197D24,0xA
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequencePlayerDisable.s,AudioSeq_SequencePlayerDisable,0x80197D4C,0x2F
-asm/non_matchings/code/audio_seqplayer/AudioSeq_AudioListPushBack.s,AudioSeq_AudioListPushBack,0x80197E08,0x10
-asm/non_matchings/code/audio_seqplayer/AudioSeq_AudioListPopBack.s,AudioSeq_AudioListPopBack,0x80197E48,0x10
-asm/non_matchings/code/audio_seqplayer/AudioSeq_InitLayerFreelist.s,AudioSeq_InitLayerFreelist,0x80197E88,0x28
-asm/non_matchings/code/audio_seqplayer/AudioSeq_ScriptReadU8.s,AudioSeq_ScriptReadU8,0x80197F28,0x5
-asm/non_matchings/code/audio_seqplayer/AudioSeq_ScriptReadS16.s,AudioSeq_ScriptReadS16,0x80197F3C,0xE
-asm/non_matchings/code/audio_seqplayer/AudioSeq_ScriptReadCompressedU16.s,AudioSeq_ScriptReadCompressedU16,0x80197F74,0x10
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerProcessScript.s,AudioSeq_SeqLayerProcessScript,0x80197FB4,0x47
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerProcessScriptStep1.s,AudioSeq_SeqLayerProcessScriptStep1,0x801980D0,0x23
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerProcessScriptStep5.s,AudioSeq_SeqLayerProcessScriptStep5,0x8019815C,0x40
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerProcessScriptStep2.s,AudioSeq_SeqLayerProcessScriptStep2,0x8019825C,0xF9
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerProcessScriptStep4.s,AudioSeq_SeqLayerProcessScriptStep4,0x80198640,0x1A8
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SeqLayerProcessScriptStep3.s,AudioSeq_SeqLayerProcessScriptStep3,0x80198CE0,0x105
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SetChannelPriorities.s,AudioSeq_SetChannelPriorities,0x801990F4,0xC
-asm/non_matchings/code/audio_seqplayer/AudioSeq_GetInstrument.s,AudioSeq_GetInstrument,0x80199124,0x1D
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SetInstrument.s,AudioSeq_SetInstrument,0x80199198,0x2B
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequenceChannelSetVolume.s,AudioSeq_SequenceChannelSetVolume,0x80199244,0x9
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequenceChannelProcessScript.s,AudioSeq_SequenceChannelProcessScript,0x80199268,0x395
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SequencePlayerProcessSequence.s,AudioSeq_SequencePlayerProcessSequence,0x8019A0BC,0x260
-asm/non_matchings/code/audio_seqplayer/AudioSeq_ProcessSequences.s,AudioSeq_ProcessSequences,0x8019AA3C,0x2D
-asm/non_matchings/code/audio_seqplayer/AudioSeq_SkipForwardSequence.s,AudioSeq_SkipForwardSequence,0x8019AAF0,0x14
-asm/non_matchings/code/audio_seqplayer/AudioSeq_ResetSequencePlayer.s,AudioSeq_ResetSequencePlayer,0x8019AB40,0x34
-asm/non_matchings/code/audio_seqplayer/AudioSeq_InitSequencePlayerChannels.s,AudioSeq_InitSequencePlayerChannels,0x8019AC10,0x37
-asm/non_matchings/code/audio_seqplayer/AudioSeq_InitSequencePlayer.s,AudioSeq_InitSequencePlayer,0x8019ACEC,0x34
-asm/non_matchings/code/audio_seqplayer/AudioSeq_InitSequencePlayers.s,AudioSeq_InitSequencePlayers,0x8019ADBC,0x21
+asm/non_matchings/code/audio_seqplayer/AudioScript_GetScriptControlFlowArgument.s,AudioScript_GetScriptControlFlowArgument,0x801974D0,0x1A
+asm/non_matchings/code/audio_seqplayer/AudioScript_HandleScriptFlowControl.s,AudioScript_HandleScriptFlowControl,0x80197538,0x77
+asm/non_matchings/code/audio_seqplayer/AudioScript_InitSequenceChannel.s,AudioScript_InitSequenceChannel,0x80197714,0x5B
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqChannelSetLayer.s,AudioScript_SeqChannelSetLayer,0x80197880,0x56
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerDisable.s,AudioScript_SeqLayerDisable,0x801979D8,0x1F
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerFree.s,AudioScript_SeqLayerFree,0x80197A54,0x14
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequenceChannelDisable.s,AudioScript_SequenceChannelDisable,0x80197AA4,0x1C
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequencePlayerSetupChannels.s,AudioScript_SequencePlayerSetupChannels,0x80197B14,0x3E
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequencePlayerDisableChannels.s,AudioScript_SequencePlayerDisableChannels,0x80197C0C,0x20
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequenceChannelEnable.s,AudioScript_SequenceChannelEnable,0x80197C8C,0x26
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequencePlayerDisableAsFinished.s,AudioScript_SequencePlayerDisableAsFinished,0x80197D24,0xA
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequencePlayerDisable.s,AudioScript_SequencePlayerDisable,0x80197D4C,0x2F
+asm/non_matchings/code/audio_seqplayer/AudioScript_AudioListPushBack.s,AudioScript_AudioListPushBack,0x80197E08,0x10
+asm/non_matchings/code/audio_seqplayer/AudioScript_AudioListPopBack.s,AudioScript_AudioListPopBack,0x80197E48,0x10
+asm/non_matchings/code/audio_seqplayer/AudioScript_InitLayerFreelist.s,AudioScript_InitLayerFreelist,0x80197E88,0x28
+asm/non_matchings/code/audio_seqplayer/AudioScript_ScriptReadU8.s,AudioScript_ScriptReadU8,0x80197F28,0x5
+asm/non_matchings/code/audio_seqplayer/AudioScript_ScriptReadS16.s,AudioScript_ScriptReadS16,0x80197F3C,0xE
+asm/non_matchings/code/audio_seqplayer/AudioScript_ScriptReadCompressedU16.s,AudioScript_ScriptReadCompressedU16,0x80197F74,0x10
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerProcessScript.s,AudioScript_SeqLayerProcessScript,0x80197FB4,0x47
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerProcessScriptStep1.s,AudioScript_SeqLayerProcessScriptStep1,0x801980D0,0x23
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerProcessScriptStep5.s,AudioScript_SeqLayerProcessScriptStep5,0x8019815C,0x40
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerProcessScriptStep2.s,AudioScript_SeqLayerProcessScriptStep2,0x8019825C,0xF9
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerProcessScriptStep4.s,AudioScript_SeqLayerProcessScriptStep4,0x80198640,0x1A8
+asm/non_matchings/code/audio_seqplayer/AudioScript_SeqLayerProcessScriptStep3.s,AudioScript_SeqLayerProcessScriptStep3,0x80198CE0,0x105
+asm/non_matchings/code/audio_seqplayer/AudioScript_SetChannelPriorities.s,AudioScript_SetChannelPriorities,0x801990F4,0xC
+asm/non_matchings/code/audio_seqplayer/AudioScript_GetInstrument.s,AudioScript_GetInstrument,0x80199124,0x1D
+asm/non_matchings/code/audio_seqplayer/AudioScript_SetInstrument.s,AudioScript_SetInstrument,0x80199198,0x2B
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequenceChannelSetVolume.s,AudioScript_SequenceChannelSetVolume,0x80199244,0x9
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequenceChannelProcessScript.s,AudioScript_SequenceChannelProcessScript,0x80199268,0x395
+asm/non_matchings/code/audio_seqplayer/AudioScript_SequencePlayerProcessSequence.s,AudioScript_SequencePlayerProcessSequence,0x8019A0BC,0x260
+asm/non_matchings/code/audio_seqplayer/AudioScript_ProcessSequences.s,AudioScript_ProcessSequences,0x8019AA3C,0x2D
+asm/non_matchings/code/audio_seqplayer/AudioScript_SkipForwardSequence.s,AudioScript_SkipForwardSequence,0x8019AAF0,0x14
+asm/non_matchings/code/audio_seqplayer/AudioScript_ResetSequencePlayer.s,AudioScript_ResetSequencePlayer,0x8019AB40,0x34
+asm/non_matchings/code/audio_seqplayer/AudioScript_InitSequencePlayerChannels.s,AudioScript_InitSequencePlayerChannels,0x8019AC10,0x37
+asm/non_matchings/code/audio_seqplayer/AudioScript_InitSequencePlayer.s,AudioScript_InitSequencePlayer,0x8019ACEC,0x34
+asm/non_matchings/code/audio_seqplayer/AudioScript_InitSequencePlayers.s,AudioScript_InitSequencePlayers,0x8019ADBC,0x21
 asm/non_matchings/code/code_8019AE40/func_8019AE40.s,func_8019AE40,0x8019AE40,0x1C
 asm/non_matchings/code/code_8019AEC0/func_8019AEC0.s,func_8019AEC0,0x8019AEC0,0x10
 asm/non_matchings/code/code_8019AF00/AudioOcarina_ReadControllerInput.s,AudioOcarina_ReadControllerInput,0x8019AF00,0x16