diff --git a/spec b/spec
index 1b64e22c75..fec44e5a75 100644
--- a/spec
+++ b/spec
@@ -4260,8 +4260,7 @@ beginseg
     name "ovl_Bg_Dblue_Waterfall"
     compress
     include "build/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.o"
-    include "build/data/ovl_Bg_Dblue_Waterfall/ovl_Bg_Dblue_Waterfall.data.o"
-    include "build/data/ovl_Bg_Dblue_Waterfall/ovl_Bg_Dblue_Waterfall.reloc.o"
+    include "build/src/overlays/actors/ovl_Bg_Dblue_Waterfall/ovl_Bg_Dblue_Waterfall_reloc.o"
 endseg
 
 beginseg
diff --git a/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.c b/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.c
index 0c124dc07d..cd3b8a9d6a 100644
--- a/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.c
+++ b/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.c
@@ -5,6 +5,7 @@
  */
 
 #include "z_bg_dblue_waterfall.h"
+#include "objects/object_dblue_object/object_dblue_object.h"
 
 #define FLAGS (ACTOR_FLAG_10)
 
@@ -15,12 +16,15 @@ void BgDblueWaterfall_Destroy(Actor* thisx, GlobalContext* globalCtx);
 void BgDblueWaterfall_Update(Actor* thisx, GlobalContext* globalCtx);
 void BgDblueWaterfall_Draw(Actor* thisx, GlobalContext* globalCtx);
 
+void func_80B8484C(BgDblueWaterfall* this, GlobalContext* globalCtx);
 void func_80B84928(BgDblueWaterfall* this, GlobalContext* globalCtx);
+void func_80B84AD4(BgDblueWaterfall* this, GlobalContext* globalCtx);
 void func_80B84AEC(BgDblueWaterfall* this, GlobalContext* globalCtx);
+void func_80B84B9C(BgDblueWaterfall* this, GlobalContext* globalCtx);
 void func_80B84BCC(BgDblueWaterfall* this, GlobalContext* globalCtx);
+void func_80B84EF0(BgDblueWaterfall* this, GlobalContext* globalCtx);
 void func_80B84F20(BgDblueWaterfall* this, GlobalContext* globalCtx);
 
-#if 0
 const ActorInit Bg_Dblue_Waterfall_InitVars = {
     ACTOR_BG_DBLUE_WATERFALL,
     ACTORCAT_PROP,
@@ -33,69 +37,596 @@ const ActorInit Bg_Dblue_Waterfall_InitVars = {
     (ActorFunc)BgDblueWaterfall_Draw,
 };
 
-// static ColliderCylinderInit sCylinderInit = {
-static ColliderCylinderInit D_80B85370 = {
-    { COLTYPE_NONE, AT_NONE, AC_ON | AC_TYPE_PLAYER, OC1_ON | OC1_TYPE_ALL, OC2_TYPE_2, COLSHAPE_CYLINDER, },
-    { ELEMTYPE_UNK4, { 0x00000000, 0x00, 0x00 }, { 0x00CBFBB0, 0x00, 0x00 }, TOUCH_NONE | TOUCH_SFX_NORMAL, BUMP_ON, OCELEM_ON, },
+static ColliderCylinderInit sCylinderInit = {
+    {
+        COLTYPE_NONE,
+        AT_NONE,
+        AC_ON | AC_TYPE_PLAYER,
+        OC1_ON | OC1_TYPE_ALL,
+        OC2_TYPE_2,
+        COLSHAPE_CYLINDER,
+    },
+    {
+        ELEMTYPE_UNK4,
+        { 0x00000000, 0x00, 0x00 },
+        { 0x00CBFBB0, 0x00, 0x00 },
+        TOUCH_NONE | TOUCH_SFX_NORMAL,
+        BUMP_ON,
+        OCELEM_ON,
+    },
     { 50, 740, -740, { 0, 0, 0 } },
 };
 
-// static InitChainEntry sInitChain[] = {
-static InitChainEntry D_80B853A8[] = {
+Color_RGBA8 D_80B8539C = { 200, 255, 255, 255 };
+Color_RGBA8 D_80B853A0 = { 200, 200, 200, 0 };
+
+s32 func_80B83C80(Vec3f* arg0, Vec3f* arg1) {
+    f32 temp_f0 = Math3D_LengthSquared(arg0);
+    f32 temp_f2;
+
+    if (temp_f0 < 0.0000010000001f) {
+        return false;
+    }
+
+    temp_f2 = 1.0f / sqrtf(temp_f0);
+    arg1->x = arg0->x * temp_f2;
+    arg1->y = arg0->y * temp_f2;
+    arg1->z = arg0->z * temp_f2;
+
+    return true;
+}
+
+s32 func_80B83D04(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 phi_v1;
+    s32 sp18 = BGDBLUEWATERFALL_GET_100(&this->actor);
+
+    if (Flags_GetSwitch(globalCtx, BGDBLUEWATERFALL_GET_7F(&this->actor))) {
+        phi_v1 = true;
+    } else {
+        phi_v1 = false;
+    }
+    return phi_v1 ^ sp18;
+}
+
+s32 func_80B83D58(Actor* thisx, GlobalContext* globalCtx) {
+    BgDblueWaterfall* this = THIS;
+
+    if (Flags_GetSwitch(globalCtx, BGDBLUEWATERFALL_GET_7F(&this->actor))) {
+        return false;
+    }
+    return true;
+}
+
+void func_80B83D94(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad;
+    s32 sp20 = BGDBLUEWATERFALL_GET_7F(&this->actor);
+    s32 sp1C = BGDBLUEWATERFALL_GET_100(&this->actor);
+    s32 phi_v0;
+
+    if (Flags_GetSwitch(globalCtx, sp20)) {
+        phi_v0 = true;
+    } else {
+        phi_v0 = false;
+    }
+
+    if (phi_v0 != sp1C) {
+        if (phi_v0) {
+            Flags_UnsetSwitch(globalCtx, sp20);
+        } else {
+            Flags_SetSwitch(globalCtx, sp20);
+        }
+    }
+}
+
+void func_80B83E1C(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad;
+    s32 sp20 = BGDBLUEWATERFALL_GET_7F(&this->actor);
+    s32 sp1C = BGDBLUEWATERFALL_GET_100(&this->actor);
+    s32 phi_v0;
+
+    if (Flags_GetSwitch(globalCtx, sp20)) {
+        phi_v0 = true;
+    } else {
+        phi_v0 = false;
+    }
+
+    if (phi_v0 == sp1C) {
+        if (phi_v0) {
+            Flags_UnsetSwitch(globalCtx, sp20);
+        } else {
+            Flags_SetSwitch(globalCtx, sp20);
+        }
+    }
+}
+
+void func_80B83EA4(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 i;
+    s32 temp_s1;
+    Vec3f spD4;
+    Vec3f spC8;
+    Vec3f spBC;
+    Vec3f spB0;
+    Vec3f spA4;
+    Vec3f sp98;
+    s32 phi_s3;
+
+    if (this->collider.info.bumperFlags & BUMP_HIT) {
+        f32 temp_f0_2;
+        f32 temp_f20;
+
+        spB0.x = this->collider.info.bumper.hitPos.x;
+        spB0.y = this->collider.info.bumper.hitPos.y;
+        spB0.z = this->collider.info.bumper.hitPos.z;
+
+        sp98.x = spB0.x - this->actor.world.pos.x;
+        sp98.y = 0.0f;
+        sp98.z = spB0.z - this->actor.world.pos.z;
+
+        if (!func_80B83C80(&sp98, &spA4)) {
+            Math_Vec3f_Copy(&spA4, &gZeroVec3f);
+        }
+
+        sp98.y = 0.0f;
+        spBC.y = -1.4f;
+
+        for (i = 0, phi_s3 = 0; i < 15; i++, phi_s3 += 0x1111) {
+            temp_s1 = (s32)(Rand_ZeroOne() * 4369.0f) + phi_s3;
+            temp_f0_2 = Rand_ZeroOne();
+            temp_f20 = 1.0f - SQ(temp_f0_2);
+
+            sp98.x = Math_SinS(temp_s1) * temp_f20;
+            sp98.z = Math_CosS(temp_s1) * temp_f20;
+            temp_f20 *= 5.0f;
+
+            spD4.x = (sp98.x * temp_f20) + spB0.x;
+            spD4.y = ((Rand_ZeroOne() * 16.0f) - 8.0f) + spB0.y;
+            spD4.z = (sp98.z * temp_f20) + spB0.z;
+
+            spC8.x = ((2.0f * Rand_ZeroOne()) - 1.0f) + ((spA4.x * 3.0f) + (sp98.x * 5.0f));
+            spC8.y = (Rand_ZeroOne() * 10.0f) + 5.0f;
+            spC8.z = ((2.0f * Rand_ZeroOne()) - 1.0f) + ((spA4.z * 3.0f) + (sp98.z * 5.0f));
+
+            spBC.x = spC8.x * -0.02f;
+            spBC.z = spC8.z * -0.02f;
+
+            EffectSsEnIce_Spawn(globalCtx, &spD4, (Rand_ZeroOne() * 0.3f) + 0.1f, &spC8, &spBC, &D_80B8539C,
+                                &D_80B853A0, 30);
+        }
+    }
+}
+
+void func_80B841A0(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    Vec3f sp94;
+    s32 i;
+    f32 temp_f0;
+    f32 temp_f20;
+    f32 temp_f22;
+    f32 temp_f24;
+    f32 temp_f26;
+    s32 temp_s3;
+    s32 phi_s2;
+
+    if (this->collider.info.bumperFlags & BUMP_HIT) {
+        temp_f22 = this->collider.info.bumper.hitPos.x;
+        temp_f24 = this->collider.info.bumper.hitPos.y;
+        temp_f26 = this->collider.info.bumper.hitPos.z;
+
+        for (i = 0, phi_s2 = 0; i < 10; i++, phi_s2 += 0x1999) {
+            temp_s3 = (s32)(Rand_ZeroOne() * 6553.0f) + phi_s2;
+            temp_f0 = Rand_ZeroOne();
+            temp_f20 = (1.0f - SQ(temp_f0)) * 14.0f;
+
+            sp94.x = (Math_SinS(temp_s3) * temp_f20) + temp_f22;
+            sp94.y = ((Rand_ZeroOne() * 20.0f) - 10.0f) + temp_f24;
+            sp94.z = (Math_CosS(temp_s3) * temp_f20) + temp_f26;
+
+            EffectSsGSplash_Spawn(globalCtx, &sp94, NULL, NULL, 0, 250);
+        }
+
+        Actor_PlaySfxAtPos(&this->actor, NA_SE_IT_REFLECTION_WATER);
+    }
+}
+
+void func_80B84348(BgDblueWaterfall* this, GlobalContext* globalCtx, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6,
+                   f32 arg7, s32 arg8) {
+    static s16 D_80B853A4 = 0;
+    s32 pad;
+    f32 spB8 = 1.0f / arg8;
+    s32 i;
+    f32 spB0 = this->actor.world.pos.y + arg3;
+    s32 pad2;
+    f32 temp_f22;
+    f32 temp_f24;
+    Vec3f sp98;
+    Vec3f sp8C;
+    Vec3f sp80;
+    f32 temp_f26;
+    f32 temp_f20;
+
+    for (i = 0; i < arg8; i++) {
+        D_80B853A4 += 0x4E20;
+
+        temp_f20 = Math_SinS(D_80B853A4);
+        temp_f24 = (Rand_ZeroOne() * (arg2 - arg3)) + (spB8 * i);
+        temp_f22 = Math_CosS(D_80B853A4);
+        temp_f26 = ((Rand_ZeroOne() * 0.8f) + 0.2f) * arg4;
+
+        sp8C.x = temp_f20 * temp_f26;
+        sp8C.y = (Rand_ZeroOne() * 4.0f) + arg5;
+        sp8C.z = temp_f22 * temp_f26;
+
+        sp80.x = sp8C.x * -0.016f;
+        sp80.y = sp8C.y * -0.015f;
+        sp80.z = sp8C.z * -0.016f;
+
+        sp98.x = (temp_f20 * 50.0f) + this->actor.world.pos.x;
+        sp98.y = temp_f24 + spB0;
+        sp98.z = (temp_f22 * 50.0f) + this->actor.world.pos.z;
+
+        EffectSsIceSmoke_Spawn(globalCtx, &sp98, &sp8C, &sp80, (Rand_ZeroOne() * arg7) + arg6);
+    }
+}
+
+void func_80B84568(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad;
+    CollisionPoly* sp40;
+    WaterBox* sp3C;
+    s32 sp38;
+    f32 sp34 = BgCheck_EntityRaycastFloor5(&globalCtx->colCtx, &sp40, &sp38, &this->actor, &this->actor.world.pos);
+    f32 sp30;
+
+    if (WaterBox_GetSurface1_2(globalCtx, &globalCtx->colCtx, this->actor.world.pos.x, this->actor.world.pos.z, &sp30,
+                               &sp3C)) {
+        if (sp30 < sp34) {
+            this->unk_198 = sp34;
+        } else {
+            this->unk_198 = sp30;
+        }
+    } else {
+        this->unk_198 = sp34;
+    }
+}
+
+void func_80B84610(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad[2];
+    Vec3f sp34;
+    Player* player = GET_PLAYER(globalCtx);
+
+    if (this->unk_1A7 <= 0) {
+        this->unk_1A7 = 16;
+    } else {
+        this->unk_1A7 -= (s8)((u32)Rand_Next() >> 0x1F);
+    }
+
+    if (this->unk_1A7 >= 6) {
+        this->unk_1A8 += Rand_ZeroOne() * 0.1f;
+        if (this->unk_1A8 > 0.5f) {
+            this->unk_1A8 = 0.5f;
+        } else {
+            this->unk_1A8 = this->unk_1A8;
+        }
+    } else {
+        this->unk_1A8 -= Rand_ZeroOne() * 0.2f;
+        if (this->unk_1A8 > -0.5f) {
+            this->unk_1A8 = -0.5f;
+        } else {
+            this->unk_1A8 = this->unk_1A8;
+        }
+    }
+
+    Matrix_StatePush();
+    Matrix_RotateY(BINANG_ADD(this->actor.yawTowardsPlayer, 0x4000), MTXMODE_NEW);
+    Matrix_GetStateTranslationAndScaledZ(this->unk_1A8, &sp34);
+    Matrix_StatePop();
+
+    player->actor.world.pos.x += sp34.x;
+    player->actor.world.pos.z += sp34.z;
+    if (this && this && this) {}
+    player->unk_B80 = 8.0f;
+    player->unk_B84 = this->actor.yawTowardsPlayer;
+}
+
+static InitChainEntry sInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 4000, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneScale, 1500, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneDownward, 1500, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 100, ICHAIN_STOP),
 };
 
-#endif
+void BgDblueWaterfall_Init(Actor* thisx, GlobalContext* globalCtx) {
+    s32 pad;
+    BgDblueWaterfall* this = THIS;
 
-extern ColliderCylinderInit D_80B85370;
-extern InitChainEntry D_80B853A8[];
+    Actor_ProcessInitChain(&this->actor, sInitChain);
+    this->actor.shape.rot.z = 0;
+    this->actor.world.rot.z = 0;
 
-extern UNK_TYPE D_0600B280;
-extern UNK_TYPE D_0600B448;
+    Collider_InitCylinder(globalCtx, &this->collider);
+    Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
+    Collider_UpdateCylinder(&this->actor, &this->collider);
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B83C80.s")
+    this->unk_190 = Lib_SegmentedToVirtual(object_dblue_object_Matanimheader_00B448);
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B83D04.s")
+    Actor_SetFocus(&this->actor, -100.0f);
+    func_80B84568(this, globalCtx);
+    func_80B8484C(this, globalCtx);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B83D58.s")
+void BgDblueWaterfall_Destroy(Actor* thisx, GlobalContext* globalCtx) {
+    BgDblueWaterfall* this = THIS;
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B83D94.s")
+    Collider_DestroyCylinder(globalCtx, &this->collider);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B83E1C.s")
+void func_80B8484C(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad;
+    s32 temp = func_80B83D04(this, globalCtx);
+    s32 sp1C = this->actor.home.rot.z * 10;
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B83EA4.s")
+    if (temp) {
+        this->unk_19E = 0;
+        this->unk_19F = 255;
+        this->unk_1A0 = 0;
+        this->collider.dim.radius = 55;
+        this->collider.dim.height = 150;
+        this->collider.dim.yShift = -150;
+        this->actor.colChkInfo.mass = MASS_IMMOVABLE;
+    } else {
+        this->unk_19E = 255;
+        this->unk_19F = 0;
+        this->unk_1A0 = 0;
+        this->collider.dim.radius = 50;
+        this->collider.dim.height = 740;
+        this->collider.dim.yShift = -740;
+        this->actor.colChkInfo.mass = MASS_IMMOVABLE;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B841A0.s")
+    if ((sp1C != 0) && !func_80B83D58(&this->actor, globalCtx)) {
+        this->unk_19C = sp1C;
+    } else {
+        this->unk_19C = 0;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84348.s")
+    this->unk_1A3 = false;
+    this->actionFunc = func_80B84928;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84568.s")
+void func_80B84928(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad;
+    s32 sp30 = func_80B83D04(this, globalCtx);
+    s32 sp2C = (this->collider.base.acFlags & AC_HIT) != 0;
+    s32 sp28 = false;
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84610.s")
+    if (sp2C) {
+        this->collider.base.acFlags &= ~AC_HIT;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/BgDblueWaterfall_Init.s")
+    if ((sp30 == 0) && (this->collider.base.ocFlags2 & OC2_HIT_PLAYER)) {
+        func_80B84610(this, globalCtx);
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/BgDblueWaterfall_Destroy.s")
+    if (this->unk_19C > 0) {
+        this->unk_19C--;
+        if (this->unk_19C == 0) {
+            if (sp30 != 0) {
+                func_80B83D94(this, globalCtx);
+                func_80B84EF0(this, globalCtx);
+            } else {
+                func_80B83E1C(this, globalCtx);
+                func_80B84B9C(this, globalCtx);
+            }
+            sp28 = true;
+        }
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B8484C.s")
+    if (!sp28) {
+        if (sp2C) {
+            if (sp30 != 0) {
+                func_80B83EA4(this, globalCtx);
+                if (this->collider.info.acHitInfo->toucher.dmgFlags & 0x800) {
+                    this->unk_1A4 = this->actor.cutscene;
+                    func_80B84AD4(this, globalCtx);
+                }
+            } else {
+                func_80B841A0(this, globalCtx);
+                if (this->collider.info.acHitInfo->toucher.dmgFlags & 0x1000) {
+                    this->unk_1A4 = ActorCutscene_GetAdditionalCutscene(this->actor.cutscene);
+                    func_80B84AD4(this, globalCtx);
+                }
+            }
+        } else {
+            CollisionCheck_SetAC(globalCtx, &globalCtx->colChkCtx, &this->collider.base);
+            CollisionCheck_SetOC(globalCtx, &globalCtx->colChkCtx, &this->collider.base);
+        }
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84928.s")
+void func_80B84AD4(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    this->actionFunc = func_80B84AEC;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84AD4.s")
+void func_80B84AEC(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad;
+    s32 sp20;
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84AEC.s")
+    if (ActorCutscene_GetCanPlayNext(this->unk_1A4)) {
+        sp20 = func_80B83D04(this, globalCtx);
+        ActorCutscene_StartAndSetUnkLinkFields(this->unk_1A4, &this->actor);
+        this->unk_1A3 = true;
+        if (sp20) {
+            func_80B83D94(this, globalCtx);
+            func_80B84EF0(this, globalCtx);
+        } else {
+            func_80B83E1C(this, globalCtx);
+            func_80B84B9C(this, globalCtx);
+        }
+    } else {
+        ActorCutscene_SetIntentToPlay(this->unk_1A4);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84B9C.s")
+void func_80B84B9C(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    this->unk_19C = 60;
+    this->unk_19E = 255;
+    this->unk_19F = 0;
+    this->unk_1A0 = 0;
+    this->actionFunc = func_80B84BCC;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84BCC.s")
+void func_80B84BCC(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    s32 pad;
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84EF0.s")
+    this->unk_19C--;
+    if (this->unk_19C > 0) {
+        s32 sp38 = this->unk_19C & 1;
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/func_80B84F20.s")
+        if (this->unk_19C > 56) {
+            func_80B84348(this, globalCtx, 0.0f, -5500.0f, 0.4f, -15.0f, 370.0f, 100.0f, 6);
+        }
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/BgDblueWaterfall_Update.s")
+        if (!sp38) {
+            if ((this->unk_19C < 24) && (this->unk_19C > 10)) {
+                if (this->unk_198 > -32000.0f) {
+                    func_80B84348(this, globalCtx, (this->unk_198 - this->actor.world.pos.y) + 50.0f,
+                                  (this->unk_198 - this->actor.world.pos.y), 7.0f, -1.0f, 280.0f, 100.0f, 3);
+                }
+            }
 
-#pragma GLOBAL_ASM("asm/non_matchings/overlays/ovl_Bg_Dblue_Waterfall/BgDblueWaterfall_Draw.s")
+            if (this->unk_19C > 50) {
+                func_80B84348(this, globalCtx, 0.0f, -400.0f, 0.6f, -12.0f, 370.0f, 100.0f, 2);
+            } else if (this->unk_19C > 40) {
+                func_80B84348(this, globalCtx, 0.0f, -400.0f, 1.0f, -12.0f, 370.0f, 100.0f, 2);
+            } else if (this->unk_19C > 20) {
+                func_80B84348(this, globalCtx, 0.0f, -400.0f, 1.8f, -12.0f, 370.0f, 100.0f, 2);
+            }
+        }
+
+        if (this->unk_19E > 6) {
+            this->unk_19E -= 6;
+        } else {
+            this->unk_19E = 0;
+        }
+
+        if (this->unk_19C >= 55) {
+            if (this->unk_1A0 < 205) {
+                this->unk_1A0 += 50;
+            } else {
+                this->unk_1A0 = 255;
+            }
+        } else if (this->unk_19C >= 36) {
+            if (this->unk_1A0 >= 16) {
+                this->unk_1A0 -= 15;
+            } else {
+                this->unk_1A0 = 0;
+            }
+        } else {
+            this->unk_1A0 = 0;
+        }
+
+        if (this->unk_19C < 60) {
+            if (this->unk_19F < 245) {
+                this->unk_19F += 10;
+            } else {
+                this->unk_19F = 255;
+            }
+        }
+
+        func_800B9010(&this->actor, NA_SE_EV_ICE_FREEZE - SFX_FLAG);
+    } else {
+        if (this->unk_1A3) {
+            ActorCutscene_Stop(this->unk_1A4);
+        }
+        func_80B8484C(this, globalCtx);
+    }
+}
+
+void func_80B84EF0(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    this->unk_19C = 60;
+    this->unk_19E = 0;
+    this->unk_19F = 255;
+    this->unk_1A0 = 0;
+    this->actionFunc = func_80B84F20;
+}
+
+void func_80B84F20(BgDblueWaterfall* this, GlobalContext* globalCtx) {
+    this->unk_19C--;
+
+    if (this->unk_19C > 0) {
+        if (this->unk_19C >= 58) {
+            func_80B84348(this, globalCtx, 100.0f, -100.0f, 4.0f, -6.0f, 370.0f, 100.0f, 0xC);
+        }
+
+        if (this->unk_19C < 50) {
+            if (this->unk_19E < 250) {
+                this->unk_19E += 5;
+            } else {
+                this->unk_19E = 255;
+            }
+        }
+
+        if (this->unk_19F >= 6) {
+            this->unk_19F -= 5;
+        } else {
+            this->unk_19F = 0;
+        }
+
+        func_800B9010(&this->actor, NA_SE_EV_ICE_MELT_LEVEL - SFX_FLAG);
+    } else {
+        if (this->unk_1A3) {
+            ActorCutscene_Stop(this->unk_1A4);
+        }
+        func_80B8484C(this, globalCtx);
+    }
+}
+
+void BgDblueWaterfall_Update(Actor* thisx, GlobalContext* globalCtx) {
+    BgDblueWaterfall* this = THIS;
+
+    this->actionFunc(this, globalCtx);
+}
+
+void BgDblueWaterfall_Draw(Actor* thisx, GlobalContext* globalCtx) {
+    s32 pad;
+    BgDblueWaterfall* this = THIS;
+
+    OPEN_DISPS(globalCtx->state.gfxCtx);
+
+    func_8012C2DC(globalCtx->state.gfxCtx);
+
+    gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+
+    if (this->unk_19E > 0) {
+        s32 sp38 = this->unk_19E * 0.49803922f;
+
+        AnimatedMat_Draw(globalCtx, this->unk_190);
+
+        gDPSetPrimColor(POLY_XLU_DISP++, 0, 0x8A, 255, 255, 255, sp38);
+        gSPDisplayList(POLY_XLU_DISP++, object_dblue_object_DL_00B280);
+    }
+
+    if (this->unk_19F > 0) {
+        if (this->unk_19F < 255) {
+            gSPSegment(POLY_XLU_DISP++, 0x09, D_801AEF88);
+            gDPSetPrimColor(POLY_XLU_DISP++, 0, 0x9B, 255, 255, 255, this->unk_19F);
+            gSPDisplayList(POLY_XLU_DISP++, object_dblue_object_DL_003358);
+        } else {
+            func_8012C28C(globalCtx->state.gfxCtx);
+
+            gSPSegment(POLY_OPA_DISP++, 0x09, D_801AEFA0);
+            gDPSetPrimColor(POLY_OPA_DISP++, 0, 0x9B, 255, 255, 255, 255);
+            gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
+                      G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+            gSPDisplayList(POLY_OPA_DISP++, object_dblue_object_DL_003358);
+        }
+
+        gDPSetPrimColor(POLY_XLU_DISP++, 0, 0xFF, 255, 255, 255, this->unk_19F);
+        gSPDisplayList(POLY_XLU_DISP++, object_dblue_object_DL_003250);
+    }
+
+    if (this->unk_1A0 > 0) {
+        gDPSetPrimColor(POLY_XLU_DISP++, 0, 0xFF, 255, 255, 255, this->unk_1A0);
+        gSPDisplayList(POLY_XLU_DISP++, object_dblue_object_DL_003770);
+    }
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
diff --git a/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.h b/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.h
index eb12538fcd..0fa908629a 100644
--- a/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.h
+++ b/src/overlays/actors/ovl_Bg_Dblue_Waterfall/z_bg_dblue_waterfall.h
@@ -7,11 +7,25 @@ struct BgDblueWaterfall;
 
 typedef void (*BgDblueWaterfallActionFunc)(struct BgDblueWaterfall*, GlobalContext*);
 
+#define BGDBLUEWATERFALL_GET_7F(thisx) ((thisx)->params & 0x7F)
+#define BGDBLUEWATERFALL_GET_100(thisx) (((thisx)->params >> 8) & 1)
+
 typedef struct BgDblueWaterfall {
     /* 0x0000 */ Actor actor;
-    /* 0x0144 */ char unk_144[0x50];
+    /* 0x0144 */ ColliderCylinder collider;
+    /* 0x0190 */ AnimatedMaterial* unk_190;
     /* 0x0194 */ BgDblueWaterfallActionFunc actionFunc;
-    /* 0x0198 */ char unk_198[0x14];
+    /* 0x0198 */ f32 unk_198;
+    /* 0x019C */ s16 unk_19C;
+    /* 0x019E */ u8 unk_19E;
+    /* 0x019F */ u8 unk_19F;
+    /* 0x01A0 */ u8 unk_1A0;
+    /* 0x01A1 */ UNK_TYPE1 unk1A1[2];
+    /* 0x01A3 */ s8 unk_1A3;
+    /* 0x01A4 */ s16 unk_1A4;
+    /* 0x01A6 */ UNK_TYPE1 unk1A6[1];
+    /* 0x01A7 */ s8 unk_1A7;
+    /* 0x01A8 */ f32 unk_1A8;
 } BgDblueWaterfall; // size = 0x1AC
 
 extern const ActorInit Bg_Dblue_Waterfall_InitVars;
diff --git a/undefined_syms.txt b/undefined_syms.txt
index 8cec768381..36199793c2 100644
--- a/undefined_syms.txt
+++ b/undefined_syms.txt
@@ -579,14 +579,6 @@ D_0600D250 = 0x0600D250;
 D_060002C8 = 0x060002C8;
 D_060005C4 = 0x060005C4;
 
-// ovl_Bg_Dblue_Waterfall
-
-D_06003250 = 0x06003250;
-D_06003358 = 0x06003358;
-D_06003770 = 0x06003770;
-D_0600B280 = 0x0600B280;
-D_0600B448 = 0x0600B448;
-
 // ovl_Bg_Dkjail_Ivy
 
 D_06000080 = 0x06000080;