d_a_arrow work (#2139)

* WIP commit, about halfway done

* More progress, fixed up some issues

* Most functions match, minor issues in draw/create, dtor needs particle work

* Forgot to remove NONMATCHING define

---------

Co-authored-by: GinNoOokami <noreply>

2 files changed, 1279 insertions, 160 deletions

diff --git a/rel/d/a/d_a_arrow/d_a_arrow.cpp b/rel/d/a/d_a_arrow/d_a_arrow.cpp
index 3149129f1e..4c6d0c9f43 100644
--- a/rel/d/a/d_a_arrow/d_a_arrow.cpp
+++ b/rel/d/a/d_a_arrow/d_a_arrow.cpp
@@ -4,8 +4,16 @@
 //
 
 #include "rel/d/a/d_a_arrow/d_a_arrow.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "SSystem/SComponent/c_math.h"
 #include "dol2asm.h"
+#include "f_op/f_op_kankyo_mng.h"
 #include "d/com/d_com_inf_game.h"
+#include "d/a/d_a_alink.h"
+#include "d/d_bomb.h"
+#include "rel/d/a/e/d_a_e_pz/d_a_e_pz.h"
+#include "rel/d/a/d_a_horse/d_a_horse.h"
+#include "rel/d/a/d_a_hozelda/d_a_hozelda.h"
 
 //
 // Forward References:
@@ -47,7 +55,7 @@ extern "C" void procSlingHit__9daArrow_cFv();
 extern "C" void execute__9daArrow_cFv();
 extern "C" static void daArrow_execute__FP9daArrow_c();
 extern "C" void draw__9daArrow_cFv();
-extern "C" static void daArrow_draw__FP9daArrow_c();
+extern "C" static int daArrow_draw__FP9daArrow_c();
 extern "C" static void daAlink_searchHorseZelda__FP10fopAc_ac_cPv();
 extern "C" void create__9daArrow_cFv();
 extern "C" void cleanup__18dPa_levelEcallBackFv();
@@ -55,9 +63,9 @@ extern "C" void __dt__18dPa_levelEcallBackFv();
 extern "C" void __dt__8cM3dGSphFv();
 extern "C" void __dt__8cM3dGAabFv();
 extern "C" void __dt__10dCcD_GSttsFv();
-extern "C" static void daArrow_create__FP9daArrow_c();
+extern "C" static int daArrow_create__FP9daArrow_c();
 extern "C" void __dt__9daArrow_cFv();
-extern "C" static void daArrow_delete__FP9daArrow_c();
+extern "C" static int daArrow_delete__FP9daArrow_c();
 extern "C" void __dt__10cCcD_GSttsFv();
 extern "C" void execute__18JPAEmitterCallBackFP14JPABaseEmitter();
 extern "C" void executeAfter__18JPAEmitterCallBackFP14JPABaseEmitter();
@@ -216,33 +224,42 @@ extern "C" void __register_global_object();
 // Declarations:
 //
 
-/* ############################################################################################## */
-/* 8049DE04-8049DE04 000180 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-#pragma push
-#pragma force_active on
-SECTION_DEAD static char const* const stringBase_8049DE04 = "HoZelda";
-#pragma pop
-
 /* 80499C6C-80499D6C 0000EC 0100+00 1/1 0/0 0/0 .text            createHeap__9daArrow_cFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::createHeap() {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/createHeap__9daArrow_cFv.s"
+int daArrow_c::createHeap() {
+    J3DModelData* model_data;
+
+    if (mArrowType == 2) {
+        model_data = (J3DModelData*)dComIfG_getObjectRes("HoZelda", 0x1f);
+    } else {
+        u16 index;
+        
+        if (mArrowType == 4) {
+            index = 0x20;
+        } else if (mArrowType == 1) {
+            index = 0x1d;
+        } else {
+            index = 0x1c;
+        }
+        model_data = (J3DModelData*)dComIfG_getObjectRes(daAlink_c::getAlinkArcName(), index);
+    }
+
+    mpModel = mDoExt_J3DModel__create(model_data, 0x80000, 0x11000084);
+
+    if (mpModel == NULL) {
+        return FALSE;
+    }
+
+    mSoundObjArrow.init(&current.pos, 1);
+    mReverb = dComIfGp_getReverb(fopAcM_GetRoomNo(this));
+
+    return TRUE;
 }
-#pragma pop
 
 /* 80499D6C-80499D8C 0001EC 0020+00 1/1 0/0 0/0 .text            daArrow_createHeap__FP10fopAc_ac_c
  */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm void daArrow_createHeap(fopAc_ac_c* param_0) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/daArrow_createHeap__FP10fopAc_ac_c.s"
+static int daArrow_createHeap(fopAc_ac_c* i_this) {
+    return static_cast<daArrow_c*>(i_this)->createHeap();
 }
-#pragma pop
 
 /* ############################################################################################## */
 /* 8049DC84-8049DC90 000000 000C+00 15/15 0/0 0/0 .rodata          @3768 */
@@ -283,6 +300,7 @@ const static dCcD_SrcSph l_coSphSrc = {
 };
 #pragma pop
 
+#ifndef NONMATCHING
 /* 8049DD1C-8049DD24 000098 0004+04 2/12 0/0 0/0 .rodata          @4130 */
 SECTION_RODATA static u8 const lit_4130[4 + 4 /* padding */] = {
     0x00,
@@ -323,9 +341,40 @@ SECTION_RODATA static u8 const lit_4133[8] = {
 };
 COMPILER_STRIP_GATE(0x8049DD34, &lit_4133);
 #pragma pop
+#endif
 
 /* 80499D8C-80499F9C 00020C 0210+00 1/1 0/0 0/0 .text
  * atHitCallBack__9daArrow_cFP12dCcD_GObjInfP10fopAc_ac_cP12dCcD_GObjInf */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::atHitCallBack(dCcD_GObjInf* i_atObjInf, fopAc_ac_c* i_tgActor, dCcD_GObjInf* i_tgObjInf) {
+    if (i_tgObjInf->ChkTgArrowThrough()) {
+        if (i_tgActor != NULL && fopAcM_GetName(i_tgActor) == PROC_E_PZ) {
+            ((daE_PZ_c*)i_tgActor)->onBombArrowHit();
+        }
+    } else if (i_tgActor != NULL && fopAcM_IsActor(i_tgActor)) {
+        cXyz* hit_pos_p = i_atObjInf->GetAtHitPosP();
+        f32 dist_to_hitpos = current.pos.abs(*hit_pos_p);
+
+        if (dist_to_hitpos < field_0x998) {
+            field_0x998 = dist_to_hitpos;
+            mHitAcID = fopAcM_GetID(i_tgActor);
+
+            if (mArrowType == 1) {
+                field_0x9a8 = *hit_pos_p;
+            } else if (i_tgObjInf->ChkTgShield()) {
+                field_0x93e = 1;
+            } else {
+                field_0x93e = 0;
+                dJntCol_c * jnt = fopAcM_GetJntCol(i_tgActor);
+                if (jnt != NULL) {
+                    field_0x960 = jnt->getArrowOffsetPosAndAngle(hit_pos_p, &shape_angle, &field_0x9a8, &field_0x9b4);
+                }
+            }
+        }
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -335,35 +384,47 @@ asm void daArrow_c::atHitCallBack(dCcD_GObjInf* param_0, fopAc_ac_c* param_1,
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/atHitCallBack__9daArrow_cFP12dCcD_GObjInfP10fopAc_ac_cP12dCcD_GObjInf.s"
 }
 #pragma pop
+#endif
 
 /* 80499F9C-80499FBC 00041C 0020+00 1/1 0/0 0/0 .text
  * daArrow_atHitCallBack__FP10fopAc_ac_cP12dCcD_GObjInfP10fopAc_ac_cP12dCcD_GObjInf */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm void daArrow_atHitCallBack(fopAc_ac_c* param_0, dCcD_GObjInf* param_1,
-                                      fopAc_ac_c* param_2, dCcD_GObjInf* param_3) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/daArrow_atHitCallBack__FP10fopAc_ac_cP12dCcD_GObjInfP10fopAc_ac_cP12dCcD_GObjInf.s"
+static void daArrow_atHitCallBack(fopAc_ac_c* i_this, dCcD_GObjInf* i_atObjInf, fopAc_ac_c* i_tgActor, dCcD_GObjInf* i_tgObjInf) {
+    static_cast<daArrow_c*>(i_this)->atHitCallBack(i_atObjInf, i_tgActor, i_tgObjInf);
 }
-#pragma pop
 
 /* 80499FBC-8049A04C 00043C 0090+00 5/5 0/0 0/0 .text            decAlphaBlur__9daArrow_cFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::decAlphaBlur() {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/decAlphaBlur__9daArrow_cFv.s"
+void daArrow_c::decAlphaBlur() {
+    for (int i = 0; i < field_0x946; i++) {
+        JPABaseEmitter* emitter = dComIfGp_particle_getEmitter(field_0x97c[0]);
+        if (emitter != NULL) {
+            u8 alpha = emitter->getGlobalAlpha();
+            if (alpha > 0x33) {
+                setBlur();
+                emitter->setGlobalAlpha(alpha - 51);
+            } else {
+                emitter->setGlobalAlpha(0);
+            }
+        }
+    }
 }
-#pragma pop
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD3C-8049DD40 0000B8 0004+00 4/10 0/0 0/0 .rodata          @4187 */
 SECTION_RODATA static f32 const lit_4187 = 1.0f;
 COMPILER_STRIP_GATE(0x8049DD3C, &lit_4187);
+#endif
 
 /* 8049A04C-8049A110 0004CC 00C4+00 5/5 0/0 0/0 .text            setBlur__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setBlur() {
+    for (int i = 0; i < field_0x946; i++) {
+        field_0x97c[i] = dComIfGp_particle_set(field_0x97c[i], field_0x94c, &current.pos, &tevStr);
+        dComIfGp_particle_levelEmitterOnEventMove(field_0x97c[i]);
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -372,15 +433,38 @@ asm void daArrow_c::setBlur() {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setBlur__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* ############################################################################################## */
 /* 8049DD40-8049DD4C 0000BC 000C+00 1/1 0/0 0/0 .rodata          effName$4192 */
+#ifndef NONMATCHING
 SECTION_RODATA static u8 const effName_4192[12] = {
     0x89, 0x6F, 0x89, 0x70, 0x89, 0x71, 0x89, 0x72, 0x89, 0x73, 0x89, 0x74,
 };
 COMPILER_STRIP_GATE(0x8049DD40, &effName_4192);
+#else
+static u16 const effName_4192[] = {
+    0x896F,
+    0x8970,
+    0x8971,
+    0x8972,
+    0x8973,
+    0x8974,
+};
+#endif
 
 /* 8049A110-8049A1EC 000590 00DC+00 1/1 0/0 0/0 .text setLightArrowHitMark__9daArrow_cFPC4cXyz */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setLightArrowHitMark(cXyz const* param_0) {
+    for (int i = 0; i < 6; i++) {
+        dComIfGp_particle_set(effName_4192[i], param_0, &shape_angle, NULL);
+    }
+    
+    field_0x93f = 1;
+    mSoundObjArrow.startSound(Z2SE_ZELDA_ARROW_HIT, 0, mReverb);
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -389,7 +473,9 @@ asm void daArrow_c::setLightArrowHitMark(cXyz const* param_0) {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setLightArrowHitMark__9daArrow_cFPC4cXyz.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD4C-8049DD54 0000C8 0008+00 0/1 0/0 0/0 .rodata          effName$4214 */
 #pragma push
@@ -408,9 +494,40 @@ SECTION_RODATA static u8 const localEffPos[12] = {
 };
 COMPILER_STRIP_GATE(0x8049DD54, &localEffPos);
 #pragma pop
+#else
+static u16 const effName_4214[] = {
+    0x8975,
+    0x8976,
+    0x8977,
+    0x8978,
+
+};
+static Vec const localEffPos = {0.0f, 0.0f, 90.0f};
+#endif
 
 /* 8049A1EC-8049A334 00066C 0148+00 2/2 0/0 0/0 .text            setLightChargeEffect__9daArrow_cFi
  */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setLightChargeEffect(int param_0) {
+    if (mpModel != NULL) {
+        cXyz pos;
+        BOOL bVar1 = param_0 == 0 && (fopAcM_GetParam(this) == 1 || fopAcM_GetParam(this) == 2 || fopAcM_GetParam(this) == 0);
+        mDoMtx_multVec(mpModel->getBaseTRMtx(), &localEffPos, &pos);
+        for (int i = 0; i < 4; i++) {
+            if (bVar1) {
+                field_0x96c[i] = dComIfGp_particle_set(field_0x96c[i], effName_4214[i], &pos, &tevStr);
+                dComIfGp_particle_levelEmitterOnEventMove(field_0x96c[i]);
+            } else {
+                JPABaseEmitter* emitter = dComIfGp_particle_getEmitter(field_0x96c[i]);
+                if (emitter != NULL) {
+                    emitter->stopDrawParticle(); 
+                }
+            }
+        }
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -419,6 +536,7 @@ asm void daArrow_c::setLightChargeEffect(int param_0) {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setLightChargeEffect__9daArrow_cFi.s"
 }
 #pragma pop
+#endif
 
 /* 8049A334-8049A370 0007B4 003C+00 1/1 0/0 0/0 .text            __dt__4cXyzFv */
 #pragma push
@@ -431,6 +549,7 @@ extern "C" asm void __dt__4cXyzFv() {
 }
 #pragma pop
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD60-8049DD64 0000DC 0004+00 0/1 0/0 0/0 .rodata          @4385 */
 #pragma push
@@ -445,18 +564,61 @@ COMPILER_STRIP_GATE(0x8049DD60, &lit_4385);
 SECTION_RODATA static f32 const lit_4386 = 80.0f;
 COMPILER_STRIP_GATE(0x8049DD64, &lit_4386);
 #pragma pop
+#endif
 
 /* 8049A370-8049A76C 0007F0 03FC+00 2/2 0/0 0/0 .text
  * setArrowWaterNextPos__9daArrow_cFP4cXyzP4cXyz                */
+#ifdef NONMATCHING
+// matches with literals
+int daArrow_c::setArrowWaterNextPos(cXyz* i_start, cXyz* i_end) {
+    field_0x5dc.Set(i_start, i_end, this);
+
+    if (dComIfG_Bgsp().LineCross(&field_0x5dc)) {
+        if (dComIfG_Bgsp().GetPolyAtt0(field_0x5dc) == 6) {
+            *i_end = field_0x5dc.i_GetCross();
+            return 2;
+        }
+        
+        cXyz v = *i_end - field_0x5dc.i_GetCross();
+        f32 dis = (*i_end).abs(*i_start);
+
+        if (dis > 0.0001f) {
+            dis = v.abs() / dis;
+        } else {
+            dis = 1.0f;
+        }
+
+        v.normalizeZP();
+        *i_end = field_0x5dc.i_GetCross() + v * 80.0f * dis;
+        return 1;
+    } 
+    
+    if (fopAcM_wt_c::waterCheck(i_start) && fopAcM_wt_c::getWaterY() > i_start->y) {
+        if (fopAcM_wt_c::getPolyAtt0() == 6) {
+            i_end->y = fopAcM_wt_c::getWaterY();
+            return 4;
+        }
+
+        cXyz v = *i_end - *i_start;
+        v.normalizeZP();
+        *i_end = *i_start + (v * 80.0f);
+        return 3;
+    }
+
+    return 0;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::setArrowWaterNextPos(cXyz* param_0, cXyz* param_1) {
+asm int daArrow_c::setArrowWaterNextPos(cXyz* param_0, cXyz* param_1) {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setArrowWaterNextPos__9daArrow_cFP4cXyzP4cXyz.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD68-8049DD6C 0000E4 0004+00 0/1 0/0 0/0 .rodata          @4445 */
 #pragma push
@@ -478,8 +640,64 @@ COMPILER_STRIP_GATE(0x8049DD6C, &lit_4446);
 SECTION_RODATA static f32 const lit_4447 = -300.0f;
 COMPILER_STRIP_GATE(0x8049DD70, &lit_4447);
 #pragma pop
+#endif
 
 /* 8049A76C-8049A9CC 000BEC 0260+00 2/2 0/0 0/0 .text            setArrowAt__9daArrow_cFf */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setArrowAt(f32 param_0) {
+    daAlink_c* player = daAlink_getAlinkActorClass();
+
+    f32 radius;
+    if (mArrowType == 4) {
+        radius = 8.0f;
+    } else {
+        radius = 5.0f;
+    }
+
+    f32 arrow_start = player->getArrowIncAtMaxStart();
+    if (param_0 > arrow_start) {
+        f32 inc = player->getArrowIncAtMax();
+        if (inc <= arrow_start) {
+            radius += player->getArrowIncAtR();
+        } else {
+            f32 mod = (param_0 - arrow_start) / (inc - arrow_start);
+            if (mod > 1.0f) {
+                mod = 1.0f;
+            }
+            radius += (mod * player->getArrowIncAtR());
+        }
+    }
+
+    cXyz target = current.pos + speed * (mOutLengthRate + 1.0f);
+
+    if (field_0x945 == 0) {
+        setArrowWaterNextPos(&current.pos, &target);
+    } else {
+        f32 fVar7 = target.y - field_0x9fc.y;
+        if (fVar7 < -300.0f) {
+            f32 fVar1 = fabsf(target.y - current.pos.y);
+            fVar7 = -300.0f - fVar7;
+
+            if (fVar1 > fVar7) {
+                target = current.pos + speed * ((mOutLengthRate + 1.0f) * ((fVar1 - fVar7) / fVar1));
+            }
+        }
+    }
+
+    field_0x56c.Set(&current.pos, &target, this);
+
+    if (dComIfG_Bgsp().LineCross(&field_0x56c)) {
+        target = field_0x56c.i_GetCross();
+    }
+
+    static_cast<cM3dGCps*>(&field_0x688)->Set(current.pos, target, radius);
+    field_0x688.CalcAtVec();
+
+    g_dComIfG_gameInfo.play.mCcs.Set(&field_0x688); // fake match: debug rom shows dComIfG_Ccsp()
+    g_dComIfG_gameInfo.play.mCcs.SetMass(&field_0x688, 1); // fake match: debug rom shows dComIfG_Ccsp()
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -488,13 +706,90 @@ asm void daArrow_c::setArrowAt(f32 param_0) {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setArrowAt__9daArrow_cFf.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD74-8049DD78 0000F0 0004+00 1/1 0/0 0/0 .rodata          @4541 */
 SECTION_RODATA static f32 const lit_4541 = 100.0f;
 COMPILER_STRIP_GATE(0x8049DD74, &lit_4541);
+#endif
 
 /* 8049A9CC-8049AC84 000E4C 02B8+00 2/2 0/0 0/0 .text            arrowShooting__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::arrowShooting() {
+    daAlink_c* link = daAlink_getAlinkActorClass();
+
+    field_0x950 = link->getBombArrowFlyExplodeTime();
+
+    if (mArrowType == 4) {
+        current.angle.x = -link->getBodyAngleX();
+        current.angle.y = link->shape_angle.y + link->getBodyAngleY();
+    } else if (dComIfGp_checkPlayerStatus0(0, 0x200000) || fopAcM_GetParam(this) == 2)  {
+        cXyz* pos = link->checkBowCameraArrowPosP(&shape_angle.x, &shape_angle.y);
+        if (pos != NULL) {
+            current.pos = *pos;
+            
+            if (link->checkMagneBootsOn()) {
+                mDoMtx_stack_c::copy(link->getMagneBootsMtx());
+                mDoMtx_stack_c::ZXYrotM(shape_angle);
+                mDoMtx_MtxToRot(mDoMtx_stack_c::get(), &shape_angle);
+            }
+
+            current.angle.x = -shape_angle.x;
+            current.angle.y = shape_angle.y;
+        }
+    }
+
+    speedF = 100.f;
+    mStartPos = current.pos;
+
+    f32 cos = cM_scos(current.angle.x);
+    speed.x = cos * (field_0x99c * cM_ssin(current.angle.y));
+    speed.y = field_0x99c * cM_ssin(current.angle.x);
+    speed.z = cos * (field_0x99c * cM_scos(current.angle.y));
+
+    daPy_py_c* player = daPy_getPlayerActorClass();
+    if (player->checkHorseRide()) {
+        daHorse_c* horse = dComIfGp_getHorseActor();
+        cMtx_YrotS(*calc_mtx, horse->shape_angle.y);
+
+        cXyz src;
+        cXyz dst;
+
+        src.x = 0.0f;
+        src.y = 0.0f;
+        src.z = horse->speedF;
+
+        MtxPosition(&src, &dst);
+
+        speed += dst;
+    }
+
+    if (mArrowType == 2) {
+        field_0x688.SetAtMtrl(04);
+        field_0x688.OnAtNoHitMark();
+    } else {
+        if (mArrowType == 4) {
+            field_0x688.SetAtType(0x80);
+            field_0x688.SetAtSe(22);
+            field_0x688.SetAtAtp(0);
+            field_0x688.OnAtNoHitMark();
+        }
+
+        field_0x94e = m_count;
+        m_count++;
+        if (m_count == 6) {
+            m_count = 0;
+        }
+    }
+
+    setBlur();
+    setArrowAt(0.0f);
+    clearNearActorData();
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -503,18 +798,32 @@ asm void daArrow_c::arrowShooting() {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/arrowShooting__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049AC84-8049ACE0 001104 005C+00 3/3 0/0 0/0 .text setBombArrowExplode__9daArrow_cFP4cXyz */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::setBombArrowExplode(cXyz* param_0) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/setBombArrowExplode__9daArrow_cFP4cXyz.s"
+void daArrow_c::setBombArrowExplode(cXyz* param_0) {
+    dBomb_c::createNormalBombExplode(param_0);
+    field_0x93f = 1;
 }
-#pragma pop
 
 /* 8049ACE0-8049AD74 001160 0094+00 1/1 0/0 0/0 .text            setRoomInfo__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setRoomInfo() {
+    int roomNo;
+
+    if (fopAcM_gc_c::gndCheck(&current.pos)) {
+        roomNo = fopAcM_gc_c::getRoomId();
+        tevStr.mEnvrIdxOverride = fopAcM_gc_c::getPolyColor();
+    } else {
+        roomNo = dComIfGp_roomControl_getStayNo();
+    }
+    
+    tevStr.mRoomNo = roomNo;
+    field_0x64c.SetRoomId(roomNo);
+    fopAcM_SetRoomNo(this, roomNo);
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -523,17 +832,16 @@ asm void daArrow_c::setRoomInfo() {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setRoomInfo__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049AD74-8049AD94 0011F4 0020+00 2/2 0/0 0/0 .text            clearNearActorData__9daArrow_cFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::clearNearActorData() {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/clearNearActorData__9daArrow_cFv.s"
+void daArrow_c::clearNearActorData() {
+    field_0x93e = 0;
+    field_0x998 = FLT_MAX;
+    mHitAcID = -1;
 }
-#pragma pop
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD78-8049DD7C 0000F4 0004+00 0/1 0/0 0/0 .rodata          @4576 */
 #pragma push
@@ -575,17 +883,36 @@ SECTION_RODATA static u8 const lit_4582[8] = {
 };
 COMPILER_STRIP_GATE(0x8049DD8C, &lit_4582);
 #pragma pop
+#endif
 
 /* 8049AD94-8049AE64 001214 00D0+00 2/2 0/0 0/0 .text            getVibAngle__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+s16 daArrow_c::getVibAngle() {
+    s16 angle;
+    if (cLib_calcTimer(&field_0x952)) {
+        field_0x954 += (s16)(21243.0f - cM_rndF(4096.0f));
+
+        f32 f = field_0x952 * 0.02f;
+        angle = f * 1024.0f * f * cM_ssin(field_0x954);
+    } else {
+        angle = 0;
+    }
+
+    return angle;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::getVibAngle() {
+asm s16 daArrow_c::getVibAngle() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/getVibAngle__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD94-8049DD98 000110 0004+00 1/2 0/0 0/0 .rodata          @4606 */
 SECTION_RODATA static f32 const lit_4606 = -95.0f;
@@ -597,8 +924,25 @@ COMPILER_STRIP_GATE(0x8049DD94, &lit_4606);
 SECTION_RODATA static f32 const lit_4607 = -47.5f;
 COMPILER_STRIP_GATE(0x8049DD98, &lit_4607);
 #pragma pop
+#endif
 
 /* 8049AE64-8049AF18 0012E4 00B4+00 4/4 0/0 0/0 .text            setNormalMatrix__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setNormalMatrix() {
+    mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
+    mDoMtx_stack_c::ZXYrotM(shape_angle.x, shape_angle.y, 0);
+
+    u32 param = fopAcM_GetParam(this);
+    if (param == 4) {
+        mDoMtx_stack_c::transM(0.0f, 0.0f, -95.0f);
+    } else if (param == 5) {
+        mDoMtx_stack_c::transM(0.0f, 0.0f, -47.5f);
+
+    }
+    mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -607,7 +951,9 @@ asm void daArrow_c::setNormalMatrix() {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setNormalMatrix__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DD9C-8049DDA0 000118 0004+00 0/1 0/0 0/0 .rodata          @4630 */
 #pragma push
@@ -636,6 +982,7 @@ COMPILER_STRIP_GATE(0x8049DDA4, &lit_4632);
 SECTION_RODATA static f32 const lit_4633 = 9.0f / 10.0f;
 COMPILER_STRIP_GATE(0x8049DDA8, &lit_4633);
 #pragma pop
+#endif
 
 /* 8049DF60-8049DF64 000008 0001+03 1/1 0/0 0/0 .bss             @1109 */
 static u8 lit_1109[1 + 3 /* padding */];
@@ -730,6 +1077,7 @@ static u8 lit_1010[1 + 3 /* padding */];
 static u8 lit_1009[1 + 3 /* padding */];
 #pragma pop
 
+#ifndef NONMATCHING
 /* 8049DFA0-8049DFB0 000048 000C+04 0/1 0/0 0/0 .bss             @4612 */
 #pragma push
 #pragma force_active on
@@ -741,8 +1089,20 @@ static u8 lit_4612[12 + 4 /* padding */];
 #pragma force_active on
 static u8 localOffset[12];
 #pragma pop
+#endif
 
 /* 8049AF18-8049AFEC 001398 00D4+00 3/3 0/0 0/0 .text            setSmokePos__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setSmokePos() {
+    static cXyz localOffset(-3.3f, -3.0f, 94.0f);
+
+    mDoMtx_multVec(mpModel->getBaseTRMtx(), &localOffset, &field_0x9cc);
+    field_0x958.y = shape_angle.y;
+
+    mSmokePos = (field_0x9cc - field_0x9d8) * 0.9f;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -751,7 +1111,9 @@ asm void daArrow_c::setSmokePos() {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setSmokePos__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDAC-8049DDB0 000128 0004+00 0/2 0/0 0/0 .rodata          @4674 */
 #pragma push
@@ -766,8 +1128,34 @@ COMPILER_STRIP_GATE(0x8049DDAC, &lit_4674);
 SECTION_RODATA static f32 const lit_4675 = -2.0f;
 COMPILER_STRIP_GATE(0x8049DDB0, &lit_4675);
 #pragma pop
+#endif
 
 /* 8049AFEC-8049B120 00146C 0134+00 3/3 0/0 0/0 .text            setKeepMatrix__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setKeepMatrix() {
+    if (mArrowType == 2) {
+        daHoZelda_c* actor = (daHoZelda_c*)field_0xa08.getActor();
+        if (actor != NULL) {
+            mDoMtx_stack_c::copy(actor->getRightHandMtx());
+            mDoMtx_stack_c::transM(20.0f, -2.0f, 0.0f);
+            mDoMtx_XYZrotM(mDoMtx_stack_c::get(), cM_deg2s(90.0f), cM_deg2s(60.0f), cM_deg2s(90.0f));
+        } else {
+            field_0x93f = 1;
+            return;
+        }
+    } else {
+        mDoMtx_stack_c::YrotS(-0x8000);
+        mDoMtx_stack_c::revConcat(daAlink_getAlinkActorClass()->getLeftItemMatrix());
+    }
+    mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
+    mDoMtx_multVecZero(mpModel->getBaseTRMtx(), &current.pos);
+    mDoMtx_MtxToRot(mpModel->getBaseTRMtx(), &shape_angle);
+
+    current.angle.y = shape_angle.y;
+    current.angle.x = -shape_angle.x;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -776,23 +1164,69 @@ asm void daArrow_c::setKeepMatrix() {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setKeepMatrix__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049B120-8049B214 0015A0 00F4+00 2/2 0/0 0/0 .text            setStopActorMatrix__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+fopAc_ac_c* daArrow_c::setStopActorMatrix() {
+    s16 vibe_angle = getVibAngle();
+    fopAc_ac_c* actor = fopAcM_SearchByID(mHitAcID);
+    if (actor == NULL) {
+        return NULL;
+    }
+
+    dJntCol_c* jnt = fopAcM_GetJntCol(actor);
+    if (jnt == NULL) {
+        return NULL;
+    }
+    
+    jnt->setArrowPosAndAngle(&field_0x9a8, &field_0x9b4, field_0x960, &current.pos, &shape_angle);
+    mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
+    mDoMtx_stack_c::ZXYrotM(shape_angle.x + vibe_angle, shape_angle.y, shape_angle.z);
+    mDoMtx_stack_c::transM(0.0f, 0.0f, -95.0f);
+    mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
+
+    return actor;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::setStopActorMatrix() {
+asm fopAc_ac_c* daArrow_c::setStopActorMatrix() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setStopActorMatrix__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDB4-8049DDB8 000130 0004+00 1/1 0/0 0/0 .rodata          @4749 */
 SECTION_RODATA static f32 const lit_4749 = 0.25f;
 COMPILER_STRIP_GATE(0x8049DDB4, &lit_4749);
+#endif
 
 /* 8049B214-8049B370 001694 015C+00 4/4 0/0 0/0 .text            setBombMoveEffect__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+void daArrow_c::setBombMoveEffect() {
+    if (mArrowType == 1 && field_0x945 == 0 && field_0x943 == 0) {
+        setSmokePos();
+        field_0x964 = dComIfGp_particle_set(field_0x964, 0x1e0, &field_0x9cc, &tevStr, &field_0x958, NULL, 0xff, &field_0xa10, -1, NULL, NULL, NULL);
+        dComIfGp_particle_levelEmitterOnEventMove(field_0x964);
+        field_0xa10.setRate(0.25f);
+
+        field_0x968 = dComIfGp_particle_set(field_0x968, 0x1de, &field_0x9cc, &tevStr, &field_0x958, NULL, 0xff, NULL, -1, NULL, NULL, NULL);
+        dComIfGp_particle_levelEmitterOnEventMove(field_0x968);
+
+        JPABaseEmitter* emitter = dComIfGp_particle_getEmitter(field_0x968);
+        if (emitter != NULL) {
+            emitter->playDrawParticle();
+        }
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -801,7 +1235,9 @@ asm void daArrow_c::setBombMoveEffect() {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/setBombMoveEffect__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDB8-8049DDBC 000134 0004+00 0/3 0/0 0/0 .rodata          @4763 */
 #pragma push
@@ -809,27 +1245,49 @@ asm void daArrow_c::setBombMoveEffect() {
 SECTION_RODATA static f32 const lit_4763 = -1.0f;
 COMPILER_STRIP_GATE(0x8049DDB8, &lit_4763);
 #pragma pop
+#endif
 
 /* 8049B370-8049B45C 0017F0 00EC+00 2/2 0/0 0/0 .text            checkReget__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+bool daArrow_c::checkReget() {
+    if (field_0x7cc.ChkCoHit()) {
+        dComIfGp_setItemArrowNumCount(1);
+        fopAcM_createItemForSimpleDemo(&current.pos, ARROW_1, -1, NULL, NULL, 0.0f, 0.0f);
+        mDoAud_seStart(Z2SE_CONSUMP_ITEM_GET, 0, 0, 0);
+        field_0x93f = 1;
+        return true;
+    } else {
+        field_0x7cc.SetC(current.pos);
+        dComIfG_Ccsp()->Set(&field_0x7cc);
+        return false;
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::checkReget() {
+asm bool daArrow_c::checkReget() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/checkReget__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
+
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDBC-8049DDC0 000138 0004+00 2/3 0/0 0/0 .rodata          @4868 */
 SECTION_RODATA static f32 const lit_4868 = 95.0f;
 COMPILER_STRIP_GATE(0x8049DDBC, &lit_4868);
+#endif
 
 /* 8049DE0C-8049DE18 000000 000C+00 1/1 0/0 0/0 .data            cNullVec__6Z2Calc */
 SECTION_DATA static u8 cNullVec__6Z2Calc[12] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
+#ifndef NONMATCHING
 /* 8049DE18-8049DE2C 00000C 0004+10 0/0 0/0 0/0 .data            @1787 */
 #pragma push
 #pragma force_active on
@@ -842,24 +1300,100 @@ SECTION_DATA static u32 lit_1787[1 + 4 /* padding */] = {
     0x00000000,
 };
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* 8049DE2C-8049DE38 -00001 000C+00 1/1 0/0 0/0 .data            @4777 */
 SECTION_DATA static void* lit_4777[3] = {
     (void*)NULL,
     (void*)0xFFFFFFFF,
     (void*)procMove__9daArrow_cFv,
 };
+#endif
 
 /* 8049B45C-8049B764 0018DC 0308+00 1/0 0/0 0/0 .text            procWait__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+int daArrow_c::procWait() {
+    setKeepMatrix();
+
+    u32 param = fopAcM_GetParam(this);
+    if (param == 1 || param == 2) {
+        tevStr.mFogColor.r = 0;
+        tevStr.mFogColor.g = 0;
+        tevStr.mFogColor.b = 0;
+
+        daAlink_c* link = daAlink_getAlinkActorClass();
+        if (mArrowType == 1) {
+            field_0x688.SetAtAtp(0);
+            if (!link->checkCanoeSlider()) {
+                field_0x688.OnAtSPrmBit(0x20);
+            }
+        } else {
+            field_0x688.SetAtAtp(2);
+        }
+        link->getArrowFlyData(&mFlyMax, &field_0x99c, 0);
+        mOutLengthRate = 95.0f / field_0x99c;
+        field_0xa10.setOldPosP(&field_0x9d8, &field_0x9e4);
+        JPABaseEmitter* emitter = dComIfGp_particle_getEmitter(field_0x964);
+        if (emitter != NULL) {
+            emitter->setParticleCallBackPtr(NULL);
+        }
+        mProcFunc = &daArrow_c::procMove;
+        arrowShooting();
+        setBombMoveEffect();
+    } else if (mArrowType == 1) {
+        setSmokePos();
+        
+        field_0x964 = dComIfGp_particle_set(field_0x964, 0x1df, &field_0x9cc, &tevStr, &field_0x958, NULL, 0xff, NULL, -1, NULL, NULL, NULL);
+        dComIfGp_particle_levelEmitterOnEventMove(field_0x964);
+        
+        JPABaseEmitter* emitter = dComIfGp_particle_getEmitter(field_0x964);
+        if (emitter != NULL) {
+            emitter->setParticleCallBackPtr(dPa_control_c::getParticleTracePCB());
+            emitter->setUserWork((u32)&mSmokePos);
+
+            if (field_0x942 != 0) {
+                emitter->stopDrawParticle();
+            } else {
+                emitter->playDrawParticle();
+            }
+        }
+        
+        field_0x968 = dComIfGp_particle_set(field_0x968, 0x1de, &field_0x9cc, &tevStr, &field_0x958, NULL, 0xff, NULL, -1, NULL, NULL, NULL);
+        dComIfGp_particle_levelEmitterOnEventMove(field_0x968);
+        emitter = dComIfGp_particle_getEmitter(field_0x968);
+        if (emitter != NULL) {
+            if (field_0x942 != 0) {
+                emitter->stopDrawParticle();
+            } else {
+                emitter->playDrawParticle();
+            }
+        }
+
+        mSoundObjArrow.startLevelSound(0x8000a, 0, mReverb);
+    }
+
+    if(dComIfGp_checkCameraAttentionStatus(dComIfGp_getPlayerCameraID(0), 2)) {
+        field_0x942 = 3;
+    } else {
+        field_0x942 = 0;
+    }
+
+    return TRUE;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::procWait() {
+asm int daArrow_c::procWait() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/procWait__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDC0-8049DDC4 00013C 0004+00 0/1 0/0 0/0 .rodata          @5356 */
 #pragma push
@@ -871,7 +1405,7 @@ COMPILER_STRIP_GATE(0x8049DDC0, &lit_5356);
 /* 8049DDC4-8049DDC8 000140 0004+00 0/1 0/0 0/0 .rodata          @5357 */
 #pragma push
 #pragma force_active on
-SECTION_RODATA static u32 const lit_5357 = 0x3F980000;
+SECTION_RODATA static u32 const lit_5357 = 0x3F980000; // 1.1875
 COMPILER_STRIP_GATE(0x8049DDC4, &lit_5357);
 #pragma pop
 
@@ -946,6 +1480,7 @@ SECTION_DATA static void* lit_5716[3] = {
     (void*)0xFFFFFFFF,
     (void*)procWait__9daArrow_cFv,
 };
+#endif
 
 /* 8049DE8C-8049DEAC -00001 0020+00 1/0 0/0 0/0 .data            l_daArrowMethodTable */
 SECTION_DATA static void* l_daArrowMethodTable[8] = {
@@ -1029,14 +1564,321 @@ SECTION_DATA extern void* __vt__8cM3dGPla[3] = {
 };
 
 /* 8049B764-8049C6B8 001BE4 0F54+00 2/0 0/0 0/0 .text            procMove__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+int daArrow_c::procMove() {
+    if (fopAcM_GetParam(this) == 6) {
+        setBlur();
+        mProcFunc = &daArrow_c::procActorControllStop;
+        speedF = 0.0f;
+        procActorControllStop();
+        return TRUE;
+    }
+
+    current.pos += speed;
+    cXyz v = current.pos + speed * mOutLengthRate;
+    BOOL bVar14 = FALSE;
+    if (field_0x945 == 0) {
+        field_0x56c.Set(&old.pos, &v, this);
+
+        cXyz v2;
+        if (dComIfG_Bgsp().LineCross(&field_0x56c)) {
+            v2 = field_0x56c.i_GetCross();
+        } else {
+            v2 = v;
+        }
+
+        int water_next_pos = setArrowWaterNextPos(&old.pos, &v2);
+        if (water_next_pos != 0) {
+            if (water_next_pos == 2 || water_next_pos == 4) {
+                bVar14 = TRUE;
+            } else if (water_next_pos == 1) {
+                fopKyM_createWpillar(field_0x5dc.GetCrossP(), 0.3f, 0);
+                mDoAud_seStart(0x60031, field_0x5dc.GetCrossP(), 0, mReverb);
+            }
+
+            field_0x945 = 1;
+            if (water_next_pos == 4 || water_next_pos == 3) {
+                field_0x9fc = old.pos;
+            } else {
+                field_0x9fc = field_0x5dc.i_GetCross();
+            }
+
+            speed.normalizeZP();
+            current.pos = v2 - (speed * 95.0f); 
+            speed *= 80.0f;
+
+            if (mArrowType != 4) {
+                mOutLengthRate = 1.1875f;
+            }
+
+            v = v2;
+        }
+    }
+
+    field_0x56c.Set(&old.pos, &v, this);
+
+    u8 uVar17;
+    BOOL line_cross = dComIfG_Bgsp().LineCross(&field_0x56c);
+    if (field_0x688.ChkTgHit() && field_0x688.GetTgHitGObj() != NULL) {
+        uVar17 = field_0x688.GetTgHitGObj()->GetAtMtrl();
+    } else {
+        uVar17 = 0;
+    }
+
+    if (uVar17 == 2 || (line_cross && daAlink_c::checkIcePolygonDamage(&field_0x56c))) {
+        field_0x943 = 1;
+    } else if (uVar17 == 3) {
+        current.pos = *field_0x688.GetTgHitPosP();
+        if(field_0x688.GetTgRVecP()->abs2XZ() < 1.0f ) {
+            if (field_0x688.GetTgHitAc() != NULL) {
+                current.angle.y = fopAcM_searchActorAngleY(this, field_0x688.GetTgHitAc());
+            } else {
+                current.angle.y = cLib_targetAngleY(&old.pos, &current.pos);
+            }
+        } else {
+            current.angle.y = cM_atan2s(-field_0x688.GetTgRVecP()->x, -field_0x688.GetTgRVecP()->z);
+        }
+        shape_angle.y = current.angle.y;
+        procReturnInit(1);
+        return TRUE;
+    }
+
+    int iVar3;
+    if (field_0x688.ChkAtHit() != 0) {
+        if (mArrowType == 1 && field_0x943 == 0) {
+            if (field_0x945 != 0) {
+                field_0x93f = 1;
+                return TRUE;
+            }
+
+            if (mHitAcID != -1) {
+                setBombArrowExplode(&field_0x9a8);
+                return TRUE;
+            }
+        }
+
+        if (mArrowType == 4) {
+            if (field_0x688.GetAtHitAc() != NULL && fopAcM_GetName(field_0x688.GetAtHitAc()) == PROC_E_PZ) {
+                iVar3 = 0;
+            } else {
+                procSlingHitInit(field_0x688.GetAtHitPosP(), &field_0x688);
+                return TRUE;
+            }
+        } else if (field_0x943 != 0) {
+            iVar3 = 2;
+        } else {
+            if (mHitAcID == -1) {
+                iVar3 = 0;
+            } else {
+                iVar3 = 1;
+                fopAc_ac_c* hit_ac = fopAcM_SearchByID(mHitAcID);
+                if (field_0x93e) {
+                    iVar3 = 2;
+                } else {
+                    if (hit_ac != NULL && fopAcM_GetJntCol(hit_ac) != NULL) {
+                        if (field_0x960 >= 0) {
+                            iVar3 = 4;
+                        } else {
+                            if (field_0x960 == -1) {
+                                iVar3 = 3;
+                            } else if (field_0x960 == -2) {
+                                iVar3 = 2;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (iVar3 != 4) {
+            clearNearActorData();
+        }
+    } else {
+        if (line_cross && field_0x943 != 0) {
+            iVar3 = 2;
+        } else {
+            iVar3 = 0;
+        }
+    }
+
+    if (iVar3 != 0 && iVar3 != 3) {
+        if (mArrowType == 2) {
+            setLightArrowHitMark(field_0x688.GetAtHitPosP());
+            setBlur();
+        } else if (mArrowType == 4) {
+            procSlingHitInit(field_0x56c.GetCrossP(), NULL);
+        } else if (iVar3 == 2) {
+            if (field_0x945) {
+                field_0x93f = 1;
+            } else {
+                procReturnInit(0);
+                current.pos = old.pos;
+                setNormalMatrix();
+            }
+        } else if (iVar3 == 4) {
+            setBlur();
+            fopAcM_SetParam(this, 3);
+            mProcFunc = &daArrow_c::procActorStop;
+            speedF = 0.0f;
+            setStopActorMatrix();
+        } else {
+            field_0x93f = 1;
+            if (field_0x945 == 0 && field_0x688.ChkAtHit()) {
+                current.pos = *field_0x688.GetAtHitPosP();
+                setBlur();
+            }
+        }
+        return TRUE;
+    }
+
+    if (line_cross) {
+        current.pos = field_0x56c.i_GetCross();
+
+        if (field_0x945 != 0 && (mArrowType == 1 || current.pos.y - field_0x9fc.y < -300.0f)) {
+            field_0x93f = 1;
+            return TRUE;
+        }
+
+        dKy_Sound_set(current.pos, 3, fopAcM_GetID(this), 10);
+
+        if (mArrowType == 1) {
+            setBombArrowExplode(&current.pos);
+            return TRUE;
+        }
+
+        if (mArrowType == 2) {
+            setLightArrowHitMark(&current.pos);
+        }
+
+        cM3dGPla local_4c;
+        u32 se_id;
+        dComIfG_Bgsp().GetTriPla(field_0x56c, &local_4c);
+        int local_d8 = dComIfG_Bgsp().GetPolyAtt0(field_0x56c);
+        if (local_d8 == 2 || mArrowType == 4 || local_d8 == 0xe || local_d8 == 10 || local_d8 == 8) {
+            if (field_0x945 != 0) {
+                field_0x93f = 1;
+                return TRUE;
+            }
+
+            csXyz angle(
+                cM_atan2s(local_4c.i_GetNP()->y, local_4c.i_GetNP()->absXZ()), 
+                cM_atan2s(-local_4c.i_GetNP()->x, -local_4c.i_GetNP()->z), 
+                0.0f
+            );
+            if (mArrowType == 4) {
+                se_id = 0x40018;
+                current.angle = angle;
+                procSlingHitInit(&current.pos, NULL);
+            } else {
+                procReturnInit(0);
+                dComIfGp_setHitMark(9, this, &current.pos, &angle, NULL, 0);
+                se_id = 0x40017;
+            }
+        } else {
+            setBlur();
+            mProcFunc = &daArrow_c::procBGStop;
+            fopAcM_SetParam(this, 4);
+            speedF = 0.0f;
+            se_id = Z2SE_HIT_AL_ARROW_STICK;
+            current.angle.x = shape_angle.x;
+            dComIfG_Bgsp().ArrowStickCallBack(field_0x56c, this, field_0x56c.i_GetCross());
+        }
+
+        daAlink_getAlinkActorClass()->itemHitSE(se_id, dKy_pol_sound_get(&field_0x56c) & 0xff, &mSoundObjArrow);
+    } else {
+        if (field_0x945 != 0) {
+            if (bVar14) {
+                field_0x93f = 1;
+                return TRUE;
+            }
+
+            f32 f = current.pos.y - field_0x9fc.y;
+            if (f < -300.0f) {
+                field_0x688.OffAtSetBit();
+                field_0x688.ResetAtHit();
+                if (cLib_chaseF(&scale.x, 0.0f, 0.1f)) {
+                    field_0x93f = 1;
+                    return TRUE;
+                }
+
+                f32 x = scale.x;
+                scale.y = x;
+                scale.z = x;
+                mpModel->setBaseScale(scale);
+            } else {
+                if (f > 95.0f) {
+                    field_0x93f = 1;
+                    return TRUE;
+                }
+                setArrowAt(current.pos.abs(mStartPos));
+            }
+        } else {
+            f32 distance = current.pos.abs(mStartPos);
+            if (distance > mFlyMax || fopAcM_GetGravity(this) < 0.0f) {
+                if (mArrowType == 4) {
+                    fopAcM_SetGravity(this, -5.0f);
+                } else {
+                    fopAcM_SetGravity(this, -2.0f);
+                }
+                speed.y += fopAcM_GetGravity(this);
+
+                if (field_0x956 != 0) {
+                    field_0x956--;
+                } else {
+                    field_0x93f = 1;
+                    return TRUE;
+
+                }
+                shape_angle.x = speed.atan2sY_XZ();
+                current.angle.x = -shape_angle.x;
+
+                if (mArrowType != 4) {
+                    mOutLengthRate = 95.0f / speed.abs();
+                }
+            }
+
+            u32 sound_id;
+            if (mArrowType == 2) {
+                sound_id = 0x6001c;
+            } else {
+                if (fopAcM_GetParam(this) == 2) {
+                    if (mArrowType == 1) {
+                        sound_id = Z2SE_OBJ_ARROWBOMB_FLYGAIN;
+                    } else {
+                        sound_id = Z2SE_OBJ_ARROW_FLY_GAIN;
+                    }
+                } else if (mArrowType == 1) {
+                    sound_id = Z2SE_OBJ_ARROWBOMB_FLY;
+                } else {
+                    sound_id = Z2SE_OBJ_ARROW_FLY_NORMAL;
+                }
+            }
+
+            if (mArrowType != 4) {
+                mSoundObjArrow.startLevelSound(sound_id, 0, mReverb);
+            }
+
+            setArrowAt(distance);
+            setBlur();
+        }
+    }
+
+    setNormalMatrix();
+    setBombMoveEffect();
+
+    return TRUE;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::procMove() {
+asm int daArrow_c::procMove() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/procMove__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049C6B8-8049C700 002B38 0048+00 1/0 0/0 0/0 .text            __dt__8cM3dGPlaFv */
 #pragma push
@@ -1049,6 +1891,7 @@ extern "C" asm void __dt__8cM3dGPlaFv() {
 }
 #pragma pop
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDD0-8049DDD4 00014C 0004+00 0/1 0/0 0/0 .rodata          @5385 */
 #pragma push
@@ -1070,17 +1913,49 @@ COMPILER_STRIP_GATE(0x8049DDD4, &lit_5386);
 SECTION_RODATA static f32 const lit_5387 = 11264.0f;
 COMPILER_STRIP_GATE(0x8049DDD8, &lit_5387);
 #pragma pop
+#endif
 
 /* 8049C700-8049C874 002B80 0174+00 1/1 0/0 0/0 .text            procReturnInit__9daArrow_cFi */
+#ifdef NONMATCHING
+// matches with literals
+int daArrow_c::procReturnInit(int param_0) {
+    setBlur();
+    setBombMoveEffect();
+    fopAcM_SetParam(this, 5);
+
+    mProcFunc = &daArrow_c::procReturn;
+    speedF = 0.0f;
+
+    s16 rnd_y = cM_rndFX(8192.0f) + (current.angle.y + 0x8000);
+    s16 sVar6;
+
+    if (param_0 != 0) {
+        sVar6 = 8192.0f - cM_rndF(4096.0f);
+    } else {
+        sVar6 = -cM_rndF(4096.0f);
+    }
+
+    f32 f = cM_rndF(15.0f) + 15.0f;
+    speed.y = f * cM_ssin(sVar6);
+    speed.x = (f * cM_ssin(rnd_y)) * cM_scos(sVar6);
+    speed.z = (f * cM_scos(rnd_y)) * cM_scos(sVar6);
+
+    field_0x954 = 11264.0f - cM_rndF(4096.0f);
+
+    return TRUE;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::procReturnInit(int param_0) {
+asm int daArrow_c::procReturnInit(int param_0) {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/procReturnInit__9daArrow_cFi.s"
 }
 #pragma pop
+#endif
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDDC-8049DDE0 000158 0004+00 0/1 0/0 0/0 .rodata          @5458 */
 #pragma push
@@ -1102,91 +1977,250 @@ COMPILER_STRIP_GATE(0x8049DDE0, &lit_5459);
 SECTION_RODATA static f32 const lit_5460 = 5000.0f;
 COMPILER_STRIP_GATE(0x8049DDE4, &lit_5460);
 #pragma pop
+#endif
 
 /* 8049C874-8049CB70 002CF4 02FC+00 1/0 0/0 0/0 .text            procReturn__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+int daArrow_c::procReturn() {
+    setBombMoveEffect();
+
+    speed.y -= 2.0f;
+    current.pos += speed;
+
+    shape_angle.x += field_0x954;
+
+    cXyz pos = current.pos + speed * mOutLengthRate;
+    field_0x56c.Set(&old.pos, &pos, this);
+    decAlphaBlur();
+
+    if(dComIfG_Bgsp().LineCross(&field_0x56c)) {
+        if (mArrowType == 1 && field_0x943 == 0) {
+            setBombArrowExplode(field_0x56c.GetCrossP());
+            return TRUE;
+        }
+
+        cM3dGPla cStack_34;
+        cXyz pos;
+        dComIfG_Bgsp().GetTriPla(field_0x56c, &cStack_34);
+        f32 speed_magnitude = speed.abs();
+        C_VECReflect(&speed, cStack_34.i_GetNP(), &pos);
+        speed.x = pos.x * speed_magnitude * 0.5f;
+        speed.y = pos.y * speed_magnitude * 0.5f;
+        speed.z = pos.z * speed_magnitude * 0.5f;
+        field_0x954 = -(field_0x954 >> 1);
+
+        if (dBgS_CheckBGroundPoly(field_0x56c)) {
+            field_0x93d = 1;
+        }
+    } else {
+        if ((field_0x93d != 0 && speed.y <= 0.0f) || mStartPos.y - 5000.0f > current.pos.y) {
+            field_0x93f = 1;
+            return TRUE;
+        }
+    }
+
+    setNormalMatrix();
+
+    return TRUE;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::procReturn() {
+asm int daArrow_c::procReturn() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/procReturn__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049CB70-8049CC60 002FF0 00F0+00 1/0 0/0 0/0 .text            procBGStop__9daArrow_cFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::procBGStop() {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/procBGStop__9daArrow_cFv.s"
+int daArrow_c::procBGStop() {
+    if (field_0x944 != 0 || !dComIfG_Bgsp().ChkPolySafe(field_0x56c)) {
+        field_0x93f = 1;
+        return TRUE;
+    }
+
+    BOOL update_angle = FALSE;
+    s16 angle = getVibAngle();
+
+    if(field_0x952) {
+        update_angle = TRUE;
+    }
+    decAlphaBlur();
+
+    if (dComIfG_Bgsp().ChkMoveBG(field_0x56c)) {
+        dComIfG_Bgsp().MoveBgTransPos(field_0x56c, true, &current.pos, &current.angle, &shape_angle);
+        update_angle = TRUE;
+    }
+
+    if (update_angle) {
+        shape_angle.x = current.angle.x + angle;
+        setNormalMatrix();
+    }
+
+    checkReget();
+    return TRUE;
 }
-#pragma pop
 
 /* 8049CC60-8049CCCC 0030E0 006C+00 1/0 0/0 0/0 .text            procActorStop__9daArrow_cFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::procActorStop() {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/procActorStop__9daArrow_cFv.s"
+int daArrow_c::procActorStop() {
+    decAlphaBlur();
+
+    fopAc_ac_c* actor = setStopActorMatrix();
+    if (field_0x944 != 0 || actor == NULL) {
+        field_0x93f = 1;
+    } else {
+        if (actor->group != 4) {
+            checkReget();
+        }
+    }
+
+    return TRUE;
 }
-#pragma pop
 
 /* 8049CCCC-8049CCF0 00314C 0024+00 2/1 0/0 0/0 .text            procActorControllStop__9daArrow_cFv
  */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::procActorControllStop() {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/procActorControllStop__9daArrow_cFv.s"
+int daArrow_c::procActorControllStop() {
+    decAlphaBlur();
+    return TRUE;
 }
-#pragma pop
 
 /* 8049CCF0-8049CE50 003170 0160+00 1/1 0/0 0/0 .text
  * procSlingHitInit__9daArrow_cFP4cXyzP12dCcD_GObjInf           */
+#ifdef NONMATCHING
+// matches with literals
+int daArrow_c::procSlingHitInit(cXyz* param_0, dCcD_GObjInf* param_1) {
+    fopAc_ac_c* hit_ac;
+    if (param_1 != NULL) {
+        hit_ac = param_1->GetAtHitAc();
+    } else {
+        hit_ac = NULL;
+    }
+
+    if (!daAlink_c::notSwordHitVibActor(hit_ac)) {
+        u16 hitmark;
+        if (hit_ac != NULL && fopAcM_checkStatus(hit_ac, 0x10000) != 0) {
+            hitmark = 1;
+        } else {
+            hitmark = 9;
+            if (hit_ac != NULL && param_1->GetAtHitGObj() != NULL) {
+                if (param_1->GetAtHitGObj()->ChkTgNoSlingHitInfSet()) {
+                    mDoAud_seStart(0x40018, param_0, 0x2d, mReverb);
+                }
+            }
+        }
+        dComIfGp_setHitMark(hitmark, hit_ac, param_0, &current.angle, NULL, 0);
+    }
+
+    setBlur();
+    fopAcM_SetParam(this, 8);
+    mProcFunc = &daArrow_c::procSlingHit;
+    speedF = 0.0f;
+    field_0x956 = 5;
+
+    return TRUE;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::procSlingHitInit(cXyz* param_0, dCcD_GObjInf* param_1) {
+asm int daArrow_c::procSlingHitInit(cXyz* param_0, dCcD_GObjInf* param_1) {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/procSlingHitInit__9daArrow_cFP4cXyzP12dCcD_GObjInf.s"
 }
 #pragma pop
+#endif
 
 /* 8049CE50-8049CEA0 0032D0 0050+00 1/0 0/0 0/0 .text            procSlingHit__9daArrow_cFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void daArrow_c::procSlingHit() {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/procSlingHit__9daArrow_cFv.s"
+int daArrow_c::procSlingHit() {
+    decAlphaBlur();
+
+    if (field_0x956 != 0) {
+        field_0x956--;
+    } else {
+        field_0x93f = 1;
+    }
+    return TRUE;
 }
-#pragma pop
 
 /* 8049CEA0-8049D0AC 003320 020C+00 1/1 0/0 0/0 .text            execute__9daArrow_cFv */
+#ifdef NONMATCHING
+// matches with literals
+int daArrow_c::execute() {
+    field_0xa08.setActor();
+    mReverb = dComIfGp_getReverb(fopAcM_GetRoomNo(this));
+
+    if (field_0x945 == 0 && field_0x943 == 0) {
+        field_0x9e4 = field_0x9d8;
+        field_0x9d8 = field_0x9cc;
+    }
+
+    if (field_0x93f != 0) {
+        setLightChargeEffect(1);
+        fopAcM_delete(this);
+        return TRUE;
+    } else {
+        if (field_0x94e == m_count) {
+            field_0x944 = 1;
+        }
+
+        if (field_0x942 != 0) {
+            field_0x942--;
+        }
+
+        (this->*mProcFunc)();
+
+        if (mArrowType == 1 && field_0x93f == 0) {
+            if (field_0x950 != 0) {
+                field_0x950--;
+            } else {
+                f32 amp = cM_scos(current.angle.x) * 95.0f;
+                cXyz pos(
+                    current.pos.x + amp * cM_ssin(current.angle.y),
+                    current.pos.y + cM_ssin(current.angle.x) * 95.0f,
+                    current.pos.z + amp * cM_scos(current.angle.y)
+                );
+                setBombArrowExplode(&pos);
+                return TRUE;
+            }
+        }
+
+        if (mArrowType == 2) {
+            setLightChargeEffect(0);
+        }
+
+        attention_info.position = current.pos;
+        eyePos = current.pos;
+
+        setRoomInfo();
+
+        mSoundObjArrow.framework(0, mReverb);
+    }
+
+    return TRUE;
+}
+
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::execute() {
+asm int daArrow_c::execute() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/execute__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049D0AC-8049D0CC 00352C 0020+00 1/0 0/0 0/0 .text            daArrow_execute__FP9daArrow_c */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm void daArrow_execute(daArrow_c* param_0) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/daArrow_execute__FP9daArrow_c.s"
+static int daArrow_execute(daArrow_c* i_this) {
+    return i_this->execute();
 }
-#pragma pop
 
 /* ############################################################################################## */
 /* 8049DDE8-8049DDF0 000164 0008+00 0/1 0/0 0/0 .rodata          tmpColor$5589 */
+#ifndef NONMATCHING
 #pragma push
 #pragma force_active on
 SECTION_RODATA static u8 const tmpColor[8] = {
@@ -1208,38 +2242,95 @@ COMPILER_STRIP_GATE(0x8049DDF0, &lit_5676);
 SECTION_RODATA static f32 const lit_5677 = 50.0f;
 COMPILER_STRIP_GATE(0x8049DDF4, &lit_5677);
 #pragma pop
+#endif
 
 /* 8049D0CC-8049D40C 00354C 0340+00 1/1 0/0 0/0 .text            draw__9daArrow_cFv */
+#ifdef NONMATCHING
+// regalloc, literals
+int daArrow_c::draw() {
+    g_env_light.settingTevStruct(0, &current.pos, &tevStr);
+
+    if (field_0x942 != 0 || field_0x93f != 0 || fopAcM_GetParam(this) == 8) {
+        return TRUE;
+    }
+    
+    GXColorS10 tmpColor = {0, 0, 0};
+    J3DGXColorS10 color = (tmpColor);
+
+    daAlink_c* link = daAlink_getAlinkActorClass();
+    if (fopAcM_GetParam(this) == 0 && field_0x940 != 0) {
+        setKeepMatrix();
+        field_0x940 = 0;
+    }
+
+    if (mArrowType == 1) {
+        if (field_0x943 != 0) {
+            color.r = link->getFreezeR();
+            color.g = link->getFreezeG();
+            color.b = link->getFreezeB();
+        } else {
+            s16 explode_time = daAlink_getAlinkActorClass()->getBombExplodeTime();
+            f32 r;
+
+            if (field_0x950 > explode_time >> 1) {
+                r = fabsf(cM_fsin((field_0x950 - (explode_time >> 1)) * M_PI / (explode_time >> 2)));
+            } else if (field_0x950 > explode_time >> 2) {
+                r = fabsf(cM_fsin((field_0x950 - (explode_time >> 1)) * M_PI / (explode_time >> 3)));
+            } else {
+                r = fabsf(cM_fsin((field_0x950 - (explode_time >> 3)) * M_PI / (explode_time >> 4)));
+            }
+
+            color.r = (u8)(r * 50.0f);
+        }
+        
+        mpModel->getModelData()->getMaterialNodePointer(1)->setTevColor(1, &color);
+    }
+
+    if (field_0x943 != 0) {
+        tevStr.mFogColor.r = link->getFreezeR();
+        tevStr.mFogColor.g = link->getFreezeG();
+        tevStr.mFogColor.b = link->getFreezeB();
+    }
+
+    g_env_light.setLightTevColorType_MAJI(mpModel, &tevStr);
+    mDoExt_modelUpdateDL(mpModel);
+
+    if (mArrowType == 1) {
+        color.r = 0;
+        color.g = 0;
+        color.b = 0;
+        mpModel->getModelData()->getMaterialNodePointer(1)->setTevColor(1, &color);
+    }
+
+    return TRUE;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::draw() {
+asm int daArrow_c::draw() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/draw__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049D40C-8049D42C 00388C 0020+00 1/0 0/0 0/0 .text            daArrow_draw__FP9daArrow_c */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm void daArrow_draw(daArrow_c* param_0) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/daArrow_draw__FP9daArrow_c.s"
+static int daArrow_draw(daArrow_c* i_this) {
+    return i_this->draw();
 }
-#pragma pop
 
 /* 8049D42C-8049D440 0038AC 0014+00 1/1 0/0 0/0 .text daAlink_searchHorseZelda__FP10fopAc_ac_cPv
  */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm void daAlink_searchHorseZelda(fopAc_ac_c* param_0, void* param_1) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/daAlink_searchHorseZelda__FP10fopAc_ac_cPv.s"
+static void* daAlink_searchHorseZelda(fopAc_ac_c* param_0, void* param_1) {
+    if (fopAcM_GetName(param_0) == PROC_HOZELDA) {
+        return param_0;
+    }
+
+    return NULL;
 }
-#pragma pop
 
+#ifndef NONMATCHING
 /* ############################################################################################## */
 /* 8049DDF8-8049DDFC 000174 0004+00 0/1 0/0 0/0 .rodata          @5813 */
 #pragma push
@@ -1261,16 +2352,82 @@ COMPILER_STRIP_GATE(0x8049DDFC, &lit_5814);
 SECTION_RODATA static f32 const lit_5815 = 110.0f;
 COMPILER_STRIP_GATE(0x8049DE00, &lit_5815);
 #pragma pop
+#endif
 
 /* 8049D440-8049D808 0038C0 03C8+00 1/1 0/0 0/0 .text            create__9daArrow_cFv */
+#ifdef NONMATCHING
+// regalloc, stack issue, literals
+cPhs__Step daArrow_c::create() {
+    fopAcM_SetupActor(this, daArrow_c);
+
+    mArrowType = fopAcM_GetParamBit(this, 8, 8);
+    fopAcM_SetParam(this, (u8)fopAcM_GetParam(this));
+    
+    if (!fopAcM_entrySolidHeap(this, daArrow_createHeap, mArrowType == 1 ? 0xea0 : 0x810)) {
+        return cPhs_ERROR_e;
+    }
+    
+    if (mArrowType == 2) {
+        field_0xa08.setData(fopAcM_Search((fopAcIt_JudgeFunc)daAlink_searchHorseZelda, NULL));
+        field_0x946 = 6;
+        field_0x94c = 0x896e;
+    } else if (mArrowType == 0) {
+        field_0x946 = 1;
+        field_0x94c = 0x3b8;
+    } else if (mArrowType == 4) {
+        field_0x946 = 1;
+        field_0x94c = 0xa55;
+    } else {
+        field_0x946 = 0;
+    }
+
+    field_0x940 = 1;
+
+    field_0x64c.Init(10, 0xff, this);
+    field_0x688.Set(l_atCpsSrc);
+    field_0x688.SetStts(&field_0x64c);
+    field_0x688.SetAtHitCallback(daArrow_atHitCallBack);
+    field_0x7cc.Set(l_coSphSrc);
+    field_0x7cc.SetStts(&field_0x64c);
+
+    daAlink_c* player = daAlink_getAlinkActorClass();
+    if (mArrowType == 4) {
+        setNormalMatrix();
+        player->getArrowFlyData(&mFlyMax, &field_0x99c, 0);
+        mOutLengthRate = 0.0f;
+        arrowShooting();
+        mProcFunc = &daArrow_c::procMove;
+    } else {
+        mProcFunc = &daArrow_c::procWait;
+        setKeepMatrix();
+    }
+
+    fopAcM_SetMtx(this, mpModel->getBaseTRMtx());
+    fopAcM_SetMin(this, -6.0f, -6.0f, 0.0f);
+    fopAcM_SetMax(this, 6.0f, 6.0f, 110.0f);
+
+    setSmokePos();
+
+    field_0x94e = -1; 
+    field_0x956 = 300;
+    field_0x952 = 50.0f - cM_rndF(20.0f);
+
+    field_0x950 = player->getBombExplodeTime();
+    field_0x5dc.OffFullGrp();
+    field_0x5dc.OnWaterGrp();
+
+    return cPhs_COMPLEATE_e;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void daArrow_c::create() {
+asm cPhs__Step daArrow_c::create() {
     nofralloc
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/create__9daArrow_cFv.s"
 }
 #pragma pop
+#endif
 
 /* 8049D808-8049D80C 003C88 0004+00 1/0 0/0 0/0 .text            cleanup__18dPa_levelEcallBackFv */
 void dPa_levelEcallBack::cleanup() {
@@ -1322,14 +2479,9 @@ extern "C" asm void __dt__10dCcD_GSttsFv() {
 #pragma pop
 
 /* 8049D96C-8049D98C 003DEC 0020+00 1/0 0/0 0/0 .text            daArrow_create__FP9daArrow_c */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm void daArrow_create(daArrow_c* param_0) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/daArrow_create__FP9daArrow_c.s"
+static int daArrow_create(daArrow_c* i_this) {
+    return i_this->create();
 }
-#pragma pop
 
 /* 8049D98C-8049DBD8 003E0C 024C+00 1/1 0/0 0/0 .text            __dt__9daArrow_cFv */
 #pragma push
@@ -1342,14 +2494,10 @@ asm daArrow_c::~daArrow_c() {
 #pragma pop
 
 /* 8049DBD8-8049DC00 004058 0028+00 1/0 0/0 0/0 .text            daArrow_delete__FP9daArrow_c */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm void daArrow_delete(daArrow_c* param_0) {
-    nofralloc
-#include "asm/rel/d/a/d_a_arrow/d_a_arrow/daArrow_delete__FP9daArrow_c.s"
+static int daArrow_delete(daArrow_c* i_this) {
+    i_this->~daArrow_c();
+    return TRUE;
 }
-#pragma pop
 
 /* 8049DC00-8049DC48 004080 0048+00 1/0 0/0 0/0 .text            __dt__10cCcD_GSttsFv */
 #pragma push
@@ -1387,6 +2535,7 @@ void JPAEmitterCallBack::drawAfter(JPABaseEmitter* param_0) {
     /* empty function */
 }
 
+#ifndef NONMATCHING
 /* 8049DC58-8049DC74 0040D8 001C+00 1/1 0/0 0/0 .text            cLib_calcTimer<s>__FPs */
 #pragma push
 #pragma optimization_level 0
@@ -1396,6 +2545,7 @@ extern "C" asm void func_8049DC58(void* _this, s16* param_0) {
 #include "asm/rel/d/a/d_a_arrow/d_a_arrow/func_8049DC58.s"
 }
 #pragma pop
+#endif
 
 /* ############################################################################################## */
 /* 8049DFBC-8049DFC0 000064 0004+00 0/0 0/0 0/0 .bss
diff --git a/rel/d/a/e/d_a_e_pz/d_a_e_pz.cpp b/rel/d/a/e/d_a_e_pz/d_a_e_pz.cpp
index 5d1ab47719..56fd7a3d6d 100644
--- a/rel/d/a/e/d_a_e_pz/d_a_e_pz.cpp
+++ b/rel/d/a/e/d_a_e_pz/d_a_e_pz.cpp
@@ -99,37 +99,6 @@ struct daPy_py_c {
     static u8 m_midnaActor[4];
 };
 
-struct daE_PZ_c {
-    /* 807585BC */ void draw();
-    /* 80758800 */ void setBck(int, u8, f32, f32);
-    /* 807588AC */ void setActionMode(int, int);
-    /* 807588B8 */ void mEntrySUB(bool);
-    /* 80758A94 */ void mPzScaleSet(bool);
-    /* 80758BA0 */ void mEnemyScaleSet();
-    /* 80758D44 */ void getCutType();
-    /* 80758DA4 */ void mSetFirePos();
-    /* 80758E04 */ void damage_check();
-    /* 807592F4 */ void executeSearchPoint();
-    /* 807593CC */ void executeOpeningDemo();
-    /* 8075B7E0 */ void mPointerSet();
-    /* 8075B970 */ void executeWait();
-    /* 8075C6AC */ void executeAttack();
-    /* 8075CB80 */ void executeDamage();
-    /* 8075CE68 */ void executeDead();
-    /* 8075D94C */ void executeSummonsBullet();
-    /* 8075F0BC */ void executeBullet();
-    /* 8075F3A8 */ void action();
-    /* 8075F510 */ void action_fire();
-    /* 8075F578 */ void fire_mtx_set();
-    /* 8075F734 */ void mtx_set();
-    /* 8075F7E8 */ void cc_set();
-    /* 8075F964 */ void execute();
-    /* 8075FA88 */ void _delete();
-    /* 8075FB4C */ void CreateHeap();
-    /* 8076010C */ void create();
-    /* 807607EC */ daE_PZ_c();
-};
-
 struct daE_PZ_HIO_c {
     /* 8075856C */ daE_PZ_HIO_c();
     /* 80760C60 */ ~daE_PZ_HIO_c();