diff --git a/include/Inagaki/GameAudioMain.h b/include/Inagaki/GameAudioMain.h
index fdcacd8e..ebc9ede7 100644
--- a/include/Inagaki/GameAudioMain.h
+++ b/include/Inagaki/GameAudioMain.h
@@ -111,6 +111,10 @@ class Main
     }
 
     CustomMgr *getCustomMgr() { return mMgr; }
+
+    u32 get_80() const {
+        return _80;
+    }
     // } FABRICATED
 
     CameraMgr *getCamera() {
@@ -145,7 +149,8 @@ class Main
     JAISoundHandle _68;           //
     JAISoundHandle _6c;           //
     JAISoundHandle _70;           //
-    u8 _74[0xa8 - 0x74];          //
+    u8 _74[0x80 - 0x74];          //
+    u32 _80;                      //
     JAISoundHandle _84[4];        // 
     u8 _94[0xa8 - 0x94];          //
 
diff --git a/include/Inagaki/GameSoundMgr.h b/include/Inagaki/GameSoundMgr.h
index f8ee249e..990dff53 100644
--- a/include/Inagaki/GameSoundMgr.h
+++ b/include/Inagaki/GameSoundMgr.h
@@ -186,7 +186,7 @@ class KartSoundMgr : public SoundMgr<KartSoundMgr>
 public:
     KartSoundMgr(Vec *, JKRHeap *, u8, u8);                           // 0x80123118
     ~KartSoundMgr();                                                  // 0x80123328
-    void startSoundHandleNumber(u8, u32, u32);                        // 0x801233fc
+    virtual void startSoundHandleNumber(u8, u32, u32);                // 0x801233fc
     virtual void dispose();                                           // 0x801236d0
     virtual void init();                                              // 0x80123708
     void changeDriver(bool);                                          // 0x80123ad4
@@ -225,24 +225,81 @@ class KartSoundMgr : public SoundMgr<KartSoundMgr>
     void clearInvincibleBgm(u8);                                      // 0x80128c30
     void setChibiFlag(bool, bool);                                    // 0x80128e98
 
+    // UNUSED {
+    void startSoundEngine(u8, u32);
+    void changeAttribute(u8);
+    void checkCourseSound(u8);
+    void setHandleVolume(JAISoundHandle&, f32);
+    void setWaterDepth(f32);
+    void getEngineIDOffsetAtt();
+    // } UNUSED
+
     static u8 smKartCount;
     static u8 smEntryKartCount;
     static u8 smGoalKartCount;
 
     static u8 smKartRankClassMem[7];
 
-    u8 _5c[0x61 - 0x5c];
+    u8 _5c;
+    u8 _5d;
+    u8 _5e;
+    u8 _5f;
+    u8 _60;
     u8 _61;
     u8 mKartCount; // 62
     u8 _63;
     u8 _64;
     u8 _65;
     u8 _66;
-    u8 _67[0x6c - 0x67];
+    u8 _67;
+    f32 _68;
     f32 _6c;
-    u8 _70[0x8d - 0x70];
+    f32 _70;
+    u32 _74;
+    u32 _78;
+    u32 _7c;
+    u32 _80;
+    f32 _84;
+    f32 _88;
+    u8 _8c;
     u8 _8d;
-    u8 _8e[0x134 - 0x8e];
+    u16 _8e;
+    u16 _90;
+    u16 _92;
+    u16 _94;
+    u16 _96;
+    f32 _98;
+    u8 _9c;
+    u8 _9d[3]; // padding
+    f32 _a0;
+    f32 _a4[4];
+    f32 _b4[4];
+    f32 _c4[4];
+    f32 mWaterDepths[4];
+    u8 _e4[4];
+    u8 _e8[4];
+    f32 _ec;
+    f32 _f0;
+    u32 _f4;
+    u16 _f8;
+    u8 _fa[2]; // padding
+    f32 _fc;
+    u8 _100;
+    u8 _101;
+    u8 _102;
+    u8 _103;
+    u8 _104;
+    u8 _105;
+    u8 _106[0x110 - 0x106];
+    f32 _110;
+    f32 _114;
+    u8 _118[0x11c - 0x118];
+    u32 _11c;
+    f32 mGoalVolume;
+    f32 mCameraVolume; // 124
+    f32 mDeltaVolume; // 128
+    u32 mGoalVolumeCounter; // 12c
+    CrsArea* _130;
 };
 
 class CharacterSoundMgr : public SoundMgr<CharacterSoundMgr> {
@@ -345,6 +402,10 @@ class ShoreSoundMgr : public SoundMgr<ShoreSoundMgr> {
 private:
     static CustomAudience<4> *smAudience; // 0x80416278
 
+    JGeometry::TVec3f& getPlayPos(s32 index) { // fabricated
+        return _64[index];
+    }
+
     u8 _5c;
     u8 _5d;
     u8 _5e[0x60 - 0x5e]; // padding?
diff --git a/include/JSystem/JAudio/Interface/JAISound.h b/include/JSystem/JAudio/Interface/JAISound.h
index b4f9ccfe..0e9e85db 100644
--- a/include/JSystem/JAudio/Interface/JAISound.h
+++ b/include/JSystem/JAudio/Interface/JAISound.h
@@ -230,6 +230,20 @@ struct JAISoundFader
         mIntensity = 0.0f;
         fadeIn(fadeCount);
     }
+
+    // Same as fadeInFromOut but branching order is inversed
+    // Needed by KartSoundMgr...
+    void fadeInFromOut2(u32 fadeCount)
+    {
+        mIntensity = 0.f;
+        if (fadeCount != 0) {
+            mTransition.set(1.0f, mIntensity, fadeCount);
+        }
+        else
+        {
+            forceIn();
+        }
+    }
     bool isOut() { return (mTransition.mCount == 0 && mIntensity < 0.01f); }
     void calc() { mIntensity = mTransition.apply(mIntensity); }
     f32 getIntensity() { return mIntensity; }
diff --git a/include/Kaneshige/Course/CrsGround.h b/include/Kaneshige/Course/CrsGround.h
index 60478082..31ff63b8 100644
--- a/include/Kaneshige/Course/CrsGround.h
+++ b/include/Kaneshige/Course/CrsGround.h
@@ -45,6 +45,19 @@ class CrsGround
     {
         // TODO
         Mat_1 = 1,
+        Mat_5 = 5,
+        Mat_6 = 6,
+        Mat_7 = 7,
+        Mat_8 = 8,
+        Mat_9 = 9,
+        Mat_10 = 10,
+        Mat_15 = 15,
+        Mat_16 = 16,
+        Mat_17 = 17,
+        Mat_18 = 18,
+        Mat_19 = 19,
+        Mat_25 = 25,
+        Mat_27 = 27,
         Mat_255 = 0xff,
     };
 
diff --git a/src/Inagaki/KartSoundMgr.cpp b/src/Inagaki/KartSoundMgr.cpp
index ef2ff92d..867613a1 100644
--- a/src/Inagaki/KartSoundMgr.cpp
+++ b/src/Inagaki/KartSoundMgr.cpp
@@ -1,8 +1,28 @@
 #include "Inagaki/GameSoundMgr.h"
 
+#include "Inagaki/GameAudioAudience.h"
+#include "Inagaki/GameAudioCommon.h"
+#include "Inagaki/GameAudioCamera.h"
+#include "Inagaki/GameAudioMain.h"
+#include "Inagaki/GameSoundTable.h"
+#include "JSystem/JAudio/Interface/JAISound.h"
+#include "JSystem/JAudio/JAUSoundObject.h"
+#include "JSystem/JAudio/System/JASGadget.h"
+#include "JSystem/JGeometry/Vec.h"
+#include "Kaneshige/Course/CrsArea.h"
+#include "JSystem/JAudio/JASFakeMatch2.h"
+#include "Kaneshige/Course/CrsGround.h"
+
+static bool float_equal(f32 f1, f32 f2) {
+    return f1 == f2;
+}
+    // } FABRICATED)
+
 namespace GameAudio {
 
 // TODO
+static const u8 cKartRankClassTable0[7] = {0, 0, 1, 1, 1, 2, 2};
+static const u8 cKartRankClassTable1[7] = {0, 0, 1, 1, 2, 2, 2};
 
 u32 BoundSe[0x19];
 u32 WheelSpinSe[0x19];
@@ -11,50 +31,437 @@ u32 SpinTurnSe[0x19];
 
 f32 GA_ENEMY_VOLUME_DOWN_VALUE = 0.85f;
 const f32 EngineKeisuuRaceUp[] = {
-    0.006f, 0.006f, 0.005f, 0.003f, 
-    0.015f, 0.015f, 0.013f, 0.011f, 
+    0.006f, 0.006f, 0.005f, 0.003f,
+    0.015f, 0.015f, 0.013f, 0.011f,
     0.02f,
 };
 
 const f32 EngineKeisuuRaceDown[] = {
-    0.005f, 0.003f, 0.005f, 0.002f, 
-    0.012f, 0.012f, 0.012f, 0.009f, 
+    0.005f, 0.003f, 0.005f, 0.002f,
+    0.012f, 0.012f, 0.012f, 0.009f,
     0.019f,
 };
 
+const f32 DashEngineAdjustInitialValue[] = {
+    0.3f, 0.3f, 0.3f, 0.3f,
+    0.3f, 0.3f, 0.3f, 0.3f,
+    0.3f
+};
+
+const f32 DashEngineIncPerFrame[] = {
+    0.025f, 0.025f, 0.025f, 0.095f,
+    0.025f, 0.025f, 0.025f, 0.025f,
+    0.025f
+};
+
+const f32 DashEngineDecPerFrame[] = {
+    0.005f, 0.005f, 0.005f, 0.005f,
+    0.005f, 0.005f, 0.005f, 0.005f,
+    0.005f
+};
+
 u8 KartSoundMgr::smKartCount;
 u8 KartSoundMgr::smEntryKartCount;
 u8 KartSoundMgr::smGoalKartCount;
 
 u8 KartSoundMgr::smKartRankClassMem[7] = {};
 
-KartSoundMgr::KartSoundMgr(Vec *pos, JKRHeap *heap, u8 p3, u8 p4) : SoundMgr(pos, heap, 12) {
+KartSoundMgr::KartSoundMgr(Vec *pos, JKRHeap *heap, u8 p3, u8 p4)
+    : SoundMgr(pos, heap, 12) {
+    _114 = 1.f;
+    _110 = 1.f;
+    _11c = 0;
+    mCameraVolume = 1.f;
+    mGoalVolume = 1.f;
+    mGoalVolumeCounter = 0;
+    _C = 0xff;
+
+    _61 = p3;
+
+    if(p3 == 0) {
+        smKartCount++;
+        mKartCount = smKartCount;
+    }
+    else {
+        mKartCount = 4;
+    }
+
+    if(p3 != 2) {
+        smEntryKartCount++;
+    }
+
+    _66 = p4;
+    _130 = new CrsArea();
+    u8 index = 0;
+
+    if(_66 == 0) {
+        _64 = 3;
+    }
+    else {
+        u32 randomValue = GameAudio::Random::getSignalEngineRandomU32();
+        u8 rankClassIndex = randomValue % 7;
+
+        while(smKartRankClassMem[rankClassIndex] == 1 && index < 7)
+        {
+            rankClassIndex = rankClassIndex + 1;
+            index++;
+            if(rankClassIndex == 7)
+            {
+                rankClassIndex = 0;
+            }
+        }
+
+        smKartRankClassMem[rankClassIndex] = 1;
+        u8 playerMode = Parameters::getPlayerMode();
+        if(playerMode != 1)
+        {
+            _64 = cKartRankClassTable0[rankClassIndex];
+        }
+        else {
+            _64 = cKartRankClassTable1[rankClassIndex];
+        }
+    }
+
+    init();
+
+    _7c = 0;
+
+    const u32 sceneMax = Main::getAudio()->getCamera()->getSceneMax();
+
+    if(sceneMax > 1 && sceneMax > mKartCount)
+    {
+        _7c = (1 << mKartCount) ^ 0xf;
+    }
+}
 
+KartSoundMgr::~KartSoundMgr() {
+    setChibiFlag(false, false);
+    for(u8 index = 0; index < 7; index++)
+    {
+        smKartRankClassMem[index] = 0;
+    }
+
+    if(_66 == 0)
+    {
+        const s32 kartCount = mKartCount;
+        if(kartCount < 4)
+        {
+            CustomAudience<4>::smCameraVolume[kartCount] = 1.f;
+        }
+    }
+
+    smKartCount = 0;
+    smEntryKartCount = 0;
+    smGoalKartCount = 0;
 }
 
-KartSoundMgr::~KartSoundMgr() {}
+void KartSoundMgr::startSoundHandleNumber(u8 handleIndex, u32 soundID, u32 fadeCount) {
+    if(mKillSw || _66 == 2)
+    {
+        return;
+    }
+
+    JAISoundStarter* soundStarter = JASGlobalInstance<JAISoundStarter>::getInstance();
+
+    JAISoundHandle& handle = (*this)[handleIndex];
+
+    soundStarter->startSound(soundID, &handle, NULL);
 
-void KartSoundMgr::startSoundHandleNumber(u8, u32, u32) {}
+    JAISound* sound;
+
+    if(!handle.isSoundAttached())
+    {
+        return;
+    }
+
+    if(handle->audible_ == NULL)
+    {
+        Main* main = Main::getAudio();
+        u32 scene = 0;
+        CameraMgr* camera = main->getCamera();
+        u32 sceneMax = camera->getSceneMax();
+
+        if(sceneMax > 1 && sceneMax > mKartCount)
+        {
+            scene = (1 << mKartCount) ^ 0xf;
+        }
+
+        sound = handle.operator->();
+
+        JGeometry::TVec3f vec(*mSoundPos);
+        sound->newAudible(vec, &_18, scene, NULL);
+    }
+    sound = handle.operator->();
+
+    sound->fader_.fadeInFromOut2(fadeCount);
+
+    setEcho(&handle, _6c);
+}
+
+void KartSoundMgr::dispose() {
+    JAUSoundObject::dispose();
+
+    clearInvincibleBgm(3);
+}
 
-void KartSoundMgr::dispose() {}
+void KartSoundMgr::startSoundEngine(u8, u32) {} // UNUSED
+
+void KartSoundMgr::init() {
+    _60 = 0;
+    _5d = 0;
+    _68 = 0.f;
+    _63 = 0;
+    _5c = 0;
+    _6c = 0.f;
+    _70 = 0.f;
+    _80 = 0;
+    _84 = 0.f;
+    _88 = 0.f;
+    _8c = 0;
+    _8d = 0;
+    _8e = 0;
+    _90 = 0;
+    _92 = 0;
+    _94 = 0;
+    _96 = 0;
+    _98 = 0.f;
+    _9c = 0;
+    _a0 = 0.f;
+
+    for(u8 index = 0; index < 4; index++)
+    {
+        _a4[index] = 0.f;
+        _b4[index] = 0.f;
+        _c4[index] = 0.f;
+        _e4[index] = 0;
+        mWaterDepths[index] = 0.f;
+        _e8[index] = 0;
+    }
+
+    _ec = 0.f;
+    _f0 = 0.f;
+    _f4 = 0;
+    _f8 = 0;
+    _100 = 0;
+    _101 = 0;
+    _102 = 0;
+    _103 = 0;
+    _104 = 0;
+    _105 = 1;
+    _fc = 0.f;
+    _5f = 0;
+    _114 = 0.f;
+    _110 = 0.f;
+    _11c = 0;
+    mCameraVolume = 1.f;
+    mGoalVolume = 1.f;
+    mGoalVolumeCounter = 0.f;
+    _78 = 0;
+    _5e = 0;
+    _74 = 0;
+    _65 = 0xff;
+
+    if(_66 == 0)
+    {
+        const s32 kartCount = mKartCount;
+        const f32 volume = mCameraVolume;
+        if(kartCount < 4)
+        {
+            CustomAudience<4>::smCameraVolume[kartCount] = volume;
+        }
+    }
+
+    Main* main = Main::getAudio();
+    CustomSoundTable* soundTable = main->getSoundTable();
+    for(s32 index = 0; index < _10; index++)
+    {
+        if(!(*this)[index].isSoundAttached())
+        {
+            continue;
+        }
+        JAISound* sound = (*this)[index].operator->();
+        u32 swBit = soundTable->getSwBit(sound->getID().mId.mFullId);
+        if(!(swBit & 0x00800000))
+        {
+            continue;
+        }
+        (*this)[index]->stop();
+    }
+
+    setChibiFlag(false, false);
+    clearInvincibleBgm(3);
+    smGoalKartCount = 0;
+}
 
-void KartSoundMgr::init() {}
+void KartSoundMgr::changeAttribute(u8) {} // UNUSED
 
 void KartSoundMgr::changeDriver(bool) {}
 
-void KartSoundMgr::frameWork(u8) {}
+void KartSoundMgr::checkCourseSound(u8) {} // UNUSED
+
+void KartSoundMgr::frameWork(u8 p1) {
+    if(_66 == 0) {
+        _130->search(6, *mSoundPos);
+        Course::Area* area = _130->getArea();
+        if(area != NULL) {
+            ECourseID courseID = Parameters::getRaceCourse();
+            switch(courseID) {
+            case 0x2a:
+                if(p1 <= 3)
+                {
+                    JAISoundHandle& handle = (*this)[7];
+                    if(!handle.isSoundAttached())
+                    {
+                        startSoundHandleNumber(7, 0x40024, 0);
+                    }
+                }
+                break;
+
+            case 0x29:
+                _5c = 1;
+                _6c = 0.5f;
+                break;
+            }
+        }
+        else {
+            ECourseID courseID = Parameters::getRaceCourse();
+            switch(courseID) {
+            case 0x29:
+                _5c = 0;
+                break;
+            }
+        }
+    }
+    checkEcho();
+
+    if(mKillSw || _66 == 2) {
+        return;
+    }
+
+    crushRenzokuTaisaku();
+    slipParamSet();
+    if(_63 != 3) {
+        _65 = p1;
+    }
+    checkAfterGoalVolume();
+}
+
+void KartSoundMgr::checkAfterGoalVolume() {
+    if(_66 != 0) {
+        return;
+    }
+
+    if(_5e != 1)
+    {
+        return;
+    }
+
+    const f32 goalVolumeOn = 0.35f;
+    const f32 goalVolumeOff = 0.0f;
+    if(_78 == 0) {
+        JAISoundHandle& handle = (*this)[3];
+        if(handle.isSoundAttached())
+        {
+            handle->stop();
+        }
+
+        Main* main = Main::getAudio();
+        CameraMgr* camera = main->getCamera();
+
+        if(camera->getSceneMax() == 2) {
+            u8 mode = Parameters::getRaceMode();
+            if(mode == 1) {
+                _7c = 0xc;
+                _80 = 0x78;
+            }
+        }
+    }
+    else if (_78 == 0x3c) {
+        if(mGoalVolumeCounter != 0 || !float_equal(mCameraVolume, goalVolumeOn))
+        {
+            if(mGoalVolumeCounter == 0 || !float_equal(mGoalVolume,goalVolumeOn)) {
+                mGoalVolume = goalVolumeOn;
+                mDeltaVolume = (mCameraVolume - mGoalVolume) / 61.f;
+                mGoalVolumeCounter = 0x3d;
+            }
+        }
+    }
+    else if (_78 == 0x168) {
+        if(mGoalVolumeCounter != 0 || !float_equal(mCameraVolume, goalVolumeOff))
+        {
+            if(mGoalVolumeCounter == 0 || !float_equal(mGoalVolume, goalVolumeOff))
+            {
+                mGoalVolume = goalVolumeOff;
+                mDeltaVolume = (mCameraVolume - mGoalVolume) / 301.f;
+                mGoalVolumeCounter = 0x12d;
+            }
+        }
+    }
+    _78++;
+
+    u8 camera;
+    if(mGoalVolumeCounter == 0)
+    {
+        camera = 0;
+    }
+    else {
+        if(--mGoalVolumeCounter){
+            camera = 1;
+            mCameraVolume -= mDeltaVolume;
+        }
+        else {
+            camera = 1;
+            mCameraVolume = mGoalVolume;
+        }
+    }
+
+    if(camera == 0)
+    {
+        return;
+    }
+
+    s32 kartCount = mKartCount;
+    f32 cameraVolume = mCameraVolume;
+
+    if(kartCount >= 4){
+        return;
+    }
+
+    CustomAudience<4>::smCameraVolume[kartCount] = cameraVolume;
+}
+
+void KartSoundMgr::setHandleVolume(JAISoundHandle&, f32) {} // UNUSED
 
-void KartSoundMgr::checkAfterGoalVolume() {}
+void KartSoundMgr::setWaterDepth(f32) {} // UNUSED
 
-void KartSoundMgr::setWaterDepth(u8, f32) {}
+void KartSoundMgr::setWaterDepth(u8 index, f32 depth) {
+    mWaterDepths[index] = depth;
+}
 
 void KartSoundMgr::setSlip(u8, u8, u8, f32) {}
 
 void KartSoundMgr::setConductStatus(f32, f32, bool, bool, bool, u8, CrsArea *) {}
 
-void KartSoundMgr::setWaterCutoffPort(u16) {}
+void KartSoundMgr::setWaterCutoffPort(u16 port) {
+    JAISoundHandle &handle = (*this)[3];
+    if (handle.isSoundAttached()) {
+        handle->getTrack()->writePort(0xa, port);
+    }
+}
+
+void KartSoundMgr::getEngineIDOffsetAtt() {} // UNUSED
+
+void KartSoundMgr::countGoalKart() {
+    if(_5e != 0){
+        return;
+    }
 
-void KartSoundMgr::countGoalKart() {}
+    if(_63 == _8d)
+    {
+        return;
+    }
+    smGoalKartCount++;
+}
 
 void KartSoundMgr::setConductLocomotiveAccel() {}
 
@@ -70,11 +477,87 @@ void KartSoundMgr::setConductTrouble(f32, u8) {}
 
 void KartSoundMgr::setConductRace(bool) {}
 
-void KartSoundMgr::setConductAfterGoal(bool) {}
+void KartSoundMgr::setConductAfterGoal(bool enable) {
+    setConductRace(enable);
+}
 
-void KartSoundMgr::setCrushSe(CrsGround::EMat, f32) {}
+void KartSoundMgr::setCrushSe(CrsGround::EMat mat, f32 f1) {
+    switch (mat) {
+    case CrsGround::Mat_5:
+    case CrsGround::Mat_17:
+        setCrushSe(0x1001DU, f1);
+        return;
+    case CrsGround::Mat_8:
+        setCrushSe(0x10015U, f1);
+        return;
+    case CrsGround::Mat_7:
+    case CrsGround::Mat_15:
+        setCrushSe(0x10021U, f1);
+        return;
+    case CrsGround::Mat_16:
+        setCrushSe(0x10023U, f1);
+        return;
+    case CrsGround::Mat_18:
+        setCrushSe(0x10053U, f1);
+        return;
+    case CrsGround::Mat_19:
+        setCrushSe(0x10056U, f1);
+        return;
+    case CrsGround::Mat_9:
+        setCrushSe(0x10019U, f1);
+        return;
+    case CrsGround::Mat_25:
+        setCrushSe(0x10067U, f1);
+        return;
+    case CrsGround::Mat_27:
+        setCrushSe(0x1007DU, f1);
+        return;
+    case CrsGround::Mat_255:
+        break;
+    default:
+        setCrushSe(0x10015U, f1);
+        return;
+    }
+}
 
-void KartSoundMgr::setCrushSe(u32, f32) {}
+void KartSoundMgr::setCrushSe(u32 r4, f32 f1) {
+    const u32 randomId = Common::changeRandomId(r4, 0);
+    const u32 randomId2 = Random::getRandomU32();
+
+    if(mKillSw || _66 == 2) {
+        return;
+    }
+
+    if(_66 != 0) {
+        return;
+    }
+
+    Main* main = Main::getAudio();
+
+    if(main->get_80() - _74 < 0x3c) {
+        return;
+    }
+
+    _74 = main->get_80();
+
+    if(_9c != 0) {
+        return;
+    }
+
+    startSoundHandleNumber(0, randomId, 0);
+
+    JAISoundHandle& handle = (*this)[0];
+    const f32 f30 = f1 + 0.6f;
+    if(handle.isSoundAttached()) {
+        const f32 volume = f30 * 0.8f;
+        handle->getAuxiliary().moveVolume(volume, 0);
+        _a0 = f30;
+    }
+
+    u8 r3 = (randomId2 & 0x7);
+
+    _9c = r3 + 4;
+}
 
 void KartSoundMgr::setBrakeSe(u32) {}