Reformat to something more readable for me :3

2026-05-24 11:31:35 -05:00
parent 4328104536
commit da3d3b9727
141 changed files with 29855 additions and 20635 deletions
@@ -86,10 +86,10 @@ struct Instrument **instOut = _instOut;\
        _instId--; \
    } \
    inst = gCtlEntries[(*seqChannel).bankId].instruments[_instId]; \
-    if (inst == NULL) { \
+    if (inst == nullptr) { \
        while (_instId != 0xff) { \
            inst = gCtlEntries[(*seqChannel).bankId].instruments[_instId]; \
-            if (inst != NULL) { \
+            if (inst != nullptr) { \
                goto gi ## l; \
            } \
            _instId--; \
@@ -109,13 +109,14 @@ struct Instrument **instOut = _instOut;\
        goto ret ## l; \
    } \
    gAudioErrorFlags = _instId + 0x20000; \
-    *instOut = NULL; \
+    *instOut = nullptr; \
    ret ## l: ; \
 }
 #endif

-void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
-    struct SequencePlayer *seqPlayer;   // sp5C, t4
+void seq_channel_layer_process_script(struct SequenceChannelLayer *layer)
+{
+    struct SequencePlayer *seqPlayer; // sp5C, t4
    struct SequenceChannel *seqChannel; // sp58, t5
    struct M64ScriptState *state;
    struct Portamento *portamento;
@@ -124,51 +125,57 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
    struct Drum *drum;
    s32 temp_a0_5;
    u8 sameSound;
-    u8 cmd;                             // a0 sp3E, EU s2
-    u8 cmdSemitone;                     // sp3D, t0
-    u16 sp3A;                           // t2, a0, a1
-    f32 tuning;                         // f0
-    s32 vel;                            // sp30, t3
-    s32 usedSemitone;                   // a1
-    f32 freqScale;                      // sp28, f0
+    u8 cmd; // a0 sp3E, EU s2
+    u8 cmdSemitone; // sp3D, t0
+    u16 sp3A; // t2, a0, a1
+    f32 tuning; // f0
+    s32 vel; // sp30, t3
+    s32 usedSemitone; // a1
+    f32 freqScale; // sp28, f0
    f32 sp24;
    f32 temp_f12;
    f32 temp_f2;

-//! Copt: manually inline these functions in the scope of this routine
-#ifdef __sgi
-#pragma inline routine(m64_read_u8)
-#pragma inline routine(m64_read_compressed_u16)
-#pragma inline routine(m64_read_s16)
-#pragma inline routine(get_instrument)
-#endif
+    //! Copt: manually inline these functions in the scope of this routine
+    #ifdef __sgi
+    #pragma inline routine(m64_read_u8)
+    #pragma inline routine(m64_read_compressed_u16)
+    #pragma inline routine(m64_read_s16)
+    #pragma inline routine(get_instrument)
+    #endif

    sameSound = TRUE;
-    if ((*layer).enabled == FALSE) {
+    if ((*layer).enabled == FALSE)
+    {
        return;
    }

-    if ((*layer).delay > 1) {
+    if ((*layer).delay > 1)
+    {
        (*layer).delay--;
-        if (!layer->stopSomething && layer->delay <= layer->duration) {
+        if (!layer->stopSomething && layer->delay <= layer->duration)
+        {
            seq_channel_layer_note_decay(layer);
            layer->stopSomething = TRUE;
        }
        return;
    }

-    if (!layer->continuousNotes) {
+    if (!layer->continuousNotes)
+    {
        seq_channel_layer_note_decay(layer);
    }

    if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_1 ||
-        PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_2) {
+        PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_2)
+    {
        layer->portamento.mode = 0;
    }

    seqChannel = (*layer).seqChannel;
    seqPlayer = (*seqChannel).seqPlayer;
-    for (;;) {
+    for (;;)
+    {
        state = &layer->scriptState;
        //M64_READ_U8(state, cmd);
        {
@@ -177,13 +184,16 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
            cmd = *_ptr_pc;
        }

-        if (cmd <= 0xc0) {
+        if (cmd <= 0xc0)
+        {
            break;
        }

-        switch (cmd) {
+        switch (cmd)
+        {
            case 0xff: // layer_end; function return or end of script
-                if (state->depth == 0) {
+                if (state->depth == 0)
+                {
                    // N.B. this function call is *not* inlined even though it's
                    // within the same file, unlike in the rest of this function.
                    seq_channel_layer_disable(layer);
@@ -204,9 +214,12 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
                break;

            case 0xf7: // layer_loopend
-                if (--state->remLoopIters[state->depth - 1] != 0) {
+                if (--state->remLoopIters[state->depth - 1] != 0)
+                {
                    state->pc = state->stack[state->depth - 1];
-                } else {
+                }
+                else
+                {
                    state->depth--;
                }
                break;
@@ -219,19 +232,25 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
            case 0xc1: // layer_setshortnotevelocity
            case 0xca: // layer_setpan
                temp_a0_5 = *(state->pc++);
-                if (cmd == 0xc1) {
+                if (cmd == 0xc1)
+                {
                    layer->velocitySquare = (f32)(temp_a0_5 * temp_a0_5);
-                } else {
-                    layer->pan = (f32) temp_a0_5 / US_FLOAT(128.0);
+                }
+                else
+                {
+                    layer->pan = (f32)temp_a0_5 / US_FLOAT(128.0);
                }
                break;

            case 0xc2: // layer_transpose; set transposition in semitones
            case 0xc9: // layer_setshortnoteduration
                temp_a0_5 = *(state->pc++);
-                if (cmd == 0xc9) {
+                if (cmd == 0xc9)
+                {
                    layer->noteDuration = temp_a0_5;
-                } else {
+                }
+                else
+                {
                    layer->transposition = temp_a0_5;
                }
                break;
@@ -240,17 +259,20 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
            case 0xc5: // layer_somethingoff
                //! copt needs a ternary:
                //layer->continuousNotes = (cmd == 0xc4) ? TRUE : FALSE;
+            {
+                u8 setting;
+                if (cmd == 0xc4)
                {
-                    u8 setting;
-                    if (cmd == 0xc4) {
-                        setting = TRUE;
-                    } else {
-                        setting = FALSE;
-                    }
-                    layer->continuousNotes = setting;
-                    seq_channel_layer_note_decay(layer);
+                    setting = TRUE;
                }
-                break;
+                else
+                {
+                    setting = FALSE;
+                }
+                layer->continuousNotes = setting;
+                seq_channel_layer_note_decay(layer);
+            }
+            break;

            case 0xc3: // layer_setshortnotedefaultplaypercentage
                M64_READ_COMPRESSED_U16(state, sp3A);
@@ -260,7 +282,8 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
            case 0xc6: // layer_setinstr
                M64_READ_U8(state, cmdSemitone);

-                if (cmdSemitone < 127) {
+                if (cmdSemitone < 127)
+                {
                    GET_INSTRUMENT(seqChannel, cmdSemitone, &(*layer).instrument, &(*layer).adsr, cmdSemitone, 1);
                }
                break;
@@ -273,13 +296,15 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
                cmdSemitone += (*layer).transposition;
                cmdSemitone += (*seqPlayer).transposition;

-                if (cmdSemitone >= 0x80) {
+                if (cmdSemitone >= 0x80)
+                {
                    cmdSemitone = 0;
                }
                layer->portamentoTargetNote = cmdSemitone;

                // If special, the next param is u8 instead of var
-                if (PORTAMENTO_IS_SPECIAL((*layer).portamento)) {
+                if (PORTAMENTO_IS_SPECIAL((*layer).portamento))
+                {
                    layer->portamentoTime = *((state)->pc++);
                    break;
                }
@@ -293,7 +318,8 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
                break;

            default:
-                switch (cmd & 0xf0) {
+                switch (cmd & 0xf0)
+                {
                    case 0xd0: // layer_setshortnotevelocityfromtable
                        sp3A = seqPlayer->shortNoteVelocityTable[cmd & 0xf];
                        (*layer).velocitySquare = (f32)(sp3A * sp3A);
@@ -305,14 +331,19 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
        }
    }

-    if (cmd == 0xc0) { // layer_delay
+    if (cmd == 0xc0)
+    { // layer_delay
        M64_READ_COMPRESSED_U16(state, layer->delay);
        layer->stopSomething = TRUE;
-    } else {
+    }
+    else
+    {
        layer->stopSomething = FALSE;

-        if (seqChannel->largeNotes == TRUE) {
-            switch (cmd & 0xc0) {
+        if (seqChannel->largeNotes == TRUE)
+        {
+            switch (cmd & 0xc0)
+            {
                case 0x00: // layer_note0 (play percentage, velocity, duration)
                    M64_READ_COMPRESSED_U16(state, sp3A);
                    vel = *((*state).pc++);
@@ -333,11 +364,13 @@ void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
                    layer->noteDuration = *((*state).pc++);
                    goto l1090;
            }
-l1090:
-            cmdSemitone = cmd - (cmd & 0xc0);
+        l1090: cmdSemitone = cmd - (cmd & 0xc0);
            layer->velocitySquare = vel * vel;
-        } else {
-            switch (cmd & 0xc0) {
+        }
+        else
+        {
+            switch (cmd & 0xc0)
+            {
                case 0x00: // play note, type 0 (play percentage)
                    M64_READ_COMPRESSED_U16(state, sp3A);
                    layer->playPercentage = sp3A;
@@ -351,9 +384,7 @@ l1090:
                    sp3A = layer->playPercentage;
                    goto l1138;
            }
-l1138:
-
-            cmdSemitone = cmd - (cmd & 0xc0);
+        l1138: cmdSemitone = cmd - (cmd & 0xc0);
        }

        layer->delay = sp3A;
@@ -361,14 +392,20 @@ l1138:
        if ((seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_STOP_NOTES) != 0)
            || seqChannel->stopSomething2
            || !seqChannel->hasInstrument
-        ) {
+        )
+        {
            layer->stopSomething = TRUE;
-        } else {
-            if (seqChannel->instOrWave == 0) { // drum
+        }
+        else
+        {
+            if (seqChannel->instOrWave == 0)
+            { // drum
                cmdSemitone += (*seqChannel).transposition + (*layer).transposition;
-                if (cmdSemitone >= gCtlEntries[seqChannel->bankId].numDrums) {
+                if (cmdSemitone >= gCtlEntries[seqChannel->bankId].numDrums)
+                {
                    cmdSemitone = gCtlEntries[seqChannel->bankId].numDrums;
-                    if (cmdSemitone == 0) {
+                    if (cmdSemitone == 0)
+                    {
                        // this goto looks a bit like a function return...
                        layer->stopSomething = TRUE;
                        goto skip;
@@ -378,9 +415,12 @@ l1138:
                }

                drum = gCtlEntries[seqChannel->bankId].drums[cmdSemitone];
-                if (drum == NULL) {
+                if (drum == nullptr)
+                {
                    layer->stopSomething = TRUE;
-                } else {
+                }
+                else
+                {
                    layer->adsr.envelope = drum->envelope;
                    layer->adsr.releaseRate = drum->releaseRate;
                    layer->pan = FLOAT_CAST(drum->pan) / US_FLOAT(128.0);
@@ -389,35 +429,50 @@ l1138:
                }

            skip:;
-            } else { // instrument
+            }
+            else
+            { // instrument
                cmdSemitone += (*seqPlayer).transposition + (*seqChannel).transposition + (*layer).transposition;
-                if (cmdSemitone >= 0x80) {
+                if (cmdSemitone >= 0x80)
+                {
                    layer->stopSomething = TRUE;
-                } else {
+                }
+                else
+                {
                    instrument = layer->instrument;
-                    if (instrument == NULL) {
+                    if (instrument == nullptr)
+                    {
                        instrument = seqChannel->instrument;
                    }

-                    if (layer->portamento.mode != 0) {
+                    if (layer->portamento.mode != 0)
+                    {
                        //! copt needs a ternary:
                        //usedSemitone = (layer->portamentoTargetNote < cmdSemitone) ? cmdSemitone : layer->portamentoTargetNote;
-                        if (layer->portamentoTargetNote < cmdSemitone) {
+                        if (layer->portamentoTargetNote < cmdSemitone)
+                        {
                            usedSemitone = cmdSemitone;
-                        } else {
+                        }
+                        else
+                        {
                            usedSemitone = layer->portamentoTargetNote;
                        }

-                        if (instrument != NULL) {
-                            sound = (u8) usedSemitone < instrument->normalRangeLo ? &instrument->lowNotesSound
-                                  : (u8) usedSemitone <= instrument->normalRangeHi ?
-                                        &instrument->normalNotesSound : &instrument->highNotesSound;
+                        if (instrument != nullptr)
+                        {
+                            sound = (u8)usedSemitone < instrument->normalRangeLo
+                                        ? &instrument->lowNotesSound
+                                        : (u8)usedSemitone <= instrument->normalRangeHi
+                                              ? &instrument->normalNotesSound
+                                              : &instrument->highNotesSound;

                            sameSound = (sound == (*layer).sound);
                            layer->sound = sound;
                            tuning = (*sound).tuning;
-                        } else {
-                            layer->sound = NULL;
+                        }
+                        else
+                        {
+                            layer->sound = nullptr;
                            tuning = 1.0f;
                        }

@@ -425,7 +480,8 @@ l1138:
                        temp_f12 = gNoteFrequencies[layer->portamentoTargetNote] * tuning;

                        portamento = &layer->portamento;
-                        switch (PORTAMENTO_MODE(layer->portamento)) {
+                        switch (PORTAMENTO_MODE(layer->portamento))
+                        {
                            case PORTAMENTO_MODE_1:
                            case PORTAMENTO_MODE_3:
                            case PORTAMENTO_MODE_5:
@@ -439,30 +495,35 @@ l1138:
                                sp24 = temp_f12;
                                goto l13cc;
                        }
-l13cc:
-                        portamento->extent = sp24 / freqScale - US_FLOAT(1.0);
-                        if (PORTAMENTO_IS_SPECIAL((*layer).portamento)) {
+                    l13cc: portamento->extent = sp24 / freqScale - US_FLOAT(1.0);
+                        if (PORTAMENTO_IS_SPECIAL((*layer).portamento))
+                        {
                            portamento->speed = US_FLOAT(32512.0) * FLOAT_CAST((*seqPlayer).tempo)
-                                                / ((f32)(*layer).delay * (f32) gTempoInternalToExternal
+                                                / ((f32)(*layer).delay * (f32)gTempoInternalToExternal
                                                   * FLOAT_CAST((*layer).portamentoTime));
-                        } else {
+                        }
+                        else
+                        {
                            portamento->speed = US_FLOAT(127.0) / FLOAT_CAST((*layer).portamentoTime);
                        }
                        portamento->cur = 0.0f;
                        layer->freqScale = freqScale;
-                        if (PORTAMENTO_MODE((*layer).portamento) == PORTAMENTO_MODE_5) {
+                        if (PORTAMENTO_MODE((*layer).portamento) == PORTAMENTO_MODE_5)
+                        {
                            layer->portamentoTargetNote = cmdSemitone;
                        }
-                    } else if (instrument != NULL) {
-                        sound = cmdSemitone < instrument->normalRangeLo ?
-                                         &instrument->lowNotesSound : cmdSemitone <= instrument->normalRangeHi ?
-                                         &instrument->normalNotesSound : &instrument->highNotesSound;
+                    }
+                    else if (instrument != nullptr)
+                    {
+                        sound = cmdSemitone < instrument->normalRangeLo ? &instrument->lowNotesSound : cmdSemitone <= instrument->normalRangeHi ? &instrument->normalNotesSound : &instrument->highNotesSound;

                        sameSound = (sound == (*layer).sound);
                        layer->sound = sound;
                        layer->freqScale = gNoteFrequencies[cmdSemitone] * (*sound).tuning;
-                    } else {
-                        layer->sound = NULL;
+                    }
+                    else
+                    {
+                        layer->sound = nullptr;
                        layer->freqScale = gNoteFrequencies[cmdSemitone];
                    }
                }
@@ -471,30 +532,41 @@ l13cc:
        }
    }

-    if (layer->stopSomething == TRUE) {
-        if (layer->note != NULL || layer->continuousNotes) {
+    if (layer->stopSomething == TRUE)
+    {
+        if (layer->note != nullptr || layer->continuousNotes)
+        {
            seq_channel_layer_note_decay(layer);
        }
        return;
    }

    cmdSemitone = FALSE;
-    if (!layer->continuousNotes) {
+    if (!layer->continuousNotes)
+    {
        cmdSemitone = TRUE;
-    } else if (layer->note == NULL || layer->status == SOUND_LOAD_STATUS_NOT_LOADED) {
+    }
+    else if (layer->note == nullptr || layer->status == SOUND_LOAD_STATUS_NOT_LOADED)
+    {
        cmdSemitone = TRUE;
-    } else if (sameSound == FALSE) {
+    }
+    else if (sameSound == FALSE)
+    {
        seq_channel_layer_note_decay(layer);
        cmdSemitone = TRUE;
-    } else if (layer->sound == NULL) {
+    }
+    else if (layer->sound == nullptr)
+    {
        init_synthetic_wave(layer->note, layer);
    }

-    if (cmdSemitone != FALSE) {
+    if (cmdSemitone != FALSE)
+    {
        (*layer).note = alloc_note(layer);
    }

-    if (layer->note != NULL && layer->note->parentLayer == layer) {
+    if (layer->note != nullptr && layer->note->parentLayer == layer)
+    {
        note_vibrato_init(layer->note);
    }
 }
@@ -10,30 +10,46 @@ extern struct OSMesgQueue OSMesgQueue3;

 #ifdef VERSION_EU
 struct ReverbSettingsEU sReverbSettings[] = {
-    { 0x04, 0x0c, 0x2fff },
-    { 0x04, 0x0a, 0x47ff },
-    { 0x04, 0x10, 0x2fff },
-    { 0x04, 0x0e, 0x3fff },
-    { 0x04, 0x0c, 0x4fff },
-    { 0x04, 0x0a, 0x37ff }
+    {0x04, 0x0c, 0x2fff},
+    {0x04, 0x0a, 0x47ff},
+    {0x04, 0x10, 0x2fff},
+    {0x04, 0x0e, 0x3fff},
+    {0x04, 0x0c, 0x4fff},
+    {0x04, 0x0a, 0x37ff}
 };
 struct AudioSessionSettingsEU gAudioSessionPresets[] = {
-    { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[0], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
-      0x00004400, 0x00002a00 },
-    { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[1], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
-      0x00004400, 0x00002a00 },
-    { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[2], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
-      0x00004400, 0x00002a00 },
-    { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[3], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
-      0x00004400, 0x00002a00 },
-    { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[4], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
-      0x00004400, 0x00002a00 },
-    { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[0], 0x7fff, 0x0000, 0x00004000, 0x00006e00,
-      0x00003f00, 0x00002a00 },
-    { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[1], 0x7fff, 0x0000, 0x00004100, 0x00006e00,
-      0x00004400, 0x00002a80 },
-    { 0x00007d00, 0x01, 0x14, 0x01, 0x00, &sReverbSettings[5], 0x7fff, 0x0000, 0x00003500, 0x00006280,
-      0x00004000, 0x00001b00 }
+    {
+        0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[0], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
+        0x00004400, 0x00002a00
+    },
+    {
+        0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[1], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
+        0x00004400, 0x00002a00
+    },
+    {
+        0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[2], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
+        0x00004400, 0x00002a00
+    },
+    {
+        0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[3], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
+        0x00004400, 0x00002a00
+    },
+    {
+        0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[4], 0x7fff, 0x0000, 0x00003a40, 0x00006d00,
+        0x00004400, 0x00002a00
+    },
+    {
+        0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[0], 0x7fff, 0x0000, 0x00004000, 0x00006e00,
+        0x00003f00, 0x00002a00
+    },
+    {
+        0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[1], 0x7fff, 0x0000, 0x00004100, 0x00006e00,
+        0x00004400, 0x00002a80
+    },
+    {
+        0x00007d00, 0x01, 0x14, 0x01, 0x00, &sReverbSettings[5], 0x7fff, 0x0000, 0x00003500, 0x00006280,
+        0x00004000, 0x00001b00
+    }
 };
 #endif

@@ -51,7 +67,7 @@ struct AudioSessionSettingsEU gAudioSessionPresets[] = {
 #if defined(VERSION_JP) || defined(VERSION_US)
 struct AudioSessionSettings gAudioSessionPresets[18] = {
 #ifdef VERSION_JP
-    { 32000, 16, 1, 0x0800, 0x2FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 },
+{ 32000, 16, 1, 0x0800, 0x2FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 },
    { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 },
    { 32000, 16, 1, 0x1000, 0x2FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 },
    { 32000, 16, 1, 0x0E00, 0x3FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 },
@@ -60,7 +76,7 @@ struct AudioSessionSettings gAudioSessionPresets[18] = {
    { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x3F00, 0x6200, 0x4400, 0x2A80 },
    { 32000, 20, 1, 0x0800, 0x37FF, 0x7FFF, 0x3300, 0x5500, 0x4000, 0x1B00 },
 #else
-    { 32000, 16, 1, 0x0C00, 0x2FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 },
+{ 32000, 16, 1, 0x0C00, 0x2FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 },
    { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 },
    { 32000, 16, 1, 0x1000, 0x2FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 },
    { 32000, 16, 1, 0x0E00, 0x3FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 },
@@ -69,7 +85,7 @@ struct AudioSessionSettings gAudioSessionPresets[18] = {
    { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x4100, 0x6E00, 0x4400, 0x2A80 },
    { 32000, 20, 1, 0x0800, 0x37FF, 0x7FFF, 0x34C0, 0x6280, 0x4000, 0x1B00 },
 #endif
-    { 27000, 16, 1, 0x0800, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 },
+{ 27000, 16, 1, 0x0800, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 },
    { 27000, 16, 1, 0x0800, 0x3FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 },
    { 27000, 16, 1, 0x1000, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 },
    { 27000, 16, 1, 0x1000, 0x3FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 },
@@ -85,15 +101,15 @@ struct AudioSessionSettings gAudioSessionPresets[18] = {
 #if defined(VERSION_JP) || defined(VERSION_US)
 u16 gAudioCosineTable[128] = {
    0x7FFF, 32764, 32757, 32744, 32727, 32704, 32677, 32644, 32607, 32564, 32517, 32464, 32407,
-    32344,  32277, 32205, 32127, 32045, 31958, 31866, 31770, 31668, 31561, 31450, 31334, 31213,
-    31087,  30957, 30822, 30682, 30537, 30388, 30234, 30075, 29912, 29744, 29572, 29395, 29214,
-    29028,  28838, 28643, 28444, 28241, 28033, 27821, 27605, 27385, 27160, 26931, 26698, 26461,
-    26220,  25975, 25726, 25473, 25216, 24956, 24691, 24423, 24151, 23875, 23596, 23313, 23026,
-    22736,  22442, 22145, 21845, 21541, 21234, 20924, 20610, 20294, 19974, 19651, 19325, 18997,
-    18665,  18331, 17993, 17653, 17310, 16965, 16617, 16266, 15913, 15558, 15200, 14840, 14477,
-    14113,  13746, 13377, 13006, 12633, 12258, 11881, 11503, 11122, 10740, 10357, 9971,  9584,
-    9196,   8806,  8415,  8023,  7630,  7235,  6839,  6442,  6044,  5646,  5246,  4845,  4444,
-    4042,   3640,  3237,  2833,  2429,  2025,  1620,  1216,  810,   405,   0,
+    32344, 32277, 32205, 32127, 32045, 31958, 31866, 31770, 31668, 31561, 31450, 31334, 31213,
+    31087, 30957, 30822, 30682, 30537, 30388, 30234, 30075, 29912, 29744, 29572, 29395, 29214,
+    29028, 28838, 28643, 28444, 28241, 28033, 27821, 27605, 27385, 27160, 26931, 26698, 26461,
+    26220, 25975, 25726, 25473, 25216, 24956, 24691, 24423, 24151, 23875, 23596, 23313, 23026,
+    22736, 22442, 22145, 21845, 21541, 21234, 20924, 20610, 20294, 19974, 19651, 19325, 18997,
+    18665, 18331, 17993, 17653, 17310, 16965, 16617, 16266, 15913, 15558, 15200, 14840, 14477,
+    14113, 13746, 13377, 13006, 12633, 12258, 11881, 11503, 11122, 10740, 10357, 9971, 9584,
+    9196, 8806, 8415, 8023, 7630, 7235, 6839, 6442, 6044, 5646, 5246, 4845, 4444,
+    4042, 3640, 3237, 2833, 2429, 2025, 1620, 1216, 810, 405, 0,
 };
 #endif

@@ -106,8 +122,8 @@ f32 gPitchBendFrequencyScale[256] = {
    0.5f,
 #else
 f32 gPitchBendFrequencyScale[255] = {
-#endif
-    0.5f,      0.502736f, 0.505488f, 0.508254f, 0.511036f, 0.513833f, 0.516645f, 0.519472f, 0.522315f,
+    #endif
+    0.5f, 0.502736f, 0.505488f, 0.508254f, 0.511036f, 0.513833f, 0.516645f, 0.519472f, 0.522315f,
    0.525174f, 0.528048f, 0.530938f, 0.533843f, 0.536765f, 0.539702f, 0.542656f, 0.545626f, 0.548612f,
    0.551614f, 0.554633f, 0.557669f, 0.560721f, 0.563789f, 0.566875f, 0.569977f, 0.573097f, 0.576233f,
    0.579387f, 0.582558f, 0.585746f, 0.588951f, 0.592175f, 0.595415f, 0.598674f, 0.601950f, 0.605245f,
@@ -121,7 +137,7 @@ f32 gPitchBendFrequencyScale[255] = {
    0.858284f, 0.862982f, 0.867704f, 0.872453f, 0.877228f, 0.882029f, 0.886856f, 0.891709f, 0.896590f,
    0.901496f, 0.906430f, 0.911391f, 0.916379f, 0.921394f, 0.926436f, 0.931507f, 0.936604f, 0.941730f,
    0.946884f, 0.952066f, 0.957277f, 0.962516f, 0.967783f, 0.973080f, 0.978405f, 0.983760f, 0.989144f,
-    0.994557f, 1.0f,      1.005473f, 1.010975f, 1.016508f, 1.022071f, 1.027665f, 1.033289f, 1.038944f,
+    0.994557f, 1.0f, 1.005473f, 1.010975f, 1.016508f, 1.022071f, 1.027665f, 1.033289f, 1.038944f,
    1.044630f, 1.050347f, 1.056095f, 1.061875f, 1.067687f, 1.073530f, 1.079405f, 1.085312f, 1.091252f,
    1.097224f, 1.103229f, 1.109267f, 1.115337f, 1.121441f, 1.127579f, 1.133750f, 1.139955f, 1.146193f,
    1.152466f, 1.158773f, 1.165115f, 1.171491f, 1.177903f, 1.184349f, 1.190831f, 1.197348f, 1.203901f,
@@ -171,30 +187,30 @@ u8 gDefaultShortNoteDurationTable[16] = {

 #if defined(VERSION_JP) || defined(VERSION_US)
 // gVibratoCurve[k] = k*8
-s8 gVibratoCurve[16] = { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 };
+s8 gVibratoCurve[16] = {0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120};
 #endif

 struct AdsrEnvelope gDefaultEnvelope[] = {
-    { BSWAP16(4), BSWAP16(32000) },    // go from 0 to 32000 over the course of 16ms
-    { BSWAP16(1000), BSWAP16(32000) }, // stay there for 4.16 seconds
-    { BSWAP16(ADSR_HANG), 0 }          // then continue staying there
+    {BSWAP16(4), BSWAP16(32000)}, // go from 0 to 32000 over the course of 16ms
+    {BSWAP16(1000), BSWAP16(32000)}, // stay there for 4.16 seconds
+    {BSWAP16(ADSR_HANG), 0} // then continue staying there
 };
 #endif

 #ifdef VERSION_EU
-struct NoteSubEu gZeroNoteSub = { 0 };
-struct NoteSubEu gDefaultNoteSub = { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, { NULL } };
+struct NoteSubEu gZeroNoteSub = {0};
+struct NoteSubEu gDefaultNoteSub = {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {nullptr}};
 #endif

 #if defined(VERSION_EU) || defined(VERSION_SH)
 s16 sSawtoothWaves[256] = {
-    0,       1023,   2047,    3071,   4095,    5119,   6143,    7167,   8191,    9215,   10239,
-    11263,   0x2FFF, 13311,   0x37FF, 15359,   0x3FFF, 17407,   0x47FF, 19455,   0x4FFF, 21503,
-    22527,   23551,  24575,   25599,  26623,   27647,  28671,   29695,  30719,   31743,  -0x7FFF,
-    -31743,  -30719, -29695,  -28671, -27647,  -26623, -25599,  -24575, -23551,  -22527, -21503,
+    0, 1023, 2047, 3071, 4095, 5119, 6143, 7167, 8191, 9215, 10239,
+    11263, 0x2FFF, 13311, 0x37FF, 15359, 0x3FFF, 17407, 0x47FF, 19455, 0x4FFF, 21503,
+    22527, 23551, 24575, 25599, 26623, 27647, 28671, 29695, 30719, 31743, -0x7FFF,
+    -31743, -30719, -29695, -28671, -27647, -26623, -25599, -24575, -23551, -22527, -21503,
    -0x4FFF, -19455, -0x47FF, -17407, -0x3FFF, -15359, -0x37FF, -13311, -0x2FFF, -11263, -10239,
-    -9215,   -8191,  -7167,   -6143,  -5119,   -4095,  -3071,   -2047,  -1023,
-    0,      0x7FF,  0xFFF,  0x17FF, 0x1FFF, 0x27FF, 0x2FFF, 0x37FF, 0x3FFF, 0x47FF, 0x4FFF,
+    -9215, -8191, -7167, -6143, -5119, -4095, -3071, -2047, -1023,
+    0, 0x7FF, 0xFFF, 0x17FF, 0x1FFF, 0x27FF, 0x2FFF, 0x37FF, 0x3FFF, 0x47FF, 0x4FFF,
    0x57FF, 0x5FFF, 0x67FF, 0x6FFF, 0x77FF, 0x8001, 0x8801, 0x9001, 0x9801, 0xa001, 0xa801,
    0xb001, 0xb801, 0xc001, 0xc801, 0xd001, 0xd801, 0xe001, 0xe801, 0xf001, 0xf801, 0x0000,
    0x07ff, 0x0fff, 0x17ff, 0x1fff, 0x27ff, 0x2fff, 0x37ff, 0x3fff, 0x47ff, 0x4fff, 0x57ff,
@@ -337,52 +353,52 @@ s16 gEuUnknownWave7[256] = {
    0x0000, 0x8d2e, 0x4e20, 0xe14e, 0x0000, 0x1eb2, 0xb1e0, 0x72d2, 0x0000, 0x8d2e, 0x4e20, 0xe14e,
    0x0000, 0x1eb2, 0xb1e0, 0x72d2,
 };
-s16 *gWaveSamples[6] = { sSawtoothWaves, sTriangleWaves, sSineWaves, sSquareWaves, sEuUnknownWave6, gEuUnknownWave7 };
+s16 *gWaveSamples[6] = {sSawtoothWaves, sTriangleWaves, sSineWaves, sSquareWaves, sEuUnknownWave6, gEuUnknownWave7};

 #else
 // !VERSION_EU

 s16 sSineWave[0x40] = {
-    0,      3211,   6392,   9511,   12539,   15446,  18204,  20787,  23169,  25329,  27244,
-    28897,  30272,  31356,  32137,  32609,   0x7FFF, 32609,  32137,  31356,  30272,  28897,
-    27244,  25329,  23169,  20787,  18204,   15446,  12539,  9511,   6392,   3211,   0,
-    -3211,  -6392,  -9511,  -12539, -15446,  -18204, -20787, -23169, -25329, -27244, -28897,
+    0, 3211, 6392, 9511, 12539, 15446, 18204, 20787, 23169, 25329, 27244,
+    28897, 30272, 31356, 32137, 32609, 0x7FFF, 32609, 32137, 31356, 30272, 28897,
+    27244, 25329, 23169, 20787, 18204, 15446, 12539, 9511, 6392, 3211, 0,
+    -3211, -6392, -9511, -12539, -15446, -18204, -20787, -23169, -25329, -27244, -28897,
    -30272, -31356, -32137, -32609, -0x7FFF, -32609, -32137, -31356, -30272, -28897, -27244,
-    -25329, -23169, -20787, -18204, -15446,  -12539, -9511,  -6392,  -3211,
+    -25329, -23169, -20787, -18204, -15446, -12539, -9511, -6392, -3211,
 };

 s16 sSquareWave[0x40] = {
-    0,       0,       0,       0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,
-    0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0x7FFF,  0,
-    0,       0,       0,       0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
+    0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF,
    -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF,
 };
 s16 sTriangleWave[0x40] = {
-    0,       0x7FF,   0xFFF,   0x17FF,  0x1FFF,  0x27FF,  0x2FFF,  0x37FF,  0x3FFF,  0x47FF,  0x4FFF,
-    0x57FF,  0x5FFF,  0x67FF,  0x6FFF,  0x77FF,  0x7FFF,  0x77FF,  0x6FFF,  0x67FF,  0x5FFF,  0x57FF,
-    0x4FFF,  0x47FF,  0x3FFF,  0x37FF,  0x2FFF,  0x27FF,  0x1FFF,  0x17FF,  0xFFF,   0x7FF,   0,
-    -0x7FF,  -0xFFF,  -0x17FF, -0x1FFF, -10239,  -0x2FFF, -0x37FF, -0x3FFF, -0x47FF, -0x4FFF, -22527,
-    -24575,  -26623,  -28671,  -30719,  -0x7FFF, -30719,  -28671,  -26623,  -24575,  -22527,  -0x4FFF,
-    -0x47FF, -0x3FFF, -0x37FF, -0x2FFF, -0x27FF, -0x1FFF, -0x17FF, -0xFFF,  -0x7FF,
+    0, 0x7FF, 0xFFF, 0x17FF, 0x1FFF, 0x27FF, 0x2FFF, 0x37FF, 0x3FFF, 0x47FF, 0x4FFF,
+    0x57FF, 0x5FFF, 0x67FF, 0x6FFF, 0x77FF, 0x7FFF, 0x77FF, 0x6FFF, 0x67FF, 0x5FFF, 0x57FF,
+    0x4FFF, 0x47FF, 0x3FFF, 0x37FF, 0x2FFF, 0x27FF, 0x1FFF, 0x17FF, 0xFFF, 0x7FF, 0,
+    -0x7FF, -0xFFF, -0x17FF, -0x1FFF, -10239, -0x2FFF, -0x37FF, -0x3FFF, -0x47FF, -0x4FFF, -22527,
+    -24575, -26623, -28671, -30719, -0x7FFF, -30719, -28671, -26623, -24575, -22527, -0x4FFF,
+    -0x47FF, -0x3FFF, -0x37FF, -0x2FFF, -0x27FF, -0x1FFF, -0x17FF, -0xFFF, -0x7FF,
 };

 s16 sSawtoothWave[0x40] = {
-    0,       1023,   2047,    3071,   4095,    5119,   6143,    7167,   8191,    9215,   10239,
-    11263,   0x2FFF, 13311,   0x37FF, 15359,   0x3FFF, 17407,   0x47FF, 19455,   0x4FFF, 21503,
-    22527,   23551,  24575,   25599,  26623,   27647,  28671,   29695,  30719,   31743,  -0x7FFF,
-    -31743,  -30719, -29695,  -28671, -27647,  -26623, -25599,  -24575, -23551,  -22527, -21503,
+    0, 1023, 2047, 3071, 4095, 5119, 6143, 7167, 8191, 9215, 10239,
+    11263, 0x2FFF, 13311, 0x37FF, 15359, 0x3FFF, 17407, 0x47FF, 19455, 0x4FFF, 21503,
+    22527, 23551, 24575, 25599, 26623, 27647, 28671, 29695, 30719, 31743, -0x7FFF,
+    -31743, -30719, -29695, -28671, -27647, -26623, -25599, -24575, -23551, -22527, -21503,
    -0x4FFF, -19455, -0x47FF, -17407, -0x3FFF, -15359, -0x37FF, -13311, -0x2FFF, -11263, -10239,
-    -9215,   -8191,  -7167,   -6143,  -5119,   -4095,  -3071,   -2047,  -1023,
+    -9215, -8191, -7167, -6143, -5119, -4095, -3071, -2047, -1023,
 };
-s16 *gWaveSamples[4] = { sSawtoothWave, sTriangleWave, sSineWave, sSquareWave };
+s16 *gWaveSamples[4] = {sSawtoothWave, sTriangleWave, sSineWave, sSquareWave};
 #endif

 #ifdef VERSION_SH
 s32 unk_sh_data_0[2] = {0, 0};
 f32 gPitchBendFrequencyScale[256] = {
-    0.5f,      0.5f,      0.502736f, 0.505488f, 0.508254f, 0.511036f, 0.513833f, 0.516645f, 0.519472f,
+    0.5f, 0.5f, 0.502736f, 0.505488f, 0.508254f, 0.511036f, 0.513833f, 0.516645f, 0.519472f,
    0.522315f, 0.525174f, 0.528048f, 0.530938f, 0.533843f, 0.536765f, 0.539702f, 0.542656f, 0.545626f,
    0.548612f, 0.551614f, 0.554633f, 0.557669f, 0.560721f, 0.563789f, 0.566875f, 0.569977f, 0.573097f,
    0.576233f, 0.579387f, 0.582558f, 0.585746f, 0.588951f, 0.592175f, 0.595415f, 0.598674f, 0.601950f,
@@ -396,7 +412,7 @@ f32 gPitchBendFrequencyScale[256] = {
    0.853613f, 0.858284f, 0.862982f, 0.867704f, 0.872453f, 0.877228f, 0.882029f, 0.886856f, 0.891709f,
    0.896590f, 0.901496f, 0.906430f, 0.911391f, 0.916379f, 0.921394f, 0.926436f, 0.931507f, 0.936604f,
    0.941730f, 0.946884f, 0.952066f, 0.957277f, 0.962516f, 0.967783f, 0.973080f, 0.978405f, 0.983760f,
-    0.989144f, 0.994557f, 1.0f,      1.005473f, 1.010975f, 1.016508f, 1.022071f, 1.027665f, 1.033289f,
+    0.989144f, 0.994557f, 1.0f, 1.005473f, 1.010975f, 1.016508f, 1.022071f, 1.027665f, 1.033289f,
    1.038944f, 1.044630f, 1.050347f, 1.056095f, 1.061875f, 1.067687f, 1.073530f, 1.079405f, 1.085312f,
    1.091252f, 1.097224f, 1.103229f, 1.109267f, 1.115337f, 1.121441f, 1.127579f, 1.133750f, 1.139955f,
    1.146193f, 1.152466f, 1.158773f, 1.165115f, 1.171491f, 1.177903f, 1.184349f, 1.190831f, 1.197348f,
@@ -416,38 +432,38 @@ f32 gPitchBendFrequencyScale[256] = {

 #ifdef VERSION_SH
 f32 unk_sh_data_1[] = {
-  0.890899f,  0.890899f,  0.89171f,   0.892521f,  0.893333f,  0.894146f,  0.89496f,   0.895774f,
-  0.89659f,   0.897406f,  0.898222f,  0.89904f,   0.899858f,  0.900677f,  0.901496f,  0.902317f,
-  0.903138f,  0.90396f,   0.904783f,  0.905606f,  0.90643f,   0.907255f,  0.908081f,  0.908907f,
-  0.909734f,  0.910562f,  0.911391f,  0.91222f,   0.91305f,   0.913881f,  0.914713f,  0.915545f,
-  0.916379f,  0.917213f,  0.918047f,  0.918883f,  0.919719f,  0.920556f,  0.921394f,  0.922232f,
-  0.923072f,  0.923912f,  0.924752f,  0.925594f,  0.926436f,  0.927279f,  0.928123f,  0.928968f,
-  0.929813f,  0.93066f,   0.931507f,  0.932354f,  0.933203f,  0.934052f,  0.934902f,  0.935753f,
-  0.936604f,  0.937457f,  0.93831f,   0.939164f,  0.940019f,  0.940874f,  0.94173f,   0.942587f,
-  0.943445f,  0.944304f,  0.945163f,  0.946023f,  0.946884f,  0.947746f,  0.948608f,  0.949472f,
-  0.950336f,  0.951201f,  0.952066f,  0.952933f,  0.9538f,    0.954668f,  0.955537f,  0.956406f,
-  0.957277f,  0.958148f,  0.95902f,   0.959893f,  0.960766f,  0.961641f,  0.962516f,  0.963392f,
-  0.964268f,  0.965146f,  0.966024f,  0.966903f,  0.967783f,  0.968664f,  0.969546f,  0.970428f,
-  0.971311f,  0.972195f,  0.97308f,   0.973965f,  0.974852f,  0.975739f,  0.976627f,  0.977516f,
-  0.978405f,  0.979296f,  0.980187f,  0.981079f,  0.981972f,  0.982865f,  0.98376f,   0.984655f,
-  0.985551f,  0.986448f,  0.987346f,  0.988244f,  0.989144f,  0.990044f,  0.990945f,  0.991847f,
-  0.992749f,  0.993653f,  0.994557f,  0.995462f,  0.996368f,  0.997275f,  0.998182f,  0.999091f,
-  1.0f,       1.00091f,   1.001821f,  1.002733f,  1.003645f,  1.004559f,  1.005473f,  1.006388f,
-  1.007304f,  1.00822f,   1.009138f,  1.010056f,  1.010975f,  1.011896f,  1.012816f,  1.013738f,
-  1.014661f,  1.015584f,  1.016508f,  1.017433f,  1.018359f,  1.019286f,  1.020214f,  1.021142f,
-  1.022071f,  1.023002f,  1.023933f,  1.024864f,  1.025797f,  1.026731f,  1.027665f,  1.0286f,
-  1.029536f,  1.030473f,  1.031411f,  1.03235f,   1.033289f,  1.03423f,   1.035171f,  1.036113f,
-  1.037056f,  1.038f,     1.038944f,  1.03989f,   1.040836f,  1.041783f,  1.042731f,  1.04368f,
-  1.04463f,   1.045581f,  1.046532f,  1.047485f,  1.048438f,  1.049392f,  1.050347f,  1.051303f,
-  1.05226f,   1.053217f,  1.054176f,  1.055135f,  1.056095f,  1.057056f,  1.058018f,  1.058981f,
-  1.059945f,  1.06091f,   1.061875f,  1.062842f,  1.063809f,  1.064777f,  1.065746f,  1.066716f,
-  1.067687f,  1.068658f,  1.069631f,  1.070604f,  1.071578f,  1.072554f,  1.07353f,   1.074507f,
-  1.075485f,  1.076463f,  1.077443f,  1.078424f,  1.079405f,  1.080387f,  1.08137f,   1.082355f,
-  1.08334f,   1.084325f,  1.085312f,  1.0863f,    1.087289f,  1.088278f,  1.089268f,  1.09026f,
-  1.091252f,  1.092245f,  1.093239f,  1.094234f,  1.09523f,   1.096226f,  1.097224f,  1.098223f,
-  1.099222f,  1.100222f,  1.101224f,  1.102226f,  1.103229f,  1.104233f,  1.105238f,  1.106244f,
-  1.10725f,   1.108258f,  1.109267f,  1.110276f,  1.111287f,  1.112298f,  1.11331f,   1.114323f,
-  1.115337f,  1.116352f,  1.117368f,  1.118385f,  1.119403f,  1.120422f,  1.121441f,  1.122462f,
+    0.890899f, 0.890899f, 0.89171f, 0.892521f, 0.893333f, 0.894146f, 0.89496f, 0.895774f,
+    0.89659f, 0.897406f, 0.898222f, 0.89904f, 0.899858f, 0.900677f, 0.901496f, 0.902317f,
+    0.903138f, 0.90396f, 0.904783f, 0.905606f, 0.90643f, 0.907255f, 0.908081f, 0.908907f,
+    0.909734f, 0.910562f, 0.911391f, 0.91222f, 0.91305f, 0.913881f, 0.914713f, 0.915545f,
+    0.916379f, 0.917213f, 0.918047f, 0.918883f, 0.919719f, 0.920556f, 0.921394f, 0.922232f,
+    0.923072f, 0.923912f, 0.924752f, 0.925594f, 0.926436f, 0.927279f, 0.928123f, 0.928968f,
+    0.929813f, 0.93066f, 0.931507f, 0.932354f, 0.933203f, 0.934052f, 0.934902f, 0.935753f,
+    0.936604f, 0.937457f, 0.93831f, 0.939164f, 0.940019f, 0.940874f, 0.94173f, 0.942587f,
+    0.943445f, 0.944304f, 0.945163f, 0.946023f, 0.946884f, 0.947746f, 0.948608f, 0.949472f,
+    0.950336f, 0.951201f, 0.952066f, 0.952933f, 0.9538f, 0.954668f, 0.955537f, 0.956406f,
+    0.957277f, 0.958148f, 0.95902f, 0.959893f, 0.960766f, 0.961641f, 0.962516f, 0.963392f,
+    0.964268f, 0.965146f, 0.966024f, 0.966903f, 0.967783f, 0.968664f, 0.969546f, 0.970428f,
+    0.971311f, 0.972195f, 0.97308f, 0.973965f, 0.974852f, 0.975739f, 0.976627f, 0.977516f,
+    0.978405f, 0.979296f, 0.980187f, 0.981079f, 0.981972f, 0.982865f, 0.98376f, 0.984655f,
+    0.985551f, 0.986448f, 0.987346f, 0.988244f, 0.989144f, 0.990044f, 0.990945f, 0.991847f,
+    0.992749f, 0.993653f, 0.994557f, 0.995462f, 0.996368f, 0.997275f, 0.998182f, 0.999091f,
+    1.0f, 1.00091f, 1.001821f, 1.002733f, 1.003645f, 1.004559f, 1.005473f, 1.006388f,
+    1.007304f, 1.00822f, 1.009138f, 1.010056f, 1.010975f, 1.011896f, 1.012816f, 1.013738f,
+    1.014661f, 1.015584f, 1.016508f, 1.017433f, 1.018359f, 1.019286f, 1.020214f, 1.021142f,
+    1.022071f, 1.023002f, 1.023933f, 1.024864f, 1.025797f, 1.026731f, 1.027665f, 1.0286f,
+    1.029536f, 1.030473f, 1.031411f, 1.03235f, 1.033289f, 1.03423f, 1.035171f, 1.036113f,
+    1.037056f, 1.038f, 1.038944f, 1.03989f, 1.040836f, 1.041783f, 1.042731f, 1.04368f,
+    1.04463f, 1.045581f, 1.046532f, 1.047485f, 1.048438f, 1.049392f, 1.050347f, 1.051303f,
+    1.05226f, 1.053217f, 1.054176f, 1.055135f, 1.056095f, 1.057056f, 1.058018f, 1.058981f,
+    1.059945f, 1.06091f, 1.061875f, 1.062842f, 1.063809f, 1.064777f, 1.065746f, 1.066716f,
+    1.067687f, 1.068658f, 1.069631f, 1.070604f, 1.071578f, 1.072554f, 1.07353f, 1.074507f,
+    1.075485f, 1.076463f, 1.077443f, 1.078424f, 1.079405f, 1.080387f, 1.08137f, 1.082355f,
+    1.08334f, 1.084325f, 1.085312f, 1.0863f, 1.087289f, 1.088278f, 1.089268f, 1.09026f,
+    1.091252f, 1.092245f, 1.093239f, 1.094234f, 1.09523f, 1.096226f, 1.097224f, 1.098223f,
+    1.099222f, 1.100222f, 1.101224f, 1.102226f, 1.103229f, 1.104233f, 1.105238f, 1.106244f,
+    1.10725f, 1.108258f, 1.109267f, 1.110276f, 1.111287f, 1.112298f, 1.11331f, 1.114323f,
+    1.115337f, 1.116352f, 1.117368f, 1.118385f, 1.119403f, 1.120422f, 1.121441f, 1.122462f,
 };

 // Shindou moved these variables down here. :/
@@ -476,43 +492,43 @@ u8 gDefaultShortNoteDurationTable[16] = {
 };

 struct AdsrEnvelope gDefaultEnvelope[] = {
-    { BSWAP16(4), BSWAP16(32000) },    // go from 0 to 32000 over the course of 16ms
-    { BSWAP16(1000), BSWAP16(32000) }, // stay there for 4.16 seconds
-    { BSWAP16(ADSR_HANG), 0 }          // then continue staying there
+    {BSWAP16(4), BSWAP16(32000)}, // go from 0 to 32000 over the course of 16ms
+    {BSWAP16(1000), BSWAP16(32000)}, // stay there for 4.16 seconds
+    {BSWAP16(ADSR_HANG), 0} // then continue staying there
 };

-u8 unk_sh_data2[4] = { 0, 0, 0, 0 };
+u8 unk_sh_data2[4] = {0, 0, 0, 0};

-struct NoteSubEu gZeroNoteSub = { 0 };
+struct NoteSubEu gZeroNoteSub = {0};
 struct NoteSubEu gDefaultNoteSub = {
-    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, { NULL },
+    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {nullptr},
 #ifdef VERSION_SH
-    0
+0
 #endif
 };

 u16 gHeadsetPanQuantization[0x40] = {
-0x3C, 0x3A, 0x38, 0x36, 0x34, 0x32, 0x30, 0x2E,
-0x2C, 0x2A, 0x28, 0x26, 0x24, 0x22, 0x20, 0x1E,
-0x1C, 0x1A, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0E,
-0x0C, 0x0A, 0x08, 0x06, 0x04, 0x02,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0x3C, 0x3A, 0x38, 0x36, 0x34, 0x32, 0x30, 0x2E,
+    0x2C, 0x2A, 0x28, 0x26, 0x24, 0x22, 0x20, 0x1E,
+    0x1C, 0x1A, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0E,
+    0x0C, 0x0A, 0x08, 0x06, 0x04, 0x02,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 };
 #endif

 #ifdef VERSION_EU
-u8 euUnknownData_8030194c[4] = { 0x40, 0x20, 0x10, 0x08 };
+u8 euUnknownData_8030194c[4] = {0x40, 0x20, 0x10, 0x08};
 u16 gHeadsetPanQuantization[0x10] = {
    0x40, 0x40, 0x30, 0x30, 0x20, 0x20, 0x10, 0, 0, 0,
 };
 #elif !defined(VERSION_SH)
-u16 gHeadsetPanQuantization[10] = { 0x40, 0x30, 0x20, 0x10, 0, 0, 0, 0, 0, 0 };
+u16 gHeadsetPanQuantization[10] = {0x40, 0x30, 0x20, 0x10, 0, 0, 0, 0, 0, 0};
 #endif

 #if defined(VERSION_EU) || defined(VERSION_SH)
 s16 euUnknownData_80301950[64] = {
-    0, 0, 0,   0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 500, 0, 0, 0, 0, 0, 0, 0, 500, 0, 0, 0, 0, 0, 0, 0, 500, 0, 0, 0, 0, 0, 0, 0, 500, 0, 0, 0, 0,
 };
 #endif
@@ -522,21 +538,21 @@ s16 euUnknownData_80301950[64] = {
 // f(1/2 * 127) = 1/sqrt(2)
 // f(2/2 * 127) = 0
 f32 gHeadsetPanVolume[128] = {
-    1.0f,      0.995386f, 0.990772f, 0.986157f, 0.981543f, 0.976929f, 0.972315f, 0.967701f, 0.963087f,
-    0.958472f, 0.953858f, 0.949244f, 0.94463f,  0.940016f, 0.935402f, 0.930787f, 0.926173f, 0.921559f,
-    0.916945f, 0.912331f, 0.907717f, 0.903102f, 0.898488f, 0.893874f, 0.88926f,  0.884646f, 0.880031f,
+    1.0f, 0.995386f, 0.990772f, 0.986157f, 0.981543f, 0.976929f, 0.972315f, 0.967701f, 0.963087f,
+    0.958472f, 0.953858f, 0.949244f, 0.94463f, 0.940016f, 0.935402f, 0.930787f, 0.926173f, 0.921559f,
+    0.916945f, 0.912331f, 0.907717f, 0.903102f, 0.898488f, 0.893874f, 0.88926f, 0.884646f, 0.880031f,
    0.875417f, 0.870803f, 0.866189f, 0.861575f, 0.856961f, 0.852346f, 0.847732f, 0.843118f, 0.838504f,
-    0.83389f,  0.829276f, 0.824661f, 0.820047f, 0.815433f, 0.810819f, 0.806205f, 0.801591f, 0.796976f,
-    0.792362f, 0.787748f, 0.783134f, 0.77852f,  0.773906f, 0.769291f, 0.764677f, 0.760063f, 0.755449f,
-    0.750835f, 0.74622f,  0.741606f, 0.736992f, 0.732378f, 0.727764f, 0.72315f,  0.718535f, 0.713921f,
-    0.709307f, 0.70537f,  0.70211f,  0.69885f,  0.695591f, 0.692331f, 0.689071f, 0.685811f, 0.682551f,
+    0.83389f, 0.829276f, 0.824661f, 0.820047f, 0.815433f, 0.810819f, 0.806205f, 0.801591f, 0.796976f,
+    0.792362f, 0.787748f, 0.783134f, 0.77852f, 0.773906f, 0.769291f, 0.764677f, 0.760063f, 0.755449f,
+    0.750835f, 0.74622f, 0.741606f, 0.736992f, 0.732378f, 0.727764f, 0.72315f, 0.718535f, 0.713921f,
+    0.709307f, 0.70537f, 0.70211f, 0.69885f, 0.695591f, 0.692331f, 0.689071f, 0.685811f, 0.682551f,
    0.679291f, 0.676031f, 0.672772f, 0.669512f, 0.666252f, 0.662992f, 0.659732f, 0.656472f, 0.653213f,
    0.649953f, 0.646693f, 0.643433f, 0.640173f, 0.636913f, 0.633654f, 0.630394f, 0.627134f, 0.623874f,
    0.620614f, 0.617354f, 0.614094f, 0.610835f, 0.607575f, 0.604315f, 0.601055f, 0.597795f, 0.594535f,
    0.591276f, 0.588016f, 0.584756f, 0.581496f, 0.578236f, 0.574976f, 0.571717f, 0.568457f, 0.565197f,
    0.561937f, 0.558677f, 0.555417f, 0.552157f, 0.548898f, 0.545638f, 0.542378f, 0.539118f, 0.535858f,
-    0.532598f, 0.529339f, 0.526079f, 0.522819f, 0.519559f, 0.516299f, 0.513039f, 0.50978f,  0.50652f,
-    0.50326f,  0.5f
+    0.532598f, 0.529339f, 0.526079f, 0.522819f, 0.519559f, 0.516299f, 0.513039f, 0.50978f, 0.50652f,
+    0.50326f, 0.5f
 };

 // Linearly interpolated between
@@ -546,165 +562,165 @@ f32 gHeadsetPanVolume[128] = {
 // f(3/4 * 127) = 0
 // f(4/4 * 127) = 1/sqrt(8)
 f32 gStereoPanVolume[128] = {
-    0.707f,    0.716228f, 0.725457f, 0.734685f, 0.743913f, 0.753142f, 0.76237f,  0.771598f, 0.780827f,
-    0.790055f, 0.799283f, 0.808512f, 0.81774f,  0.826968f, 0.836197f, 0.845425f, 0.854654f, 0.863882f,
-    0.87311f,  0.882339f, 0.891567f, 0.900795f, 0.910024f, 0.919252f, 0.92848f,  0.937709f, 0.946937f,
-    0.956165f, 0.965394f, 0.974622f, 0.98385f,  0.993079f, 0.997693f, 0.988465f, 0.979236f, 0.970008f,
+    0.707f, 0.716228f, 0.725457f, 0.734685f, 0.743913f, 0.753142f, 0.76237f, 0.771598f, 0.780827f,
+    0.790055f, 0.799283f, 0.808512f, 0.81774f, 0.826968f, 0.836197f, 0.845425f, 0.854654f, 0.863882f,
+    0.87311f, 0.882339f, 0.891567f, 0.900795f, 0.910024f, 0.919252f, 0.92848f, 0.937709f, 0.946937f,
+    0.956165f, 0.965394f, 0.974622f, 0.98385f, 0.993079f, 0.997693f, 0.988465f, 0.979236f, 0.970008f,
    0.960779f, 0.951551f, 0.942323f, 0.933095f, 0.923866f, 0.914638f, 0.905409f, 0.896181f, 0.886953f,
    0.877724f, 0.868496f, 0.859268f, 0.850039f, 0.840811f, 0.831583f, 0.822354f, 0.813126f, 0.803898f,
    0.794669f, 0.785441f, 0.776213f, 0.766984f, 0.757756f, 0.748528f, 0.739299f, 0.730071f, 0.720843f,
-    0.711614f, 0.695866f, 0.673598f, 0.651331f, 0.629063f, 0.606795f, 0.584528f, 0.56226f,  0.539992f,
-    0.517724f, 0.495457f, 0.473189f, 0.450921f, 0.428654f, 0.406386f, 0.384118f, 0.36185f,  0.339583f,
-    0.317315f, 0.295047f, 0.27278f,  0.250512f, 0.228244f, 0.205976f, 0.183709f, 0.161441f, 0.139173f,
-    0.116905f, 0.094638f, 0.07237f,  0.050102f, 0.027835f, 0.005567f, 0.00835f,  0.019484f, 0.030618f,
-    0.041752f, 0.052886f, 0.06402f,  0.075154f, 0.086287f, 0.097421f, 0.108555f, 0.119689f, 0.130823f,
-    0.141957f, 0.153091f, 0.164224f, 0.175358f, 0.186492f, 0.197626f, 0.20876f,  0.219894f, 0.231028f,
+    0.711614f, 0.695866f, 0.673598f, 0.651331f, 0.629063f, 0.606795f, 0.584528f, 0.56226f, 0.539992f,
+    0.517724f, 0.495457f, 0.473189f, 0.450921f, 0.428654f, 0.406386f, 0.384118f, 0.36185f, 0.339583f,
+    0.317315f, 0.295047f, 0.27278f, 0.250512f, 0.228244f, 0.205976f, 0.183709f, 0.161441f, 0.139173f,
+    0.116905f, 0.094638f, 0.07237f, 0.050102f, 0.027835f, 0.005567f, 0.00835f, 0.019484f, 0.030618f,
+    0.041752f, 0.052886f, 0.06402f, 0.075154f, 0.086287f, 0.097421f, 0.108555f, 0.119689f, 0.130823f,
+    0.141957f, 0.153091f, 0.164224f, 0.175358f, 0.186492f, 0.197626f, 0.20876f, 0.219894f, 0.231028f,
    0.242161f, 0.253295f, 0.264429f, 0.275563f, 0.286697f, 0.297831f, 0.308965f, 0.320098f, 0.331232f,
    0.342366f, 0.3535f
 };

 // gDefaultVolume[k] = cos(pi/2 * k / 127)
 f32 gDefaultPanVolume[128] = {
-    1.0f,      0.999924f, 0.999694f, 0.999312f, 0.998776f, 0.998088f, 0.997248f, 0.996254f, 0.995109f,
+    1.0f, 0.999924f, 0.999694f, 0.999312f, 0.998776f, 0.998088f, 0.997248f, 0.996254f, 0.995109f,
    0.993811f, 0.992361f, 0.990759f, 0.989006f, 0.987101f, 0.985045f, 0.982839f, 0.980482f, 0.977976f,
-    0.97532f,  0.972514f, 0.96956f,  0.966457f, 0.963207f, 0.959809f, 0.956265f, 0.952574f, 0.948737f,
-    0.944755f, 0.940629f, 0.936359f, 0.931946f, 0.92739f,  0.922692f, 0.917853f, 0.912873f, 0.907754f,
+    0.97532f, 0.972514f, 0.96956f, 0.966457f, 0.963207f, 0.959809f, 0.956265f, 0.952574f, 0.948737f,
+    0.944755f, 0.940629f, 0.936359f, 0.931946f, 0.92739f, 0.922692f, 0.917853f, 0.912873f, 0.907754f,
    0.902497f, 0.897101f, 0.891567f, 0.885898f, 0.880093f, 0.874153f, 0.868079f, 0.861873f, 0.855535f,
    0.849066f, 0.842467f, 0.835739f, 0.828884f, 0.821901f, 0.814793f, 0.807561f, 0.800204f, 0.792725f,
-    0.785125f, 0.777405f, 0.769566f, 0.76161f,  0.753536f, 0.745348f, 0.737045f, 0.72863f,  0.720103f,
-    0.711466f, 0.70272f,  0.693867f, 0.684908f, 0.675843f, 0.666676f, 0.657406f, 0.648036f, 0.638567f,
-    0.629f,    0.619337f, 0.609579f, 0.599728f, 0.589785f, 0.579752f, 0.56963f,  0.559421f, 0.549126f,
-    0.538748f, 0.528287f, 0.517745f, 0.507124f, 0.496425f, 0.485651f, 0.474802f, 0.46388f,  0.452888f,
+    0.785125f, 0.777405f, 0.769566f, 0.76161f, 0.753536f, 0.745348f, 0.737045f, 0.72863f, 0.720103f,
+    0.711466f, 0.70272f, 0.693867f, 0.684908f, 0.675843f, 0.666676f, 0.657406f, 0.648036f, 0.638567f,
+    0.629f, 0.619337f, 0.609579f, 0.599728f, 0.589785f, 0.579752f, 0.56963f, 0.559421f, 0.549126f,
+    0.538748f, 0.528287f, 0.517745f, 0.507124f, 0.496425f, 0.485651f, 0.474802f, 0.46388f, 0.452888f,
    0.441826f, 0.430697f, 0.419502f, 0.408243f, 0.396921f, 0.385538f, 0.374097f, 0.362598f, 0.351044f,
    0.339436f, 0.327776f, 0.316066f, 0.304308f, 0.292503f, 0.280653f, 0.268761f, 0.256827f, 0.244854f,
    0.232844f, 0.220798f, 0.208718f, 0.196606f, 0.184465f, 0.172295f, 0.160098f, 0.147877f, 0.135634f,
-    0.12337f,  0.111087f, 0.098786f, 0.086471f, 0.074143f, 0.061803f, 0.049454f, 0.037097f, 0.024734f,
+    0.12337f, 0.111087f, 0.098786f, 0.086471f, 0.074143f, 0.061803f, 0.049454f, 0.037097f, 0.024734f,
    0.012368f, 0.0f
 };

 #if defined(VERSION_JP) || defined(VERSION_US)
 // gVolRampingLhs136[k] = 2^16 * max(1, (256*k)^(1/17)
 f32 gVolRampingLhs136[128] = {
-    65536.0f,    90811.555f,  94590.766f,  96873.96f,   98527.26f,   99829.06f,   100905.47f,
-    101824.61f,  102627.57f,  103341.086f, 103983.55f,  104568.164f, 105104.75f,  105600.8f,
-    106062.14f,  106493.46f,  106898.52f,  107280.414f, 107641.73f,  107984.62f,  108310.93f,
-    108622.23f,  108919.875f, 109205.055f, 109478.8f,   109742.0f,   109995.48f,  110239.94f,
-    110476.02f,  110704.305f, 110925.3f,   111139.45f,  111347.21f,  111548.945f, 111745.0f,
-    111935.7f,   112121.35f,  112302.2f,   112478.51f,  112650.51f,  112818.4f,   112982.38f,
-    113142.66f,  113299.37f,  113452.69f,  113602.766f, 113749.734f, 113893.73f,  114034.87f,
-    114173.26f,  114309.02f,  114442.26f,  114573.055f, 114701.5f,   114827.69f,  114951.695f,
-    115073.6f,   115193.47f,  115311.375f, 115427.39f,  115541.56f,  115653.96f,  115764.63f,
-    115873.64f,  115981.04f,  116086.86f,  116191.164f, 116293.99f,  116395.38f,  116495.38f,
-    116594.02f,  116691.34f,  116787.39f,  116882.19f,  116975.77f,  117068.17f,  117159.414f,
-    117249.54f,  117338.57f,  117426.53f,  117513.45f,  117599.35f,  117684.266f, 117768.2f,
-    117851.195f, 117933.266f, 118014.44f,  118094.72f,  118174.14f,  118252.71f,  118330.46f,
-    118407.4f,   118483.55f,  118558.914f, 118633.53f,  118707.4f,   118780.54f,  118852.97f,
-    118924.695f, 118995.74f,  119066.11f,  119135.82f,  119204.88f,  119273.31f,  119341.125f,
-    119408.32f,  119474.92f,  119540.93f,  119606.36f,  119671.22f,  119735.52f,  119799.28f,
-    119862.5f,   119925.195f, 119987.36f,  120049.02f,  120110.18f,  120170.84f,  120231.016f,
-    120290.71f,  120349.945f, 120408.7f,   120467.016f, 120524.875f, 120582.3f,   120639.28f,
-    120695.84f,  120751.984f
+    65536.0f, 90811.555f, 94590.766f, 96873.96f, 98527.26f, 99829.06f, 100905.47f,
+    101824.61f, 102627.57f, 103341.086f, 103983.55f, 104568.164f, 105104.75f, 105600.8f,
+    106062.14f, 106493.46f, 106898.52f, 107280.414f, 107641.73f, 107984.62f, 108310.93f,
+    108622.23f, 108919.875f, 109205.055f, 109478.8f, 109742.0f, 109995.48f, 110239.94f,
+    110476.02f, 110704.305f, 110925.3f, 111139.45f, 111347.21f, 111548.945f, 111745.0f,
+    111935.7f, 112121.35f, 112302.2f, 112478.51f, 112650.51f, 112818.4f, 112982.38f,
+    113142.66f, 113299.37f, 113452.69f, 113602.766f, 113749.734f, 113893.73f, 114034.87f,
+    114173.26f, 114309.02f, 114442.26f, 114573.055f, 114701.5f, 114827.69f, 114951.695f,
+    115073.6f, 115193.47f, 115311.375f, 115427.39f, 115541.56f, 115653.96f, 115764.63f,
+    115873.64f, 115981.04f, 116086.86f, 116191.164f, 116293.99f, 116395.38f, 116495.38f,
+    116594.02f, 116691.34f, 116787.39f, 116882.19f, 116975.77f, 117068.17f, 117159.414f,
+    117249.54f, 117338.57f, 117426.53f, 117513.45f, 117599.35f, 117684.266f, 117768.2f,
+    117851.195f, 117933.266f, 118014.44f, 118094.72f, 118174.14f, 118252.71f, 118330.46f,
+    118407.4f, 118483.55f, 118558.914f, 118633.53f, 118707.4f, 118780.54f, 118852.97f,
+    118924.695f, 118995.74f, 119066.11f, 119135.82f, 119204.88f, 119273.31f, 119341.125f,
+    119408.32f, 119474.92f, 119540.93f, 119606.36f, 119671.22f, 119735.52f, 119799.28f,
+    119862.5f, 119925.195f, 119987.36f, 120049.02f, 120110.18f, 120170.84f, 120231.016f,
+    120290.71f, 120349.945f, 120408.7f, 120467.016f, 120524.875f, 120582.3f, 120639.28f,
+    120695.84f, 120751.984f
 };

 // gVolRampingRhs136[k] = 1 / max(1, (256*k)^(1/17))
 f32 gVolRampingRhs136[128] = {
-    1.0f,      0.72167f,  0.692837f, 0.676508f, 0.665156f, 0.656482f, 0.649479f, 0.643616f, 0.638581f,
-    0.634172f, 0.630254f, 0.62673f,  0.62353f,  0.620601f, 0.617902f, 0.615399f, 0.613067f, 0.610885f,
-    0.608835f, 0.606901f, 0.605073f, 0.603339f, 0.60169f,  0.600119f, 0.598618f, 0.597183f, 0.595806f,
+    1.0f, 0.72167f, 0.692837f, 0.676508f, 0.665156f, 0.656482f, 0.649479f, 0.643616f, 0.638581f,
+    0.634172f, 0.630254f, 0.62673f, 0.62353f, 0.620601f, 0.617902f, 0.615399f, 0.613067f, 0.610885f,
+    0.608835f, 0.606901f, 0.605073f, 0.603339f, 0.60169f, 0.600119f, 0.598618f, 0.597183f, 0.595806f,
    0.594485f, 0.593215f, 0.591991f, 0.590812f, 0.589674f, 0.588573f, 0.587509f, 0.586478f, 0.585479f,
-    0.58451f,  0.583568f, 0.582654f, 0.581764f, 0.580898f, 0.580055f, 0.579233f, 0.578432f, 0.57765f,
+    0.58451f, 0.583568f, 0.582654f, 0.581764f, 0.580898f, 0.580055f, 0.579233f, 0.578432f, 0.57765f,
    0.576887f, 0.576142f, 0.575414f, 0.574701f, 0.574005f, 0.573323f, 0.572656f, 0.572002f, 0.571361f,
    0.570733f, 0.570118f, 0.569514f, 0.568921f, 0.568339f, 0.567768f, 0.567207f, 0.566656f, 0.566114f,
    0.565582f, 0.565058f, 0.564543f, 0.564036f, 0.563537f, 0.563046f, 0.562563f, 0.562087f, 0.561618f,
    0.561156f, 0.560701f, 0.560253f, 0.559811f, 0.559375f, 0.558945f, 0.558521f, 0.558102f, 0.557689f,
-    0.557282f, 0.55688f,  0.556483f, 0.556091f, 0.555704f, 0.555322f, 0.554944f, 0.554571f, 0.554203f,
-    0.553839f, 0.553479f, 0.553123f, 0.552772f, 0.552424f, 0.55208f,  0.55174f,  0.551404f, 0.551071f,
+    0.557282f, 0.55688f, 0.556483f, 0.556091f, 0.555704f, 0.555322f, 0.554944f, 0.554571f, 0.554203f,
+    0.553839f, 0.553479f, 0.553123f, 0.552772f, 0.552424f, 0.55208f, 0.55174f, 0.551404f, 0.551071f,
    0.550742f, 0.550417f, 0.550095f, 0.549776f, 0.549461f, 0.549148f, 0.548839f, 0.548534f, 0.548231f,
-    0.547931f, 0.547634f, 0.54734f,  0.547048f, 0.54676f,  0.546474f, 0.546191f, 0.54591f,  0.545632f,
-    0.545357f, 0.545084f, 0.544813f, 0.544545f, 0.54428f,  0.544016f, 0.543755f, 0.543496f, 0.543239f,
+    0.547931f, 0.547634f, 0.54734f, 0.547048f, 0.54676f, 0.546474f, 0.546191f, 0.54591f, 0.545632f,
+    0.545357f, 0.545084f, 0.544813f, 0.544545f, 0.54428f, 0.544016f, 0.543755f, 0.543496f, 0.543239f,
    0.542985f, 0.542732f
 };

 // gVolRampingLhs144[k] = 2^16 * max(1, (256*k)^(1/18))
 f32 gVolRampingLhs144[128] = {
-    65536.0f,    89180.734f,  92681.9f,    94793.33f,   96320.52f,   97522.02f,  98514.84f,
-    99362.14f,   100101.99f,  100759.16f,  101350.664f, 101888.74f,  102382.46f, 102838.75f,
-    103263.016f, 103659.58f,  104031.914f, 104382.89f,  104714.88f,  105029.89f, 105329.61f,
-    105615.5f,   105888.81f,  106150.63f,  106401.914f, 106643.49f,  106876.12f, 107100.44f,
-    107317.05f,  107526.47f,  107729.17f,  107925.6f,   108116.125f, 108301.12f, 108480.88f,
-    108655.72f,  108825.91f,  108991.68f,  109153.28f,  109310.914f, 109464.77f, 109615.04f,
-    109761.88f,  109905.46f,  110045.92f,  110183.41f,  110318.02f,  110449.91f, 110579.17f,
-    110705.914f, 110830.234f, 110952.234f, 111071.99f,  111189.59f,  111305.12f, 111418.64f,
-    111530.23f,  111639.95f,  111747.875f, 111854.05f,  111958.54f,  112061.4f,  112162.67f,
-    112262.42f,  112360.68f,  112457.51f,  112552.93f,  112647.0f,   112739.76f, 112831.23f,
-    112921.46f,  113010.484f, 113098.33f,  113185.02f,  113270.61f,  113355.11f, 113438.555f,
-    113520.97f,  113602.375f, 113682.805f, 113762.27f,  113840.81f,  113918.44f, 113995.18f,
-    114071.055f, 114146.08f,  114220.266f, 114293.65f,  114366.24f,  114438.06f, 114509.12f,
-    114579.44f,  114649.02f,  114717.91f,  114786.086f, 114853.586f, 114920.42f, 114986.6f,
-    115052.14f,  115117.055f, 115181.34f,  115245.04f,  115308.13f,  115370.65f, 115432.59f,
-    115493.98f,  115554.81f,  115615.11f,  115674.875f, 115734.12f,  115792.85f, 115851.08f,
-    115908.82f,  115966.07f,  116022.85f,  116079.16f,  116135.01f,  116190.4f,  116245.35f,
-    116299.87f,  116353.945f, 116407.6f,   116460.84f,  116513.67f,  116566.09f, 116618.125f,
-    116669.76f,  116721.01f
+    65536.0f, 89180.734f, 92681.9f, 94793.33f, 96320.52f, 97522.02f, 98514.84f,
+    99362.14f, 100101.99f, 100759.16f, 101350.664f, 101888.74f, 102382.46f, 102838.75f,
+    103263.016f, 103659.58f, 104031.914f, 104382.89f, 104714.88f, 105029.89f, 105329.61f,
+    105615.5f, 105888.81f, 106150.63f, 106401.914f, 106643.49f, 106876.12f, 107100.44f,
+    107317.05f, 107526.47f, 107729.17f, 107925.6f, 108116.125f, 108301.12f, 108480.88f,
+    108655.72f, 108825.91f, 108991.68f, 109153.28f, 109310.914f, 109464.77f, 109615.04f,
+    109761.88f, 109905.46f, 110045.92f, 110183.41f, 110318.02f, 110449.91f, 110579.17f,
+    110705.914f, 110830.234f, 110952.234f, 111071.99f, 111189.59f, 111305.12f, 111418.64f,
+    111530.23f, 111639.95f, 111747.875f, 111854.05f, 111958.54f, 112061.4f, 112162.67f,
+    112262.42f, 112360.68f, 112457.51f, 112552.93f, 112647.0f, 112739.76f, 112831.23f,
+    112921.46f, 113010.484f, 113098.33f, 113185.02f, 113270.61f, 113355.11f, 113438.555f,
+    113520.97f, 113602.375f, 113682.805f, 113762.27f, 113840.81f, 113918.44f, 113995.18f,
+    114071.055f, 114146.08f, 114220.266f, 114293.65f, 114366.24f, 114438.06f, 114509.12f,
+    114579.44f, 114649.02f, 114717.91f, 114786.086f, 114853.586f, 114920.42f, 114986.6f,
+    115052.14f, 115117.055f, 115181.34f, 115245.04f, 115308.13f, 115370.65f, 115432.59f,
+    115493.98f, 115554.81f, 115615.11f, 115674.875f, 115734.12f, 115792.85f, 115851.08f,
+    115908.82f, 115966.07f, 116022.85f, 116079.16f, 116135.01f, 116190.4f, 116245.35f,
+    116299.87f, 116353.945f, 116407.6f, 116460.84f, 116513.67f, 116566.09f, 116618.125f,
+    116669.76f, 116721.01f
 };

 // gVolRampingRhs144[k] = 1 / max(1, (256*k)^(1/18))
 f32 gVolRampingRhs144[128] = {
-    1.0f,      0.734867f, 0.707107f, 0.691357f, 0.680395f, 0.672012f, 0.66524f,  0.659567f, 0.654692f,
-    0.650422f, 0.646626f, 0.643211f, 0.64011f,  0.637269f, 0.634651f, 0.632223f, 0.629961f, 0.627842f,
+    1.0f, 0.734867f, 0.707107f, 0.691357f, 0.680395f, 0.672012f, 0.66524f, 0.659567f, 0.654692f,
+    0.650422f, 0.646626f, 0.643211f, 0.64011f, 0.637269f, 0.634651f, 0.632223f, 0.629961f, 0.627842f,
    0.625852f, 0.623975f, 0.622199f, 0.620515f, 0.618913f, 0.617387f, 0.615929f, 0.614533f, 0.613196f,
-    0.611912f, 0.610677f, 0.609487f, 0.60834f,  0.607233f, 0.606163f, 0.605128f, 0.604125f, 0.603153f,
-    0.60221f,  0.601294f, 0.600403f, 0.599538f, 0.598695f, 0.597874f, 0.597074f, 0.596294f, 0.595533f,
-    0.59479f,  0.594064f, 0.593355f, 0.592661f, 0.591983f, 0.591319f, 0.590669f, 0.590032f, 0.589408f,
-    0.588796f, 0.588196f, 0.587608f, 0.58703f,  0.586463f, 0.585906f, 0.58536f,  0.584822f, 0.584294f,
+    0.611912f, 0.610677f, 0.609487f, 0.60834f, 0.607233f, 0.606163f, 0.605128f, 0.604125f, 0.603153f,
+    0.60221f, 0.601294f, 0.600403f, 0.599538f, 0.598695f, 0.597874f, 0.597074f, 0.596294f, 0.595533f,
+    0.59479f, 0.594064f, 0.593355f, 0.592661f, 0.591983f, 0.591319f, 0.590669f, 0.590032f, 0.589408f,
+    0.588796f, 0.588196f, 0.587608f, 0.58703f, 0.586463f, 0.585906f, 0.58536f, 0.584822f, 0.584294f,
    0.583775f, 0.583265f, 0.582762f, 0.582268f, 0.581782f, 0.581303f, 0.580832f, 0.580368f, 0.579911f,
-    0.57946f,  0.579017f, 0.578579f, 0.578148f, 0.577722f, 0.577303f, 0.576889f, 0.576481f, 0.576078f,
-    0.575681f, 0.575289f, 0.574902f, 0.574519f, 0.574142f, 0.573769f, 0.5734f,   0.573036f, 0.572677f,
-    0.572321f, 0.57197f,  0.571623f, 0.57128f,  0.57094f,  0.570605f, 0.570273f, 0.569945f, 0.56962f,
+    0.57946f, 0.579017f, 0.578579f, 0.578148f, 0.577722f, 0.577303f, 0.576889f, 0.576481f, 0.576078f,
+    0.575681f, 0.575289f, 0.574902f, 0.574519f, 0.574142f, 0.573769f, 0.5734f, 0.573036f, 0.572677f,
+    0.572321f, 0.57197f, 0.571623f, 0.57128f, 0.57094f, 0.570605f, 0.570273f, 0.569945f, 0.56962f,
    0.569299f, 0.568981f, 0.568667f, 0.568355f, 0.568047f, 0.567743f, 0.567441f, 0.567142f, 0.566846f,
-    0.566553f, 0.566263f, 0.565976f, 0.565692f, 0.56541f,  0.565131f, 0.564854f, 0.56458f,  0.564309f,
-    0.56404f,  0.563773f, 0.563509f, 0.563247f, 0.562987f, 0.56273f,  0.562475f, 0.562222f, 0.561971f,
+    0.566553f, 0.566263f, 0.565976f, 0.565692f, 0.56541f, 0.565131f, 0.564854f, 0.56458f, 0.564309f,
+    0.56404f, 0.563773f, 0.563509f, 0.563247f, 0.562987f, 0.56273f, 0.562475f, 0.562222f, 0.561971f,
    0.561722f, 0.561476f
 };

 // gVolRampingLhs128[k] = 2^16 * max(1, (256*k)^(1/16))
 f32 gVolRampingLhs128[128] = {
-    65536.0f,    92681.9f,    96785.28f,   99269.31f,   101070.33f,  102489.78f,  103664.336f,
-    104667.914f, 105545.09f,  106324.92f,  107027.39f,  107666.84f,  108253.95f,  108796.87f,
-    109301.95f,  109774.29f,  110217.98f,  110636.39f,  111032.33f,  111408.164f, 111765.9f,
-    112107.234f, 112433.66f,  112746.46f,  113046.766f, 113335.555f, 113613.72f,  113882.02f,
-    114141.164f, 114391.77f,  114634.414f, 114869.58f,  115097.74f,  115319.31f,  115534.68f,
-    115744.19f,  115948.16f,  116146.875f, 116340.625f, 116529.66f,  116714.195f, 116894.46f,
-    117070.64f,  117242.945f, 117411.52f,  117576.55f,  117738.17f,  117896.54f,  118051.77f,
-    118204.0f,   118353.35f,  118499.92f,  118643.83f,  118785.16f,  118924.01f,  119060.47f,
-    119194.625f, 119326.555f, 119456.336f, 119584.03f,  119709.71f,  119833.445f, 119955.29f,
-    120075.31f,  120193.555f, 120310.08f,  120424.94f,  120538.17f,  120649.836f, 120759.97f,
-    120868.62f,  120975.82f,  121081.62f,  121186.05f,  121289.14f,  121390.94f,  121491.47f,
-    121590.766f, 121688.87f,  121785.79f,  121881.57f,  121976.24f,  122069.82f,  122162.33f,
-    122253.805f, 122344.266f, 122433.73f,  122522.23f,  122609.77f,  122696.4f,   122782.11f,
-    122866.93f,  122950.89f,  123033.99f,  123116.26f,  123197.72f,  123278.37f,  123358.24f,
-    123437.34f,  123515.69f,  123593.3f,   123670.19f,  123746.36f,  123821.84f,  123896.63f,
-    123970.76f,  124044.23f,  124117.04f,  124189.23f,  124260.78f,  124331.73f,  124402.07f,
-    124471.83f,  124540.99f,  124609.59f,  124677.63f,  124745.12f,  124812.055f, 124878.47f,
-    124944.34f,  125009.71f,  125074.57f,  125138.92f,  125202.79f,  125266.164f, 125329.06f,
-    125391.5f,   125453.47f
+    65536.0f, 92681.9f, 96785.28f, 99269.31f, 101070.33f, 102489.78f, 103664.336f,
+    104667.914f, 105545.09f, 106324.92f, 107027.39f, 107666.84f, 108253.95f, 108796.87f,
+    109301.95f, 109774.29f, 110217.98f, 110636.39f, 111032.33f, 111408.164f, 111765.9f,
+    112107.234f, 112433.66f, 112746.46f, 113046.766f, 113335.555f, 113613.72f, 113882.02f,
+    114141.164f, 114391.77f, 114634.414f, 114869.58f, 115097.74f, 115319.31f, 115534.68f,
+    115744.19f, 115948.16f, 116146.875f, 116340.625f, 116529.66f, 116714.195f, 116894.46f,
+    117070.64f, 117242.945f, 117411.52f, 117576.55f, 117738.17f, 117896.54f, 118051.77f,
+    118204.0f, 118353.35f, 118499.92f, 118643.83f, 118785.16f, 118924.01f, 119060.47f,
+    119194.625f, 119326.555f, 119456.336f, 119584.03f, 119709.71f, 119833.445f, 119955.29f,
+    120075.31f, 120193.555f, 120310.08f, 120424.94f, 120538.17f, 120649.836f, 120759.97f,
+    120868.62f, 120975.82f, 121081.62f, 121186.05f, 121289.14f, 121390.94f, 121491.47f,
+    121590.766f, 121688.87f, 121785.79f, 121881.57f, 121976.24f, 122069.82f, 122162.33f,
+    122253.805f, 122344.266f, 122433.73f, 122522.23f, 122609.77f, 122696.4f, 122782.11f,
+    122866.93f, 122950.89f, 123033.99f, 123116.26f, 123197.72f, 123278.37f, 123358.24f,
+    123437.34f, 123515.69f, 123593.3f, 123670.19f, 123746.36f, 123821.84f, 123896.63f,
+    123970.76f, 124044.23f, 124117.04f, 124189.23f, 124260.78f, 124331.73f, 124402.07f,
+    124471.83f, 124540.99f, 124609.59f, 124677.63f, 124745.12f, 124812.055f, 124878.47f,
+    124944.34f, 125009.71f, 125074.57f, 125138.92f, 125202.79f, 125266.164f, 125329.06f,
+    125391.5f, 125453.47f
 };

 // gVolRampingRhs128[k] = 1 / max(1, (256*k)^(1/16))
 f32 gVolRampingRhs128[128] = {
-    1.0f,      0.707107f, 0.677128f, 0.660184f, 0.64842f,  0.639439f, 0.632194f, 0.626133f, 0.620929f,
-    0.616375f, 0.612329f, 0.608693f, 0.605391f, 0.60237f,  0.599587f, 0.597007f, 0.594604f, 0.592355f,
+    1.0f, 0.707107f, 0.677128f, 0.660184f, 0.64842f, 0.639439f, 0.632194f, 0.626133f, 0.620929f,
+    0.616375f, 0.612329f, 0.608693f, 0.605391f, 0.60237f, 0.599587f, 0.597007f, 0.594604f, 0.592355f,
    0.590243f, 0.588251f, 0.586369f, 0.584583f, 0.582886f, 0.581269f, 0.579725f, 0.578247f, 0.576832f,
-    0.575473f, 0.574166f, 0.572908f, 0.571696f, 0.570525f, 0.569394f, 0.5683f,   0.567241f, 0.566214f,
+    0.575473f, 0.574166f, 0.572908f, 0.571696f, 0.570525f, 0.569394f, 0.5683f, 0.567241f, 0.566214f,
    0.565218f, 0.564251f, 0.563311f, 0.562398f, 0.561508f, 0.560642f, 0.559799f, 0.558976f, 0.558173f,
-    0.55739f,  0.556625f, 0.555877f, 0.555146f, 0.554431f, 0.553732f, 0.553047f, 0.552376f, 0.551719f,
+    0.55739f, 0.556625f, 0.555877f, 0.555146f, 0.554431f, 0.553732f, 0.553047f, 0.552376f, 0.551719f,
    0.551075f, 0.550443f, 0.549823f, 0.549216f, 0.548619f, 0.548033f, 0.547458f, 0.546892f, 0.546337f,
    0.545791f, 0.545254f, 0.544726f, 0.544206f, 0.543695f, 0.543192f, 0.542696f, 0.542209f, 0.541728f,
    0.541255f, 0.540788f, 0.540329f, 0.539876f, 0.539429f, 0.538988f, 0.538554f, 0.538125f, 0.537702f,
    0.537285f, 0.536873f, 0.536467f, 0.536065f, 0.535669f, 0.535277f, 0.534891f, 0.534509f, 0.534131f,
-    0.533759f, 0.53339f,  0.533026f, 0.532666f, 0.53231f,  0.531958f, 0.53161f,  0.531266f, 0.530925f,
+    0.533759f, 0.53339f, 0.533026f, 0.532666f, 0.53231f, 0.531958f, 0.53161f, 0.531266f, 0.530925f,
    0.530588f, 0.530255f, 0.529926f, 0.529599f, 0.529277f, 0.528957f, 0.528641f, 0.528328f, 0.528018f,
-    0.527711f, 0.527407f, 0.527106f, 0.526808f, 0.526513f, 0.52622f,  0.525931f, 0.525644f, 0.525359f,
+    0.527711f, 0.527407f, 0.527106f, 0.526808f, 0.526513f, 0.52622f, 0.525931f, 0.525644f, 0.525359f,
    0.525077f, 0.524798f, 0.524522f, 0.524247f, 0.523975f, 0.523706f, 0.523439f, 0.523174f, 0.522911f,
    0.522651f, 0.522393f
 };
@@ -888,11 +904,11 @@ volatile s32 gAudioLoadLock = AUDIO_LOCK_UNINITIALIZED;
 #endif

 #if defined(VERSION_EU)
-u8 bufferDelete2[12] = { 0 };
+u8 bufferDelete2[12] = {0};
 u8 D_EU_80302010 = 0;
 u8 D_EU_80302014 = 0;

-struct OSMesgQueue *OSMesgQueues[4] = { &OSMesgQueue0, &OSMesgQueue1, &OSMesgQueue2, &OSMesgQueue3 };
+struct OSMesgQueue *OSMesgQueues[4] = {&OSMesgQueue0, &OSMesgQueue1, &OSMesgQueue2, &OSMesgQueue3};
 #elif defined(VERSION_JP) || defined(VERSION_US)
 s8 sUnused8033EF8 = 24;
 #endif
@@ -14,29 +14,32 @@
 f32 gTrackVolume = 1.0f;

 #if defined(VERSION_EU) || defined(VERSION_SH)
-void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 recalculateVolume) {
+void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 recalculateVolume)
+{
    f32 channelVolume;
    s32 i;

-    if (seqChannel->changes.as_bitfields.volume || recalculateVolume) {
+    if (seqChannel->changes.as_bitfields.volume || recalculateVolume)
+    {
        channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->appliedFadeVolume;
-        if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0) {
+        if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0)
+        {
            channelVolume = seqChannel->seqPlayer->muteVolumeScale * channelVolume;
        }
 #ifdef VERSION_SH
-        seqChannel->appliedVolume = channelVolume * channelVolume;
+seqChannel->appliedVolume= channelVolume* channelVolume;
 #else
-        seqChannel->appliedVolume = channelVolume;
+seqChannel->appliedVolume= channelVolume;
 #endif
-    }
+}

    if (seqChannel->changes.as_bitfields.pan) {
        seqChannel->pan = seqChannel->newPan * seqChannel->panChannelWeight;
    }

-    for (i = 0; i < 4; ++i) {
+    for (i =0; i<4;++i) {
        struct SequenceChannelLayer *layer = seqChannel->layers[i];
-        if (layer != NULL && layer->enabled && layer->note != NULL) {
+        if (layer != nullptr && layer->enabled && layer->note != nullptr) {
            if (layer->notePropertiesNeedInit) {
                layer->noteFreqScale = layer->freqScale * seqChannel->freqScale;
                layer->noteVelocity = layer->velocitySquare * seqChannel->appliedVolume;
@@ -55,58 +58,69 @@ void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 reca
            }
        }
    }
-    seqChannel->changes.as_u8 = 0;
+seqChannel->changes.as_u8=0;
 }
 #else
-static void sequence_channel_process_sound(struct SequenceChannel *seqChannel) {
+static void sequence_channel_process_sound(struct SequenceChannel *seqChannel)
+{
    f32 channelVolume;
    f32 panLayerWeight;
    f32 panFromChannel;
    s32 i;

    channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->fadeVolume;
-    if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0) {
+    if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0)
+    {
        channelVolume *= seqChannel->seqPlayer->muteVolumeScale;
    }

    panFromChannel = seqChannel->pan * seqChannel->panChannelWeight;
    panLayerWeight = US_FLOAT(1.0) - seqChannel->panChannelWeight;

-    for (i = 0; i < 4; i++) {
+    for (i = 0; i < 4; i++)
+    {
        struct SequenceChannelLayer *layer = seqChannel->layers[i];
-        if (layer != NULL && layer->enabled && layer->note != NULL) {
+        if (layer != nullptr && layer->enabled && layer->note != nullptr)
+        {
            layer->noteFreqScale = layer->freqScale * seqChannel->freqScale;
            layer->noteVelocity = layer->velocitySquare * (channelVolume * gTrackVolume);
-            layer->notePan = (layer->pan * panLayerWeight) + panFromChannel;
+            layer->notePan = layer->pan * panLayerWeight + panFromChannel;
        }
    }
 }
 #endif

-void sequence_player_process_sound(struct SequencePlayer *seqPlayer) {
+void sequence_player_process_sound(struct SequencePlayer *seqPlayer)
+{
    s32 i;

-    if (seqPlayer->fadeRemainingFrames != 0) {
+    if (seqPlayer->fadeRemainingFrames != 0)
+    {
        seqPlayer->fadeVolume += seqPlayer->fadeVelocity;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+        #if defined(VERSION_EU) || defined(VERSION_SH)
        seqPlayer->recalculateVolume = TRUE;
-#endif
+        #endif

-        if (seqPlayer->fadeVolume > US_FLOAT2(1)) {
+        if (seqPlayer->fadeVolume > US_FLOAT2(1))
+        {
            seqPlayer->fadeVolume = US_FLOAT2(1);
        }
-        if (seqPlayer->fadeVolume < 0) {
+        if (seqPlayer->fadeVolume < 0)
+        {
            seqPlayer->fadeVolume = 0;
        }

-        if (--seqPlayer->fadeRemainingFrames == 0) {
-#if defined(VERSION_EU) || defined(VERSION_SH)
-            if (seqPlayer->state == 2) {
+        if (--seqPlayer->fadeRemainingFrames == 0)
+        {
+            #if defined(VERSION_EU) || defined(VERSION_SH)
+            if (seqPlayer->state == 2)
+            {
                sequence_player_disable(seqPlayer);
                return;
            }
-#else
-            switch (seqPlayer->state) {
+            #else
+            switch (seqPlayer->state)
+            {
                case SEQUENCE_PLAYER_STATE_FADE_OUT:
                    sequence_player_disable(seqPlayer);
                    return;
@@ -119,77 +133,85 @@ void sequence_player_process_sound(struct SequencePlayer *seqPlayer) {
                case SEQUENCE_PLAYER_STATE_4:
                    break;
            }
-#endif
+            #endif
        }
    }

-#if defined(VERSION_EU) || defined(VERSION_SH)
-    if (seqPlayer->recalculateVolume) {
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    if (seqPlayer->recalculateVolume)
+    {
        seqPlayer->appliedFadeVolume = seqPlayer->fadeVolume * seqPlayer->fadeVolumeScale;
    }
-#endif
+    #endif

    // Process channels
-    for (i = 0; i < CHANNELS_MAX; i++) {
+    for (i = 0; i < CHANNELS_MAX; i++)
+    {
        if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[i]) == TRUE
-            && seqPlayer->channels[i]->enabled == TRUE) {
-#if defined(VERSION_EU) || defined(VERSION_SH)
+            && seqPlayer->channels[i]->enabled == TRUE)
+        {
+            #if defined(VERSION_EU) || defined(VERSION_SH)
            sequence_channel_process_sound(seqPlayer->channels[i], seqPlayer->recalculateVolume);
-#else
+            #else
            sequence_channel_process_sound(seqPlayer->channels[i]);
-#endif
+            #endif
        }
    }

-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    seqPlayer->recalculateVolume = FALSE;
-#endif
+    #endif
 }

-f32 get_portamento_freq_scale(struct Portamento *p) {
+f32 get_portamento_freq_scale(struct Portamento *p)
+{
    u32 v0;
    f32 result;
-#if defined(VERSION_JP) || defined(VERSION_US)
-    if (p->mode == 0) {
+    #if defined(VERSION_JP) || defined(VERSION_US)
+    if (p->mode == 0)
+    {
        return 1.0f;
    }
-#endif
+    #endif

    p->cur += p->speed;
-    v0 = (u32) p->cur;
+    v0 = (u32)p->cur;

-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    if (v0 > 127)
-#else
+    #else
    if (v0 >= 127)
-#endif
+    #endif
    {
        v0 = 127;
    }

-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 128] - US_FLOAT(1.0));
-#else
+    #else
    result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 127] - US_FLOAT(1.0));
-#endif
+    #endif
    return result;
 }

 #if defined(VERSION_EU) || defined(VERSION_SH)
-s16 get_vibrato_pitch_change(struct VibratoState *vib) {
+s16 get_vibrato_pitch_change(struct VibratoState *vib)
+{
    s32 index;
-    vib->time += (s32) vib->rate;
+    vib->time += (s32)vib->rate;
    index = (vib->time >> 10) & 0x3F;
    return vib->curve[index] >> 8;
 }
 #else
-s8 get_vibrato_pitch_change(struct VibratoState *vib) {
+s8 get_vibrato_pitch_change(struct VibratoState *vib)
+{
    s32 index;
    vib->time += vib->rate;

-    index = (vib->time >> 10) & 0x3F;
+    index = vib->time >> 10 & 0x3F;

-    switch (index & 0x30) {
+    switch (index & 0x30)
+    {
        case 0x10:
            index = 31 - index;

@@ -209,181 +231,225 @@ s8 get_vibrato_pitch_change(struct VibratoState *vib) {
 }
 #endif

-f32 get_vibrato_freq_scale(struct VibratoState *vib) {
+f32 get_vibrato_freq_scale(struct VibratoState *vib)
+{
    s32 pitchChange;
    f32 extent;
    f32 result;

-    if (vib->delay != 0) {
+    if (vib->delay != 0)
+    {
        vib->delay--;
        return 1;
    }

-    if (vib->extentChangeTimer) {
-        if (vib->extentChangeTimer == 1) {
-            vib->extent = (s32) vib->seqChannel->vibratoExtentTarget;
-        } else {
+    if (vib->extentChangeTimer)
+    {
+        if (vib->extentChangeTimer == 1)
+        {
+            vib->extent = (s32)vib->seqChannel->vibratoExtentTarget;
+        }
+        else
+        {
            vib->extent +=
-                ((s32) vib->seqChannel->vibratoExtentTarget - vib->extent) / (s32) vib->extentChangeTimer;
+                    ((s32)vib->seqChannel->vibratoExtentTarget - vib->extent) / (s32)vib->extentChangeTimer;
        }

        vib->extentChangeTimer--;
-    } else if (vib->seqChannel->vibratoExtentTarget != (s32) vib->extent) {
-        if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) {
-            vib->extent = (s32) vib->seqChannel->vibratoExtentTarget;
+    }
+    else if (vib->seqChannel->vibratoExtentTarget != (s32)vib->extent)
+    {
+        if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0)
+        {
+            vib->extent = (s32)vib->seqChannel->vibratoExtentTarget;
        }
    }

-    if (vib->rateChangeTimer) {
-        if (vib->rateChangeTimer == 1) {
-            vib->rate = (s32) vib->seqChannel->vibratoRateTarget;
-        } else {
-            vib->rate += ((s32) vib->seqChannel->vibratoRateTarget - vib->rate) / (s32) vib->rateChangeTimer;
+    if (vib->rateChangeTimer)
+    {
+        if (vib->rateChangeTimer == 1)
+        {
+            vib->rate = (s32)vib->seqChannel->vibratoRateTarget;
+        }
+        else
+        {
+            vib->rate += ((s32)vib->seqChannel->vibratoRateTarget - vib->rate) / (s32)vib->rateChangeTimer;
        }

        vib->rateChangeTimer--;
-    } else if (vib->seqChannel->vibratoRateTarget != (s32) vib->rate) {
-        if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) {
-            vib->rate = (s32) vib->seqChannel->vibratoRateTarget;
+    }
+    else if (vib->seqChannel->vibratoRateTarget != (s32)vib->rate)
+    {
+        if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0)
+        {
+            vib->rate = (s32)vib->seqChannel->vibratoRateTarget;
        }
    }

-    if (vib->extent == 0) {
+    if (vib->extent == 0)
+    {
        return 1.0f;
    }

    pitchChange = get_vibrato_pitch_change(vib);
-    extent = (f32) vib->extent / US_FLOAT(4096.0);
+    extent = (f32)vib->extent / US_FLOAT(4096.0);

-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 128] - US_FLOAT(1.0));
-#else
+    #else
    result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 127] - US_FLOAT(1.0));
-#endif
+    #endif
    return result;
 }

-void note_vibrato_update(struct Note *note) {
-#if defined(VERSION_EU) || defined(VERSION_SH)
-    if (note->portamento.mode != 0) {
+void note_vibrato_update(struct Note *note)
+{
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    if (note->portamento.mode != 0)
+    {
        note->portamentoFreqScale = get_portamento_freq_scale(&note->portamento);
    }
-    if (note->vibratoState.active && note->parentLayer != NO_LAYER) {
+    if (note->vibratoState.active && note->parentLayer != NO_LAYER)
+    {
        note->vibratoFreqScale = get_vibrato_freq_scale(&note->vibratoState);
    }
-#else
-    if (note->vibratoState.active) {
+    #else
+    if (note->vibratoState.active)
+    {
        note->portamentoFreqScale = get_portamento_freq_scale(&note->portamento);
-        if (note->parentLayer != NO_LAYER) {
+        if (note->parentLayer != NO_LAYER)
+        {
            note->vibratoFreqScale = get_vibrato_freq_scale(&note->vibratoState);
        }
    }
-#endif
+    #endif
 }

-void note_vibrato_init(struct Note *note) {
+void note_vibrato_init(struct Note *note)
+{
    struct VibratoState *vib;
-    UNUSED struct SequenceChannel *seqChannel;
-#if defined(VERSION_EU) || defined(VERSION_SH)
-    struct NotePlaybackState *seqPlayerState = (struct NotePlaybackState *) &note->priority;
-#endif
+    UNUSED
+    struct SequenceChannel *seqChannel;
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    struct NotePlaybackState *seqPlayerState = (struct NotePlaybackState *)&note->priority;
+    #endif

    note->vibratoFreqScale = 1.0f;
    note->portamentoFreqScale = 1.0f;

    vib = &note->vibratoState;

-#if defined(VERSION_JP) || defined(VERSION_US)
+    #if defined(VERSION_JP) || defined(VERSION_US)
    if (note->parentLayer->seqChannel->vibratoExtentStart == 0
        && note->parentLayer->seqChannel->vibratoExtentTarget == 0
-        && note->parentLayer->portamento.mode == 0) {
+        && note->parentLayer->portamento.mode == 0)
+    {
        vib->active = FALSE;
        return;
    }
-#endif
+    #endif

    vib->active = TRUE;
    vib->time = 0;

-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    vib->curve = gWaveSamples[2];
    vib->seqChannel = note->parentLayer->seqChannel;
-    if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) {
+    if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0)
+    {
        vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentTarget);
-    } else {
+    }
+    else
+    {
        vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentStart);
    }

-    if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) {
+    if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0)
+    {
        vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateTarget);
-    } else {
+    }
+    else
+    {
        vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateStart);
    }
    vib->delay = vib->seqChannel->vibratoDelay;

    seqPlayerState->portamento = seqPlayerState->parentLayer->portamento;
-#else
+    #else
    vib->curve = gVibratoCurve;
    vib->seqChannel = note->parentLayer->seqChannel;
    seqChannel = vib->seqChannel;

-    if ((vib->extentChangeTimer = seqChannel->vibratoExtentChangeDelay) == 0) {
+    if ((vib->extentChangeTimer = seqChannel->vibratoExtentChangeDelay) == 0)
+    {
        vib->extent = seqChannel->vibratoExtentTarget;
-    } else {
+    }
+    else
+    {
        vib->extent = seqChannel->vibratoExtentStart;
    }

-    if ((vib->rateChangeTimer = seqChannel->vibratoRateChangeDelay) == 0) {
+    if ((vib->rateChangeTimer = seqChannel->vibratoRateChangeDelay) == 0)
+    {
        vib->rate = seqChannel->vibratoRateTarget;
-    } else {
+    }
+    else
+    {
        vib->rate = seqChannel->vibratoRateStart;
    }
    vib->delay = seqChannel->vibratoDelay;

    note->portamento = note->parentLayer->portamento;
-#endif
+    #endif
 }

-void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, UNUSED s16 *volOut) {
+void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, UNUSED s16 *volOut)
+{
    adsr->action = 0;
    adsr->state = ADSR_STATE_DISABLED;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    adsr->delay = 0;
    adsr->envelope = envelope;
-#ifdef VERSION_SH
+    #ifdef VERSION_SH
    adsr->sustain = 0.0f;
-#endif
+    #endif
    adsr->current = 0.0f;
-#else
+    #else
    adsr->initial = 0;
    adsr->delay = 0;
    adsr->velocity = 0;
    adsr->envelope = envelope;
    adsr->volOut = volOut;
-#endif
+    #endif
 }

 #if defined(VERSION_EU) || defined(VERSION_SH)
-f32 adsr_update(struct AdsrState *adsr) {
+f32 adsr_update(struct AdsrState *adsr)
+{
+
 #else
-s32 adsr_update(struct AdsrState *adsr) {
-#endif
+s32 adsr_update(struct AdsrState *adsr)
+{
+    #endif
    u8 action = adsr->action;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    u8 state = adsr->state;
    switch (state) {
-#else
-    switch (adsr->state) {
-#endif
+    #else
+    switch (adsr->state)
+    {
+            #endif
        case ADSR_STATE_DISABLED:
            return 0;

-        case ADSR_STATE_INITIAL: {
-#if defined(VERSION_JP) || defined(VERSION_US)
+        case ADSR_STATE_INITIAL:
+        {
+            #if defined(VERSION_JP) || defined(VERSION_US)
            adsr->current = adsr->initial;
            adsr->target = adsr->initial;
-#endif
-            if (action & ADSR_ACTION_HANG) {
+            #endif
+            if (action & ADSR_ACTION_HANG)
+            {
                adsr->state = ADSR_STATE_HANG;
                break;
            }
@@ -392,18 +458,19 @@ s32 adsr_update(struct AdsrState *adsr) {

        case ADSR_STATE_START_LOOP:
            adsr->envIndex = 0;
-#if defined(VERSION_JP) || defined(VERSION_US)
+            #if defined(VERSION_JP) || defined(VERSION_US)
            adsr->currentHiRes = adsr->current << 0x10;
-#endif
+            #endif
            adsr->state = ADSR_STATE_LOOP;
            // fallthrough

-#ifdef VERSION_SH
-            restart:
-#endif
+            #ifdef VERSION_SH
+        restart:
+            #endif
        case ADSR_STATE_LOOP:
            adsr->delay = BSWAP16(adsr->envelope[adsr->envIndex].delay);
-            switch (adsr->delay) {
+            switch (adsr->delay)
+            {
                case ADSR_DISABLE:
                    adsr->state = ADSR_STATE_DISABLED;
                    break;
@@ -412,134 +479,149 @@ s32 adsr_update(struct AdsrState *adsr) {
                    break;
                case ADSR_GOTO:
                    adsr->envIndex = BSWAP16(adsr->envelope[adsr->envIndex].arg);
-#ifdef VERSION_SH
+                    #ifdef VERSION_SH
                    goto restart;
-#else
+                    #else
                    break;
-#endif
+                    #endif
                case ADSR_RESTART:
                    adsr->state = ADSR_STATE_INITIAL;
                    break;

                default:
-#if defined(VERSION_EU) || defined(VERSION_SH)
-                    if (adsr->delay >= 4) {
+                    #if defined(VERSION_EU) || defined(VERSION_SH)
+                    if (adsr->delay >= 4)
+                    {
                        adsr->delay = adsr->delay * gAudioBufferParameters.updatesPerFrame
-#ifdef VERSION_SH
+                    #ifdef VERSION_SH
                        / gAudioBufferParameters.presetUnk4
-#endif
+                    #endif
                        / 4;
                    }
-#if defined(VERSION_SH)
-                    if (adsr->delay == 0) {
+                    #if defined(VERSION_SH)
+                    if (adsr->delay == 0)
+                    {
                        adsr->delay = 1;
                    }
-                    adsr->target = (f32) BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0f;
-#elif defined(VERSION_EU)
-                    adsr->target = (f32) BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0;
-#endif
+                    adsr->target = (f32)BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0f;
+                    #elif defined(VERSION_EU)
+                    adsr->target = (f32)BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0;
+                    #endif
                    adsr->target = adsr->target * adsr->target;
                    adsr->velocity = (adsr->target - adsr->current) / adsr->delay;
-#else
+                    #else
                    adsr->target = BSWAP16(adsr->envelope[adsr->envIndex].arg);
                    adsr->velocity = ((adsr->target - adsr->current) << 0x10) / adsr->delay;
-#endif
+                    #endif
                    adsr->state = ADSR_STATE_FADE;
                    adsr->envIndex++;
                    break;
            }
-            if (adsr->state != ADSR_STATE_FADE) {
+            if (adsr->state != ADSR_STATE_FADE)
+            {
                break;
            }
-            // fallthrough
+        // fallthrough

        case ADSR_STATE_FADE:
-#if defined(VERSION_EU) || defined(VERSION_SH)
+            #if defined(VERSION_EU) || defined(VERSION_SH)
            adsr->current += adsr->velocity;
-#else
+            #else
            adsr->currentHiRes += adsr->velocity;
            adsr->current = adsr->currentHiRes >> 0x10;
-#endif
-            if (--adsr->delay <= 0) {
+            #endif
+            if (--adsr->delay <= 0)
+            {
                adsr->state = ADSR_STATE_LOOP;
            }
-            // fallthrough
+        // fallthrough

        case ADSR_STATE_HANG:
            break;

        case ADSR_STATE_DECAY:
-        case ADSR_STATE_RELEASE: {
+        case ADSR_STATE_RELEASE:
+        {
            adsr->current -= adsr->fadeOutVel;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+            #if defined(VERSION_EU) || defined(VERSION_SH)
            if (adsr->sustain != 0.0f && state == ADSR_STATE_DECAY) {
-#else
-            if (adsr->sustain != 0 && adsr->state == ADSR_STATE_DECAY) {
-#endif
-                if (adsr->current < adsr->sustain) {
+            #else
+            if (adsr->sustain != 0 && adsr->state == ADSR_STATE_DECAY)
+            {
+                #endif
+                if (adsr->current < adsr->sustain)
+                {
                    adsr->current = adsr->sustain;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+                    #if defined(VERSION_EU) || defined(VERSION_SH)
                    adsr->delay = 128;
-#else
+                    #else
                    adsr->delay = adsr->sustain / 16;
-#endif
+                    #endif
                    adsr->state = ADSR_STATE_SUSTAIN;
                }
                break;
            }

-#if defined(VERSION_SH)
-            if (adsr->current < 0.00001f) {
+            #if defined(VERSION_SH)
+            if (adsr->current < 0.00001f)
+            {
                adsr->current = 0.0f;
                adsr->state = ADSR_STATE_DISABLED;
            }
-#elif defined(VERSION_EU)
-            if (adsr->current < 0) {
+            #elif defined(VERSION_EU)
+            if (adsr->current < 0)
+            {
                adsr->current = 0.0f;
                adsr->state = ADSR_STATE_DISABLED;
            }
-#else
-            if (adsr->current < 100) {
+            #else
+            if (adsr->current < 100)
+            {
                adsr->current = 0;
                adsr->state = ADSR_STATE_DISABLED;
            }
-#endif
+            #endif
            break;
        }

        case ADSR_STATE_SUSTAIN:
            adsr->delay -= 1;
-            if (adsr->delay == 0) {
+            if (adsr->delay == 0)
+            {
                adsr->state = ADSR_STATE_RELEASE;
            }
            break;
    }

-    if ((action & ADSR_ACTION_DECAY)) {
+    if (action & ADSR_ACTION_DECAY)
+    {
        adsr->state = ADSR_STATE_DECAY;
        adsr->action = action & ~ADSR_ACTION_DECAY;
    }

-    if ((action & ADSR_ACTION_RELEASE)) {
+    if (action & ADSR_ACTION_RELEASE)
+    {
        adsr->state = ADSR_STATE_RELEASE;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+        #if defined(VERSION_EU) || defined(VERSION_SH)
        adsr->action = action & ~ADSR_ACTION_RELEASE;
-#else
+        #else
        adsr->action = action & ~(ADSR_ACTION_RELEASE | ADSR_ACTION_DECAY);
-#endif
+        #endif
    }

-#if defined(VERSION_EU) || defined(VERSION_SH)
-    if (adsr->current < 0.0f) {
+    #if defined(VERSION_EU) || defined(VERSION_SH)
+    if (adsr->current < 0.0f)
+    {
        return 0.0f;
    }
-    if (adsr->current > 1.0f) {
+    if (adsr->current > 1.0f)
+    {
        eu_stubbed_printf_1("Audio:Envp: overflow  %f\n", adsr->current);
        return 1.0f;
    }
    return adsr->current;
-#else
+    #else
    *adsr->volOut = adsr->current;
    return 0;
-#endif
+    #endif
 }
@@ -36,8 +36,11 @@
 extern f32 gTrackVolume;

 void sequence_player_process_sound(struct SequencePlayer *seqPlayer);
+
 void note_vibrato_update(struct Note *note);
+
 void note_vibrato_init(struct Note *note);
+
 void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, s16 *volOut);
 #if defined(VERSION_EU) || defined(VERSION_SH)
 f32 adsr_update(struct AdsrState *adsr);
@@ -24,7 +24,8 @@ extern u32 gAudioRandom;
 extern f32 gAudioVolume;
 extern u8 gAudioReverb;

-struct Sound {
+struct Sound
+{
    s32 soundBits;
    f32 *position;
 }; // size = 0x8
@@ -35,39 +36,73 @@ extern u8 sSoundRequestCount;
 extern u8 gAudioSPTaskYieldBuffer[]; // ucode yield data ptr; only used in JP

 struct SPTask *create_next_audio_frame_task(void);
+
 void create_next_audio_buffer(s16 *samples, u32 num_samples);
+
 void audio_signal_game_loop_tick(void);
+
 void update_game_sound(void);
+
 void seq_player_fade_out(u8 player, u16 fadeDuration);
+
 void fade_volume_scale(u8 player, u8 targetScale, u16 fadeDuration);
+
 void seq_player_lower_volume(u8 player, u16 fadeDuration, u8 percentage);
+
 void seq_player_unlower_volume(u8 player, u16 fadeDuration);
+
 void set_audio_muted(u8 muted);
+
 void sound_init(void);
+
 void get_currently_playing_sound(u8 bank, u8 *numPlayingSounds, u8 *numSoundsInBank, u8 *soundId);
+
 void stop_sound(u32 soundBits, f32 *pos);
-void stop_sounds_from_source(f32 *pos);
+
+void stop_sounds_from_source(f32 * pos);
+
 void stop_sounds_in_continuous_banks(void);
+
 void sound_banks_disable(u8 player, u16 bankMask);
+
 void sound_banks_enable(u8 player, u16 bankMask);
+
 void set_sound_moving_speed(u8 bank, u8 speed);
+
 void play_dialog_sound(u8 dialogID);
+
 void play_music(u8 player, u16 seqArgs, u16 fadeTimer);
+
 void stop_background_music(u16 seqId);
+
 void fadeout_background_music(u16 arg0, u16 fadeOut);
+
 void drop_queued_background_music(void);
+
 u16 get_current_background_music(void);
+
 void play_secondary_music(u8 seqId, u8 bgMusicVolume, u8 volume, u16 fadeTimer);
+
 void func_80321080(u16 fadeTimer);
+
 void func_803210D4(u16 fadeOutTime);
+
 void play_course_clear(void);
+
 void play_peachs_jingle(void);
+
 void play_puzzle_jingle(void);
+
 void play_star_fanfare(void);
+
 void play_power_star_jingle(u8 arg0);
+
 void play_race_fanfare(void);
+
 void play_toads_jingle(void);
+
 void sound_reset(u8 presetId);
+
 void audio_set_sound_mode(u8 arg0);

 void audio_init(void); // in load.c
@@ -23,34 +23,41 @@ struct SoundAllocPool
    s32 numAllocatedEntries;
 }; // size = 0x10

-struct SeqOrBankEntry {
+struct SeqOrBankEntry
+{
    u8 *ptr;
    u32 size;
-#ifdef VERSION_SH
+    #ifdef VERSION_SH
    s16 poolIndex;
    s16 id;
-#else
+    #else
    s32 id; // seqId or bankId
-#endif
+    #endif
 }; // size = 0xC

 struct PersistentPool
 {
-    /*0x00*/ u32 numEntries;
-    /*0x04*/ struct SoundAllocPool pool;
-    /*0x14*/ struct SeqOrBankEntry entries[32];
+    /*0x00*/
+    u32 numEntries;
+    /*0x04*/
+    struct SoundAllocPool pool;
+    /*0x14*/
+    struct SeqOrBankEntry entries[32];
 }; // size = 0x194

 struct TemporaryPool
 {
    /*EU,   SH*/
-    /*0x00, 0x00*/ u32 nextSide;
-    /*0x04,     */ struct SoundAllocPool pool;
+    /*0x00, 0x00*/
+    u32 nextSide;
+    /*0x04,     */
+    struct SoundAllocPool pool;
    /*0x04,        pool.start     */
    /*0x08,        pool.cur       */
    /*0x0C, 0x0C   pool.size      */
    /*0x10, 0x10   pool.numAllocatedEntries */
-    /*0x14,     */ struct SeqOrBankEntry entries[2];
+    /*0x14,     */
+    struct SeqOrBankEntry entries[2];
    /*0x14, 0x14   entries[0].ptr */
    /*0x18,        entries[0].size*/
    /*0x1C, 0x1E   entries[0].id  */
@@ -61,9 +68,12 @@ struct TemporaryPool

 struct SoundMultiPool
 {
-    /*0x000*/ struct PersistentPool persistent;
-    /*0x194*/ struct TemporaryPool temporary;
-    /*     */ u32 pad2[4];
+    /*0x000*/
+    struct PersistentPool persistent;
+    /*0x194*/
+    struct TemporaryPool temporary;
+    /*     */
+    u32 pad2[4];
 }; // size = 0x1D0

 struct Unk1Pool
@@ -85,10 +95,14 @@ struct UnkEntry

 struct UnkPool
 {
-    /*0x00*/  struct SoundAllocPool pool;
-    /*0x10*/  struct UnkEntry entries[64];
-    /*0x510*/ s32 numEntries;
-    /*0x514*/ u32 unk514;
+    /*0x00*/
+    struct SoundAllocPool pool;
+    /*0x10*/
+    struct UnkEntry entries[64];
+    /*0x510*/
+    s32 numEntries;
+    /*0x514*/
+    u32 unk514;
 };

 extern u8 gAudioHeap[];
@@ -115,14 +129,18 @@ extern volatile u8 gAudioResetStatus;
 #endif

 void *soundAlloc(struct SoundAllocPool *pool, u32 size);
+
 void *sound_alloc_uninitialized(struct SoundAllocPool *pool, u32 size);
+
 void sound_init_main_pools(s32 sizeForAudioInitPool);
+
 void sound_alloc_pool_init(struct SoundAllocPool *pool, void *memAddr, u32 size);
 #ifdef VERSION_SH
 void *alloc_bank_or_seq(s32 poolIdx, s32 size, s32 arg3, s32 id);
 void *get_bank_or_seq(s32 poolIdx, s32 arg1, s32 id);
 #else
 void *alloc_bank_or_seq(struct SoundMultiPool *arg0, s32 arg1, s32 size, s32 arg3, s32 id);
+
 void *get_bank_or_seq(struct SoundMultiPool *arg0, s32 arg1, s32 id);
 #endif
 #if defined(VERSION_EU) || defined(VERSION_SH)
@@ -56,7 +56,8 @@ extern s8 gSoundMode;
 #ifdef VERSION_SH
 extern OSMesgQueue gUnkQueue1;

-struct UnkStructSH8034EC88 {
+struct UnkStructSH8034EC88
+{
    u8 *endAndMediumIdentification;
    struct AudioBankSample *sample;
    u8 *ramAddr;
@@ -64,7 +65,8 @@ struct UnkStructSH8034EC88 {
    s32 isFree;
 };

-struct PatchStruct {
+struct PatchStruct
+{
    s32 bankId1;
    s32 bankId2;
    void *baseAddr1;
@@ -78,7 +80,8 @@ extern struct UnkStructSH8034EC88 D_SH_8034EC88[0x80];

 struct AudioBank *bank_load_immediate(s32 bankId, s32 arg1);

-void audio_dma_partial_copy_async(uintptr_t *devAddr, u8 **vAddr, ssize_t *remaining, OSMesgQueue *queue, OSIoMesg *mesg);
+void audio_dma_partial_copy_async(uintptr_t * devAddr, u8 * *vAddr, ssize_t * remaining, OSMesgQueue * queue, OSIoMesg * mesg);
+
 void decrease_sample_dma_ttls(void);
 #ifdef VERSION_SH
 void *dma_sample_data(uintptr_t devAddr, u32 size, s32 arg2, u8 *dmaIndexRef, s32 medium);
@@ -105,7 +108,7 @@ struct AudioBankSample *func_sh_802f4978(s32 bankId, s32 idx);
 s32 func_sh_802f47c8(s32 bankId, u8 idx, s8 *io);
 void *func_sh_802f3f08(s32 poolIdx, s32 arg1, s32 arg2, s32 arg3, OSMesgQueue *retQueue);
 void func_sh_802f41e4(s32 audioResetStatus);
-BAD_RETURN(s32) func_sh_802f3368(s32 bankId);
+BAD_RETURN (s32) func_sh_802f3368(s32 bankId);
 void *func_sh_802f3764(s32 arg0, s32 idx, s32 *arg2);
 s32 func_sh_802f3024(s32 bankId, s32 instId, s32 arg2);
 void func_sh_802f30f4(s32 arg0, s32 arg1, s32 arg2, OSMesgQueue *arg3);
@@ -7,5 +7,5 @@ struct seqFile *gSoundDataRaw;
 struct seqFile *gMusicData;

 #ifndef VERSION_SH
-unsigned char* gBankSetsData;
+unsigned char *gBankSetsData;
 #endif
@@ -17,17 +17,29 @@
 #define NOTE_ALLOC_GLOBAL_FREELIST 8

 void process_notes(void);
+
 void seq_channel_layer_note_decay(struct SequenceChannelLayer *seqLayer);
+
 void seq_channel_layer_note_release(struct SequenceChannelLayer *seqLayer);
+
 void init_synthetic_wave(struct Note *note, struct SequenceChannelLayer *seqLayer);
+
 void init_note_lists(struct NotePool *pool);
+
 void init_note_free_list(void);
+
 void note_pool_clear(struct NotePool *pool);
+
 void note_pool_fill(struct NotePool *pool, s32 count);
+
 void audio_list_push_front(struct AudioListItem *list, struct AudioListItem *item);
+
 void audio_list_remove(struct AudioListItem *item);
+
 struct Note *alloc_note(struct SequenceChannelLayer *seqLayer);
+
 void reclaim_notes(void);
+
 void note_init_all(void);

 #if defined(VERSION_SH)
@@ -34,7 +34,8 @@ s32 audio_shut_down_and_reset_step(void);
 void func_802ad7ec(u32);

 #ifdef TARGET_N64
-struct SPTask *create_next_audio_frame_task(void) {
+struct SPTask *create_next_audio_frame_task(void)
+{
    u32 samplesRemainingInAI;
    s32 writtenCmds;
    s32 index;
@@ -46,12 +47,13 @@ struct SPTask *create_next_audio_frame_task(void) {
    OSMesg sp2C;

    gAudioFrameCount++;
-    if (gAudioFrameCount % gAudioBufferParameters.presetUnk4 != 0) {
+    if (gAudioFrameCount % gAudioBufferParameters.presetUnk4 != 0)
+    {
        stubbed_printf("DAC:Lost 1 Frame.\n");
-        return NULL;
+        return nullptr;
    }

-    osSendMesg(OSMesgQueues[0], (OSMesg) gAudioFrameCount, 0);
+    osSendMesg(OSMesgQueues[0], (OSMesg)gAudioFrameCount, 0);

    gAudioTaskIndex ^= 1;
    gCurrAiBufferIndex++;
@@ -59,28 +61,35 @@ struct SPTask *create_next_audio_frame_task(void) {
    index = (gCurrAiBufferIndex - 2 + NUMAIBUFFERS) % NUMAIBUFFERS;
    samplesRemainingInAI = osAiGetLength() / 4;

-    if (gAiBufferLengths[index] != 0) {
+    if (gAiBufferLengths[index] != 0)
+    {
        osAiSetNextBuffer(gAiBuffers[index], gAiBufferLengths[index] * 4);
    }

    oldDmaCount = gCurrAudioFrameDmaCount;
-    if (oldDmaCount > AUDIO_FRAME_DMA_QUEUE_SIZE) {
+    if (oldDmaCount > AUDIO_FRAME_DMA_QUEUE_SIZE)
+    {
        stubbed_printf("DMA: Request queue over.( %d )\n", oldDmaCount);
    }
    gCurrAudioFrameDmaCount = 0;

    decrease_sample_dma_ttls();
-    if (osRecvMesg(OSMesgQueues[2], &sp30, 0) != -1) {
-        gAudioResetPresetIdToLoad = (u8) (s32) sp30;
+    if (osRecvMesg(OSMesgQueues[2], &sp30, 0) != -1)
+    {
+        gAudioResetPresetIdToLoad = (u8)(s32)
+        sp30;
        gAudioResetStatus = 5;
    }

-    if (gAudioResetStatus != 0) {
-        if (audio_shut_down_and_reset_step() == 0) {
-            if (gAudioResetStatus == 0) {
-                osSendMesg(OSMesgQueues[3], (OSMesg) (s32) gAudioResetPresetIdToLoad, OS_MESG_NOBLOCK);
+    if (gAudioResetStatus != 0)
+    {
+        if (audio_shut_down_and_reset_step() == 0)
+        {
+            if (gAudioResetStatus == 0)
+            {
+                osSendMesg(OSMesgQueues[3], (OSMesg)(s32) gAudioResetPresetIdToLoad, OS_MESG_NOBLOCK);
            }
-            return NULL;
+            return nullptr;
        }
    }

@@ -90,16 +99,19 @@ struct SPTask *create_next_audio_frame_task(void) {
    currAiBuffer = gAiBuffers[index];

    gAiBufferLengths[index] = ((gAudioBufferParameters.samplesPerFrameTarget - samplesRemainingInAI +
-         EXTRA_BUFFERED_AI_SAMPLES_TARGET) & ~0xf) + SAMPLES_TO_OVERPRODUCE;
-    if (gAiBufferLengths[index] < gAudioBufferParameters.minAiBufferLength) {
+                                EXTRA_BUFFERED_AI_SAMPLES_TARGET) & ~0xf) + SAMPLES_TO_OVERPRODUCE;
+    if (gAiBufferLengths[index] < gAudioBufferParameters.minAiBufferLength)
+    {
        gAiBufferLengths[index] = gAudioBufferParameters.minAiBufferLength;
    }
-    if (gAiBufferLengths[index] > gAudioBufferParameters.maxAiBufferLength) {
+    if (gAiBufferLengths[index] > gAudioBufferParameters.maxAiBufferLength)
+    {
        gAiBufferLengths[index] = gAudioBufferParameters.maxAiBufferLength;
    }

-    if (osRecvMesg(OSMesgQueues[1], &sp2C, OS_MESG_NOBLOCK) != -1) {
-        func_802ad7ec((u32) sp2C);
+    if (osRecvMesg(OSMesgQueues[1], &sp2C, OS_MESG_NOBLOCK) != -1)
+    {
+        func_802ad7ec((u32)sp2C);
    }

    flags = 0;
@@ -108,48 +120,54 @@ struct SPTask *create_next_audio_frame_task(void) {
    gAudioRandom = gAudioRandom + writtenCmds / 8;

    index = gAudioTaskIndex;
-    gAudioTask->msgqueue = NULL;
-    gAudioTask->msg = NULL;
+    gAudioTask->msgqueue = nullptr;
+    gAudioTask->msg = nullptr;

    task = &gAudioTask->task.t;
    task->type = M_AUDTASK;
    task->flags = flags;
    task->ucode_boot = rspF3DBootStart;
-    task->ucode_boot_size = (u8 *) rspF3DBootEnd - (u8 *) rspF3DBootStart;
+    task->ucode_boot_size = (u8 *)rspF3DBootEnd - (u8 *)rspF3DBootStart;
    task->ucode = rspAspMainStart;
    task->ucode_data = rspAspMainDataStart;
    task->ucode_size = 0x800; // (this size is ignored)
    task->ucode_data_size = (rspAspMainDataEnd - rspAspMainDataStart) * sizeof(u64);
-    task->dram_stack = NULL;
+    task->dram_stack = nullptr;
    task->dram_stack_size = 0;
-    task->output_buff = NULL;
-    task->output_buff_size = NULL;
+    task->output_buff = nullptr;
+    task->output_buff_size = nullptr;
    task->data_ptr = gAudioCmdBuffers[index];
    task->data_size = writtenCmds * sizeof(u64);
-    task->yield_data_ptr = NULL;
+    task->yield_data_ptr = nullptr;
    task->yield_data_size = 0;
    return gAudioTask;
 }
 #else
-struct SPTask *create_next_audio_frame_task(void) {
-    return NULL;
+struct SPTask *create_next_audio_frame_task(void)
+{
+    return nullptr;
 }
-void create_next_audio_buffer(s16 *samples, u32 num_samples) {
+void create_next_audio_buffer(s16 *samples, u32 num_samples)
+{
    s32 writtenCmds;
    OSMesg msg;
    gAudioFrameCount++;
    decrease_sample_dma_ttls();
-    if (osRecvMesg(OSMesgQueues[2], &msg, 0) != -1) {
-        gAudioResetPresetIdToLoad = (u8) (intptr_t) msg;
+    if (osRecvMesg(OSMesgQueues[2], &msg, 0) != -1)
+    {
+        gAudioResetPresetIdToLoad = (u8)(intptr_t)
+        msg;
        gAudioResetStatus = 5;
    }

-    if (gAudioResetStatus != 0) {
+    if (gAudioResetStatus != 0)
+    {
        audio_reset_session();
        gAudioResetStatus = 0;
    }
-    if (osRecvMesg(OSMesgQueues[1], &msg, OS_MESG_NOBLOCK) != -1) {
-        func_802ad7ec((u32) msg);
+    if (osRecvMesg(OSMesgQueues[1], &msg, OS_MESG_NOBLOCK) != -1)
+    {
+        func_802ad7ec((u32)msg);
    }
    synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples);
    gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount);
@@ -157,48 +175,55 @@ void create_next_audio_buffer(s16 *samples, u32 num_samples) {
 }
 #endif

-void eu_process_audio_cmd(struct EuAudioCmd *cmd) {
+void eu_process_audio_cmd(struct EuAudioCmd *cmd)
+{
    s32 i;

-    switch (cmd->u.s.op) {
-    case 0x81:
-        preload_sequence(cmd->u.s.arg2, 3);
-        break;
+    switch (cmd->u.s.op)
+    {
+        case 0x81:
+            preload_sequence(cmd->u.s.arg2, 3);
+            break;

-    case 0x82:
-    case 0x88:
-        load_sequence(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3);
-        func_8031D690(cmd->u.s.arg1, cmd->u2.as_s32);
-        break;
+        case 0x82:
+        case 0x88:
+            load_sequence(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3);
+            func_8031D690(cmd->u.s.arg1, cmd->u2.as_s32);
+            break;

-    case 0x83:
-        if (gSequencePlayers[cmd->u.s.arg1].enabled != FALSE) {
-            if (cmd->u2.as_s32 == 0) {
-                sequence_player_disable(&gSequencePlayers[cmd->u.s.arg1]);
+        case 0x83:
+            if (gSequencePlayers[cmd->u.s.arg1].enabled != FALSE)
+            {
+                if (cmd->u2.as_s32 == 0)
+                {
+                    sequence_player_disable(&gSequencePlayers[cmd->u.s.arg1]);
+                }
+                else
+                {
+                    seq_player_fade_to_zero_volume(cmd->u.s.arg1, cmd->u2.as_s32);
+                }
            }
-            else {
-                seq_player_fade_to_zero_volume(cmd->u.s.arg1, cmd->u2.as_s32);
+            break;
+
+        case 0xf0:
+            gSoundMode = cmd->u2.as_s32;
+            break;
+
+        case 0xf1:
+            for (i = 0; i < 4; i++)
+            {
+                gSequencePlayers[i].muted = TRUE;
+                gSequencePlayers[i].recalculateVolume = TRUE;
            }
-        }
-        break;
+            break;

-    case 0xf0:
-        gSoundMode = cmd->u2.as_s32;
-        break;
-
-    case 0xf1:
-        for (i = 0; i < 4; i++) {
-            gSequencePlayers[i].muted = TRUE;
-            gSequencePlayers[i].recalculateVolume = TRUE;
-        }
-        break;
-
-    case 0xf2:
-        for (i = 0; i < 4; i++) {
-            gSequencePlayers[i].muted = FALSE;
-            gSequencePlayers[i].recalculateVolume = TRUE;
-        }
-        break;
+        case 0xf2:
+            for (i = 0; i < 4; i++)
+            {
+                gSequencePlayers[i].muted = FALSE;
+                gSequencePlayers[i].recalculateVolume = TRUE;
+            }
+            break;
    }
 }

@@ -212,18 +237,21 @@ extern OSMesg OSMesg1;
 extern OSMesg OSMesg2;
 extern OSMesg OSMesg3;

-void seq_player_fade_to_zero_volume(s32 player, FadeT fadeOutTime) {
-    if (fadeOutTime == 0) {
+void seq_player_fade_to_zero_volume(s32 player, FadeT fadeOutTime)
+{
+    if (fadeOutTime == 0)
+    {
        fadeOutTime = 1;
    }
    gSequencePlayers[player].fadeVelocity = -(gSequencePlayers[player].fadeVolume / fadeOutTime);
    gSequencePlayers[player].state = 2;
    gSequencePlayers[player].fadeRemainingFrames = fadeOutTime;
-
 }

-void func_8031D690(s32 player, FadeT fadeInTime) {
-    if (fadeInTime != 0) {
+void func_8031D690(s32 player, FadeT fadeInTime)
+{
+    if (fadeInTime != 0)
+    {
        gSequencePlayers[player].state = 1;
        gSequencePlayers[player].fadeTimerUnkEu = fadeInTime;
        gSequencePlayers[player].fadeRemainingFrames = fadeInTime;
@@ -232,7 +260,8 @@ void func_8031D690(s32 player, FadeT fadeInTime) {
    }
 }

-void port_eu_init_queues(void) {
+void port_eu_init_queues(void)
+{
    D_EU_80302010 = 0;
    D_EU_80302014 = 0;
    osCreateMesgQueue(OSMesgQueues[0], &OSMesg0, 1);
@@ -241,100 +270,114 @@ void port_eu_init_queues(void) {
    osCreateMesgQueue(OSMesgQueues[3], &OSMesg3, 1);
 }

-void func_802ad6f0(s32 arg0, s32 *arg1) {
+void func_802ad6f0(s32 arg0, s32 *arg1)
+{
    struct EuAudioCmd *cmd = &sAudioCmd[D_EU_80302010 & 0xff];
    cmd->u.first = arg0;
    cmd->u2.as_u32 = *arg1;
    D_EU_80302010++;
 }

-void func_802ad728(u32 arg0, f32 arg1) {
-    func_802ad6f0(arg0, (s32*) &arg1);
+void func_802ad728(u32 arg0, f32 arg1)
+{
+    func_802ad6f0(arg0, (s32 *)&arg1);
 }

-void func_802ad74c(u32 arg0, u32 arg1) {
-    func_802ad6f0(arg0, (s32*) &arg1);
+void func_802ad74c(u32 arg0, u32 arg1)
+{
+    func_802ad6f0(arg0, (s32 *)&arg1);
 }

-void func_802ad770(u32 arg0, s8 arg1) {
+void func_802ad770(u32 arg0, s8 arg1)
+{
    s32 sp1C = arg1 << 24;
    func_802ad6f0(arg0, &sp1C);
 }

-void func_802ad7a0(void) {
+void func_802ad7a0(void)
+{
    osSendMesg(OSMesgQueues[1],
-            (OSMesg)(u32)((D_EU_80302014 & 0xff) << 8 | (D_EU_80302010 & 0xff)),
-            OS_MESG_NOBLOCK);
+               (OSMesg)(u32)((D_EU_80302014 & 0xff) << 8 | (D_EU_80302010 & 0xff)),
+               OS_MESG_NOBLOCK);
    D_EU_80302014 = D_EU_80302010;
 }

-void func_802ad7ec(u32 arg0) {
+void func_802ad7ec(u32 arg0)
+{
    struct EuAudioCmd *cmd;
    struct SequencePlayer *seqPlayer;
    struct SequenceChannel *chan;
    u8 end = arg0 & 0xff;
    u8 i = (arg0 >> 8) & 0xff;

-    for (;;) {
+    for (;;)
+    {
        if (i == end) break;
        cmd = &sAudioCmd[i++ & 0xff];

-        if (cmd->u.s.arg1 < SEQUENCE_PLAYERS) {
+        if (cmd->u.s.arg1 < SEQUENCE_PLAYERS)
+        {
            seqPlayer = &gSequencePlayers[cmd->u.s.arg1];
-            if ((cmd->u.s.op & 0x80) != 0) {
+            if ((cmd->u.s.op & 0x80) != 0)
+            {
                eu_process_audio_cmd(cmd);
            }
-            else if ((cmd->u.s.op & 0x40) != 0) {
-                switch (cmd->u.s.op) {
-                case 0x41:
-                    seqPlayer->fadeVolumeScale = cmd->u2.as_f32;
-                    seqPlayer->recalculateVolume = TRUE;
-                    break;
+            else if ((cmd->u.s.op & 0x40) != 0)
+            {
+                switch (cmd->u.s.op)
+                {
+                    case 0x41:
+                        seqPlayer->fadeVolumeScale = cmd->u2.as_f32;
+                        seqPlayer->recalculateVolume = TRUE;
+                        break;

-                case 0x47:
-                    seqPlayer->tempo = cmd->u2.as_s32 * TATUMS_PER_BEAT;
-                    break;
+                    case 0x47:
+                        seqPlayer->tempo = cmd->u2.as_s32 * TATUMS_PER_BEAT;
+                        break;

-                case 0x48:
-                    seqPlayer->transposition = cmd->u2.as_s8;
-                    break;
+                    case 0x48:
+                        seqPlayer->transposition = cmd->u2.as_s8;
+                        break;

-                case 0x46:
-                    seqPlayer->seqVariationEu[cmd->u.s.arg3] = cmd->u2.as_s8;
-                    break;
+                    case 0x46:
+                        seqPlayer->seqVariationEu[cmd->u.s.arg3] = cmd->u2.as_s8;
+                        break;
                }
            }
-            else if (seqPlayer->enabled != FALSE && cmd->u.s.arg2 < 0x10) {
+            else if (seqPlayer->enabled != FALSE && cmd->u.s.arg2 < 0x10)
+            {
                chan = seqPlayer->channels[cmd->u.s.arg2];
                if (IS_SEQUENCE_CHANNEL_VALID(chan))
                {
-                    switch (cmd->u.s.op) {
-                    case 1:
-                        chan->volumeScale = cmd->u2.as_f32;
-                        chan->changes.as_bitfields.volume = TRUE;
-                        break;
-                    case 2:
-                        chan->volume = cmd->u2.as_f32;
-                        chan->changes.as_bitfields.volume = TRUE;
-                        break;
-                    case 3:
-                        chan->newPan = cmd->u2.as_s8;
-                        chan->changes.as_bitfields.pan = TRUE;
-                        break;
-                    case 4:
-                        chan->freqScale = cmd->u2.as_f32;
-                        chan->changes.as_bitfields.freqScale = TRUE;
-                        break;
-                    case 5:
-                        chan->reverbVol = cmd->u2.as_s8;
-                        break;
-                    case 6:
-                        if (cmd->u.s.arg3 < 8) {
-                            chan->soundScriptIO[cmd->u.s.arg3] = cmd->u2.as_s8;
-                        }
-                        break;
-                    case 8:
-                        chan->stopSomething2 = cmd->u2.as_s8;
+                    switch (cmd->u.s.op)
+                    {
+                        case 1:
+                            chan->volumeScale = cmd->u2.as_f32;
+                            chan->changes.as_bitfields.volume = TRUE;
+                            break;
+                        case 2:
+                            chan->volume = cmd->u2.as_f32;
+                            chan->changes.as_bitfields.volume = TRUE;
+                            break;
+                        case 3:
+                            chan->newPan = cmd->u2.as_s8;
+                            chan->changes.as_bitfields.pan = TRUE;
+                            break;
+                        case 4:
+                            chan->freqScale = cmd->u2.as_f32;
+                            chan->changes.as_bitfields.freqScale = TRUE;
+                            break;
+                        case 5:
+                            chan->reverbVol = cmd->u2.as_s8;
+                            break;
+                        case 6:
+                            if (cmd->u.s.arg3 < 8)
+                            {
+                                chan->soundScriptIO[cmd->u.s.arg3] = cmd->u2.as_s8;
+                            }
+                            break;
+                        case 8:
+                            chan->stopSomething2 = cmd->u2.as_s8;
                    }
                }
            }
@@ -344,7 +387,8 @@ void func_802ad7ec(u32 arg0) {
    }
 }

-void port_eu_init(void) {
+void port_eu_init(void)
+{
    port_eu_init_queues();
 }

@@ -24,7 +24,8 @@ void seq_player_fade_to_zero_volume(s32 arg0, s32 numFrames);
 void func_802ad7ec(u32 arg0);

 #ifdef TARGET_N64
-struct SPTask *create_next_audio_frame_task(void) {
+struct SPTask *create_next_audio_frame_task(void)
+{
    u32 samplesRemainingInAI;
    s32 writtenCmds;
    s32 index;
@@ -37,13 +38,15 @@ struct SPTask *create_next_audio_frame_task(void) {
    s32 writtenCmdsCopy;

    gAudioFrameCount++;
-    if (gAudioFrameCount % gAudioBufferParameters.presetUnk4 != 0) {
-        if ((gAudioFrameCount % gAudioBufferParameters.presetUnk4) + 1 == gAudioBufferParameters.presetUnk4) {
+    if (gAudioFrameCount % gAudioBufferParameters.presetUnk4 != 0)
+    {
+        if ((gAudioFrameCount % gAudioBufferParameters.presetUnk4) + 1 == gAudioBufferParameters.presetUnk4)
+        {
            return D_SH_80314FCC;
        }
-        return NULL;
+        return nullptr;
    }
-    osSendMesg(D_SH_80350F38, (OSMesg) gAudioFrameCount, OS_MESG_NOBLOCK);
+    osSendMesg(D_SH_80350F38, (OSMesg)gAudioFrameCount, OS_MESG_NOBLOCK);

    gAudioTaskIndex ^= 1;
    gCurrAiBufferIndex++;
@@ -51,123 +54,149 @@ struct SPTask *create_next_audio_frame_task(void) {
    index = (gCurrAiBufferIndex - 2 + NUMAIBUFFERS) % NUMAIBUFFERS;
    samplesRemainingInAI = osAiGetLength() / 4;

-    if (gAudioLoadLockSH < 0x10U) {
-        if (gAiBufferLengths[index] != 0) {
+    if (gAudioLoadLockSH < 0x10U)
+    {
+        if (gAiBufferLengths[index] != 0)
+        {
            osAiSetNextBuffer(gAiBuffers[index], gAiBufferLengths[index] * 4);
        }
    }

    oldDmaCount = gCurrAudioFrameDmaCount;
-    if (oldDmaCount > AUDIO_FRAME_DMA_QUEUE_SIZE) {
+    if (oldDmaCount > AUDIO_FRAME_DMA_QUEUE_SIZE)
+    {
    }
    gCurrAudioFrameDmaCount = 0;

    decrease_sample_dma_ttls();
    func_sh_802f41e4(gAudioResetStatus);
-    if (osRecvMesg(D_SH_80350F88, (OSMesg *) &sp38, OS_MESG_NOBLOCK) != -1) {
-        if (gAudioResetStatus == 0) {
+    if (osRecvMesg(D_SH_80350F88, (OSMesg *)&sp38, OS_MESG_NOBLOCK) != -1)
+    {
+        if (gAudioResetStatus == 0)
+        {
            gAudioResetStatus = 5;
        }
-        gAudioResetPresetIdToLoad = (u8) sp38;
+        gAudioResetPresetIdToLoad = (u8)sp38;
    }

-    if (gAudioResetStatus != 0) {
-        if (audio_shut_down_and_reset_step() == 0) {
-            if (gAudioResetStatus == 0) {
-                osSendMesg(D_SH_80350FA8, (OSMesg) (s32) gAudioResetPresetIdToLoad, OS_MESG_NOBLOCK);
+    if (gAudioResetStatus != 0)
+    {
+        if (audio_shut_down_and_reset_step() == 0)
+        {
+            if (gAudioResetStatus == 0)
+            {
+                osSendMesg(D_SH_80350FA8, (OSMesg)(s32) gAudioResetPresetIdToLoad, OS_MESG_NOBLOCK);
            }
            D_SH_80314FCC = 0;
-            return NULL;
+            return nullptr;
        }
    }
-    if (gAudioLoadLockSH >= 0x11U) {
-        return NULL;
+    if (gAudioLoadLockSH >= 0x11U)
+    {
+        return nullptr;
    }
-    if (gAudioLoadLockSH != 0) {
+    if (gAudioLoadLockSH != 0)
+    {
        gAudioLoadLockSH++;
    }

    gAudioTask = &gAudioTasks[gAudioTaskIndex];
-    gAudioCmd = (u64 *) gAudioCmdBuffers[gAudioTaskIndex];
+    gAudioCmd = (u64 *)gAudioCmdBuffers[gAudioTaskIndex];
    index = gCurrAiBufferIndex;
    currAiBuffer = gAiBuffers[index];

-    gAiBufferLengths[index] = (s16) ((((gAudioBufferParameters.samplesPerFrameTarget - samplesRemainingInAI) +
-         EXTRA_BUFFERED_AI_SAMPLES_TARGET) & ~0xf) + SAMPLES_TO_OVERPRODUCE);
-    if (gAiBufferLengths[index] < gAudioBufferParameters.minAiBufferLength) {
+    gAiBufferLengths[index] = (s16)((((gAudioBufferParameters.samplesPerFrameTarget - samplesRemainingInAI) +
+                                      EXTRA_BUFFERED_AI_SAMPLES_TARGET) & ~0xf) + SAMPLES_TO_OVERPRODUCE);
+    if (gAiBufferLengths[index] < gAudioBufferParameters.minAiBufferLength)
+    {
        gAiBufferLengths[index] = gAudioBufferParameters.minAiBufferLength;
    }
-    if (gAiBufferLengths[index] > gAudioBufferParameters.maxAiBufferLength) {
+    if (gAiBufferLengths[index] > gAudioBufferParameters.maxAiBufferLength)
+    {
        gAiBufferLengths[index] = gAudioBufferParameters.maxAiBufferLength;
    }

-    if (osRecvMesg(D_SH_80350F68, (OSMesg *) &sp34, 0) != -1) {
-        do {
+    if (osRecvMesg(D_SH_80350F68, (OSMesg *)&sp34, 0) != -1)
+    {
+        do
+        {
            func_802ad7ec(sp34);
-        } while (osRecvMesg(D_SH_80350F68, (OSMesg *) &sp34, 0) != -1);
+        }
+        while (osRecvMesg(D_SH_80350F68, (OSMesg *)&sp34, 0) != -1);
    }

    flags = 0;
    gAudioCmd = synthesis_execute(gAudioCmd, &writtenCmds, currAiBuffer, gAiBufferLengths[index]);
-    gAudioRandom = (u32) (osGetCount() * (gAudioRandom + gAudioFrameCount));
-    gAudioRandom = (u32) (gAiBuffers[index][gAudioFrameCount & 0xFF] + gAudioRandom);
+    gAudioRandom = (u32)(osGetCount() * (gAudioRandom + gAudioFrameCount));
+    gAudioRandom = (u32)(gAiBuffers[index][gAudioFrameCount & 0xFF] + gAudioRandom);

    index = gAudioTaskIndex;
-    gAudioTask->msgqueue = NULL;
-    gAudioTask->msg = NULL;
+    gAudioTask->msgqueue = nullptr;
+    gAudioTask->msg = nullptr;

    task = &gAudioTask->task.t;
    task->type = M_AUDTASK;
    task->flags = flags;
    task->ucode_boot = rspF3DBootStart;
-    task->ucode_boot_size = (u8 *) rspF3DStart - (u8 *) rspF3DBootStart;
+    task->ucode_boot_size = (u8 *)rspF3DStart - (u8 *)rspF3DBootStart;
    task->ucode = rspAspMainStart;
    task->ucode_data = rspAspMainDataStart;
    task->ucode_size = 0x1000;
    task->ucode_data_size = (rspAspMainDataEnd - rspAspMainDataStart) * sizeof(u64);
-    task->dram_stack = NULL;
+    task->dram_stack = nullptr;
    task->dram_stack_size = 0;
-    task->output_buff = NULL;
-    task->output_buff_size = NULL;
+    task->output_buff = nullptr;
+    task->output_buff_size = nullptr;
    task->data_ptr = gAudioCmdBuffers[index];
    task->data_size = writtenCmds * sizeof(u64);
-    task->yield_data_ptr = NULL;
+    task->yield_data_ptr = nullptr;
    task->yield_data_size = 0;

    writtenCmdsCopy = writtenCmds;
-    if (D_SH_80314FC8 < writtenCmdsCopy) {
+    if (D_SH_80314FC8 < writtenCmdsCopy)
+    {
        D_SH_80314FC8 = writtenCmdsCopy;
    }

-    if (gAudioBufferParameters.presetUnk4 == 1) {
+    if (gAudioBufferParameters.presetUnk4 == 1)
+    {
        return gAudioTask;
-    } else {
+    }
+    else
+    {
        D_SH_80314FCC = gAudioTask;
-        return NULL;
+        return nullptr;
    }
 }
 #else
-struct SPTask *create_next_audio_frame_task(void) {
-    return NULL;
+struct SPTask *create_next_audio_frame_task(void)
+{
+    return nullptr;
 }
-void create_next_audio_buffer(s16 *samples, u32 num_samples) {
+void create_next_audio_buffer(s16 *samples, u32 num_samples)
+{
    s32 writtenCmds;
    OSMesg msg;
    gAudioFrameCount++;
    decrease_sample_dma_ttls();
-    if (osRecvMesg(D_SH_80350F88, &msg, 0) != -1) {
-        gAudioResetPresetIdToLoad = (u8) (intptr_t) msg;
-        if (gAudioResetStatus == 0) {
+    if (osRecvMesg(D_SH_80350F88, &msg, 0) != -1)
+    {
+        gAudioResetPresetIdToLoad = (u8)(intptr_t)
+        msg;
+        if (gAudioResetStatus == 0)
+        {
            gAudioResetStatus = 5;
        }
    }

-    if (gAudioResetStatus != 0) {
+    if (gAudioResetStatus != 0)
+    {
        audio_reset_session();
        gAudioResetStatus = 0;
    }
-    while (osRecvMesg(D_SH_80350F68, &msg, OS_MESG_NOBLOCK) != -1) {
-        func_802ad7ec((u32) msg);
+    while (osRecvMesg(D_SH_80350F68, &msg, OS_MESG_NOBLOCK) != -1)
+    {
+        func_802ad7ec((u32)msg);
    }
    synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples);
    gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount);
@@ -176,99 +205,114 @@ void create_next_audio_buffer(s16 *samples, u32 num_samples) {
 }
 #endif

-void eu_process_audio_cmd(struct EuAudioCmd *cmd) {
+void eu_process_audio_cmd(struct EuAudioCmd *cmd)
+{
    s32 i;
    struct Note *note;
    struct NoteSubEu *sub;

-    switch (cmd->u.s.op) {
-    case 0x81:
-        preload_sequence(cmd->u.s.arg2, 3);
-        break;
+    switch (cmd->u.s.op)
+    {
+        case 0x81:
+            preload_sequence(cmd->u.s.arg2, 3);
+            break;

-    case 0x82:
-    case 0x88:
-        load_sequence(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3);
-        func_8031D690(cmd->u.s.arg1, cmd->u2.as_s32);
-        break;
+        case 0x82:
+        case 0x88:
+            load_sequence(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3);
+            func_8031D690(cmd->u.s.arg1, cmd->u2.as_s32);
+            break;

-    case 0x83:
-        if (gSequencePlayers[cmd->u.s.arg1].enabled != FALSE) {
-            if (cmd->u2.as_s32 == 0) {
-                sequence_player_disable(&gSequencePlayers[cmd->u.s.arg1]);
+        case 0x83:
+            if (gSequencePlayers[cmd->u.s.arg1].enabled != FALSE)
+            {
+                if (cmd->u2.as_s32 == 0)
+                {
+                    sequence_player_disable(&gSequencePlayers[cmd->u.s.arg1]);
+                }
+                else
+                {
+                    seq_player_fade_to_zero_volume(cmd->u.s.arg1, cmd->u2.as_s32);
+                }
            }
-            else {
-                seq_player_fade_to_zero_volume(cmd->u.s.arg1, cmd->u2.as_s32);
+            break;
+
+        case 0x84:
+            break;
+
+        case 0xf0:
+            gSoundMode = cmd->u2.as_s32;
+            break;
+
+        case 0xf1:
+            for (i = 0; i < 4; i++)
+            {
+                gSequencePlayers[i].muted = TRUE;
+                gSequencePlayers[i].recalculateVolume = TRUE;
            }
-        }
-        break;
+            break;

-    case 0x84:
-        break;
-
-    case 0xf0:
-        gSoundMode = cmd->u2.as_s32;
-        break;
-
-    case 0xf1:
-        for (i = 0; i < 4; i++) {
-            gSequencePlayers[i].muted = TRUE;
-            gSequencePlayers[i].recalculateVolume = TRUE;
-        }
-        break;
-
-    case 0xf2:
-        if (cmd->u2.as_s32 == 1) {
-            for (i = 0; i < gMaxSimultaneousNotes; i++) {
-                note = &gNotes[i];
-                sub = &note->noteSubEu;
-                if (note->noteSubEu.enabled && note->unkSH34 == 0) {
-                    if ((note->parentLayer->seqChannel->muteBehavior & 8) != 0) {
-                        sub->finished = TRUE;
+        case 0xf2:
+            if (cmd->u2.as_s32 == 1)
+            {
+                for (i = 0; i < gMaxSimultaneousNotes; i++)
+                {
+                    note = &gNotes[i];
+                    sub = &note->noteSubEu;
+                    if (note->noteSubEu.enabled && note->unkSH34 == 0)
+                    {
+                        if ((note->parentLayer->seqChannel->muteBehavior & 8) != 0)
+                        {
+                            sub->finished = TRUE;
+                        }
                    }
                }
            }
-        }
-        for (i = 0; i < 4; i++) {
-            gSequencePlayers[i].muted = FALSE;
-            gSequencePlayers[i].recalculateVolume = TRUE;
-        }
-        break;
+            for (i = 0; i < 4; i++)
+            {
+                gSequencePlayers[i].muted = FALSE;
+                gSequencePlayers[i].recalculateVolume = TRUE;
+            }
+            break;

-    case 0xf3:
-        func_sh_802f3024(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3);
-        break;
+        case 0xf3:
+            func_sh_802f3024(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3);
+            break;

-    case 0xf4:
-        func_sh_802f30f4(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3, &gUnkQueue1);
-        break;
+        case 0xf4:
+            func_sh_802f30f4(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3, &gUnkQueue1);
+            break;

-    case 0xf5:
-        func_sh_802f3158(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3, &gUnkQueue1);
-        break;
+        case 0xf5:
+            func_sh_802f3158(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3, &gUnkQueue1);
+            break;

-    case 0xf6:
-        func_sh_802f3288(cmd->u.s.arg2);
-        break;
+        case 0xf6:
+            func_sh_802f3288(cmd->u.s.arg2);
+            break;
    }
 }

-void seq_player_fade_to_zero_volume(s32 arg0, s32 fadeOutTime) {
+void seq_player_fade_to_zero_volume(s32 arg0, s32 fadeOutTime)
+{
    struct SequencePlayer *player;

-    if (fadeOutTime == 0) {
+    if (fadeOutTime == 0)
+    {
        fadeOutTime = 1;
    }
    player = &gSequencePlayers[arg0];
    player->state = 2;
    player->fadeRemainingFrames = fadeOutTime;
-    player->fadeVelocity = -(player->fadeVolume / (f32) fadeOutTime);
+    player->fadeVelocity = -(player->fadeVolume / (f32)fadeOutTime);
 }

-void func_8031D690(s32 playerIndex, s32 fadeInTime) {
+void func_8031D690(s32 playerIndex, s32 fadeInTime)
+{
    struct SequencePlayer *player;

-    if (fadeInTime != 0) {
+    if (fadeInTime != 0)
+    {
        player = &gSequencePlayers[playerIndex];
        player->state = 1;
        player->fadeTimerUnkEu = fadeInTime;
@@ -278,7 +322,8 @@ void func_8031D690(s32 playerIndex, s32 fadeInTime) {
    }
 }

-void port_eu_init_queues(void) {
+void port_eu_init_queues(void)
+{
    D_SH_80350F18 = 0;
    D_SH_80350F19 = 0;
    D_SH_80350F38 = &D_SH_80350F20;
@@ -292,36 +337,43 @@ void port_eu_init_queues(void) {
 }

 extern struct EuAudioCmd sAudioCmd[0x100];
-void func_802ad6f0(s32 arg0, s32 *arg1) {
+void func_802ad6f0(s32 arg0, s32 *arg1)
+{
    struct EuAudioCmd *cmd = &sAudioCmd[D_SH_80350F18 & 0xff];
    cmd->u.first = arg0;
    cmd->u2.as_u32 = *arg1;
    D_SH_80350F18++;
-    if (D_SH_80350F18 == D_SH_80350F19) {
+    if (D_SH_80350F18 == D_SH_80350F19)
+    {
        D_SH_80350F18--;
    }
 }

-void func_802ad728(u32 arg0, f32 arg1) {
-    func_802ad6f0(arg0, (s32 *) &arg1);
+void func_802ad728(u32 arg0, f32 arg1)
+{
+    func_802ad6f0(arg0, (s32 *)&arg1);
 }

-void func_802ad74c(u32 arg0, u32 arg1) {
-    func_802ad6f0(arg0, (s32 *) &arg1);
+void func_802ad74c(u32 arg0, u32 arg1)
+{
+    func_802ad6f0(arg0, (s32 *)&arg1);
 }

-void func_802ad770(u32 arg0, s8 arg1) {
+void func_802ad770(u32 arg0, s8 arg1)
+{
    s32 sp1C = arg1 << 24;
    func_802ad6f0(arg0, &sp1C);
 }

 char shindouDebugPrint133[] = "AudioSend: %d -> %d (%d)\n";

-void func_sh_802F64C8(void) {
+void func_sh_802F64C8(void)
+{
    static s32 D_SH_8031503C = 0;
    s32 mesg;

-    if (((D_SH_80350F18 - D_SH_80350F19 + 0x100) & 0xff) > D_SH_8031503C) {
+    if (((D_SH_80350F18 - D_SH_80350F19 + 0x100) & 0xff) > D_SH_8031503C)
+    {
        D_SH_8031503C = (D_SH_80350F18 - D_SH_80350F19 + 0x100) & 0xff;
    }
    mesg = ((D_SH_80350F19 & 0xff) << 8) | (D_SH_80350F18 & 0xff);
@@ -329,11 +381,13 @@ void func_sh_802F64C8(void) {
    D_SH_80350F19 = D_SH_80350F18;
 }

-void func_sh_802f6540(void) {
+void func_sh_802f6540(void)
+{
    D_SH_80350F19 = D_SH_80350F18;
 }

-void func_802ad7ec(u32 arg0) {
+void func_802ad7ec(u32 arg0)
+{
    struct EuAudioCmd *cmd;
    struct SequencePlayer *seqPlayer;
    struct SequenceChannel *chan;
@@ -347,102 +401,120 @@ void func_802ad7ec(u32 arg0) {
    static u8 D_SH_80315098 = 0;
    static u8 D_SH_8031509C = 0;

-    if (D_SH_8031509C == 0) {
+    if (D_SH_8031509C == 0)
+    {
        D_SH_80315098 = (arg0 >> 8) & 0xff;
    }

    end = arg0 & 0xff;

-    for (;;) {
-        if (D_SH_80315098 == end) {
+    for (;;)
+    {
+        if (D_SH_80315098 == end)
+        {
            D_SH_8031509C = 0;
            break;
        }
        cmd = &sAudioCmd[D_SH_80315098 & 0xff];
        D_SH_80315098++;
-        if (cmd->u.s.op == 0xf8) {
+        if (cmd->u.s.op == 0xf8)
+        {
            D_SH_8031509C = 1;
            break;
        }
-        else if ((cmd->u.s.op & 0xf0) == 0xf0) {
+        else if ((cmd->u.s.op & 0xf0) == 0xf0)
+        {
            eu_process_audio_cmd(cmd);
        }
-        else if (cmd->u.s.arg1 < SEQUENCE_PLAYERS) {
+        else if (cmd->u.s.arg1 < SEQUENCE_PLAYERS)
+        {
            seqPlayer = &gSequencePlayers[cmd->u.s.arg1];
-            if ((cmd->u.s.op & 0x80) != 0) {
+            if ((cmd->u.s.op & 0x80) != 0)
+            {
                eu_process_audio_cmd(cmd);
            }
-            else if ((cmd->u.s.op & 0x40) != 0) {
-                switch (cmd->u.s.op) {
-                case 0x41:
-                    if (seqPlayer->fadeVolumeScale != cmd->u2.as_f32) {
-                        seqPlayer->fadeVolumeScale = cmd->u2.as_f32;
-                        seqPlayer->recalculateVolume = TRUE;
-                    }
-                    break;
+            else if ((cmd->u.s.op & 0x40) != 0)
+            {
+                switch (cmd->u.s.op)
+                {
+                    case 0x41:
+                        if (seqPlayer->fadeVolumeScale != cmd->u2.as_f32)
+                        {
+                            seqPlayer->fadeVolumeScale = cmd->u2.as_f32;
+                            seqPlayer->recalculateVolume = TRUE;
+                        }
+                        break;

-                case 0x47:
-                    seqPlayer->tempo = cmd->u2.as_s32 * TATUMS_PER_BEAT;
-                    break;
+                    case 0x47:
+                        seqPlayer->tempo = cmd->u2.as_s32 * TATUMS_PER_BEAT;
+                        break;

-                case 0x49:
-                    seqPlayer->tempoAdd = cmd->u2.as_s32 * TEMPO_SCALE;
-                    break;
+                    case 0x49:
+                        seqPlayer->tempoAdd = cmd->u2.as_s32 * TEMPO_SCALE;
+                        break;

-                case 0x48:
-                    seqPlayer->transposition = cmd->u2.as_s8;
-                    break;
+                    case 0x48:
+                        seqPlayer->transposition = cmd->u2.as_s8;
+                        break;

-                case 0x46:
-                    seqPlayer->seqVariationEu[cmd->u.s.arg3] = cmd->u2.as_s8;
-                    break;
+                    case 0x46:
+                        seqPlayer->seqVariationEu[cmd->u.s.arg3] = cmd->u2.as_s8;
+                        break;
                }
            }
-            else if (seqPlayer->enabled != FALSE && cmd->u.s.arg2 < 0x10) {
+            else if (seqPlayer->enabled != FALSE && cmd->u.s.arg2 < 0x10)
+            {
                chan = seqPlayer->channels[cmd->u.s.arg2];
                if (IS_SEQUENCE_CHANNEL_VALID(chan))
                {
-                    switch (cmd->u.s.op) {
-                    case 1:
-                        if (chan->volumeScale != cmd->u2.as_f32) {
-                            chan->volumeScale = cmd->u2.as_f32;
-                            chan->changes.as_bitfields.volume = TRUE;
-                        }
-                        break;
-                    case 2:
-                        if (chan->volume != cmd->u2.as_f32) {
-                            chan->volume = cmd->u2.as_f32;
-                            chan->changes.as_bitfields.volume = TRUE;
-                        }
-                        break;
-                    case 3:
-                        if (chan->newPan != cmd->u2.as_s8) {
-                            chan->newPan = cmd->u2.as_s8;
-                            chan->changes.as_bitfields.pan = TRUE;
-                        }
-                        break;
-                    case 4:
-                        if (chan->freqScale != cmd->u2.as_f32) {
-                            chan->freqScale = cmd->u2.as_f32;
-                            chan->changes.as_bitfields.freqScale = TRUE;
-                        }
-                        break;
-                    case 5:
-                        //! @bug u8 s8 comparison (but harmless)
-                        if (chan->reverbVol != cmd->u2.as_s8) {
-                            chan->reverbVol = cmd->u2.as_s8;
-                        }
-                        break;
-                    case 6:
-                        if (cmd->u.s.arg3 < 8) {
-                            chan->soundScriptIO[cmd->u.s.arg3] = cmd->u2.as_s8;
-                        }
-                        break;
-                    case 8:
-                        chan->stopSomething2 = cmd->u2.as_s8;
-                        break;
-                    case 9:
-                        chan->muteBehavior = cmd->u2.as_s8;
+                    switch (cmd->u.s.op)
+                    {
+                        case 1:
+                            if (chan->volumeScale != cmd->u2.as_f32)
+                            {
+                                chan->volumeScale = cmd->u2.as_f32;
+                                chan->changes.as_bitfields.volume = TRUE;
+                            }
+                            break;
+                        case 2:
+                            if (chan->volume != cmd->u2.as_f32)
+                            {
+                                chan->volume = cmd->u2.as_f32;
+                                chan->changes.as_bitfields.volume = TRUE;
+                            }
+                            break;
+                        case 3:
+                            if (chan->newPan != cmd->u2.as_s8)
+                            {
+                                chan->newPan = cmd->u2.as_s8;
+                                chan->changes.as_bitfields.pan = TRUE;
+                            }
+                            break;
+                        case 4:
+                            if (chan->freqScale != cmd->u2.as_f32)
+                            {
+                                chan->freqScale = cmd->u2.as_f32;
+                                chan->changes.as_bitfields.freqScale = TRUE;
+                            }
+                            break;
+                        case 5:
+                            //! @bug u8 s8 comparison (but harmless)
+                            if (chan->reverbVol != cmd->u2.as_s8)
+                            {
+                                chan->reverbVol = cmd->u2.as_s8;
+                            }
+                            break;
+                        case 6:
+                            if (cmd->u.s.arg3 < 8)
+                            {
+                                chan->soundScriptIO[cmd->u.s.arg3] = cmd->u2.as_s8;
+                            }
+                            break;
+                        case 8:
+                            chan->stopSomething2 = cmd->u2.as_s8;
+                            break;
+                        case 9:
+                            chan->muteBehavior = cmd->u2.as_s8;
                    }
                }
            }
@@ -452,74 +524,91 @@ void func_802ad7ec(u32 arg0) {
    }
 }

-u32 func_sh_802f6878(s32 *arg0) {
+u32 func_sh_802f6878(s32 *arg0)
+{
    u32 sp1C;

-    if (osRecvMesg(&gUnkQueue1, (OSMesg *) &sp1C, 0) == -1) {
+    if (osRecvMesg(&gUnkQueue1, (OSMesg *)&sp1C, 0) == -1)
+    {
        *arg0 = 0;
        return 0U;
    }
-    *arg0 = (s32) (sp1C & 0xFFFFFF);
+    *arg0 = (s32)(sp1C & 0xFFFFFF);
    return sp1C >> 0x18;
 }

-u8 *func_sh_802f68e0(u32 index, u32 *a1) {
+u8 *func_sh_802f68e0(u32 index, u32 *a1)
+{
    return func_sh_802f3220(index, a1);
 }

-s32 func_sh_802f6900(void) {
+s32 func_sh_802f6900(void)
+{
    s32 ret;
    s32 sp18;

-    ret = osRecvMesg(D_SH_80350FA8, (OSMesg *) &sp18, 0);
+    ret = osRecvMesg(D_SH_80350FA8, (OSMesg *)&sp18, 0);

-    if (ret == -1) {
+    if (ret == -1)
+    {
        return 0;
    }
-    if (sp18 != gAudioResetPresetIdToLoad) {
+    if (sp18 != gAudioResetPresetIdToLoad)
+    {
        return 0;
-    } else {
+    }
+    else
+    {
        return 1;
    }
 }

 // TODO: (Scrub C)
-void func_sh_802f6958(OSMesg mesg) {
+void func_sh_802f6958(OSMesg mesg)
+{
    s32 a;
    OSMesg recvMesg;

-    do {
+    do
+    {
        a = -1;
-    } while (osRecvMesg(D_SH_80350FA8, &recvMesg, OS_MESG_NOBLOCK) != a);
+    }
+    while (osRecvMesg(D_SH_80350FA8, &recvMesg, OS_MESG_NOBLOCK) != a);
    func_sh_802f6540();
    osSendMesg(D_SH_80350F88, mesg, OS_MESG_NOBLOCK);
 }

-void func_sh_802f69cc(void) {
+void func_sh_802f69cc(void)
+{
    gAudioLoadLockSH = 1;
    func_sh_802f6958(0);
    gAudioResetStatus = 0;
 }

-s32 func_sh_802f6a08(s32 playerIndex, s32 channelIndex, s32 soundScriptIOIndex) {
+s32 func_sh_802f6a08(s32 playerIndex, s32 channelIndex, s32 soundScriptIOIndex)
+{
    struct SequenceChannel *seqChannel;
    struct SequencePlayer *player;

    player = &gSequencePlayers[playerIndex];
-    if (player->enabled) {
+    if (player->enabled)
+    {
        seqChannel = player->channels[channelIndex];
-        if (IS_SEQUENCE_CHANNEL_VALID(seqChannel)) {
+        if (IS_SEQUENCE_CHANNEL_VALID(seqChannel))
+        {
            return seqChannel->soundScriptIO[soundScriptIOIndex];
        }
    }
    return -1;
 }

-s8 func_sh_802f6a6c(s32 playerIndex, s32 index) {
+s8 func_sh_802f6a6c(s32 playerIndex, s32 index)
+{
    return gSequencePlayers[playerIndex].seqVariationEu[index];
 }

-void port_eu_init(void) {
+void port_eu_init(void)
+{
    port_eu_init_queues();
 }

@@ -540,17 +629,17 @@ char shindouDebugPrint151[] = "Audio: voiceman: progNo. undefined %d,%d\n";
 char shindouDebugPrint152[] = "Audio: voiceman: No bank error %d\n";
 char shindouDebugPrint153[] = "Audio: voiceman: Percussion Overflow %d,%d\n";
 char shindouDebugPrint154[] = "Audio: voiceman: Percussion table pointer (bank %d) is irregular %x.\n";
-char shindouDebugPrint155[] = "Audio: voiceman: Percpointer NULL %d,%d\n";
+char shindouDebugPrint155[] = "Audio: voiceman: Percpointer nullptr %d,%d\n";
 char shindouDebugPrint156[] = "--4 %x\n";
 char shindouDebugPrint157[] = "NoteOff Comes during wait release %x (note %x)\n";
 char shindouDebugPrint158[] = "Slow Release Batting\n";
-u8 euUnknownData_8030194c[4] = { 0x40, 0x20, 0x10, 0x08 };
+u8 euUnknownData_8030194c[4] = {0x40, 0x20, 0x10, 0x08};
 char shindouDebugPrint159[] = "Audio:Wavemem: Bad voiceno (%d)\n";
-char shindouDebugPrint160[] = "Audio: C-Alloc : Dealloc voice is NULL\n";
+char shindouDebugPrint160[] = "Audio: C-Alloc : Dealloc voice is nullptr\n";
 char shindouDebugPrint161[] = "Alloc Error:Dim voice-Alloc %d";
 char shindouDebugPrint162[] = "Error:Same List Add\n";
 char shindouDebugPrint163[] = "Already Cut\n";
-char shindouDebugPrint164[] = "Audio: C-Alloc : lowerPrio is NULL\n";
+char shindouDebugPrint164[] = "Audio: C-Alloc : lowerPrio is nullptr\n";
 char shindouDebugPrint165[] = "Intterupt UseStop %d (Kill %d)\n";
 char shindouDebugPrint166[] = "Intterupt RelWait %d (Kill %d)\n";
 char shindouDebugPrint167[] = "Drop Voice (Prio %x)\n";
@@ -7,12 +7,19 @@
 #include "playback.h"

 void seq_channel_layer_disable(struct SequenceChannelLayer *seqPlayer);
+
 void sequence_channel_disable(struct SequenceChannel *seqPlayer);
-void sequence_player_disable(struct SequencePlayer* seqPlayer);
+
+void sequence_player_disable(struct SequencePlayer *seqPlayer);
+
 void audio_list_push_back(struct AudioListItem *list, struct AudioListItem *item);
+
 void *audio_list_pop_back(struct AudioListItem *list);
+
 void process_sequences(s32 iterationsRemaining);
+
 void init_sequence_player(u32 player);
+
 void init_sequence_players(void);

 #endif // AUDIO_SEQPLAYER_H
@@ -6,7 +6,7 @@ char shindouDebugPrint1[] = "Terminate-Canceled Channel %d,Phase %d\n";
 char shindouDebugPrint2[] = "S->W\n";
 char shindouDebugPrint3[] = "W->S\n";
 char shindouDebugPrint4[] = "S-Resample Pitch %x (old %d -> delay %d)\n";
-s32 shindouDebugPrintPadding1[] = {0,0,0};
+s32 shindouDebugPrintPadding1[] = {0, 0, 0};

 // heap.c
 char shindouDebugPrint5[] = "Warning:Kill Note  %x \n";
@@ -60,7 +60,7 @@ char shindouDebugPrint52[] = "Try Kill %d \n";
 char shindouDebugPrint53[] = "Try Kill %x %x\n";
 char shindouDebugPrint54[] = "Try Kill %x %x %x\n";
 char shindouDebugPrint55[] = "Rom back %x %x \n";
-char shindouDebugPrint56[] = "Error sw NULL \n";
+char shindouDebugPrint56[] = "Error sw nullptr \n";
 char shindouDebugPrint57[] = "Request--------Single-Stay, %d\n";
 char shindouDebugPrint58[] = "Try Kill %d \n";
 char shindouDebugPrint59[] = "Try Kill %x %x\n";
@@ -140,7 +140,7 @@ char shindouDebugPrint127[] = "Spec Change Override. %d -> %d\n";
 char shindouDebugPrint128[] = "Audio:now-max tasklen is %d / %d\n";
 char shindouDebugPrint129[] = "Audio:Warning:ABI Tasklist length over (%d)\n";
 s32 D_SH_80314FC8 = 0x80;
-struct SPTask *D_SH_80314FCC = NULL;
+struct SPTask *D_SH_80314FCC = nullptr;
 char shindouDebugPrint130[] = "BGLOAD Start %d\n";
 char shindouDebugPrint131[] = "Error: OverFlow Your Request\n";
 char shindouDebugPrint132[] = "---AudioSending (%d->%d) \n";
@@ -30,46 +30,62 @@ struct ReverbRingBufferItem

 struct SynthesisReverb
 {
-    /*0x00, 0x00, 0x00*/ u8 resampleFlags;
-    /*0x01, 0x01, 0x01*/ u8 useReverb;
-    /*0x02, 0x02, 0x02*/ u8 framesLeftToIgnore;
-    /*0x03, 0x03, 0x03*/ u8 curFrame;
-#if defined(VERSION_EU) || defined(VERSION_SH)
+    /*0x00, 0x00, 0x00*/
+    u8 resampleFlags;
+    /*0x01, 0x01, 0x01*/
+    u8 useReverb;
+    /*0x02, 0x02, 0x02*/
+    u8 framesLeftToIgnore;
+    /*0x03, 0x03, 0x03*/
+    u8 curFrame;
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    /*      0x04, 0x04*/ u8 downsampleRate;
-#ifdef VERSION_SH
+    #ifdef VERSION_SH
    /*            0x05*/ s8 unk5;
-#endif
+    #endif
    /*      0x06, 0x06*/ u16 windowSize; // same as bufSizePerChannel
-#endif
-#ifdef VERSION_SH
+    #endif
+    #ifdef VERSION_SH
    /*            0x08*/ u16 unk08;
-#endif
-    /*0x04, 0x08, 0x0A*/ u16 reverbGain;
-    /*0x06, 0x0A, 0x0C*/ u16 resampleRate;
-#ifdef VERSION_SH
+    #endif
+    /*0x04, 0x08, 0x0A*/
+    u16 reverbGain;
+    /*0x06, 0x0A, 0x0C*/
+    u16 resampleRate;
+    #ifdef VERSION_SH
    /*            0x0E*/ u16 panRight;
    /*            0x10*/ u16 panLeft;
-#endif
-    /*0x08, 0x0C, 0x14*/ s32 nextRingBufferPos;
-    /*0x0C, 0x10, 0x18*/ s32 unkC; // never read
-    /*0x10, 0x14, 0x1C*/ s32 bufSizePerChannel;
+    #endif
+    /*0x08, 0x0C, 0x14*/
+    s32 nextRingBufferPos;
+    /*0x0C, 0x10, 0x18*/
+    s32 unkC; // never read
+    /*0x10, 0x14, 0x1C*/
+    s32 bufSizePerChannel;
+
    struct
    {
        s16 *left;
        s16 *right;
    } ringBuffer;
-    /*0x1C, 0x20, 0x28*/ s16 *resampleStateLeft;
-    /*0x20, 0x24, 0x2C*/ s16 *resampleStateRight;
-    /*0x24, 0x28, 0x30*/ s16 *unk24; // never read
-    /*0x28, 0x2C, 0x34*/ s16 *unk28; // never read
-    /*0x2C, 0x30, 0x38*/ struct ReverbRingBufferItem items[2][MAX_UPDATES_PER_FRAME];
-#if defined(VERSION_EU) || defined(VERSION_SH)
+
+    /*0x1C, 0x20, 0x28*/
+    s16 *resampleStateLeft;
+    /*0x20, 0x24, 0x2C*/
+    s16 *resampleStateRight;
+    /*0x24, 0x28, 0x30*/
+    s16 *unk24; // never read
+    /*0x28, 0x2C, 0x34*/
+    s16 *unk28; // never read
+    /*0x2C, 0x30, 0x38*/
+    struct ReverbRingBufferItem items[2][MAX_UPDATES_PER_FRAME];
+    #if defined(VERSION_EU) || defined(VERSION_SH)
    // Only used in sh:
    /*            0x100*/ s16 *unk100;
    /*            0x104*/ s16 *unk104;
    /*            0x108*/ s16 *unk108;
    /*            0x10C*/ s16 *unk10C;
-#endif
+    #endif
 }; // 0xCC <= size <= 0x100
 #if defined(VERSION_EU) || defined(VERSION_SH)
 extern struct SynthesisReverb gSynthesisReverbs[4];