diff --git a/configure.py b/configure.py
index a4ee40f66..db157d892 100644
--- a/configure.py
+++ b/configure.py
@@ -198,6 +198,10 @@ LIBS = [
         "objects": [
             Object(NonMatching, "JSystem/JFramework/JFWDisplay.cpp"),
             Object(NonMatching, "JSystem/JFramework/JFWSystem.cpp"),
+            Object(Matching,    "JSystem/J3DGraphBase/J3DVertex.cpp"),
+            Object(NonMatching, "JSystem/J3DGraphBase/J3DPacket.cpp"),
+            Object(NonMatching, "JSystem/J3DGraphBase/J3DShape.cpp"),
+            Object(Matching,    "JSystem/J3DGraphBase/J3DDrawBuffer.cpp"),
             Object(Matching,    "JSystem/J3DU/J3DUDL.cpp"),
             Object(NonMatching, "JSystem/JParticle/JPATexture.cpp"),
             Object(Matching,    "JSystem/JKernel/JKRFile.cpp"),
@@ -238,22 +242,22 @@ LIBS = [
             Object(Matching,    "SSystem/SComponent/c_tag_iter.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_xyz.cpp"),
             Object(Matching,    "SSystem/SComponent/c_sxyz.cpp"),
-            Object(NonMatching, "SSystem/SComponent/c_math.cpp"),
+            Object(Matching,    "SSystem/SComponent/c_math.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_bg_s.cpp"),
             Object(Matching,    "SSystem/SComponent/c_bg_s_chk.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_bg_s_gnd_chk.cpp"),
-            Object(NonMatching, "SSystem/SComponent/c_bg_s_lin_chk.cpp"),
+            Object(Matching,    "SSystem/SComponent/c_bg_s_lin_chk.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_bg_w.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_m2d.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_m2d_g_box.cpp"),
             Object(Matching,    "SSystem/SComponent/c_m3d_g_aab.cpp"),
-            Object(NonMatching, "SSystem/SComponent/c_m3d_g_cyl.cpp"),
+            Object(Matching,    "SSystem/SComponent/c_m3d_g_cyl.cpp"),
             Object(Matching,    "SSystem/SComponent/c_m3d_g_pla.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_m3d_g_sph.cpp"),
             Object(Matching,    "SSystem/SComponent/c_m3d_g_tri.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_lib.cpp"),
             Object(NonMatching, "SSystem/SComponent/c_angle.cpp"),
-            Object(NonMatching, "SSystem/SComponent/c_data_tbl.cpp"),
+            Object(Matching,    "SSystem/SComponent/c_data_tbl.cpp"),
         ],
     },
     {
@@ -280,7 +284,7 @@ LIBS = [
             Object(Matching,    "f_op/f_op_view.cpp"),
             Object(Matching,    "f_op/f_op_kankyo.cpp"),
             Object(Matching,    "f_op/f_op_msg.cpp"),
-            Object(NonMatching, "f_op/f_op_kankyo_mng.cpp"),
+            Object(Matching,    "f_op/f_op_kankyo_mng.cpp"),
             Object(NonMatching, "f_op/f_op_msg_mng.cpp"),
             Object(Matching,    "f_op/f_op_draw_iter.cpp"),
             Object(Matching,    "f_op/f_op_draw_tag.cpp"),
@@ -330,6 +334,7 @@ LIBS = [
             Object(NonMatching, "d/d_com_inf_game.cpp"),
             Object(NonMatching, "d/d_save.cpp"),
             Object(NonMatching, "d/d_save_init.cpp"),
+            Object(Matching,    "d/d_bg_s_movebg_actor.cpp"),
 
             Object(NonMatching, "d/actor/d_a_player_main.cpp"),
             Object(NonMatching, "d/actor/d_a_itembase_static.cpp"),
@@ -380,7 +385,7 @@ LIBS = [
     ActorRel(NonMatching, "d_a_lamp"),
     ActorRel(NonMatching, "d_a_lod_bg"),
     ActorRel(NonMatching, "d_a_lwood"),
-    ActorRel(NonMatching, "d_a_magma"),
+    ActorRel(Matching, "d_a_magma"),
     ActorRel(NonMatching, "d_a_majuu_flag"),
     ActorRel(NonMatching, "d_a_mdoor"),
     ActorRel(NonMatching, "d_a_msw"),
diff --git a/include/JSystem/J3DGraphAnimator/J3DModel.h b/include/JSystem/J3DGraphAnimator/J3DModel.h
index 69ad60894..3c31c7511 100644
--- a/include/JSystem/J3DGraphAnimator/J3DModel.h
+++ b/include/JSystem/J3DGraphAnimator/J3DModel.h
@@ -29,6 +29,10 @@ struct J3DUnkCalc2 {
 
 typedef void (*J3DCalcCallBack)(J3DModel*, u32 timing);
 
+class J3DMatPacket;
+class J3DShapePacket;
+class J3DVisibilityManager;
+
 class J3DModel {
 public:
     J3DModel() {
@@ -39,32 +43,32 @@ public:
         entryModelData(param_0, param_1, param_2);
     }
 
-    /* 800CFFF4 */ void setBaseTRMtx(f32 (*)[4]);
-    /* 80327100 */ void initialize();
-    /* 80327184 */ s32 entryModelData(J3DModelData*, u32, u32);
-    /* 80327300 */ s32 createShapePacket(J3DModelData*);
-    /* 803273CC */ s32 createMatPacket(J3DModelData*, u32);
-    /* 803275FC */ s32 newDifferedDisplayList(u32);
-    /* 8032767C */ void lock();
-    /* 803276B4 */ void unlock();
-    /* 803279A0 */ void diff();
-    /* 80327A2C */ s32 setDeformData(J3DDeformData*, u32);
-    /* 80327AA0 */ s32 setSkinDeform(J3DSkinDeform*, u32);
-    /* 80327BD4 */ void calcAnmMtx();
-    /* 80327C58 */ void calcWeightEnvelopeMtx();
-    /* 80328190 */ void calcNrmMtx();
-    /* 803281B4 */ void calcBumpMtx();
-    /* 803282B8 */ void calcBBoardMtx();
-    /* 803282EC */ void prepareShapePackets();
+    void setBaseTRMtx(f32 (*)[4]);
+    void initialize();
+    s32 entryModelData(J3DModelData*, u32, u32);
+    s32 createShapePacket(J3DModelData*);
+    s32 createMatPacket(J3DModelData*, u32);
+    s32 newDifferedDisplayList(u32);
+    void lock();
+    void unlock();
+    void diff();
+    s32 setDeformData(J3DDeformData*, u32);
+    s32 setSkinDeform(J3DSkinDeform*, u32);
+    void calcAnmMtx();
+    void calcWeightEnvelopeMtx();
+    void calcNrmMtx();
+    void calcBumpMtx();
+    void calcBBoardMtx();
+    void prepareShapePackets();
     MtxP getAnmMtx(int);
 
-    /* 80327CA4 */ virtual void update();
-    /* 80327E4C */ virtual void entry();
-    /* 80327CF0 */ virtual void calc();
-    /* 803276EC */ virtual void calcMaterial();
-    /* 80327858 */ virtual void calcDiffTexMtx();
-    /* 80327F40 */ virtual void viewCalc();
-    /* 80328350 */ virtual ~J3DModel();
+    virtual void update();
+    virtual void entry();
+    virtual void calc();
+    virtual void calcMaterial();
+    virtual void calcDiffTexMtx();
+    virtual void viewCalc();
+    virtual ~J3DModel();
 
     J3DModelData* getModelData() { return mModelData; }
 
@@ -78,39 +82,42 @@ public:
     void i_setBaseTRMtx(Mtx m) { MTXCopy(m, mBaseTransformMtx); }
     u32 getMtxCalcMode() const { return mFlags & 0x03; }
     J3DVertexBuffer* getVertexBuffer() const { return (J3DVertexBuffer*)&mVertexBuffer; }
-    J3DMatPacket* getMatPacket(u16 idx) const { return &mMatPacket[idx]; }
-    J3DShapePacket* getShapePacket(u16 idx) const { return &mShapePacket[idx]; }
-    J3DMtxBuffer* getMtxBuffer() const { return mMtxBuffer; }
-    Mtx33* getBumpMtxPtr(int idx) const { return mMtxBuffer->getBumpMtxPtr(idx); }
-    Mtx33* getNrmMtxPtr() const { return mMtxBuffer->getNrmMtxPtr(); }
-    Mtx* getDrawMtxPtr() const { return mMtxBuffer->getDrawMtxPtr(); }
+    J3DMatPacket* getMatPacket(u16 idx) const { return &mpMatPacket[idx]; }
+    J3DShapePacket* getShapePacket(u16 idx) const { return &mpShapePacket[idx]; }
+    // Mtx33* getBumpMtxPtr(int idx) const { return mMtxBuffer->getBumpMtxPtr(idx); }
+    Mtx33* getNrmMtxPtr() const { return mpNrmMtxBuf[1][mCurrentViewNo]; }
+    Mtx* getDrawMtxPtr() const { return mpDrawMtxBuf[1][mCurrentViewNo]; }
     void setBaseScale(const Vec& scale) { mBaseScale = scale; }
     void setUserArea(u32 area) { mUserArea = area; }
     u32 getUserArea() const { return mUserArea; }
     Vec* getBaseScale() { return &mBaseScale; }
-    void setAnmMtx(int i, Mtx m) { mMtxBuffer->setAnmMtx(i, m); }
 
-    // is there a better way to handle inlines with same name as non-inlines?
-    MtxP i_getAnmMtx(int p1) { return mMtxBuffer->getAnmMtx(p1); }
-    void i_setAnmMtx(int p1, Mtx mtx) { mMtxBuffer->setAnmMtx(p1, mtx); }
-
-    /* 0x04 */ J3DModelData* mModelData;
-    /* 0x08 */ u32 mFlags;
-    /* 0x0C */ u32 mDiffFlag;
-    /* 0x10 */ J3DCalcCallBack mCalcCallBack;
-    /* 0x14 */ u32 mUserArea;
-    /* 0x18 */ Vec mBaseScale;
-    /* 0x24 */ Mtx mBaseTransformMtx;
-    /* 0x54 */ Mtx mInternalView;
-    /* 0x84 */ J3DMtxBuffer* mMtxBuffer;
-    /* 0x88 */ J3DVertexBuffer mVertexBuffer;
-    /* 0xC0 */ J3DMatPacket* mMatPacket;
-    /* 0xC4 */ J3DShapePacket* mShapePacket;
-    /* 0xC8 */ J3DDeformData* mDeformData;
-    /* 0xCC */ J3DSkinDeform* mSkinDeform;
-    /* 0xD0 */ J3DVtxColorCalc* mVtxColorCalc;
-    /* 0xD4 */ J3DUnkCalc1* mUnkCalc1;
-    /* 0xD8 */ J3DUnkCalc2* mUnkCalc2;
+    /* 0x004 */ J3DModelData* mModelData;
+    /* 0x008 */ u32 mFlags;
+    /* 0x00C */ u32 mDiffFlag;
+    /* 0x010 */ J3DCalcCallBack mCalcCallBack;
+    /* 0x014 */ u32 mUserArea;
+    /* 0x018 */ Vec mBaseScale;
+    /* 0x024 */ Mtx mBaseTransformMtx;
+    /* 0x054 */ Mtx mInternalView;
+    /* 0x084 */ u8* mpScaleFlagArr;
+    /* 0x088 */ u8* mpEvlpScaleFlagArr;
+    /* 0x08C */ Mtx* mpNodeMtx;
+    /* 0x090 */ Mtx* mpWeightEnvMtx;
+    /* 0x094 */ Mtx** mpDrawMtxBuf[2];
+    /* 0x09C */ Mtx33** mpNrmMtxBuf[2];
+    /* 0x0A4 */ Mtx33*** mpBumpMtxArr[2];
+    /* 0x0AC */ u32 mMtxBufferFlag;
+    /* 0x0B0 */ u32 mCurrentViewNo;
+    /* 0x0B4 */ J3DMatPacket* mpMatPacket;
+    /* 0x0B8 */ J3DShapePacket* mpShapePacket;
+    /* 0x0BC */ J3DDeformData* mpDeformData;
+    /* 0x0C0 */ J3DSkinDeform* mpSkinDeform;
+    /* 0x0C4 */ void * pad4[2];
+    /* 0x0CC */ J3DVertexBuffer mVertexBuffer;
+    /* 0x104 */ J3DVisibilityManager * mpVisibilityManager;
 };
 
+STATIC_ASSERT(sizeof(J3DModel) == 0x108);
+
 #endif /* J3DMODEL_H */
diff --git a/include/JSystem/J3DGraphBase/J3DDrawBuffer.h b/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
index 714de468d..aae6e4ff3 100644
--- a/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
+++ b/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
@@ -4,35 +4,12 @@
 #include "JSystem/J3DGraphBase/J3DSys.h"
 #include "dolphin/types.h"
 
-// matches debug
-inline f32 J3DCalcZValue(register MtxP m, register Vec v) {
-    register f32 temp_f4;
-    register f32 out;
-    register f32 temp_f0;
-    register f32 temp_f2;
-    register f32 temp_f1 = 1.0f;
-
-    // clang-format off
-    asm {
-        psq_l temp_f0, 0(v), 0, 0 /* qr0 */
-        lfs temp_f2, 8(v)
-        psq_l temp_f4, 32(m), 0, 0 /* qr0 */
-        psq_l out, 40(m), 0, 0 /* qr0 */
-        ps_merge00 temp_f2, temp_f2, temp_f1
-        ps_mul temp_f4, temp_f0, temp_f4
-        ps_madd out, temp_f2, out, temp_f4
-        ps_sum0 out, out, out, out
-    }
-    // clang-format on
-
-    return out;
-}
-
 class J3DDrawBuffer;
 class J3DPacket;
 class J3DDrawPacket;
 class J3DMatPacket;
 class J3DShapePacket;
+class J3DCallBackPacket;
 
 typedef int (J3DDrawBuffer::*sortFunc)(J3DMatPacket*);
 typedef void (J3DDrawBuffer::*drawFunc)() const;
@@ -75,6 +52,7 @@ public:
     void setNonSort() { mSortType = 5; }
     void setZSort() { mSortType = 2; }
     void setZMtx(MtxP mtx) { mpZMtx = mtx; }
+    void setCallBackPacket(J3DCallBackPacket* pPacket);
 
 public:
     /* 0x00 */ J3DPacket** mpBuf;
diff --git a/include/JSystem/J3DGraphBase/J3DMatBlock.h b/include/JSystem/J3DGraphBase/J3DMatBlock.h
index 5e9b562d4..a726d1bc1 100644
--- a/include/JSystem/J3DGraphBase/J3DMatBlock.h
+++ b/include/JSystem/J3DGraphBase/J3DMatBlock.h
@@ -7,11 +7,11 @@
 #include "dolphin/types.h"
 
 struct J3DGXColorS10 : public GXColorS10 {
-    /* 8000E460 */ J3DGXColorS10() {}
+    J3DGXColorS10() {}
 };
 
 struct J3DGXColor : public GXColor {
-    /* 8000E538 */ J3DGXColor() {}
+    J3DGXColor() {}
 };
 
 struct J3DNBTScale : public J3DNBTScaleInfo {
@@ -27,31 +27,28 @@ extern const J3DNBTScaleInfo j3dDefaultNBTScaleInfo;
 
 class J3DTexGenBlock {
 public:
-    /* 80317354 */ virtual void reset(J3DTexGenBlock*);
+    virtual void reset(J3DTexGenBlock*);
     virtual void calc(f32 const (*)[4]) = 0;
-    virtual void calcWithoutViewMtx(f32 const (*)[4]) = 0;
-    virtual void calcPostTexMtx(f32 const (*)[4]) = 0;
-    virtual void calcPostTexMtxWithoutViewMtx(f32 const (*)[4]) = 0;
     virtual void load() = 0;
     virtual void patch() = 0;
     virtual void diff(u32) = 0;
     virtual void diffTexMtx() = 0;
     virtual void diffTexGen() = 0;
-    /* 803172FC */ virtual s32 countDLSize();
+    virtual s32 countDLSize();
     virtual u32 getType() = 0;
-    /* 8031741C */ virtual void setTexGenNum(u32 const*);
-    /* 8000E0D0 */ virtual void setTexGenNum(u32);
-    /* 8000DFE8 */ virtual u32 getTexGenNum() const;
-    /* 8000E0CC */ virtual void setTexCoord(u32, J3DTexCoord const*);
-    /* 8000DFE0 */ virtual J3DTexCoord* getTexCoord(u32);
-    /* 8003AB2C */ virtual void setTexMtx(u32, J3DTexMtx*);
-    /* 8000DFD8 */ virtual J3DTexMtx* getTexMtx(u32);
-    /* 80317424 */ virtual void setNBTScale(J3DNBTScale const*);
-    /* 80317420 */ virtual void setNBTScale(J3DNBTScale);
-    /* 80317334 */ virtual J3DNBTScale* getNBTScale();
-    /* 80317428 */ virtual bool getTexMtxOffset() const;
-    /* 80317430 */ virtual void setTexMtxOffset(u32);
-    /* 803171DC */ virtual ~J3DTexGenBlock();
+    virtual void setTexGenNum(u32 const*);
+    virtual void setTexGenNum(u32);
+    virtual u32 getTexGenNum() const;
+    virtual void setTexCoord(u32, J3DTexCoord const*);
+    virtual J3DTexCoord* getTexCoord(u32);
+    virtual void setTexMtx(u32, J3DTexMtx*);
+    virtual J3DTexMtx* getTexMtx(u32);
+    virtual void setNBTScale(J3DNBTScale const*);
+    virtual void setNBTScale(J3DNBTScale);
+    virtual J3DNBTScale* getNBTScale();
+    virtual bool getTexMtxOffset() const;
+    virtual void setTexMtxOffset(u32);
+    virtual ~J3DTexGenBlock();
 };
 
 class J3DTexGenBlockPatched : public J3DTexGenBlock {
@@ -59,30 +56,30 @@ public:
     J3DTexGenBlockPatched() {
         initialize();
     }
-    /* 80317644 */ void initialize();
+    void initialize();
 
-    /* 80320084 */ virtual void reset(J3DTexGenBlock*);
-    /* 803213C0 */ virtual void calc(f32 const (*)[4]);
-    /* 80321584 */ virtual void calcWithoutViewMtx(f32 const (*)[4]);
-    /* 803216D8 */ virtual void calcPostTexMtx(f32 const (*)[4]);
-    /* 8032181C */ virtual void calcPostTexMtxWithoutViewMtx(f32 const (*)[4]);
-    /* 80322E70 */ virtual void load();
-    /* 8031AA88 */ virtual void patch();
-    /* 8031AC68 */ virtual void diff(u32);
-    /* 8031ACD0 */ virtual void diffTexMtx();
-    /* 8031AD30 */ virtual void diffTexGen();
-    /* 80317B9C */ virtual s32 countDLSize();
-    /* 80322E74 */ virtual u32 getType();
-    /* 80322D3C */ virtual void setTexGenNum(u32 const*);
-    /* 80322D34 */ virtual void setTexGenNum(u32);
-    /* 80322D48 */ virtual u32 getTexGenNum() const;
-    /* 80322D50 */ virtual void setTexCoord(u32, J3DTexCoord const*);
-    /* 80322D64 */ virtual J3DTexCoord* getTexCoord(u32);
-    /* 80322D78 */ virtual void setTexMtx(u32, J3DTexMtx*);
-    /* 80322D88 */ virtual J3DTexMtx* getTexMtx(u32);
-    /* 80322D98 */ virtual bool getTexMtxOffset() const;
-    /* 80322DA0 */ virtual void setTexMtxOffset(u32);
-    /* 80317180 */ virtual ~J3DTexGenBlockPatched();
+    virtual void reset(J3DTexGenBlock*);
+    virtual void calc(f32 const (*)[4]);
+    virtual void calcWithoutViewMtx(f32 const (*)[4]);
+    virtual void calcPostTexMtx(f32 const (*)[4]);
+    virtual void calcPostTexMtxWithoutViewMtx(f32 const (*)[4]);
+    virtual void load();
+    virtual void patch();
+    virtual void diff(u32);
+    virtual void diffTexMtx();
+    virtual void diffTexGen();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setTexGenNum(u32 const*);
+    virtual void setTexGenNum(u32);
+    virtual u32 getTexGenNum() const;
+    virtual void setTexCoord(u32, J3DTexCoord const*);
+    virtual J3DTexCoord* getTexCoord(u32);
+    virtual void setTexMtx(u32, J3DTexMtx*);
+    virtual J3DTexMtx* getTexMtx(u32);
+    virtual bool getTexMtxOffset() const;
+    virtual void setTexMtxOffset(u32);
+    virtual ~J3DTexGenBlockPatched();
 
 private:
     /* 0x04 */ u32 mTexGenNum;
@@ -96,17 +93,17 @@ public:
     J3DTexGenBlockBasic() : mNBTScale(j3dDefaultNBTScaleInfo) {
         initialize();
     }
-    /* 803176A4 */ void initialize();
+    void initialize();
 
-    /* 803202DC */ virtual void reset(J3DTexGenBlock*);
-    /* 8031A9E8 */ virtual void load();
-    /* 8031ABC0 */ virtual void patch();
-    /* 80317BAC */ virtual s32 countDLSize();
-    /* 80322C6C */ virtual u32 getType();
-    /* 80322C9C */ virtual void setNBTScale(J3DNBTScale const*);
-    /* 80322C78 */ virtual void setNBTScale(J3DNBTScale);
-    /* 80322CC0 */ virtual J3DNBTScale* getNBTScale();
-    /* 80322CC8 */ virtual ~J3DTexGenBlockBasic();
+    virtual void reset(J3DTexGenBlock*);
+    virtual void load();
+    virtual void patch();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setNBTScale(J3DNBTScale const*);
+    virtual void setNBTScale(J3DNBTScale);
+    virtual J3DNBTScale* getNBTScale();
+    virtual ~J3DTexGenBlockBasic();
 
 private:
     /* 0x5C */ J3DNBTScale mNBTScale;
@@ -117,17 +114,17 @@ public:
     J3DTexGenBlock4() : mNBTScale(j3dDefaultNBTScaleInfo) {
         initialize();
     }
-    /* 80317674 */ void initialize();
+    void initialize();
 
-    /* 803201A0 */ virtual void reset(J3DTexGenBlock*);
-    /* 8031A948 */ virtual void load();
-    /* 8031AB18 */ virtual void patch();
-    /* 80317BA4 */ virtual s32 countDLSize();
-    /* 80322DA8 */ virtual u32 getType();
-    /* 80322DD8 */ virtual void setNBTScale(J3DNBTScale const*);
-    /* 80322DB4 */ virtual void setNBTScale(J3DNBTScale);
-    /* 80322DFC */ virtual J3DNBTScale* getNBTScale();
-    /* 80322E04 */ virtual ~J3DTexGenBlock4();
+    virtual void reset(J3DTexGenBlock*);
+    virtual void load();
+    virtual void patch();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setNBTScale(J3DNBTScale const*);
+    virtual void setNBTScale(J3DNBTScale);
+    virtual J3DNBTScale* getNBTScale();
+    virtual ~J3DTexGenBlock4();
 
 private:
     /* 0x5C */ J3DNBTScale mNBTScale;
@@ -135,62 +132,62 @@ private:
 
 class J3DTevBlock {
 public:
-    /* 80317350 */ virtual void reset(J3DTevBlock*);
-    /* 80317330 */ virtual void load();
-    /* 8031CD44 */ virtual void diff(u32);
-    /* 80321948 */ virtual void diffTexNo();
-    /* 80321938 */ virtual void diffTevReg();
-    /* 80321944 */ virtual void diffTexCoordScale();
-    /* 80321940 */ virtual void diffTevStage();
-    /* 8032193C */ virtual void diffTevStageIndirect();
-    /* 8000DBD4 */ virtual void patch();
-    /* 8032353C */ virtual void patchTexNo();
-    /* 80323540 */ virtual void patchTevReg();
-    /* 8000DBC8 */ virtual void patchTexNoAndTexCoordScale();
+    virtual void reset(J3DTevBlock*);
+    virtual void load();
+    virtual void diff(u32);
+    virtual void diffTexNo();
+    virtual void diffTevReg();
+    virtual void diffTexCoordScale();
+    virtual void diffTevStage();
+    virtual void diffTevStageIndirect();
+    virtual void patch();
+    virtual void patchTexNo();
+    virtual void patchTevReg();
+    virtual void patchTexNoAndTexCoordScale();
     virtual void ptrToIndex() = 0;
     virtual void indexToPtr() = 0;
     virtual u32 getType() = 0;
-    /* 8031730C */ virtual s32 countDLSize();
-    /* 80323544 */ virtual void setTexNo(u32, u16 const*);
-    /* 8000E0AC */ virtual void setTexNo(u32, u16);
-    /* 8000DF94 */ virtual u16 getTexNo(u32) const;
-    /* 80323548 */ virtual void setTevOrder(u32, J3DTevOrder const*);
-    /* 8000E0BC */ virtual void setTevOrder(u32, J3DTevOrder);
-    /* 8000DFB8 */ virtual J3DTevOrder* getTevOrder(u32);
-    /* 80110E80 */ virtual void setTevColor(u32, J3DGXColorS10 const*);
-    /* 8000E0C4 */ virtual void setTevColor(u32, J3DGXColorS10);
-    /* 8000DFC8 */ virtual _GXColorS10* getTevColor(u32);
-    /* 800732AC */ virtual void setTevKColor(u32, J3DGXColor const*);
-    /* 8000E0C0 */ virtual void setTevKColor(u32, J3DGXColor);
-    /* 8000DFC0 */ virtual _GXColor* getTevKColor(u32);
-    /* 80322950 */ virtual void setTevKColorSel(u32, u8 const*);
-    /* 8000E0B8 */ virtual void setTevKColorSel(u32, u8);
-    /* 8000DFB0 */ virtual bool getTevKColorSel(u32);
-    /* 80322954 */ virtual void setTevKAlphaSel(u32, u8 const*);
-    /* 8000E0B4 */ virtual void setTevKAlphaSel(u32, u8);
-    /* 8000DFA8 */ virtual bool getTevKAlphaSel(u32);
-    /* 8032354C */ virtual void setTevStageNum(u8 const*);
-    /* 8000E0C8 */ virtual void setTevStageNum(u8);
-    /* 8000DFD0 */ virtual u8 getTevStageNum() const;
-    /* 80323550 */ virtual void setTevStage(u32, J3DTevStage const*);
-    /* 8000E0A8 */ virtual void setTevStage(u32, J3DTevStage);
-    /* 8000DF8C */ virtual bool getTevStage(u32);
-    /* 8032295C */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
-    /* 80322958 */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
-    /* 80322960 */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
-    /* 8000E0B0 */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
-    /* 8000DFA0 */ virtual bool getTevSwapModeTable(u32);
-    /* 80323554 */ virtual void setIndTevStage(u32, J3DIndTevStage const*);
-    /* 8000E0A4 */ virtual void setIndTevStage(u32, J3DIndTevStage);
-    /* 8000DF84 */ virtual bool getIndTevStage(u32);
-    /* 80323558 */ virtual bool getTexNoOffset() const;
-    /* 80322964 */ virtual bool getTevRegOffset() const;
-    /* 80321FE0 */ virtual void setTexNoOffset(u32);
-    /* 8032296C */ virtual void setTevRegOffset(u32);
-    /* 80317224 */ virtual ~J3DTevBlock();
+    virtual s32 countDLSize();
+    virtual void setTexNo(u32, u16 const*);
+    virtual void setTexNo(u32, u16);
+    virtual u16 getTexNo(u32) const;
+    virtual void setTevOrder(u32, J3DTevOrder const*);
+    virtual void setTevOrder(u32, J3DTevOrder);
+    virtual J3DTevOrder* getTevOrder(u32);
+    virtual void setTevColor(u32, J3DGXColorS10 const*);
+    virtual void setTevColor(u32, J3DGXColorS10);
+    virtual _GXColorS10* getTevColor(u32);
+    virtual void setTevKColor(u32, J3DGXColor const*);
+    virtual void setTevKColor(u32, J3DGXColor);
+    virtual _GXColor* getTevKColor(u32);
+    virtual void setTevKColorSel(u32, u8 const*);
+    virtual void setTevKColorSel(u32, u8);
+    virtual bool getTevKColorSel(u32);
+    virtual void setTevKAlphaSel(u32, u8 const*);
+    virtual void setTevKAlphaSel(u32, u8);
+    virtual bool getTevKAlphaSel(u32);
+    virtual void setTevStageNum(u8 const*);
+    virtual void setTevStageNum(u8);
+    virtual u8 getTevStageNum() const;
+    virtual void setTevStage(u32, J3DTevStage const*);
+    virtual void setTevStage(u32, J3DTevStage);
+    virtual bool getTevStage(u32);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
+    virtual bool getTevSwapModeTable(u32);
+    virtual void setIndTevStage(u32, J3DIndTevStage const*);
+    virtual void setIndTevStage(u32, J3DIndTevStage);
+    virtual bool getIndTevStage(u32);
+    virtual bool getTexNoOffset() const;
+    virtual bool getTevRegOffset() const;
+    virtual void setTexNoOffset(u32);
+    virtual void setTevRegOffset(u32);
+    virtual ~J3DTevBlock();
 
 private:
-    /* 8031E098 */ void indexToPtr_private(u32);
+    void indexToPtr_private(u32);
 
     /* 0x4 */ u32 mTexNoOffset;
 };
@@ -200,51 +197,51 @@ public:
     J3DTevBlockPatched() {
         initialize();
     }
-    /* 803176E0 */ void initialize();
+    void initialize();
 
-    /* 80320418 */ virtual void reset(J3DTevBlock*);
-    /* 80322970 */ virtual void load();
-    /* 8031CE00 */ virtual void diffTexNo();
-    /* 8031D028 */ virtual void diffTevReg();
-    /* 8031D0C4 */ virtual void diffTexCoordScale();
-    /* 8031CE64 */ virtual void diffTevStage();
-    /* 8031CF78 */ virtual void diffTevStageIndirect();
-    /* 8031C228 */ virtual void patch();
-    /* 8031BF4C */ virtual void patchTexNo();
-    /* 8031BFE0 */ virtual void patchTevReg();
-    /* 8031C0AC */ virtual void patchTexNoAndTexCoordScale();
-    /* 8031DFB4 */ virtual void ptrToIndex();
-    /* 80322974 */ virtual void indexToPtr();
-    /* 80322998 */ virtual u32 getType();
-    /* 80317BB4 */ virtual s32 countDLSize();
-    /* 803229D0 */ virtual void setTexNo(u32, u16 const*);
-    /* 803229C0 */ virtual void setTexNo(u32, u16);
-    /* 803229E4 */ virtual u16 getTexNo(u32) const;
-    /* 80322A08 */ virtual void setTevOrder(u32, J3DTevOrder const*);
-    /* 803229F4 */ virtual void setTevOrder(u32, J3DTevOrder);
-    /* 80322A1C */ virtual J3DTevOrder* getTevOrder(u32);
-    /* 80322B24 */ virtual void setTevColor(u32, J3DGXColorS10 const*);
-    /* 80322AF8 */ virtual void setTevColor(u32, J3DGXColorS10);
-    /* 80322B50 */ virtual GXColorS10* getTevColor(u32);
-    /* 80322B90 */ virtual void setTevKColor(u32, J3DGXColor const*);
-    /* 80322B64 */ virtual void setTevKColor(u32, J3DGXColor);
-    /* 80322BBC */ virtual GXColor* getTevKColor(u32);
-    /* 80322BDC */ virtual void setTevKColorSel(u32, u8 const*);
-    /* 80322BD0 */ virtual void setTevKColorSel(u32, u8);
-    /* 80322BEC */ virtual bool getTevKColorSel(u32);
-    /* 803229AC */ virtual void setTevStageNum(u8 const*);
-    /* 803229A4 */ virtual void setTevStageNum(u8);
-    /* 803229B8 */ virtual u8 getTevStageNum() const;
-    /* 80322A6C */ virtual void setTevStage(u32, J3DTevStage const*);
-    /* 80322A30 */ virtual void setTevStage(u32, J3DTevStage);
-    /* 80322AA8 */ virtual bool getTevStage(u32);
-    /* 80322AD0 */ virtual void setIndTevStage(u32, J3DIndTevStage const*);
-    /* 80322ABC */ virtual void setIndTevStage(u32, J3DIndTevStage);
-    /* 80322AE4 */ virtual bool getIndTevStage(u32);
-    /* 80322BF8 */ virtual bool getTexNoOffset() const;
-    /* 80322C00 */ virtual bool getTevRegOffset() const;
-    /* 80322C08 */ virtual void setTevRegOffset(u32);
-    /* 80322C10 */ virtual ~J3DTevBlockPatched();
+    virtual void reset(J3DTevBlock*);
+    virtual void load();
+    virtual void diffTexNo();
+    virtual void diffTevReg();
+    virtual void diffTexCoordScale();
+    virtual void diffTevStage();
+    virtual void diffTevStageIndirect();
+    virtual void patch();
+    virtual void patchTexNo();
+    virtual void patchTevReg();
+    virtual void patchTexNoAndTexCoordScale();
+    virtual void ptrToIndex();
+    virtual void indexToPtr();
+    virtual u32 getType();
+    virtual s32 countDLSize();
+    virtual void setTexNo(u32, u16 const*);
+    virtual void setTexNo(u32, u16);
+    virtual u16 getTexNo(u32) const;
+    virtual void setTevOrder(u32, J3DTevOrder const*);
+    virtual void setTevOrder(u32, J3DTevOrder);
+    virtual J3DTevOrder* getTevOrder(u32);
+    virtual void setTevColor(u32, J3DGXColorS10 const*);
+    virtual void setTevColor(u32, J3DGXColorS10);
+    virtual GXColorS10* getTevColor(u32);
+    virtual void setTevKColor(u32, J3DGXColor const*);
+    virtual void setTevKColor(u32, J3DGXColor);
+    virtual GXColor* getTevKColor(u32);
+    virtual void setTevKColorSel(u32, u8 const*);
+    virtual void setTevKColorSel(u32, u8);
+    virtual bool getTevKColorSel(u32);
+    virtual void setTevStageNum(u8 const*);
+    virtual void setTevStageNum(u8);
+    virtual u8 getTevStageNum() const;
+    virtual void setTevStage(u32, J3DTevStage const*);
+    virtual void setTevStage(u32, J3DTevStage);
+    virtual bool getTevStage(u32);
+    virtual void setIndTevStage(u32, J3DIndTevStage const*);
+    virtual void setIndTevStage(u32, J3DIndTevStage);
+    virtual bool getIndTevStage(u32);
+    virtual bool getTexNoOffset() const;
+    virtual bool getTevRegOffset() const;
+    virtual void setTevRegOffset(u32);
+    virtual ~J3DTevBlockPatched();
 
 private:
     /* 0x08 */ u16 mTexNo[8];
@@ -259,7 +256,7 @@ private:
 };  // Size: 0xD8
 
 class J3DTevBlockNull : public J3DTevBlock {
-    /* 803176D4 */ void initialize();
+    void initialize();
 };
 
 class J3DTevBlock4 : public J3DTevBlock {
@@ -267,59 +264,59 @@ public:
     J3DTevBlock4() {
         initialize();
     }
-    /* 803178EC */ void initialize();
+    void initialize();
 
-    /* 8032098C */ virtual void reset(J3DTevBlock*);
-    /* 8031B4C0 */ virtual void load();
-    /* 8031D758 */ virtual void diffTexNo();
-    /* 8031D7BC */ virtual void diffTevReg();
-    /* 8031DA1C */ virtual void diffTexCoordScale();
-    /* 8031D858 */ virtual void diffTevStage();
-    /* 8031D96C */ virtual void diffTevStageIndirect();
-    /* 8031C9D0 */ virtual void patch();
-    /* 8031C6F4 */ virtual void patchTexNo();
-    /* 8031C788 */ virtual void patchTevReg();
-    /* 8031C854 */ virtual void patchTexNoAndTexCoordScale();
-    /* 80321FE8 */ virtual void ptrToIndex();
-    /* 80321FEC */ virtual void indexToPtr();
-    /* 80322010 */ virtual u32 getType();
-    /* 80317BCC */ virtual s32 countDLSize();
-    /* 8032202C */ virtual void setTexNo(u32, u16 const*);
-    /* 8032201C */ virtual void setTexNo(u32, u16);
-    /* 80322040 */ virtual u16 getTexNo(u32) const;
-    /* 80322064 */ virtual void setTevOrder(u32, J3DTevOrder const*);
-    /* 80322050 */ virtual void setTevOrder(u32, J3DTevOrder);
-    /* 80322078 */ virtual J3DTevOrder* getTevOrder(u32);
-    /* 803220B8 */ virtual void setTevColor(u32, J3DGXColorS10 const*);
-    /* 8032208C */ virtual void setTevColor(u32, J3DGXColorS10);
-    /* 803220E4 */ virtual GXColorS10* getTevColor(u32);
-    /* 80322124 */ virtual void setTevKColor(u32, J3DGXColor const*);
-    /* 803220F8 */ virtual void setTevKColor(u32, J3DGXColor);
-    /* 80322150 */ virtual GXColor* getTevKColor(u32);
-    /* 80322170 */ virtual void setTevKColorSel(u32, u8 const*);
-    /* 80322164 */ virtual void setTevKColorSel(u32, u8);
-    /* 80322180 */ virtual bool getTevKColorSel(u32);
-    /* 80322198 */ virtual void setTevKAlphaSel(u32, u8 const*);
-    /* 8032218C */ virtual void setTevKAlphaSel(u32, u8);
-    /* 803221A8 */ virtual bool getTevKAlphaSel(u32);
-    /* 803221BC */ virtual void setTevStageNum(u8 const*);
-    /* 803221B4 */ virtual void setTevStageNum(u8);
-    /* 803221C8 */ virtual u8 getTevStageNum() const;
-    /* 8032220C */ virtual void setTevStage(u32, J3DTevStage const*);
-    /* 803221D0 */ virtual void setTevStage(u32, J3DTevStage);
-    /* 80322248 */ virtual bool getTevStage(u32);
-    /* 80322294 */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
-    /* 8032225C */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
-    /* 803222DC */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
-    /* 803222CC */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
-    /* 803222EC */ virtual bool getTevSwapModeTable(u32);
-    /* 80322310 */ virtual void setIndTevStage(u32, J3DIndTevStage const*);
-    /* 803222FC */ virtual void setIndTevStage(u32, J3DIndTevStage);
-    /* 80322324 */ virtual bool getIndTevStage(u32);
-    /* 80322338 */ virtual bool getTexNoOffset() const;
-    /* 80322340 */ virtual bool getTevRegOffset() const;
-    /* 80322348 */ virtual void setTevRegOffset(u32);
-    /* 80322350 */ virtual ~J3DTevBlock4();
+    virtual void reset(J3DTevBlock*);
+    virtual void load();
+    virtual void diffTexNo();
+    virtual void diffTevReg();
+    virtual void diffTexCoordScale();
+    virtual void diffTevStage();
+    virtual void diffTevStageIndirect();
+    virtual void patch();
+    virtual void patchTexNo();
+    virtual void patchTevReg();
+    virtual void patchTexNoAndTexCoordScale();
+    virtual void ptrToIndex();
+    virtual void indexToPtr();
+    virtual u32 getType();
+    virtual s32 countDLSize();
+    virtual void setTexNo(u32, u16 const*);
+    virtual void setTexNo(u32, u16);
+    virtual u16 getTexNo(u32) const;
+    virtual void setTevOrder(u32, J3DTevOrder const*);
+    virtual void setTevOrder(u32, J3DTevOrder);
+    virtual J3DTevOrder* getTevOrder(u32);
+    virtual void setTevColor(u32, J3DGXColorS10 const*);
+    virtual void setTevColor(u32, J3DGXColorS10);
+    virtual GXColorS10* getTevColor(u32);
+    virtual void setTevKColor(u32, J3DGXColor const*);
+    virtual void setTevKColor(u32, J3DGXColor);
+    virtual GXColor* getTevKColor(u32);
+    virtual void setTevKColorSel(u32, u8 const*);
+    virtual void setTevKColorSel(u32, u8);
+    virtual bool getTevKColorSel(u32);
+    virtual void setTevKAlphaSel(u32, u8 const*);
+    virtual void setTevKAlphaSel(u32, u8);
+    virtual bool getTevKAlphaSel(u32);
+    virtual void setTevStageNum(u8 const*);
+    virtual void setTevStageNum(u8);
+    virtual u8 getTevStageNum() const;
+    virtual void setTevStage(u32, J3DTevStage const*);
+    virtual void setTevStage(u32, J3DTevStage);
+    virtual bool getTevStage(u32);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
+    virtual bool getTevSwapModeTable(u32);
+    virtual void setIndTevStage(u32, J3DIndTevStage const*);
+    virtual void setIndTevStage(u32, J3DIndTevStage);
+    virtual bool getIndTevStage(u32);
+    virtual bool getTexNoOffset() const;
+    virtual bool getTevRegOffset() const;
+    virtual void setTevRegOffset(u32);
+    virtual ~J3DTevBlock4();
 
 private:
     /* 0x08 */ u16 mTexNo[4];
@@ -340,59 +337,59 @@ public:
     J3DTevBlock2() {
         initialize();
     }
-    /* 80317810 */ void initialize();
+    void initialize();
 
-    /* 803206AC */ virtual void reset(J3DTevBlock*);
-    /* 8031AFA4 */ virtual void load();
-    /* 8031D3D0 */ virtual void diffTexNo();
-    /* 8031D434 */ virtual void diffTevReg();
-    /* 8031D694 */ virtual void diffTexCoordScale();
-    /* 8031D4D0 */ virtual void diffTevStage();
-    /* 8031D5E4 */ virtual void diffTevStageIndirect();
-    /* 8031C6A8 */ virtual void patch();
-    /* 8031C3F8 */ virtual void patchTexNo();
-    /* 8031C48C */ virtual void patchTevReg();
-    /* 8031C558 */ virtual void patchTexNoAndTexCoordScale();
-    /* 803223AC */ virtual void ptrToIndex();
-    /* 803223B0 */ virtual void indexToPtr();
-    /* 803223D4 */ virtual u32 getType();
-    /* 80317BC4 */ virtual s32 countDLSize();
-    /* 803223F0 */ virtual void setTexNo(u32, u16 const*);
-    /* 803223E0 */ virtual void setTexNo(u32, u16);
-    /* 80322404 */ virtual u16 getTexNo(u32) const;
-    /* 80322428 */ virtual void setTevOrder(u32, J3DTevOrder const*);
-    /* 80322414 */ virtual void setTevOrder(u32, J3DTevOrder);
-    /* 8032243C */ virtual J3DTevOrder* getTevOrder(u32);
-    /* 8032247C */ virtual void setTevColor(u32, J3DGXColorS10 const*);
-    /* 80322450 */ virtual void setTevColor(u32, J3DGXColorS10);
-    /* 803224A8 */ virtual GXColorS10* getTevColor(u32);
-    /* 803224E8 */ virtual void setTevKColor(u32, J3DGXColor const*);
-    /* 803224BC */ virtual void setTevKColor(u32, J3DGXColor);
-    /* 80322514 */ virtual GXColor* getTevKColor(u32);
-    /* 80322534 */ virtual void setTevKColorSel(u32, u8 const*);
-    /* 80322528 */ virtual void setTevKColorSel(u32, u8);
-    /* 80322544 */ virtual bool getTevKColorSel(u32);
-    /* 8032255C */ virtual void setTevKAlphaSel(u32, u8 const*);
-    /* 80322550 */ virtual void setTevKAlphaSel(u32, u8);
-    /* 8032256C */ virtual bool getTevKAlphaSel(u32);
-    /* 80322580 */ virtual void setTevStageNum(u8 const*);
-    /* 80322578 */ virtual void setTevStageNum(u8);
-    /* 8032258C */ virtual u8 getTevStageNum() const;
-    /* 803225D0 */ virtual void setTevStage(u32, J3DTevStage const*);
-    /* 80322594 */ virtual void setTevStage(u32, J3DTevStage);
-    /* 8032260C */ virtual bool getTevStage(u32);
-    /* 80322658 */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
-    /* 80322620 */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
-    /* 803226A0 */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
-    /* 80322690 */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
-    /* 803226B0 */ virtual bool getTevSwapModeTable(u32);
-    /* 803226D4 */ virtual void setIndTevStage(u32, J3DIndTevStage const*);
-    /* 803226C0 */ virtual void setIndTevStage(u32, J3DIndTevStage);
-    /* 803226E8 */ virtual bool getIndTevStage(u32);
-    /* 803226FC */ virtual bool getTexNoOffset() const;
-    /* 80322704 */ virtual bool getTevRegOffset() const;
-    /* 8032270C */ virtual void setTevRegOffset(u32);
-    /* 80322714 */ virtual ~J3DTevBlock2();
+    virtual void reset(J3DTevBlock*);
+    virtual void load();
+    virtual void diffTexNo();
+    virtual void diffTevReg();
+    virtual void diffTexCoordScale();
+    virtual void diffTevStage();
+    virtual void diffTevStageIndirect();
+    virtual void patch();
+    virtual void patchTexNo();
+    virtual void patchTevReg();
+    virtual void patchTexNoAndTexCoordScale();
+    virtual void ptrToIndex();
+    virtual void indexToPtr();
+    virtual u32 getType();
+    virtual s32 countDLSize();
+    virtual void setTexNo(u32, u16 const*);
+    virtual void setTexNo(u32, u16);
+    virtual u16 getTexNo(u32) const;
+    virtual void setTevOrder(u32, J3DTevOrder const*);
+    virtual void setTevOrder(u32, J3DTevOrder);
+    virtual J3DTevOrder* getTevOrder(u32);
+    virtual void setTevColor(u32, J3DGXColorS10 const*);
+    virtual void setTevColor(u32, J3DGXColorS10);
+    virtual GXColorS10* getTevColor(u32);
+    virtual void setTevKColor(u32, J3DGXColor const*);
+    virtual void setTevKColor(u32, J3DGXColor);
+    virtual GXColor* getTevKColor(u32);
+    virtual void setTevKColorSel(u32, u8 const*);
+    virtual void setTevKColorSel(u32, u8);
+    virtual bool getTevKColorSel(u32);
+    virtual void setTevKAlphaSel(u32, u8 const*);
+    virtual void setTevKAlphaSel(u32, u8);
+    virtual bool getTevKAlphaSel(u32);
+    virtual void setTevStageNum(u8 const*);
+    virtual void setTevStageNum(u8);
+    virtual u8 getTevStageNum() const;
+    virtual void setTevStage(u32, J3DTevStage const*);
+    virtual void setTevStage(u32, J3DTevStage);
+    virtual bool getTevStage(u32);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
+    virtual bool getTevSwapModeTable(u32);
+    virtual void setIndTevStage(u32, J3DIndTevStage const*);
+    virtual void setIndTevStage(u32, J3DIndTevStage);
+    virtual bool getIndTevStage(u32);
+    virtual bool getTexNoOffset() const;
+    virtual bool getTevRegOffset() const;
+    virtual void setTevRegOffset(u32);
+    virtual ~J3DTevBlock2();
 
 private:
     /* 0x08 */ u16 mTexNo[2];
@@ -413,59 +410,59 @@ public:
     J3DTevBlock16() {
         initialize();
     }
-    /* 80317A00 */ void initialize();
+    void initialize();
 
-    /* 80320E24 */ virtual void reset(J3DTevBlock*);
-    /* 8031BA04 */ virtual void load();
-    /* 8031DB14 */ virtual void diffTexNo();
-    /* 8031DB78 */ virtual void diffTevReg();
-    /* 8031DDD8 */ virtual void diffTexCoordScale();
-    /* 8031DC14 */ virtual void diffTevStage();
-    /* 8031DD28 */ virtual void diffTevStageIndirect();
-    /* 8031CCF8 */ virtual void patch();
-    /* 8031CA1C */ virtual void patchTexNo();
-    /* 8031CAB0 */ virtual void patchTevReg();
-    /* 8031CB7C */ virtual void patchTexNoAndTexCoordScale();
-    /* 8031DED0 */ virtual void ptrToIndex();
-    /* 80321C20 */ virtual void indexToPtr();
-    /* 80321C44 */ virtual u32 getType();
-    /* 80317BD4 */ virtual s32 countDLSize();
-    /* 80321C60 */ virtual void setTexNo(u32, u16 const*);
-    /* 80321C50 */ virtual void setTexNo(u32, u16);
-    /* 80321C74 */ virtual u16 getTexNo(u32) const;
-    /* 80321C98 */ virtual void setTevOrder(u32, J3DTevOrder const*);
-    /* 80321C84 */ virtual void setTevOrder(u32, J3DTevOrder);
-    /* 80321CAC */ virtual J3DTevOrder* getTevOrder(u32);
-    /* 80321CEC */ virtual void setTevColor(u32, J3DGXColorS10 const*);
-    /* 80321CC0 */ virtual void setTevColor(u32, J3DGXColorS10);
-    /* 80321D18 */ virtual GXColorS10* getTevColor(u32);
-    /* 80321D58 */ virtual void setTevKColor(u32, J3DGXColor const*);
-    /* 80321D2C */ virtual void setTevKColor(u32, J3DGXColor);
-    /* 80321D84 */ virtual GXColor* getTevKColor(u32);
-    /* 80321DA4 */ virtual void setTevKColorSel(u32, u8 const*);
-    /* 80321D98 */ virtual void setTevKColorSel(u32, u8);
-    /* 80321DB4 */ virtual bool getTevKColorSel(u32);
-    /* 80321DCC */ virtual void setTevKAlphaSel(u32, u8 const*);
-    /* 80321DC0 */ virtual void setTevKAlphaSel(u32, u8);
-    /* 80321DDC */ virtual bool getTevKAlphaSel(u32);
-    /* 80321DE8 */ virtual void setTevStageNum(u8);
-    /* 80321DF0 */ virtual void setTevStageNum(u8 const*);
-    /* 80321DFC */ virtual u8 getTevStageNum() const;
-    /* 80321E40 */ virtual void setTevStage(u32, J3DTevStage const*);
-    /* 80321E04 */ virtual void setTevStage(u32, J3DTevStage);
-    /* 80321E7C */ virtual bool getTevStage(u32);
-    /* 80321EC8 */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
-    /* 80321E90 */ virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
-    /* 80321F10 */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
-    /* 80321F00 */ virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
-    /* 80321F20 */ virtual bool getTevSwapModeTable(u32);
-    /* 80321F44 */ virtual void setIndTevStage(u32, J3DIndTevStage const*);
-    /* 80321F30 */ virtual void setIndTevStage(u32, J3DIndTevStage);
-    /* 80321F58 */ virtual bool getIndTevStage(u32);
-    /* 80321F6C */ virtual bool getTexNoOffset() const;
-    /* 80321F74 */ virtual bool getTevRegOffset() const;
-    /* 80321F7C */ virtual void setTevRegOffset(u32);
-    /* 80321F84 */ virtual ~J3DTevBlock16();
+    virtual void reset(J3DTevBlock*);
+    virtual void load();
+    virtual void diffTexNo();
+    virtual void diffTevReg();
+    virtual void diffTexCoordScale();
+    virtual void diffTevStage();
+    virtual void diffTevStageIndirect();
+    virtual void patch();
+    virtual void patchTexNo();
+    virtual void patchTevReg();
+    virtual void patchTexNoAndTexCoordScale();
+    virtual void ptrToIndex();
+    virtual void indexToPtr();
+    virtual u32 getType();
+    virtual s32 countDLSize();
+    virtual void setTexNo(u32, u16 const*);
+    virtual void setTexNo(u32, u16);
+    virtual u16 getTexNo(u32) const;
+    virtual void setTevOrder(u32, J3DTevOrder const*);
+    virtual void setTevOrder(u32, J3DTevOrder);
+    virtual J3DTevOrder* getTevOrder(u32);
+    virtual void setTevColor(u32, J3DGXColorS10 const*);
+    virtual void setTevColor(u32, J3DGXColorS10);
+    virtual GXColorS10* getTevColor(u32);
+    virtual void setTevKColor(u32, J3DGXColor const*);
+    virtual void setTevKColor(u32, J3DGXColor);
+    virtual GXColor* getTevKColor(u32);
+    virtual void setTevKColorSel(u32, u8 const*);
+    virtual void setTevKColorSel(u32, u8);
+    virtual bool getTevKColorSel(u32);
+    virtual void setTevKAlphaSel(u32, u8 const*);
+    virtual void setTevKAlphaSel(u32, u8);
+    virtual bool getTevKAlphaSel(u32);
+    virtual void setTevStageNum(u8);
+    virtual void setTevStageNum(u8 const*);
+    virtual u8 getTevStageNum() const;
+    virtual void setTevStage(u32, J3DTevStage const*);
+    virtual void setTevStage(u32, J3DTevStage);
+    virtual bool getTevStage(u32);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo const*);
+    virtual void setTevSwapModeInfo(u32, J3DTevSwapModeInfo);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable const*);
+    virtual void setTevSwapModeTable(u32, J3DTevSwapModeTable);
+    virtual bool getTevSwapModeTable(u32);
+    virtual void setIndTevStage(u32, J3DIndTevStage const*);
+    virtual void setIndTevStage(u32, J3DIndTevStage);
+    virtual bool getIndTevStage(u32);
+    virtual bool getTexNoOffset() const;
+    virtual bool getTevRegOffset() const;
+    virtual void setTevRegOffset(u32);
+    virtual ~J3DTevBlock16();
 
 private:
     /* 0x008 */ u16 mTexNo[8];
@@ -486,40 +483,40 @@ public:
     J3DTevBlock1() {
         initialize();
     }
-    /* 803177E8 */ void initialize();
+    void initialize();
 
-    /* 803205D4 */ virtual void reset(J3DTevBlock*);
-    /* 8031AD64 */ virtual void load();
-    /* 8031D1BC */ virtual void diffTexNo();
-    /* 8031D1F4 */ virtual void diffTevReg();
-    /* 8031D368 */ virtual void diffTexCoordScale();
-    /* 8031D1F8 */ virtual void diffTevStage();
-    /* 8031D2E8 */ virtual void diffTevStageIndirect();
-    /* 8031C3CC */ virtual void patch();
-    /* 8031C274 */ virtual void patchTexNo();
-    /* 8031C2E4 */ virtual void patchTevReg();
-    /* 8031C2E8 */ virtual void patchTexNoAndTexCoordScale();
-    /* 80322770 */ virtual void ptrToIndex();
-    /* 80322774 */ virtual void indexToPtr();
-    /* 80322798 */ virtual u32 getType();
-    /* 80317BBC */ virtual s32 countDLSize();
-    /* 803227B4 */ virtual void setTexNo(u32, u16 const*);
-    /* 803227A4 */ virtual void setTexNo(u32, u16);
-    /* 803227C8 */ virtual u16 getTexNo(u32) const;
-    /* 803227EC */ virtual void setTevOrder(u32, J3DTevOrder const*);
-    /* 803227D8 */ virtual void setTevOrder(u32, J3DTevOrder);
-    /* 80322800 */ virtual J3DTevOrder* getTevOrder(u32);
-    /* 80322818 */ virtual void setTevStageNum(u8 const*);
-    /* 80322814 */ virtual void setTevStageNum(u8);
-    /* 8032281C */ virtual u8 getTevStageNum() const;
-    /* 80322860 */ virtual void setTevStage(u32, J3DTevStage const*);
-    /* 80322824 */ virtual void setTevStage(u32, J3DTevStage);
-    /* 8032289C */ virtual bool getTevStage(u32);
-    /* 803228C4 */ virtual void setIndTevStage(u32, J3DIndTevStage const*);
-    /* 803228B0 */ virtual void setIndTevStage(u32, J3DIndTevStage);
-    /* 803228D8 */ virtual bool getIndTevStage(u32);
-    /* 803228EC */ virtual bool getTexNoOffset() const;
-    /* 803228F4 */ virtual ~J3DTevBlock1();
+    virtual void reset(J3DTevBlock*);
+    virtual void load();
+    virtual void diffTexNo();
+    virtual void diffTevReg();
+    virtual void diffTexCoordScale();
+    virtual void diffTevStage();
+    virtual void diffTevStageIndirect();
+    virtual void patch();
+    virtual void patchTexNo();
+    virtual void patchTevReg();
+    virtual void patchTexNoAndTexCoordScale();
+    virtual void ptrToIndex();
+    virtual void indexToPtr();
+    virtual u32 getType();
+    virtual s32 countDLSize();
+    virtual void setTexNo(u32, u16 const*);
+    virtual void setTexNo(u32, u16);
+    virtual u16 getTexNo(u32) const;
+    virtual void setTevOrder(u32, J3DTevOrder const*);
+    virtual void setTevOrder(u32, J3DTevOrder);
+    virtual J3DTevOrder* getTevOrder(u32);
+    virtual void setTevStageNum(u8 const*);
+    virtual void setTevStageNum(u8);
+    virtual u8 getTevStageNum() const;
+    virtual void setTevStage(u32, J3DTevStage const*);
+    virtual void setTevStage(u32, J3DTevStage);
+    virtual bool getTevStage(u32);
+    virtual void setIndTevStage(u32, J3DIndTevStage const*);
+    virtual void setIndTevStage(u32, J3DIndTevStage);
+    virtual bool getIndTevStage(u32);
+    virtual bool getTexNoOffset() const;
+    virtual ~J3DTevBlock1();
 
 private:
     /* 0x08 */ u16 mTexNo[1];
@@ -621,59 +618,59 @@ struct J3DAlphaComp {
 
 class J3DPEBlock {
 public:
-    /* 80317348 */ virtual void reset(J3DPEBlock*);
+    virtual void reset(J3DPEBlock*);
     virtual void load() = 0;
-    /* 8000DBCC */ virtual void patch();
-    /* 80317344 */ virtual void diff(u32);
-    /* 8031735C */ virtual void diffFog();
-    /* 80317360 */ virtual void diffBlend();
+    virtual void patch();
+    virtual void diff(u32);
+    virtual void diffFog();
+    virtual void diffBlend();
     virtual s32 countDLSize();
     virtual u32 getType() = 0;
-    /* 80317368 */ virtual void setFog(J3DFog);
-    /* 80317364 */ virtual void setFog(J3DFog*);
-    /* 8000DF5C */ virtual J3DFog* getFog();
-    /* 8031736C */ virtual void setAlphaComp(J3DAlphaComp const*);
-    /* 8000E01C */ virtual void setAlphaComp(J3DAlphaComp const&);
-    /* 8000DF54 */ virtual J3DAlphaComp* getAlphaComp();
-    /* 80317370 */ virtual void setBlend(J3DBlend const*);
-    /* 8000E018 */ virtual void setBlend(J3DBlend const&);
-    /* 8000DF4C */ virtual bool getBlend();
-    /* 80317374 */ virtual void setZMode(J3DZMode const*);
-    /* 8000E014 */ virtual void setZMode(J3DZMode);
-    /* 8000DF44 */ virtual J3DZMode* getZMode();
-    /* 80317378 */ virtual void setZCompLoc(u8 const*);
-    /* 8000E010 */ virtual void setZCompLoc(u8);
-    /* 8000DF3C */ virtual bool getZCompLoc() const;
-    /* 80317380 */ virtual void setDither(u8 const*);
-    /* 8031737C */ virtual void setDither(u8);
-    /* 80317384 */ virtual bool getDither() const;
-    /* 8031738C */ virtual bool getFogOffset() const;
-    /* 80317394 */ virtual void setFogOffset(u32);
+    virtual void setFog(J3DFog);
+    virtual void setFog(J3DFog*);
+    virtual J3DFog* getFog();
+    virtual void setAlphaComp(J3DAlphaComp const*);
+    virtual void setAlphaComp(J3DAlphaComp const&);
+    virtual J3DAlphaComp* getAlphaComp();
+    virtual void setBlend(J3DBlend const*);
+    virtual void setBlend(J3DBlend const&);
+    virtual bool getBlend();
+    virtual void setZMode(J3DZMode const*);
+    virtual void setZMode(J3DZMode);
+    virtual J3DZMode* getZMode();
+    virtual void setZCompLoc(u8 const*);
+    virtual void setZCompLoc(u8);
+    virtual bool getZCompLoc() const;
+    virtual void setDither(u8 const*);
+    virtual void setDither(u8);
+    virtual bool getDither() const;
+    virtual bool getFogOffset() const;
+    virtual void setFogOffset(u32);
     virtual ~J3DPEBlock();
 };
 
 class J3DPEBlockXlu : public J3DPEBlock {
 public:
-    /* 8031E98C */ virtual void load();
-    /* 80317BF4 */ virtual s32 countDLSize();
-    /* 80323258 */ virtual u32 getType();
-    /* 80323264 */ virtual ~J3DPEBlockXlu();
+    virtual void load();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual ~J3DPEBlockXlu();
 };
 
 class J3DPEBlockTexEdge : public J3DPEBlock {
 public:
-    /* 8031E6C8 */ virtual void load();
-    /* 80317BEC */ virtual s32 countDLSize();
-    /* 803232C0 */ virtual u32 getType();
-    /* 803232CC */ virtual ~J3DPEBlockTexEdge();
+    virtual void load();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual ~J3DPEBlockTexEdge();
 };
 
 class J3DPEBlockOpa : public J3DPEBlock {
 public:
-    /* 8031E408 */ virtual void load();
-    /* 80317BE4 */ virtual s32 countDLSize();
-    /* 80323328 */ virtual u32 getType();
-    /* 80323334 */ virtual ~J3DPEBlockOpa();
+    virtual void load();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual ~J3DPEBlockOpa();
 };
 
 class J3DPEBlockFull : public J3DPEBlock {
@@ -681,37 +678,37 @@ public:
     J3DPEBlockFull() {
         initialize();
     }
-    /* 80317B58 */ void initialize();
+    void initialize();
 
-    /* 8032129C */ virtual void reset(J3DPEBlock*);
-    /* 8031F3C0 */ virtual void load();
-    /* 8031F890 */ virtual void patch();
-    /* 8031FCA0 */ virtual void diff(u32);
-    /* 8031F940 */ virtual void diffFog();
-    /* 8031F9B8 */ virtual void diffBlend();
-    /* 80317C04 */ virtual s32 countDLSize();
-    /* 8032194C */ virtual u32 getType();
-    /* 8032197C */ virtual void setFog(J3DFog);
-    /* 80321958 */ virtual void setFog(J3DFog*);
-    /* 803219A0 */ virtual J3DFog* getFog();
-    /* 803219C4 */ virtual void setAlphaComp(J3DAlphaComp const*);
-    /* 803219A8 */ virtual void setAlphaComp(J3DAlphaComp const&);
-    /* 803219E0 */ virtual J3DAlphaComp* getAlphaComp();
-    /* 803219F4 */ virtual void setBlend(J3DBlend const*);
-    /* 803219E8 */ virtual void setBlend(J3DBlend const&);
-    /* 80321A00 */ virtual bool getBlend();
-    /* 80321A14 */ virtual void setZMode(J3DZMode const*);
-    /* 80321A08 */ virtual void setZMode(J3DZMode);
-    /* 80321A20 */ virtual J3DZMode* getZMode();
-    /* 80321A30 */ virtual void setZCompLoc(u8 const*);
-    /* 80321A28 */ virtual void setZCompLoc(u8);
-    /* 80321A3C */ virtual bool getZCompLoc() const;
-    /* 80321A4C */ virtual void setDither(u8 const*);
-    /* 80321A44 */ virtual void setDither(u8);
-    /* 80321A58 */ virtual bool getDither() const;
-    /* 80321A60 */ virtual bool getFogOffset() const;
-    /* 80321A68 */ virtual void setFogOffset(u32);
-    /* 80321A70 */ virtual ~J3DPEBlockFull();
+    virtual void reset(J3DPEBlock*);
+    virtual void load();
+    virtual void patch();
+    virtual void diff(u32);
+    virtual void diffFog();
+    virtual void diffBlend();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setFog(J3DFog);
+    virtual void setFog(J3DFog*);
+    virtual J3DFog* getFog();
+    virtual void setAlphaComp(J3DAlphaComp const*);
+    virtual void setAlphaComp(J3DAlphaComp const&);
+    virtual J3DAlphaComp* getAlphaComp();
+    virtual void setBlend(J3DBlend const*);
+    virtual void setBlend(J3DBlend const&);
+    virtual bool getBlend();
+    virtual void setZMode(J3DZMode const*);
+    virtual void setZMode(J3DZMode);
+    virtual J3DZMode* getZMode();
+    virtual void setZCompLoc(u8 const*);
+    virtual void setZCompLoc(u8);
+    virtual bool getZCompLoc() const;
+    virtual void setDither(u8 const*);
+    virtual void setDither(u8);
+    virtual bool getDither() const;
+    virtual bool getFogOffset() const;
+    virtual void setFogOffset(u32);
+    virtual ~J3DPEBlockFull();
 
 private:
     /* 0x04 */ J3DFog mFog;
@@ -728,30 +725,30 @@ public:
     J3DPEBlockFogOff() {
         initialize();
     }
-    /* 80317B34 */ void initialize();
+    void initialize();
 
-    /* 803211B4 */ virtual void reset(J3DPEBlock*);
-    /* 8031EC50 */ virtual void load();
-    /* 80321ACC */ virtual void diff(u32);
-    /* 8031F0D8 */ virtual void diffBlend();
-    /* 80317BFC */ virtual s32 countDLSize();
-    /* 80321B00 */ virtual u32 getType();
-    /* 80321B28 */ virtual void setAlphaComp(J3DAlphaComp const*);
-    /* 80321B0C */ virtual void setAlphaComp(J3DAlphaComp const&);
-    /* 80321B44 */ virtual J3DAlphaComp* getAlphaComp();
-    /* 80321B58 */ virtual void setBlend(J3DBlend const*);
-    /* 80321B4C */ virtual void setBlend(J3DBlend const&);
-    /* 80321B64 */ virtual bool getBlend();
-    /* 80321B78 */ virtual void setZMode(J3DZMode const*);
-    /* 80321B6C */ virtual void setZMode(J3DZMode);
-    /* 80321B84 */ virtual J3DZMode* getZMode();
-    /* 80321B94 */ virtual void setZCompLoc(u8 const*);
-    /* 80321B8C */ virtual void setZCompLoc(u8);
-    /* 80321BA0 */ virtual bool getZCompLoc() const;
-    /* 80321BB0 */ virtual void setDither(u8 const*);
-    /* 80321BA8 */ virtual void setDither(u8);
-    /* 80321BBC */ virtual bool getDither() const;
-    /* 80321BC4 */ virtual ~J3DPEBlockFogOff();
+    virtual void reset(J3DPEBlock*);
+    virtual void load();
+    virtual void diff(u32);
+    virtual void diffBlend();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setAlphaComp(J3DAlphaComp const*);
+    virtual void setAlphaComp(J3DAlphaComp const&);
+    virtual J3DAlphaComp* getAlphaComp();
+    virtual void setBlend(J3DBlend const*);
+    virtual void setBlend(J3DBlend const&);
+    virtual bool getBlend();
+    virtual void setZMode(J3DZMode const*);
+    virtual void setZMode(J3DZMode);
+    virtual J3DZMode* getZMode();
+    virtual void setZCompLoc(u8 const*);
+    virtual void setZCompLoc(u8);
+    virtual bool getZCompLoc() const;
+    virtual void setDither(u8 const*);
+    virtual void setDither(u8);
+    virtual bool getDither() const;
+    virtual ~J3DPEBlockFogOff();
 
 private:
     /* 0x04 */ J3DAlphaComp mAlphaComp;
@@ -762,8 +759,8 @@ private:
 };  // Size: 0x10
 
 struct J3DIndTexCoordScale {
-    /* 8000E024 */ ~J3DIndTexCoordScale();
-    /* 8000E0E4 */ J3DIndTexCoordScale();
+    ~J3DIndTexCoordScale();
+    J3DIndTexCoordScale();
 
     /* 0x0 */ u8 mScaleS;
     /* 0x1 */ u8 mScaleT;
@@ -772,15 +769,15 @@ struct J3DIndTexCoordScale {
 };
 
 struct J3DIndTexMtx {
-    /* 8000E064 */ ~J3DIndTexMtx();
-    /* 8000E0F0 */ J3DIndTexMtx();
+    ~J3DIndTexMtx();
+    J3DIndTexMtx();
 
     /* 0x00 */ Mtx23 mOffsetMtx;
     /* 0x18 */ u8 mScaleExp;
 };  // Size: 0x1C
 
 struct J3DIndTexOrder {
-    /* 8000E128 */ J3DIndTexOrder();
+    J3DIndTexOrder();
 
     /* 0x0 */ u8 mMap;
     /* 0x1 */ u8 mCoord;
@@ -790,23 +787,23 @@ struct J3DIndTexOrder {
 
 class J3DIndBlock {
 public:
-    /* 8031734C */ virtual void reset(J3DIndBlock*);
+    virtual void reset(J3DIndBlock*);
     virtual void diff(u32) = 0;
     virtual void load() = 0;
-    /* 80317314 */ virtual s32 countDLSize();
+    virtual s32 countDLSize();
     virtual u32 getType() = 0;
-    /* 8000E0A0 */ virtual void setIndTexStageNum(u8);
-    /* 8000DF7C */ virtual u8 getIndTexStageNum() const;
-    /* 80317410 */ virtual void setIndTexOrder(u32, J3DIndTexOrder);
-    /* 8031740C */ virtual void setIndTexOrder(u32, J3DIndTexOrder const*);
-    /* 8000DF74 */ virtual bool getIndTexOrder(u32);
-    /* 80317414 */ virtual void setIndTexMtx(u32, J3DIndTexMtx const*);
-    /* 8000E060 */ virtual void setIndTexMtx(u32, J3DIndTexMtx);
-    /* 8000DF6C */ virtual bool getIndTexMtx(u32);
-    /* 8000E020 */ virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale);
-    /* 80317418 */ virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale const*);
-    /* 8000DF64 */ virtual bool getIndTexCoordScale(u32);
-    /* 8031726C */ virtual ~J3DIndBlock();
+    virtual void setIndTexStageNum(u8);
+    virtual u8 getIndTexStageNum() const;
+    virtual void setIndTexOrder(u32, J3DIndTexOrder);
+    virtual void setIndTexOrder(u32, J3DIndTexOrder const*);
+    virtual bool getIndTexOrder(u32);
+    virtual void setIndTexMtx(u32, J3DIndTexMtx const*);
+    virtual void setIndTexMtx(u32, J3DIndTexMtx);
+    virtual bool getIndTexMtx(u32);
+    virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale);
+    virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale const*);
+    virtual bool getIndTexCoordScale(u32);
+    virtual ~J3DIndBlock();
 };
 
 class J3DIndBlockFull : public J3DIndBlock {
@@ -814,25 +811,25 @@ public:
     J3DIndBlockFull() {
         initialize();
     }
-    /* 80317B28 */ void initialize();
+    void initialize();
 
-    /* 803210B0 */ virtual void reset(J3DIndBlock*);
-    /* 8031E328 */ virtual void diff(u32);
-    /* 8031E12C */ virtual void load();
-    /* 80317BDC */ virtual s32 countDLSize();
-    /* 80323390 */ virtual u32 getType();
-    /* 8032339C */ virtual void setIndTexStageNum(u8);
-    /* 803233A4 */ virtual u8 getIndTexStageNum() const;
-    /* 803233AC */ virtual void setIndTexOrder(u32, J3DIndTexOrder);
-    /* 803233C0 */ virtual void setIndTexOrder(u32, J3DIndTexOrder const*);
-    /* 803233D4 */ virtual bool getIndTexOrder(u32);
-    /* 8032341C */ virtual void setIndTexMtx(u32, J3DIndTexMtx const*);
-    /* 803233E8 */ virtual void setIndTexMtx(u32, J3DIndTexMtx);
-    /* 80323450 */ virtual bool getIndTexMtx(u32);
-    /* 80323478 */ virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale const*);
-    /* 80323464 */ virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale);
-    /* 8032348C */ virtual bool getIndTexCoordScale(u32);
-    /* 803234A0 */ virtual ~J3DIndBlockFull();
+    virtual void reset(J3DIndBlock*);
+    virtual void diff(u32);
+    virtual void load();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setIndTexStageNum(u8);
+    virtual u8 getIndTexStageNum() const;
+    virtual void setIndTexOrder(u32, J3DIndTexOrder);
+    virtual void setIndTexOrder(u32, J3DIndTexOrder const*);
+    virtual bool getIndTexOrder(u32);
+    virtual void setIndTexMtx(u32, J3DIndTexMtx const*);
+    virtual void setIndTexMtx(u32, J3DIndTexMtx);
+    virtual bool getIndTexMtx(u32);
+    virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale const*);
+    virtual void setIndTexCoordScale(u32, J3DIndTexCoordScale);
+    virtual bool getIndTexCoordScale(u32);
+    virtual ~J3DIndBlockFull();
 
 private:
     /* 0x04 */ u8 mIndTexStageNum;
@@ -843,11 +840,11 @@ private:
 
 class J3DIndBlockNull : public J3DIndBlock {
 public:
-    /* 803173A0 */ virtual void reset(J3DIndBlock*);
-    /* 80317398 */ virtual void diff(u32);
-    /* 8031739C */ virtual void load();
-    /* 803173A4 */ virtual u32 getType();
-    /* 803173B0 */ virtual ~J3DIndBlockNull();
+    virtual void reset(J3DIndBlock*);
+    virtual void diff(u32);
+    virtual void load();
+    virtual u32 getType();
+    virtual ~J3DIndBlockNull();
 };
 
 struct J3DColorChanInfo {
@@ -860,7 +857,7 @@ struct J3DColorChanInfo {
 };
 
 struct J3DColorChan {
-    /* 8000E47C */ J3DColorChan();
+    J3DColorChan();
     u8 getLightMask() { return (((mColorChanID & 0x7800) >> 7) | (mColorChanID & 0x3c) >> 2); }
     void setLightMask(u8 param_1) {
         mColorChanID = (mColorChanID & ~0x3c) | ((param_1 & 0xf) << 2);
@@ -872,40 +869,40 @@ struct J3DColorChan {
 
 class J3DColorBlock {
 public:
-    /* 80317324 */ virtual void load();
-    /* 80317358 */ virtual void reset(J3DColorBlock*);
-    /* 8031733C */ virtual void patch();
-    /* 80317434 */ virtual void patchMatColor();
-    /* 8000DBD0 */ virtual void patchLight();
-    /* 80317340 */ virtual void diff(u32);
-    /* 80317438 */ virtual void diffAmbColor();
-    /* 8031743C */ virtual void diffMatColor();
-    /* 80317440 */ virtual void diffColorChan();
-    /* 80317444 */ virtual void diffLightObj(u32);
-    /* 80317304 */ virtual s32 countDLSize();
+    virtual void load();
+    virtual void reset(J3DColorBlock*);
+    virtual void patch();
+    virtual void patchMatColor();
+    virtual void patchLight();
+    virtual void diff(u32);
+    virtual void diffAmbColor();
+    virtual void diffMatColor();
+    virtual void diffColorChan();
+    virtual void diffLightObj(u32);
+    virtual s32 countDLSize();
     virtual u32 getType() = 0;
-    /* 80317448 */ virtual void setMatColor(u32, J3DGXColor const*);
-    /* 8000E0DC */ virtual void setMatColor(u32, J3DGXColor);
-    /* 8000E000 */ virtual _GXColor* getMatColor(u32);
-    /* 801A4C0C */ virtual void setAmbColor(u32, J3DGXColor const*);
-    /* 8000E0D4 */ virtual void setAmbColor(u32, J3DGXColor);
-    /* 8000DFF0 */ virtual bool getAmbColor(u32);
-    /* 8000E0E0 */ virtual void setColorChanNum(u8);
-    /* 8031744C */ virtual void setColorChanNum(u8 const*);
-    /* 8000E008 */ virtual u8 getColorChanNum() const;
-    /* 8000E0D8 */ virtual void setColorChan(u32, J3DColorChan const&);
-    /* 80317450 */ virtual void setColorChan(u32, J3DColorChan const*);
-    /* 8000DFF8 */ virtual J3DColorChan* getColorChan(u32);
-    /* 801A4C08 */ virtual void setLight(u32, J3DLightObj*);
-    /* 80317454 */ virtual bool getLight(u32);
-    /* 80317460 */ virtual void setCullMode(u8 const*);
-    /* 8031745C */ virtual void setCullMode(u8);
-    /* 80317328 */ virtual s32 getCullMode() const;
-    /* 80317464 */ virtual bool getMatColorOffset() const;
-    /* 8031746C */ virtual bool getColorChanOffset() const;
-    /* 80317474 */ virtual void setMatColorOffset(u32);
-    /* 80317478 */ virtual void setColorChanOffset(u32);
-    /* 80317138 */ virtual ~J3DColorBlock();
+    virtual void setMatColor(u32, J3DGXColor const*);
+    virtual void setMatColor(u32, J3DGXColor);
+    virtual _GXColor* getMatColor(u32);
+    virtual void setAmbColor(u32, J3DGXColor const*);
+    virtual void setAmbColor(u32, J3DGXColor);
+    virtual bool getAmbColor(u32);
+    virtual void setColorChanNum(u8);
+    virtual void setColorChanNum(u8 const*);
+    virtual u8 getColorChanNum() const;
+    virtual void setColorChan(u32, J3DColorChan const&);
+    virtual void setColorChan(u32, J3DColorChan const*);
+    virtual J3DColorChan* getColorChan(u32);
+    virtual void setLight(u32, J3DLightObj*);
+    virtual bool getLight(u32);
+    virtual void setCullMode(u8 const*);
+    virtual void setCullMode(u8);
+    virtual s32 getCullMode() const;
+    virtual bool getMatColorOffset() const;
+    virtual bool getColorChanOffset() const;
+    virtual void setMatColorOffset(u32);
+    virtual void setColorChanOffset(u32);
+    virtual ~J3DColorBlock();
 };
 
 class J3DColorBlockLightOn : public J3DColorBlock {
@@ -913,42 +910,42 @@ public:
     J3DColorBlockLightOn() {
         initialize();
     }
-    /* 80317580 */ void initialize();
+    void initialize();
 
-    /* 803187F4 */ virtual void load();
-    /* 8031FF34 */ virtual void reset(J3DColorBlock*);
-    /* 803194E8 */ virtual void patch();
-    /* 80319534 */ virtual void patchMatColor();
-    /* 803196E0 */ virtual void patchLight();
-    /* 8031A13C */ virtual void diff(u32);
-    /* 8031A1DC */ virtual void diffAmbColor();
-    /* 8031A358 */ virtual void diffMatColor();
-    /* 8031A4D4 */ virtual void diffColorChan();
-    /* 8031A8E0 */ virtual void diffLightObj(u32);
-    /* 80317B94 */ virtual s32 countDLSize();
-    /* 80322E80 */ virtual u32 getType();
-    /* 80322EB8 */ virtual void setMatColor(u32, J3DGXColor const*);
-    /* 80322E8C */ virtual void setMatColor(u32, J3DGXColor);
-    /* 80322EE4 */ virtual GXColor* getMatColor(u32);
-    /* 80322F24 */ virtual void setAmbColor(u32, J3DGXColor const*);
-    /* 80322EF8 */ virtual void setAmbColor(u32, J3DGXColor);
-    /* 80322F50 */ virtual bool getAmbColor(u32);
-    /* 80322F70 */ virtual void setColorChanNum(u8);
-    /* 80322F64 */ virtual void setColorChanNum(u8 const*);
-    /* 80322F78 */ virtual u8 getColorChanNum() const;
-    /* 80322F94 */ virtual void setColorChan(u32, J3DColorChan const&);
-    /* 80322F80 */ virtual void setColorChan(u32, J3DColorChan const*);
-    /* 80322FA8 */ virtual J3DColorChan* getColorChan(u32);
-    /* 80322FBC */ virtual void setLight(u32, J3DLightObj*);
-    /* 80322FCC */ virtual bool getLight(u32);
-    /* 80322FE4 */ virtual void setCullMode(u8 const*);
-    /* 80322FDC */ virtual void setCullMode(u8);
-    /* 80322FF0 */ virtual s32 getCullMode() const;
-    /* 80322FF8 */ virtual bool getMatColorOffset() const;
-    /* 80323000 */ virtual bool getColorChanOffset() const;
-    /* 80323008 */ virtual void setMatColorOffset(u32);
-    /* 80323010 */ virtual void setColorChanOffset(u32);
-    /* 80323018 */ virtual ~J3DColorBlockLightOn();
+    virtual void load();
+    virtual void reset(J3DColorBlock*);
+    virtual void patch();
+    virtual void patchMatColor();
+    virtual void patchLight();
+    virtual void diff(u32);
+    virtual void diffAmbColor();
+    virtual void diffMatColor();
+    virtual void diffColorChan();
+    virtual void diffLightObj(u32);
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setMatColor(u32, J3DGXColor const*);
+    virtual void setMatColor(u32, J3DGXColor);
+    virtual GXColor* getMatColor(u32);
+    virtual void setAmbColor(u32, J3DGXColor const*);
+    virtual void setAmbColor(u32, J3DGXColor);
+    virtual bool getAmbColor(u32);
+    virtual void setColorChanNum(u8);
+    virtual void setColorChanNum(u8 const*);
+    virtual u8 getColorChanNum() const;
+    virtual void setColorChan(u32, J3DColorChan const&);
+    virtual void setColorChan(u32, J3DColorChan const*);
+    virtual J3DColorChan* getColorChan(u32);
+    virtual void setLight(u32, J3DLightObj*);
+    virtual bool getLight(u32);
+    virtual void setCullMode(u8 const*);
+    virtual void setCullMode(u8);
+    virtual s32 getCullMode() const;
+    virtual bool getMatColorOffset() const;
+    virtual bool getColorChanOffset() const;
+    virtual void setMatColorOffset(u32);
+    virtual void setColorChanOffset(u32);
+    virtual ~J3DColorBlockLightOn();
 
 private:
     /* 0x04 */ J3DGXColor mMatColor[2];
@@ -966,35 +963,35 @@ public:
     J3DColorBlockLightOff() {
         initialize();
     }
-    /* 8031747C */ void initialize();
+    void initialize();
 
-    /* 80317C0C */ virtual void load();
-    /* 8031FD08 */ virtual void reset(J3DColorBlock*);
-    /* 80318EB4 */ virtual void patch();
-    /* 80318F00 */ virtual void patchMatColor();
-    /* 803190AC */ virtual void patchLight();
-    /* 80319B4C */ virtual void diff(u32);
-    /* 80319BB4 */ virtual void diffMatColor();
-    /* 80319D30 */ virtual void diffColorChan();
-    /* 80317B84 */ virtual s32 countDLSize();
-    /* 80323560 */ virtual u32 getType();
-    /* 80323184 */ virtual void setMatColor(u32, J3DGXColor const*);
-    /* 80323158 */ virtual void setMatColor(u32, J3DGXColor);
-    /* 803231B0 */ virtual GXColor* getMatColor(u32);
-    /* 803231D0 */ virtual void setColorChanNum(u8);
-    /* 803231C4 */ virtual void setColorChanNum(u8 const*);
-    /* 803231D8 */ virtual u8 getColorChanNum() const;
-    /* 803231F4 */ virtual void setColorChan(u32, J3DColorChan const&);
-    /* 803231E0 */ virtual void setColorChan(u32, J3DColorChan const*);
-    /* 80323208 */ virtual J3DColorChan* getColorChan(u32);
-    /* 80323224 */ virtual void setCullMode(u8 const*);
-    /* 8032321C */ virtual void setCullMode(u8);
-    /* 80323230 */ virtual s32 getCullMode() const;
-    /* 80323238 */ virtual bool getMatColorOffset() const;
-    /* 80323240 */ virtual bool getColorChanOffset() const;
-    /* 80323248 */ virtual void setMatColorOffset(u32);
-    /* 80323250 */ virtual void setColorChanOffset(u32);
-    /* 803170DC */ virtual ~J3DColorBlockLightOff();
+    virtual void load();
+    virtual void reset(J3DColorBlock*);
+    virtual void patch();
+    virtual void patchMatColor();
+    virtual void patchLight();
+    virtual void diff(u32);
+    virtual void diffMatColor();
+    virtual void diffColorChan();
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setMatColor(u32, J3DGXColor const*);
+    virtual void setMatColor(u32, J3DGXColor);
+    virtual GXColor* getMatColor(u32);
+    virtual void setColorChanNum(u8);
+    virtual void setColorChanNum(u8 const*);
+    virtual u8 getColorChanNum() const;
+    virtual void setColorChan(u32, J3DColorChan const&);
+    virtual void setColorChan(u32, J3DColorChan const*);
+    virtual J3DColorChan* getColorChan(u32);
+    virtual void setCullMode(u8 const*);
+    virtual void setCullMode(u8);
+    virtual s32 getCullMode() const;
+    virtual bool getMatColorOffset() const;
+    virtual bool getColorChanOffset() const;
+    virtual void setMatColorOffset(u32);
+    virtual void setColorChanOffset(u32);
+    virtual ~J3DColorBlockLightOff();
 
 private:
     /* 0x04 */ J3DGXColor mMatColor[2];
@@ -1010,16 +1007,16 @@ public:
     J3DColorBlockAmbientOn() {
         initialize();
     }
-    /* 803174DC */ void initialize();
+    void initialize();
 
-    /* 8031816C */ virtual void load();
-    /* 8031FDE4 */ virtual void reset(J3DColorBlock*);
-    /* 80317B8C */ virtual s32 countDLSize();
-    /* 80323074 */ virtual u32 getType();
-    /* 803230AC */ virtual void setAmbColor(u32, J3DGXColor const*);
-    /* 80323080 */ virtual void setAmbColor(u32, J3DGXColor);
-    /* 803230D8 */ virtual bool getAmbColor(u32);
-    /* 803230EC */ virtual ~J3DColorBlockAmbientOn();
+    virtual void load();
+    virtual void reset(J3DColorBlock*);
+    virtual s32 countDLSize();
+    virtual u32 getType();
+    virtual void setAmbColor(u32, J3DGXColor const*);
+    virtual void setAmbColor(u32, J3DGXColor);
+    virtual bool getAmbColor(u32);
+    virtual ~J3DColorBlockAmbientOn();
 
 private:
     /* 0x20 */ J3DGXColor mAmbColor[2];
diff --git a/include/JSystem/J3DGraphBase/J3DMaterial.h b/include/JSystem/J3DGraphBase/J3DMaterial.h
index 1c5853f76..6f6ed6721 100644
--- a/include/JSystem/J3DGraphBase/J3DMaterial.h
+++ b/include/JSystem/J3DGraphBase/J3DMaterial.h
@@ -12,35 +12,34 @@ class J3DMaterialAnm;
 
 class J3DMaterial {
 public:
-    /* 803157A0 */ static J3DColorBlock* createColorBlock(u32);
-    /* 803159A0 */ static J3DTexGenBlock* createTexGenBlock(u32);
-    /* 80315B04 */ static J3DTevBlock* createTevBlock(int);
-    /* 80315E78 */ static J3DIndBlock* createIndBlock(int);
-    /* 80315F60 */ static J3DPEBlock* createPEBlock(u32, u32);
-    /* 80316100 */ static u32 calcSizeColorBlock(u32);
-    /* 80316150 */ static u32 calcSizeTexGenBlock(u32);
-    /* 8031617C */ static u32 calcSizeTevBlock(int);
-    /* 803161C4 */ static u32 calcSizeIndBlock(int);
-    /* 803161D8 */ static u32 calcSizePEBlock(u32, u32);
-    /* 80316240 */ void initialize();
-    /* 80316290 */ u32 countDLSize();
-    /* 80316344 */ void makeDisplayList_private(J3DDisplayListObj*);
-    /* 80316AB0 */ void setCurrentMtx();
-    /* 80316AC8 */ void calcCurrentMtx();
-    /* 80316D68 */ void copy(J3DMaterial*);
-    /* 80316E90 */ s32 newSharedDisplayList(u32);
-    /* 80316F24 */ s32 newSingleSharedDisplayList(u32);
+    static J3DColorBlock* createColorBlock(u32);
+    static J3DTexGenBlock* createTexGenBlock(u32);
+    static J3DTevBlock* createTevBlock(int);
+    static J3DIndBlock* createIndBlock(int);
+    static J3DPEBlock* createPEBlock(u32, u32);
+    static u32 calcSizeColorBlock(u32);
+    static u32 calcSizeTexGenBlock(u32);
+    static u32 calcSizeTevBlock(int);
+    static u32 calcSizeIndBlock(int);
+    static u32 calcSizePEBlock(u32, u32);
+    void initialize();
+    u32 countDLSize();
+    void makeDisplayList_private(J3DDisplayListObj*);
+    void setCurrentMtx();
+    void calcCurrentMtx();
+    void copy(J3DMaterial*);
+    s32 newSharedDisplayList(u32);
+    s32 newSingleSharedDisplayList(u32);
 
-    /* 803169DC */ virtual void calc(f32 const (*)[4]);
-    /* 80316A54 */ virtual void calcDiffTexMtx(f32 const (*)[4]);
-    /* 80316620 */ virtual void makeDisplayList();
-    /* 80316668 */ virtual void makeSharedDisplayList();
-    /* 8031668C */ virtual void load();
-    /* 803166DC */ virtual void loadSharedDL();
-    /* 80316740 */ virtual void patch();
-    /* 803167D8 */ virtual void diff(u32);
-    /* 80316E14 */ virtual void reset();
-    /* 80316E70 */ virtual void change();
+    virtual void calc(f32 const (*)[4]);
+    virtual void makeDisplayList();
+    virtual void makeSharedDisplayList();
+    virtual void load();
+    virtual void loadSharedDL();
+    virtual void patch();
+    virtual void diff(u32);
+    virtual void reset();
+    virtual void change();
 
     J3DMaterial* getNext() const { return mNext; }
     J3DShape* getShape() const { return mShape; }
diff --git a/include/JSystem/J3DGraphBase/J3DPacket.h b/include/JSystem/J3DGraphBase/J3DPacket.h
index 07b970329..143065ab0 100644
--- a/include/JSystem/J3DGraphBase/J3DPacket.h
+++ b/include/JSystem/J3DGraphBase/J3DPacket.h
@@ -30,7 +30,7 @@ inline int calcDifferedBufferSize_TexMtxSize(int param_1) {
 }
 
 inline int calcDifferedBufferSize_TexGenSize(int param_1) {
-    return param_1 * 0x3d + 10;
+    return param_1 * 0x39 + 5;
 }
 
 inline u32 getDiffFlag_TexNoNum(u32 param_1) {
@@ -146,16 +146,24 @@ public:
     void offFlag(u32 flag) { mFlags &= ~flag; }
     void lock() { onFlag(LOCKED); }
     void unlock() { offFlag(LOCKED); }
-    J3DTexMtxObj* getTexMtxObj() const { return mpTexMtxObj; }
     bool isLocked() const { return checkFlag(1); }
 
 public:
     /* 0x10 */ u32 mFlags;
     /* 0x14 */ char mPad0[0x0C];  // unk
     /* 0x20 */ J3DDisplayListObj* mpDisplayListObj;
-    /* 0x24 */ J3DTexMtxObj* mpTexMtxObj;
 };  // Size: 0x28
 
+class J3DCallBackPacket : public J3DPacket {
+public:
+    ~J3DCallBackPacket();
+    virtual void draw();
+
+public:
+    typedef void (*CallBack)(J3DCallBackPacket * pPacket, u32 timing);
+    CallBack mpCallBack;
+};
+
 class J3DShapePacket : public J3DDrawPacket {
 public:
     J3DShapePacket();
@@ -169,7 +177,8 @@ public:
 
     void setShape(J3DShape* pShape) { mpShape = pShape; }
     void setModel(J3DModel* pModel) { mpModel = pModel; }
-    void setMtxBuffer(J3DMtxBuffer* pMtxBuffer) { mpMtxBuffer = pMtxBuffer; }
+    void setDrawMtx(Mtx** pDrawMtx) { mpDrawMtx = pDrawMtx; }
+    void setNrmMtx(Mtx33** pNrmMtx) { mpNrmMtx = pNrmMtx; }
     void setBaseMtxPtr(Mtx* pMtx) { mpBaseMtxPtr = pMtx; }
 
     J3DShape* getShape() const { return mpShape; }
@@ -177,12 +186,15 @@ public:
     Mtx* getBaseMtxPtr() const { return mpBaseMtxPtr; }
 
 public:
-    /* 0x28 */ J3DShape* mpShape;
-    /* 0x2C */ J3DMtxBuffer* mpMtxBuffer;
+    /* 0x24 */ J3DShape* mpShape;
+    /* 0x28 */ Mtx** mpDrawMtx;
+    /* 0x2C */ Mtx33** mpNrmMtx;
     /* 0x30 */ Mtx* mpBaseMtxPtr;
-    /* 0x34 */ u32 mDiffFlag;
-    /* 0x38 */ J3DModel* mpModel;
-};  // Size: 0x3C
+    /* 0x34 */ u32* mpCurrentViewNo;
+    /* 0x38 */ u32 mDiffFlag;
+    /* 0x3C */ u8* mpScaleFlagArray;
+    /* 0x40 */ J3DModel* mpModel;
+};  // Size: 0x44
 
 class J3DMatPacket : public J3DDrawPacket {
 public:
diff --git a/include/JSystem/J3DGraphBase/J3DShape.h b/include/JSystem/J3DGraphBase/J3DShape.h
index 457724a86..a1fdf2479 100644
--- a/include/JSystem/J3DGraphBase/J3DShape.h
+++ b/include/JSystem/J3DGraphBase/J3DShape.h
@@ -121,6 +121,7 @@ public:
     static void resetVcdVatCache() { sOldVcdVatCmd = NULL; }
 
     static void* sOldVcdVatCmd;
+    static u8 sEnvelopeFlag;
 
 private:
     friend struct J3DShapeFactory;
diff --git a/include/JSystem/J3DGraphBase/J3DShapeMtx.h b/include/JSystem/J3DGraphBase/J3DShapeMtx.h
index 029e73ece..8c2a29f8a 100644
--- a/include/JSystem/J3DGraphBase/J3DShapeMtx.h
+++ b/include/JSystem/J3DGraphBase/J3DShapeMtx.h
@@ -54,6 +54,7 @@ public:
     static u32 sCurrentPipeline;
     // static J3DScaleFlag sCurrentScaleFlag;
     static u8* sCurrentScaleFlag;
+    static u8 sNBTFlag;
     static u32 sTexMtxLoadType;
 
     static void setCurrentPipeline(u32 pipeline) { sCurrentPipeline = pipeline; }
diff --git a/include/JSystem/J3DGraphBase/J3DSys.h b/include/JSystem/J3DGraphBase/J3DSys.h
index 3bcf84f71..35fc1ca7c 100644
--- a/include/JSystem/J3DGraphBase/J3DSys.h
+++ b/include/JSystem/J3DGraphBase/J3DSys.h
@@ -44,27 +44,27 @@ struct J3DSys {
     /* 0x05C */ u8 field_0x5c[0x04];
     /* 0x060 */ u32 mTexCacheRegionNum;
     /* 0x064 */ GXTexRegion mTexCacheRegion[8];
-    /* 0x0E4 */ u8 field_0xe4[0x20];
-    /* 0x104 */ Mtx* mModelDrawMtx;
-    /* 0x108 */ Mtx33* mModelNrmMtx;
-    /* 0x10C */ void* mVtxPos;
-    /* 0x110 */ void* mVtxNrm;
-    /* 0x114 */ _GXColor* mVtxCol;
-    /* 0x118 */ Vec* mNBTScale;
+    /* 0x0E4 */ u8 field_0xe4[0x24];
+    /* 0x108 */ Mtx* mModelDrawMtx;
+    /* 0x10C */ Mtx33* mModelNrmMtx;
+    /* 0x110 */ void* mVtxPos;
+    /* 0x114 */ void* mVtxNrm;
+    /* 0x118 */ _GXColor* mVtxCol;
+    /* 0x11C */ Vec* mNBTScale;
 
-    /* 8030FDE8 */ J3DSys();
-    /* 8030FEC0 */ void loadPosMtxIndx(int, u16) const;
-    /* 8030FEE4 */ void loadNrmMtxIndx(int, u16) const;
-    /* 8030FF0C */ void setTexCacheRegion(_GXTexCacheSize);
-    /* 803100BC */ void drawInit();
-    /* 8031073C */ void reinitGX();
-    /* 8031079C */ void reinitGenMode();
-    /* 803107E8 */ void reinitLighting();
-    /* 80310894 */ void reinitTransform();
-    /* 80310998 */ void reinitTexture();
-    /* 80310A3C */ void reinitTevStages();
-    /* 80310D44 */ void reinitIndStages();
-    /* 80310E3C */ void reinitPixelProc();
+    J3DSys();
+    void loadPosMtxIndx(int, u16) const;
+    void loadNrmMtxIndx(int, u16) const;
+    void setTexCacheRegion(_GXTexCacheSize);
+    void drawInit();
+    void reinitGX();
+    void reinitGenMode();
+    void reinitLighting();
+    void reinitTransform();
+    void reinitTexture();
+    void reinitTevStages();
+    void reinitIndStages();
+    void reinitPixelProc();
 
     enum DrawMode {
         /* 0x3 */ OPA_TEX_EDGE = 3,
diff --git a/include/JSystem/J3DGraphBase/J3DTransform.h b/include/JSystem/J3DGraphBase/J3DTransform.h
index 327774c75..2cc2cc506 100644
--- a/include/JSystem/J3DGraphBase/J3DTransform.h
+++ b/include/JSystem/J3DGraphBase/J3DTransform.h
@@ -210,4 +210,6 @@ inline void J3DPSMulMtxVec(register Mtx3P mtx, register SVec* vec, register SVec
     }
 }
 
+f32 J3DCalcZValue(register MtxP m, register Vec v);
+
 #endif /* J3DTRANSFORM_H */
diff --git a/include/JSystem/J3DGraphBase/J3DVertex.h b/include/JSystem/J3DGraphBase/J3DVertex.h
index 0b184b0f0..5598f4914 100644
--- a/include/JSystem/J3DGraphBase/J3DVertex.h
+++ b/include/JSystem/J3DGraphBase/J3DVertex.h
@@ -22,6 +22,7 @@ struct J3DVtxColorCalc {
 class J3DVertexData {
 public:
     J3DVertexData();
+    ~J3DVertexData();
 
     void* getVtxPosArray() const { return mVtxPosArray; }
     void* getVtxNrmArray() const { return mVtxNrmArray; }
@@ -46,32 +47,32 @@ private:
     /* 0x04 */ u32 mNrmNum;
     /* 0x08 */ u32 mColNum;
     /* 0x0C */ u32 mTexCoordNum;
-    /* 0x10 */ u32 mPacketNum;
-    /* 0x14 */ GXVtxAttrFmtList* mVtxAttrFmtList;
-    /* 0x18 */ void* mVtxPosArray;
-    /* 0x1C */ void* mVtxNrmArray;
-    /* 0x20 */ void* mVtxNBTArray;
-    /* 0x24 */ GXColor* mVtxColorArray[2];
-    /* 0x2C */ void* mVtxTexCoordArray[8];
-    /* 0x4C */ u8 mVtxPosFrac;
-    /* 0x50 */ GXCompType mVtxPosType;
-    /* 0x54 */ u8 mVtxNrmFrac;
-    /* 0x58 */ GXCompType mVtxNrmType;
+    /* 0x10 */ GXVtxAttrFmtList* mVtxAttrFmtList;
+    /* 0x14 */ void* mVtxPosArray;
+    /* 0x18 */ void* mVtxNrmArray;
+    /* 0x1C */ void* mVtxNBTArray;
+    /* 0x20 */ GXColor* mVtxColorArray[2];
+    /* 0x28 */ void* mVtxTexCoordArray[8];
+    /* 0x48 */ u8 mVtxPosFrac;
+    /* 0x4C */ GXCompType mVtxPosType;
+    /* 0x50 */ u8 mVtxNrmFrac;
+    /* 0x54 */ GXCompType mVtxNrmType;
+    /* 0x58 */ u32 mPacketNum;
 };
 
 class J3DVertexBuffer {
 public:
     J3DVertexBuffer() { init(); }
 
-    /* 80310F78 */ void setVertexData(J3DVertexData*);
-    /* 80310FD8 */ void init();
-    /* 80311030 */ ~J3DVertexBuffer();
-    /* 8031106C */ void setArray() const;
-    /* 80311090 */ s32 copyLocalVtxPosArray(u32);
-    /* 803111B0 */ s32 copyLocalVtxNrmArray(u32);
-    /* 803112D0 */ s32 copyLocalVtxArray(u32);
-    /* 80311478 */ s32 allocTransformedVtxPosArray();
-    /* 8031152C */ s32 allocTransformedVtxNrmArray();
+    void setVertexData(J3DVertexData*);
+    void init();
+    ~J3DVertexBuffer();
+    void setArray() const;
+    s32 copyLocalVtxPosArray(u32);
+    s32 copyLocalVtxNrmArray(u32);
+    s32 copyLocalVtxArray(u32);
+    s32 allocTransformedVtxPosArray();
+    s32 allocTransformedVtxNrmArray();
 
     void setCurrentVtxPos(void* pVtxPos) { mCurrentVtxPos = pVtxPos; }
     void* getCurrentVtxPos() { return mCurrentVtxPos; }
diff --git a/include/SSystem/SComponent/c_bg_s_poly_info.h b/include/SSystem/SComponent/c_bg_s_poly_info.h
index 55c265b49..6844dcd70 100644
--- a/include/SSystem/SComponent/c_bg_s_poly_info.h
+++ b/include/SSystem/SComponent/c_bg_s_poly_info.h
@@ -2,17 +2,24 @@
 #define C_BG_S_POLY_INFO_H
 
 #include "dolphin/types.h"
+#include "global.h"
 
+class cBgW;
 class cBgS_PolyInfo {
 private:
     /* 0x00 */ u16 mPolyIndex;
     /* 0x02 */ u16 mBgIndex;
-    /* 0x04 */ void* unk_0x04;
+    /* 0x04 */ cBgW* mpBgW;
     /* 0x08 */ unsigned int mActorId;
 
 public:
     cBgS_PolyInfo();
-    void ClearPi();
+    void ClearPi() {
+        mPolyIndex = -1;
+        mBgIndex = 0x100;
+        mpBgW = NULL;
+        mActorId = -1;
+    }
     void SetPolyInfo(const cBgS_PolyInfo&);
     void SetActorInfo(int, void*, unsigned int);
     bool ChkSafe(const void*, unsigned int) const;
diff --git a/include/SSystem/SComponent/c_bg_w.h b/include/SSystem/SComponent/c_bg_w.h
index 44a271052..9bd6781ea 100644
--- a/include/SSystem/SComponent/c_bg_w.h
+++ b/include/SSystem/SComponent/c_bg_w.h
@@ -1,16 +1,16 @@
 #ifndef C_BG_W_H
 #define C_BG_W_H
 
-#include "dolphin/types.h"
+#include "SSystem/SComponent/c_xyz.h"
+#include "dolphin/mtx/mtx.h"
 
 class cBgW_BgId {
 private:
-    /* 0x0 */ u16 m_id;
+    /* 0x0 */ int m_id;
     /* 0x4 vtable */
 
 public:
     void Release();
-    bool ChkUsed() const;
     void Regist(int);
 
     virtual ~cBgW_BgId() {}
@@ -19,10 +19,99 @@ public:
     void Ct() { m_id = 0x100; }
 
     u16 GetId() const { return m_id; }
+    bool ChkUsed() const {
+        if (m_id >= 0 && m_id < 0x100) {
+            return true;
+        }
+        return false;
+    }
 };
 
-bool cBgW_CheckBGround(float a1);
-bool cBgW_CheckBRoof(float a1);
-bool cBgW_CheckBWall(float a1);
+class cBgW_TriElm;
+class cBgW_RwgElm;
+class cBgW_BlkElm;
+class cBgW_GrpElm;
+class cBgW_NodeTree;
+class cBgD_t;
+class cBgS_LinChk;
+class cBgS_GndChk;
+class cBgS_ShdwDraw;
+class cBgS_PolyPassChk;
+class cBgS_GrpPassChk;
+
+class cBgW : public cBgW_BgId {
+public:
+    enum Flags_e {
+        MOVE_BG_e = 0x1,
+        NO_VTX_TBL_e = 0x10,
+        GLOBAL_e = 0x20,
+        LOCK_e = 0x80,
+    };
+
+    cBgW();
+
+    void FreeArea();
+    void GlobalVtx();
+    void SetVtx();
+    
+    void SetTri();
+    void BlckConnect(u16*, int*, int);
+    void MakeBlckTransMinMax(cXyz*, cXyz*);
+    void MakeBlckMinMax(int, cXyz*, cXyz*);
+    void MakeBlckBnd(int, cXyz*, cXyz*);
+    void MakeNodeTreeRp(int);
+    void MakeNodeTreeGrpRp(int);
+    void MakeNodeTree();
+    void ChkMemoryError();
+    bool Set(cBgD_t*, u32, f32(*)[3][4]);
+    void RwgLineCheck(u16, cBgS_LinChk*);
+    void LineCheckRp(cBgS_LinChk*, int);
+    void LineCheckGrpRp(cBgS_LinChk*, int, int);
+    void RwgGroundCheckCommon(f32, u16, cBgS_GndChk*);
+    void RwgGroundCheckGnd(u16, cBgS_GndChk*);
+    void RwgGroundCheckWall(u16, cBgS_GndChk*);
+    void GroundCrossRp(cBgS_GndChk*, int);
+    void GroundCrossGrpRp(cBgS_GndChk*, int, int);
+    void CopyOldMtx();
+    void Move();
+    void RwgShdwDraw(int, cBgS_ShdwDraw*);
+    void ShdwDrawRp(cBgS_ShdwDraw*, int);
+    void ShdwDrawGrpRp(cBgS_ShdwDraw*, int);
+    void GetTrans(cXyz*) const;
+    void GetTriPnt(int, cXyz*, cXyz*, cXyz*) const;
+    void GetTopUnder(f32*, f32*) const;
+
+    virtual ~cBgW();
+    virtual void GetGrpToRoomIndex(int) const;
+    virtual void CalcPlane();
+    virtual void ClassifyPlane();
+    virtual void ChkPolyThrough(int, cBgS_PolyPassChk*);
+    virtual void ChkShdwDrawThrough(int, cBgS_PolyPassChk*);
+    virtual void ChkGrpThrough(int, cBgS_GrpPassChk*, int);
+
+    /* 0x08 */ Mtx* mpModelMtx;
+    /* 0x0C */ Mtx mOldMtx;
+    /* 0x3C */ Mtx mCurMtx;
+    /* 0x6C */ u8 mFlags;
+    /* 0x6D */ u8 mbNeedsFullTransform;
+    /* 0x6E */ u8 field_0x6E[0x74 - 0x6E];
+    /* 0x74 */ u8 mMoveCounter;
+    /* 0x75 */ u8 mWallCorrectPriority;
+    /* 0x76 */ u8 field_0x76[0x78 - 0x76];
+    /* 0x78 */ int mIgnorePlaneType;
+    /* 0x7C */ cXyz mTransVel;
+    /* 0x88 */ cBgW_TriElm* mpTriElm;
+    /* 0x8C */ cBgW_RwgElm* mpRwg;
+    /* 0x90 */ cXyz* mpVtxTbl;
+    /* 0x94 */ cBgD_t* mpBgDt;
+    /* 0x98 */ cBgW_BlkElm* mpBlk;
+    /* 0x9C */ cBgW_GrpElm* mpGrp;
+    /* 0xA0 */ cBgW_NodeTree* mpNodeTree;
+    /* 0xA4 */ int mRootGrpIdx;
+};
+
+bool cBgW_CheckBGround(f32 a1);
+bool cBgW_CheckBRoof(f32 a1);
+bool cBgW_CheckBWall(f32 a1);
 
 #endif /* C_BG_W_H */
diff --git a/include/SSystem/SComponent/c_cc_d.h b/include/SSystem/SComponent/c_cc_d.h
index e2fd2f853..926469245 100644
--- a/include/SSystem/SComponent/c_cc_d.h
+++ b/include/SSystem/SComponent/c_cc_d.h
@@ -22,7 +22,15 @@ class cCcD_AabAttr;
 class cCcD_CylAttr;
 class cCcD_SphAttr;
 
-enum cCcD_ObjAtType {};
+enum cCcD_ObjAtType {
+    /* 0x00000002 */ AT_TYPE_SWORD = (1 << 1),
+    /* 0x00000020 */ AT_TYPE_BOMB = (1 << 5),
+    /* 0x00000040 */ AT_TYPE_BOOMERANG = (1 << 6),
+    /* 0x00004000 */ AT_TYPE_NORMAL_ARROW = (1 << 14),
+    /* 0x00040000 */ AT_TYPE_FIRE_ARROW = (1 << 18),
+    /* 0x00080000 */ AT_TYPE_ICE_ARROW = (1 << 19),
+    /* 0x00100000 */ AT_TYPE_LIGHT_ARROW = (1 << 20),
+};
 
 class cCcD_ShapeAttr {
 public:
diff --git a/include/SSystem/SComponent/c_data_tbl.h b/include/SSystem/SComponent/c_data_tbl.h
index f231db125..386e189dc 100644
--- a/include/SSystem/SComponent/c_data_tbl.h
+++ b/include/SSystem/SComponent/c_data_tbl.h
@@ -4,13 +4,13 @@
 #include "dolphin/types.h"
 
 struct cDT_NamePTbl {
+    u32 mCount;
+    char ** mpNames;
+    
     cDT_NamePTbl();
     virtual ~cDT_NamePTbl();
     int GetIndex(const char *pName, int start) const;
     void Set(u32 count, char** pNames);
-
-    u32 mCount;
-    char ** mpNames;
 };
 
 struct cDT_DataSrc {
diff --git a/include/d/actor/d_a_item.h b/include/d/actor/d_a_item.h
index 589e11240..6e1293951 100644
--- a/include/d/actor/d_a_item.h
+++ b/include/d/actor/d_a_item.h
@@ -2,6 +2,7 @@
 #define D_A_ITEM_H
 
 #include "d/actor/d_a_itembase.h"
+#include "d/d_particle.h"
 
 class daItem_c : public daItemBase_c {
 public:
@@ -28,7 +29,7 @@ public:
     void itemDefaultRotateY();
     bool checkItemDisappear();
     void setItemTimer(int);
-    bool checkPlayerGet();
+    BOOL checkPlayerGet();
     void itemActionForRupee();
     void itemActionForHeart();
     void itemActionForKey();
@@ -45,14 +46,36 @@ public:
     void mode_water();
     void initAction();
     s32 _daItem_isdelete();
+    
+    s32 checkControl();
+    s32 startControl();
+    s32 endControl();
+    s32 checkLock();
+    s32 setLock();
+    s32 releaseLock();
+    s32 checkActionNow();
 
 public:
-    u8 temp1[0x20];
+    /* 0x648 */ s32 mSwitchId;
+    /* 0x64C */ s32 mActivationSwitch;
+    /* 0x650 */ f32 field3_0x650;
+    /* 0x654 */ u8 field4_0x654[0x658 - 0x654];
+    /* 0x658 */ s16 mItemTimer;
+    /* 0x65A */ s16 field7_0x65a;
+    /* 0x65C */ s16 field8_0x65c;
+    /* 0x65E */ u8 field10_0x65e[0x667 - 0x65E];
+    /* 0x667 */ u8 mUnknownParam;
     /* 0x668 */ u8 mItemAction;
     /* 0x669 */ u8 mStatusFlags;
     /* 0x66A */ u8 mMode;
-    /* 0x66B */ u8 mCurAction;
-    u8 temp2[0x54];
+    /* 0x66B */ u8 mCurState;
+    /* 0x66C */ u8 field23_0x66c[0x6BC - 0x66C];
+    // /* 0x674 */ dPa_rippleEcallBack mPtclRippleCb;
+    // /* 0x688 */ dPa_followEcallBack mPtclFollowCb;
+    // /* 0x69C */ dPa_smokeEcallBack mPtclSmokeCb;
+    /* 0x6BC */ JPABaseEmitter* mpParticleEmitter;
 };
 
+STATIC_ASSERT(sizeof(daItem_c) == 0x6C0);
+
 #endif /* D_A_ITEM_H */
\ No newline at end of file
diff --git a/include/d/actor/d_a_itembase.h b/include/d/actor/d_a_itembase.h
index f9584cdbb..adba40c4a 100644
--- a/include/d/actor/d_a_itembase.h
+++ b/include/d/actor/d_a_itembase.h
@@ -3,6 +3,9 @@
 
 #include "f_op/f_op_actor.h"
 #include "SSystem/SComponent/c_phase.h"
+#include "d/d_bg_s.h"
+#include "d/d_bg_s_acch.h"
+#include "d/d_cc_d.h"
 
 class mDoExt_btkAnm;
 class mDoExt_brkAnm;
@@ -15,17 +18,22 @@ struct daItemBase_c_m_data {
     /* 0x0C */ float mScaleAnimSpeed;
     /* 0x10 */ float field4_0x10;
     /* 0x14 */ short field5_0x14;
-    /* 0x16 */ short field6_0x16;
+    /* 0x16 */ short mDuration;
     /* 0x18 */ short field7_0x18;
     /* 0x1A */ u8 field8_0x1a;
     /* 0x1B */ u8 field9_0x1b;
     /* 0x1C */ short mNumFramesPerFullSpin;
-    u8 temp1[0x26];
+    u8 temp1[0x1A];
+    /* 0x38 */ f32 mPickedUpInitialSpeedY;
+    /* 0x3C */ f32 mPickedUpGravity;
+    /* 0x40 */ short field45_0x40;
     /* 0x42 */ short field47_0x42;
     u8 temp2[0x4];
     /* 0x48 */ float mVelocityScale;
 };
 
+STATIC_ASSERT(sizeof(daItemBase_c_m_data) == 0x4C);
+
 struct daItemBase_c : public fopAc_ac_c {
 public:
     s32 DeleteBase(const char*);
@@ -46,12 +54,10 @@ public:
     void hide();
     void show();
     void changeDraw();
-    void chkDraw();
+    bool chkDraw();
     void dead();
     void chkDead();
     void setLoadError();
-    void CheckItemCreateHeap(fopAc_ac_c*);
-    void CheckFieldItemCreateHeap(fopAc_ac_c*);
 
     daItemBase_c_m_data* getData();
 
@@ -66,15 +72,11 @@ public:
     /* 0x2B0 */ mDoExt_brkAnm* mBrkAnm1;
     /* 0x2B4 */ mDoExt_brkAnm* mBrkAnm2;
     /* 0x2B8 */ mDoExt_bckAnm* mBckAnm;
-    // /* 0x2BC */ dBgS_Acch mAcch;
-    // /* 0x480 */ dBgS_AcchCir mAcchCir;
-    // /* 0x4C0 */ dCcD_Stts mStts;
-    // /* 0x4FC */ dCcD_Cyl mCyl;
-    // /* 0x62C */ undefined field14_0x62c;
-    // /* 0x62D */ undefined field15_0x62d;
-    // /* 0x62E */ undefined field16_0x62e;
-    // /* 0x62F */ undefined field17_0x62f;
-    u8 temp[0x374];
+    /* 0x2BC */ dBgS_Acch mAcch;
+    /* 0x480 */ dBgS_AcchCir mAcchCir;
+    /* 0x4C0 */ dCcD_Stts mStts;
+    /* 0x4FC */ dCcD_Cyl mCyl;
+    /* 0x62C */ u8 field14_0x62c[0x630 - 0x62C];
     /* 0x630 */ int mPickupFlag;
     /* 0x634 */ int field19_0x634;
     /* 0x638 */ short field20_0x638;
diff --git a/include/d/actor/d_a_itembase_static.h b/include/d/actor/d_a_itembase_static.h
index a24ceccb8..b6405befc 100644
--- a/include/d/actor/d_a_itembase_static.h
+++ b/include/d/actor/d_a_itembase_static.h
@@ -14,6 +14,6 @@ void dead();
 void chkDead();
 void setLoadError();
 void CheckItemCreateHeap(fopAc_ac_c*);
-void CheckFieldItemCreateHeap(fopAc_ac_c*);
+s32 CheckFieldItemCreateHeap(fopAc_ac_c*);
 
 #endif /* D_A_ITEMBASE_STATIC_H */
\ No newline at end of file
diff --git a/include/d/actor/d_a_player.h b/include/d/actor/d_a_player.h
index 35da93620..118af2b85 100644
--- a/include/d/actor/d_a_player.h
+++ b/include/d/actor/d_a_player.h
@@ -2,9 +2,9 @@
 #define D_A_PLAYER
 
 #include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
-#include "d/d_cc_d.h"
-#include "d/d_com_inf_game.h"
 #include "f_op/f_op_actor_mng.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_cc_d.h"
 
 class daPy_matAnm_c : public J3DMaterialAnm {
 public:
@@ -138,4 +138,4 @@ public:
     void getRopePos() const;
 };
 
-#endif /* D_A_PLAYER */
\ No newline at end of file
+#endif /* D_A_PLAYER */
diff --git a/include/d/actor/d_a_player_link.h b/include/d/actor/d_a_player_link.h
index b966606af..31e586652 100644
--- a/include/d/actor/d_a_player_link.h
+++ b/include/d/actor/d_a_player_link.h
@@ -2,11 +2,12 @@
 #define D_A_PLAYER_LINK
 
 #include "JAZelAudio/JAIZelBasic.h"
+#include "m_Do/m_Do_ext.h"
 #include "d/d_attention.h"
 #include "d/d_bg_s_acch.h"
 #include "d/d_bg_s_lin_chk.h"
 #include "d/d_drawlist.h"
-#include "m_Do/m_Do_ext.h"
+#include "d/d_bg_w.h"
 #include "d/actor/d_a_player.h"
 
 class mDoExt_MtxCalcOldFrame;
@@ -177,11 +178,6 @@ struct MagicArmorAuraEntry {
 
 class daPy_anmIndex_c;
 
-class dBgW {
-public:
-    enum PushPullLabel {};
-};
-
 class daPy_lk_c : public daPy_py_c {
 public:
     enum daPy_HEAP_TYPE {};
diff --git a/include/d/d_bg_s.h b/include/d/d_bg_s.h
index d18675807..e98560b18 100644
--- a/include/d/d_bg_s.h
+++ b/include/d/d_bg_s.h
@@ -1,9 +1,10 @@
 #ifndef D_BG_D_BG_S_H
 #define D_BG_D_BG_S_H
 
-#include "global.h"
 #include "SSystem/SComponent/c_sxyz.h"
 #include "SSystem/SComponent/c_xyz.h"
+#include "d/d_bg_w.h"
+#include "global.h"
 
 class cBgS_LinChk;
 class cBgS_GndChk;
@@ -12,7 +13,6 @@ class cM3dGPla;
 class cBgS_ShdwDraw;
 class dBgW;
 class fopAc_ac_c;
-class dBgW_Base;
 class dBgS_Acch;
 class dBgS_RoofChk;
 class dBgS_SplGrpChk;
@@ -20,19 +20,19 @@ class dBgS_SphChk;
 
 class cBgS_ChkElm {
 public:
-    /* 0x00 */ dBgW_Base* m_bgw_base_ptr;
+    /* 0x00 */ cBgW* m_bgw_base_ptr;
     /* 0x04 */ bool m_used;
     /* 0x08 */ u32 m_actor_id;
     /* 0x0C */ fopAc_ac_c* m_actor_ptr;
     /* 0x10 vtable */
 
 public:
-    cBgS_ChkElm() { this->Init(); }
+    cBgS_ChkElm() { Init(); }
     void Init();
     void Release();
 
     virtual ~cBgS_ChkElm() {}
-    virtual void Regist2(dBgW_Base*, unsigned int, void*);
+    virtual void Regist2(cBgW*, u32, void*);
 
     bool ChkUsed() const { return m_used; }
 };  // Size: 0x14
@@ -55,7 +55,7 @@ public:
     f32 GroundCross(cBgS_GndChk*);
     static void* ConvDzb(void*);
     fopAc_ac_c* GetActorPointer(int) const;
-    dBgW_Base* GetBgWPointer(cBgS_PolyInfo&) const;
+    cBgW* GetBgWPointer(cBgS_PolyInfo&) const;
     bool ChkPolySafe(cBgS_PolyInfo&);
     void GetTriGrp(int, int) const;
     void GetGrpToRoomId(int, int) const;
@@ -76,43 +76,47 @@ class dBgS : public cBgS {
 public:
     dBgS() {}
     ~dBgS() {}
+
     void Ct();
     void Dt();
     void ClrMoveFlag();
     void Move();
-    bool Regist(dBgW_Base*, fopAc_ac_c*);
-    bool ChkMoveBG(cBgS_PolyInfo const&);
-    bool ChkMoveBG_NoDABg(cBgS_PolyInfo const&);
-    s32 GetExitId(cBgS_PolyInfo const&);
-    s32 GetPolyColor(cBgS_PolyInfo const&);
-    BOOL GetHorseNoEntry(cBgS_PolyInfo const&);
-    int GetSpecialCode(cBgS_PolyInfo const&);
-    int GetMagnetCode(cBgS_PolyInfo const&);
-    int GetMonkeyBarsCode(cBgS_PolyInfo const&);
-    u32 GetUnderwaterRoofCode(cBgS_PolyInfo const&);
-    s32 GetWallCode(cBgS_PolyInfo const&);
-    int GetPolyAtt0(cBgS_PolyInfo const&);
-    int GetPolyAtt1(cBgS_PolyInfo const&);
-    int GetGroundCode(cBgS_PolyInfo const&);
-    s32 GetCamMoveBG(cBgS_PolyInfo const&);
-    s32 GetRoomCamId(cBgS_PolyInfo const&);
-    s32 GetRoomPathId(cBgS_PolyInfo const&);
-    s32 GetRoomPathPntNo(cBgS_PolyInfo const&);
-    u8 GetGrpSoundId(cBgS_PolyInfo const&);
-    u32 ChkGrpInf(cBgS_PolyInfo const&, u32);
-    s32 GetRoomId(cBgS_PolyInfo const&);
-    bool GetPolyAttackThrough(cBgS_PolyInfo const&);
-    u32 ChkPolyHSStick(cBgS_PolyInfo const&);
+    bool Regist(cBgW*, fopAc_ac_c*);
+    bool ChkMoveBG(cBgS_PolyInfo&);
+    bool ChkMoveBG_NoDABg(cBgS_PolyInfo&);
+    int GetPolyId0(int, int, int, u32, u32);
+    int GetPolyCamId(int, int);
+    int GetMtrlSndId(cBgS_PolyInfo&);
+    int GetExitId(cBgS_PolyInfo&);
+    int GetPolyColor(cBgS_PolyInfo&);
+    int GetGrpRoomInfId(cBgS_PolyInfo&);
+    u8 GetGrpSoundId(cBgS_PolyInfo&);
+    u32 ChkGrpInf(cBgS_PolyInfo&, u32);
+    int GetPolyId1(int, int, int, u32, u32);
+    void GetLinkNo(cBgS_PolyInfo&);
+    int GetWallCode(cBgS_PolyInfo&);
+    int GetSpecialCode(cBgS_PolyInfo&);
+    void GetAttributeCodeDirect(cBgS_PolyInfo&);
+    void GetAttributeCode(cBgS_PolyInfo&);
+    void GetGroundCode(cBgS_PolyInfo&);
+    void GetPolyId2(int, int, int, u32, u32);
+    int GetCamMoveBG(cBgS_PolyInfo&);
+    int GetRoomCamId(cBgS_PolyInfo&);
+    int GetRoomPathId(cBgS_PolyInfo&);
+    int GetRoomPathPntNo(cBgS_PolyInfo&);
+    int GetRoomId(cBgS_PolyInfo&);
+    u32 ChkPolyHSStick(cBgS_PolyInfo&);
+    void LineCrossNonMoveBG(cBgS_LinChk*);
     void WallCorrect(dBgS_Acch*);
-    void WallCorrectSort(dBgS_Acch*);
     f32 RoofChk(dBgS_RoofChk*);
     bool SplGrpChk(dBgS_SplGrpChk*);
     bool SphChk(dBgS_SphChk*, void*);
-    void MoveBgCrrPos(cBgS_PolyInfo const&, bool, cXyz*, csXyz*, csXyz*, bool, bool);
-    void MoveBgTransPos(cBgS_PolyInfo const&, bool, cXyz*, csXyz*, csXyz*);
-    void MoveBgMatrixCrrPos(cBgS_PolyInfo const&, bool, cXyz*, csXyz*, csXyz*);
-    void RideCallBack(cBgS_PolyInfo const&, fopAc_ac_c*);
-    void ArrowStickCallBack(cBgS_PolyInfo const&, fopAc_ac_c*, cXyz&);
+    void WallCrrPos(dBgS_CrrPos*);
+    void MoveBgCrrPos(cBgS_PolyInfo&, bool, cXyz*, csXyz*, csXyz*);
+    void MoveBgTransPos(cBgS_PolyInfo&, bool, cXyz*, csXyz*, csXyz*);
+    void MoveBgMatrixCrrPos(cBgS_PolyInfo&, bool, cXyz*, csXyz*, csXyz*);
+    void RideCallBack(cBgS_PolyInfo&, fopAc_ac_c*);
+    void PushPullCallBack(cBgS_PolyInfo&, fopAc_ac_c*, short, dBgW::PushPullLabel);
 
     bool WaterChk(dBgS_SplGrpChk* chk) { return SplGrpChk(chk); }
 };  // Size: 0x1404
diff --git a/include/d/d_bg_s_movebg_actor.h b/include/d/d_bg_s_movebg_actor.h
new file mode 100644
index 000000000..2451c2dc2
--- /dev/null
+++ b/include/d/d_bg_s_movebg_actor.h
@@ -0,0 +1,38 @@
+#ifndef D_BG_S_MOVEBG_ACTOR_H
+#define D_BG_S_MOVEBG_ACTOR_H
+
+#include "SSystem/SComponent/c_bg_s_poly_info.h"
+#include "f_op/f_op_actor_mng.h"
+
+class dBgW;
+typedef void (*MoveBGActor_SetFunc)(dBgW*, void*, cBgS_PolyInfo&, bool, cXyz*, csXyz*,
+                                    csXyz*);
+
+class dBgS_MoveBgActor : public fopAc_ac_c {
+public:
+    /* 0x290 */ dBgW* mpBgW;
+    /* 0x294 */ Mtx mBgMtx;
+
+    dBgS_MoveBgActor();
+    int MoveBGCreateHeap();
+    int MoveBGCreate(char const*, int, MoveBGActor_SetFunc, u32);
+    int MoveBGDelete();
+    int MoveBGExecute();
+
+    int MoveBGDraw() { return Draw(); }
+
+    virtual int CreateHeap() { return 1; }
+    virtual int Create() { return 1; }
+    virtual int Execute(Mtx**) { return 1; }
+    virtual int Draw() { return 1; }
+    virtual int Delete() { return 1; }
+    virtual int IsDelete() { return 1; }
+    virtual int ToFore() { return 1; }
+    virtual int ToBack() { return 1; }
+
+    static const char* m_name;
+    static int m_dzb_id;
+    static MoveBGActor_SetFunc m_set_func;
+};
+
+#endif /* D_BG_S_MOVEBG_ACTOR_H */
\ No newline at end of file
diff --git a/include/d/d_bg_w.h b/include/d/d_bg_w.h
new file mode 100644
index 000000000..79df61fed
--- /dev/null
+++ b/include/d/d_bg_w.h
@@ -0,0 +1,65 @@
+#ifndef D_BG_W_H
+#define D_BG_W_H
+
+#include "SSystem/SComponent/c_bg_w.h"
+
+class dBgS_Acch;
+class cM3dGPla;
+class dBgS_RoofChk;
+class dBgS_SplGrpChk;
+class dBgS_SphChk;
+class cM3dGTri;
+class dBgS_CrrPos;
+class cBgS_PolyInfo;
+
+class dBgW;
+typedef void (*dBgW_CrrFunc)(dBgW*, void*, cBgS_PolyInfo&, bool, cXyz*, csXyz*, csXyz*);
+
+class dBgW : public cBgW {
+public:
+    enum PushPullLabel {};
+
+    dBgW();
+
+    void Move();
+    void positionWallCorrect(dBgS_Acch*, f32, cM3dGPla&, cXyz*, f32);
+    void RwgWallCorrect(dBgS_Acch*, u16);
+    void WallCorrectRp(dBgS_Acch*, int);
+    void WallCorrectGrpRp(dBgS_Acch*, int, int);
+    void RwgRoofChk(u16, dBgS_RoofChk*);
+    void RoofChkRp(dBgS_RoofChk*, int);
+    void RoofChkGrpRp(dBgS_RoofChk*, int, int);
+    void RwgSplGrpChk(u16, dBgS_SplGrpChk*);
+    void SplGrpChkRp(dBgS_SplGrpChk*, int);
+    void SplGrpChkGrpRp(dBgS_SplGrpChk*, int, int);
+    void RwgSphChk(u16, dBgS_SphChk*, void*);
+    void SphChkRp(dBgS_SphChk*, void*, int);
+    void SphChkGrpRp(dBgS_SphChk*, void*, int, int);
+    void positionWallCrrPos(cM3dGTri&, dBgS_CrrPos*, cXyz*, f32, f32);
+    void RwgWallCrrPos(u16, dBgS_CrrPos*);
+    void WallCrrPosRp(dBgS_CrrPos*, int);
+    void WallCrrPosGrpRp(dBgS_CrrPos*, int, int);
+    void WallCrrPos(dBgS_CrrPos*);
+    void ChangeAttributeCodeByPathPntNo(int, u32);
+
+    virtual ~dBgW() {}
+    virtual void ChkPolyThrough(int, cBgS_PolyPassChk*);
+    virtual void ChkShdwDrawThrough(int, cBgS_PolyPassChk*);
+    virtual void ChkGrpThrough(int, cBgS_GrpPassChk*, int);
+    virtual void CrrPos(cBgS_PolyInfo&, void*, bool, cXyz*, csXyz*, csXyz*);
+    virtual void TransPos(cBgS_PolyInfo&, void*, bool, cXyz*, csXyz*, csXyz*);
+    virtual void MatrixCrrPos(cBgS_PolyInfo&, void*, bool, cXyz*, csXyz*, csXyz*);
+
+    void SetCrrFunc(dBgW_CrrFunc func) { m_crr_func = func; }
+
+    /* 0xA8 */ dBgW_CrrFunc m_crr_func;
+    /* 0xAC */ s16 mOldRotY;
+    /* 0xAE */ s16 mRotYDelta;
+    /* 0xB0 */ void* mpRideCb;
+    /* 0xB4 */ void* mpPushPullCb;
+    /* 0xB8 */ s16 mRoomNo;
+    /* 0xBA */ u8 mFlag;
+    /* 0xBB */ u8 mRoomNo2;
+};
+
+#endif /* D_BG_W_H */
\ No newline at end of file
diff --git a/include/d/d_com_inf_game.h b/include/d/d_com_inf_game.h
index 022c4f011..ebeae303a 100644
--- a/include/d/d_com_inf_game.h
+++ b/include/d/d_com_inf_game.h
@@ -180,9 +180,11 @@ public:
     /* 0x47EC */ JKRArchive* mpCamResArchive;
     /* 0x47F0 */ JKRArchive* mpSwimResArchive;
     /* 0x47F4 */ JKRArchive* mpWindResArchive;
+#if VERSION != VERSION_JP
     /* 0x47F8 */ JKRArchive* mpEnglishTextArchive;
     /* 0x47FC */ JKRArchive* mpHyruleTextArchive;
-    /* 0x4800 */ u8 field_0x4800[0x4824 - 0x4800];
+#endif
+    /* 0x4800 */ u8 mpCARDHeap[0x24];
     /* 0x4824 */ dPa_control_c* mParticle;
     /* 0x4828 */ dDemo_manager_c* mDemo;
     /* 0x482C */ dMagma_packet_c* mpMagmaPacket;
@@ -428,6 +430,14 @@ inline BOOL dComIfGs_isSwitch(s32 i_no, s32 i_roomNo) {
     return g_dComIfG_gameInfo.save.isSwitch(i_no, i_roomNo);
 }
 
+inline void dComIfGs_onItem(int bitNo, int roomNo) {
+    g_dComIfG_gameInfo.save.onItem(bitNo, roomNo);
+}
+
+inline bool dComIfGs_isItem(int bitNo, int roomNo) {
+    return g_dComIfG_gameInfo.save.isItem(bitNo, roomNo);
+}
+
 /**
  * === PLAY ===
  */
@@ -507,6 +517,10 @@ inline dBgS* dComIfG_Bgsp() {
     return &g_dComIfG_gameInfo.play.mBgS;
 }
 
+inline dCcS* dComIfG_Ccsp() {
+    return &g_dComIfG_gameInfo.play.mCcS;
+}
+
 inline daShip_c* dComIfGp_getShipActor() {
     return (daShip_c*)g_dComIfG_gameInfo.play.getPlayerPtr(2);
 }
@@ -519,6 +533,10 @@ inline dStage_stageDt_c& dComIfGp_getStage() {
     return g_dComIfG_gameInfo.play.getStage();
 }
 
+inline daPy_py_c* daPy_getPlayerActorClass() {
+    return (daPy_py_c*)dComIfGp_getPlayer(0);
+}
+
 inline daPy_lk_c* daPy_getPlayerLinkActorClass() {
     return (daPy_lk_c*)g_dComIfG_gameInfo.play.getPlayerPtr(0);
 }
diff --git a/include/d/d_item.h b/include/d/d_item.h
index b902b82da..c68847686 100644
--- a/include/d/d_item.h
+++ b/include/d/d_item.h
@@ -1,6 +1,8 @@
 #ifndef D_ITEM_H
 #define D_ITEM_H
 
+#include "dolphin/types.h"
+
 void execItemGet(u8 itemNo);
 BOOL checkItemGet(u8 itemNo, BOOL defaultVal);
 void item_func_heart();
diff --git a/include/d/d_item_data.h b/include/d/d_item_data.h
index 077af275f..bcbac46ca 100644
--- a/include/d/d_item_data.h
+++ b/include/d/d_item_data.h
@@ -282,6 +282,29 @@ struct dItem_data_item_resource {
 
 STATIC_ASSERT(sizeof(dItem_data_item_resource) == 0x24);
 
+struct dItem_data_field_item_res {
+    /* 0x00 */ char * mModelArcName;
+    /* 0x04 */ short mModelFileId;
+    /* 0x06 */ short mBtkAnmResIdx1;
+    /* 0x08 */ short mBtkAnmResIdx2;
+    /* 0x0A */ short mBrkAnmResIdx1;
+    /* 0x0C */ short mBrkAnmResIdx2;
+    /* 0x0E */ short mBckAnmResIdx;
+    /* 0x10 */ u8 mTevRegAnimFrameIndex;
+    /* 0x11 */ u8 field8_0x11;
+    /* 0x12 */ u8 field9_0x12;
+    /* 0x13 */ u8 field10_0x13;
+    /* 0x14 */ u8 field11_0x14;
+    /* 0x15 */ u8 field12_0x15;
+    /* 0x16 */ u8 field13_0x16;
+    /* 0x17 */ u8 field14_0x17;
+    /* 0x18 */ u16 mHeapSize;
+    /* 0x1A */ u8 field16_0x1a;
+    /* 0x1B */ u8 field17_0x1b;
+};
+
+STATIC_ASSERT(sizeof(dItem_data_field_item_res) == 0x1C);
+
 struct dItem_data_item_info {
     /* 0x00 */ u8 mMaybeShadowRelated;
     /* 0x01 */ u8 mCollisionH; // Cylinder Height
@@ -293,8 +316,14 @@ STATIC_ASSERT(sizeof(dItem_data_item_info) == 0x4);
 
 class dItem_data {
 public:
-  static dItem_data_item_resource item_resource[0x100];
-  static dItem_data_item_info item_info[0x100];
+    static dItem_data_item_resource item_resource[0x100];
+    static dItem_data_field_item_res field_item_res[0x100];
+    static dItem_data_item_info item_info[0x100];
+    
+    static bool checkAppearEffect(u8 itemNo);
+    static s16 getAppearEffect(u8 itemNo);
+    static bool checkSpecialEffect(u8 itemNo);
+    static u16 getSpecialEffect(u8 itemNo);
 };
 
 #endif /* D_ITEM_DATA_H */
\ No newline at end of file
diff --git a/include/f_op/f_op_kankyo_mng.h b/include/f_op/f_op_kankyo_mng.h
index d875eb8e8..b9bdb8917 100644
--- a/include/f_op/f_op_kankyo_mng.h
+++ b/include/f_op/f_op_kankyo_mng.h
@@ -12,10 +12,8 @@ struct fopKyM_prm_class {
 
 typedef int (*fopKyM_CreateFunc)(void*);
 
-static fopKyM_prm_class* fopKyM_CreateAppend(void);
-static fopKyM_prm_class* createAppend(int param_1, cXyz* param_2, cXyz* param_3);
 void fopKyM_Delete(void* param_1);
-static int fopKyM_Create(s16 param_1, fopKyM_CreateFunc param_2, void* param_3);
+int fopKyM_Create(s16 param_1, fopKyM_CreateFunc param_2, void* param_3);
 base_process_class* fopKyM_fastCreate(s16 param_0, int param_1, cXyz* param_2, cXyz* param_3,
                                       fopKyM_CreateFunc);
 int fopKyM_createWpillar(cXyz const* i_pos, f32 scale, int i_param);
diff --git a/include/m_Do/m_Do_ext.h b/include/m_Do/m_Do_ext.h
index 1467a4406..747c1a007 100644
--- a/include/m_Do/m_Do_ext.h
+++ b/include/m_Do/m_Do_ext.h
@@ -246,6 +246,7 @@ public:
     void setFrame(f32 frame) { mFrameCtrl.setFrame(frame); }
     void updateDL();
     void play(Vec *, u32, u8);
+    void stopZelAnime();
 
     u32 pad[0x50]; // J3DMtxCalcMaya
     /* 0x50 */ J3DModel* mpModel;
diff --git a/src/JSystem/J3DGraphBase/J3DDrawBuffer.cpp b/src/JSystem/J3DGraphBase/J3DDrawBuffer.cpp
index 53d6c83bf..b136d2282 100644
--- a/src/JSystem/J3DGraphBase/J3DDrawBuffer.cpp
+++ b/src/JSystem/J3DGraphBase/J3DDrawBuffer.cpp
@@ -4,79 +4,252 @@
 //
 
 #include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
+#include "JSystem/J3DGraphBase/J3DPacket.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "JSystem/J3DGraphBase/J3DSys.h"
+#include "JSystem/J3DGraphBase/J3DTexture.h"
+#include "JSystem/J3DGraphBase/J3DTransform.h"
+#include "JSystem/JKernel/JKRHeap.h"
 #include "dolphin/types.h"
 
+void J3DDrawBuffer::calcZRatio() {
+    mZRatio = (mZFar - mZNear) / (f32)mBufSize;
+}
+
 /* 802EC74C-802EC7B4       .text initialize__13J3DDrawBufferFv */
 void J3DDrawBuffer::initialize() {
-    /* Nonmatching */
+    mDrawType = DRAW_HEAD;
+    mSortType = SORT_MAT;
+    mZNear = 1.0f;
+    mZFar = 10000.0f;
+    mpZMtx = NULL;
+    mpCallBackPacket = NULL;
+    mBufSize = 0x20;
+    calcZRatio();
 }
 
 /* 802EC7B4-802EC84C       .text allocBuffer__13J3DDrawBufferFUl */
-void J3DDrawBuffer::allocBuffer(unsigned long) {
-    /* Nonmatching */
+J3DError J3DDrawBuffer::allocBuffer(u32 bufSize) {
+    mpBuf = new (0x20) J3DPacket*[bufSize];
+    if (mpBuf == NULL)
+        return kJ3DError_Alloc;
+
+    mBufSize = bufSize;
+    frameInit();
+    calcZRatio();
+    return kJ3DError_Success;
 }
 
 /* 802EC84C-802EC8AC       .text __dt__13J3DDrawBufferFv */
 J3DDrawBuffer::~J3DDrawBuffer() {
-    /* Nonmatching */
+    frameInit();
+
+    delete[] mpBuf;
+    mpBuf = NULL;
 }
 
 /* 802EC8AC-802EC8E4       .text frameInit__13J3DDrawBufferFv */
 void J3DDrawBuffer::frameInit() {
-    /* Nonmatching */
+    for (u32 i = 0; i < mBufSize; i++)
+        mpBuf[i] = NULL;
+
+    mpCallBackPacket = NULL;
 }
 
 /* 802EC8E4-802ECA38       .text entryMatSort__13J3DDrawBufferFP12J3DMatPacket */
-void J3DDrawBuffer::entryMatSort(J3DMatPacket*) {
-    /* Nonmatching */
+int J3DDrawBuffer::entryMatSort(J3DMatPacket* pMatPacket) {
+    pMatPacket->drawClear();
+    pMatPacket->getShapePacket()->drawClear();
+
+    if (pMatPacket->isChanged()) {
+        pMatPacket->setNextPacket(mpBuf[0]);
+        mpBuf[0] = pMatPacket;
+        return 1;
+    }
+
+    J3DTexture* texture = j3dSys.getTexture();
+    u32 hash;
+    u16 texNo = pMatPacket->getMaterial()->getTexNo(0);
+    if (texNo == 0xFFFF) {
+        hash = 0;
+    } else {
+        hash = ((u32)texture->getResTIMG(texNo) + texture->getResTIMG(texNo)->imageOffset) >> 5;
+    }
+    u32 slot = hash & (mBufSize - 1);
+
+    if (mpBuf[slot] == NULL) {
+        mpBuf[slot] = pMatPacket;
+        return 1;
+    } else {
+        for (J3DMatPacket* pkt = (J3DMatPacket*)mpBuf[slot]; pkt != NULL; pkt = (J3DMatPacket*)pkt->getNextPacket()) {
+            if (pkt->isSame(pMatPacket)) {
+                pkt->addShapePacket(pMatPacket->getShapePacket());
+                return 0;
+            }
+        }
+
+        pMatPacket->setNextPacket(mpBuf[slot]);
+        mpBuf[slot] = pMatPacket;
+        return 1;
+    }
 }
 
 /* 802ECA38-802ECAF0       .text entryMatAnmSort__13J3DDrawBufferFP12J3DMatPacket */
-void J3DDrawBuffer::entryMatAnmSort(J3DMatPacket*) {
-    /* Nonmatching */
+int J3DDrawBuffer::entryMatAnmSort(J3DMatPacket* pMatPacket) {
+    J3DMaterialAnm* pMaterialAnm = pMatPacket->mpMaterialAnm;
+    u32 slot = (u32)pMaterialAnm & (mBufSize - 1);
+
+    if (pMaterialAnm == NULL) {
+        return entryMatSort(pMatPacket);
+    } else {
+        pMatPacket->drawClear();
+        pMatPacket->getShapePacket()->drawClear();
+        if (mpBuf[slot] == NULL) {
+            mpBuf[slot] = pMatPacket;
+            return 1;
+        } else {
+            for (J3DMatPacket* pkt = (J3DMatPacket*)mpBuf[slot]; pkt != NULL;
+                 pkt = (J3DMatPacket*)pkt->getNextPacket())
+            {
+                if (pkt->mpMaterialAnm == pMaterialAnm) {
+                    pkt->addShapePacket(pMatPacket->getShapePacket());
+                    return 0;
+                }
+            }
+
+            pMatPacket->setNextPacket(mpBuf[slot]);
+            mpBuf[slot] = pMatPacket;
+            return 1;
+        }
+    }
 }
 
 /* 802ECAF0-802ECBEC       .text entryZSort__13J3DDrawBufferFP12J3DMatPacket */
-void J3DDrawBuffer::entryZSort(J3DMatPacket*) {
-    /* Nonmatching */
+int J3DDrawBuffer::entryZSort(J3DMatPacket* i_packet) {
+    i_packet->drawClear();
+    i_packet->getShapePacket()->drawClear();
+
+    Vec tmp;
+    tmp.x = mpZMtx[0][3];
+    tmp.y = mpZMtx[1][3];
+    tmp.z = mpZMtx[2][3];
+
+    f32 value = -J3DCalcZValue(j3dSys.getViewMtx(), tmp);
+
+    u32 uvar4;
+    if (mZNear + mZRatio < value) {
+        if (mZFar - mZRatio > value) {
+            uvar4 = value / mZRatio;
+        } else {
+            uvar4 = mBufSize - 1;
+        }
+    } else {
+        uvar4 = 0;
+    }
+
+    u32 idx = (mBufSize - 1) - uvar4;
+    i_packet->setNextPacket(mpBuf[idx]);
+    mpBuf[idx] = i_packet;
+
+    return 1;
 }
 
 /* 802ECBEC-802ECC3C       .text entryModelSort__13J3DDrawBufferFP12J3DMatPacket */
-void J3DDrawBuffer::entryModelSort(J3DMatPacket*) {
-    /* Nonmatching */
+int J3DDrawBuffer::entryModelSort(J3DMatPacket* i_packet) {
+    i_packet->drawClear();
+    i_packet->getShapePacket()->drawClear();
+
+    if (mpCallBackPacket != NULL) {
+        mpCallBackPacket->addChildPacket(i_packet);
+        return 1;
+    }
+
+    return 0;
 }
 
 /* 802ECC3C-802ECC90       .text entryInvalidSort__13J3DDrawBufferFP12J3DMatPacket */
-void J3DDrawBuffer::entryInvalidSort(J3DMatPacket*) {
-    /* Nonmatching */
+int J3DDrawBuffer::entryInvalidSort(J3DMatPacket* i_packet) {
+    i_packet->drawClear();
+    i_packet->getShapePacket()->drawClear();
+
+    if (mpCallBackPacket != NULL) {
+        mpCallBackPacket->addChildPacket(i_packet->getShapePacket());
+        return 1;
+    }
+
+    return 0;
 }
 
 /* 802ECC90-802ECCC4       .text entryNonSort__13J3DDrawBufferFP12J3DMatPacket */
-void J3DDrawBuffer::entryNonSort(J3DMatPacket*) {
-    /* Nonmatching */
+int J3DDrawBuffer::entryNonSort(J3DMatPacket* i_packet) {
+    i_packet->drawClear();
+    i_packet->mpShapePacket->drawClear();
+
+    i_packet->setNextPacket(mpBuf[0]);
+    mpBuf[0] = i_packet;
+
+    return 1;
 }
 
 /* 802ECCC4-802ECCE4       .text entryImm__13J3DDrawBufferFP9J3DPacketUs */
-void J3DDrawBuffer::entryImm(J3DPacket*, unsigned short) {
-    /* Nonmatching */
+int J3DDrawBuffer::entryImm(J3DPacket* i_packet, u16 index) {
+    i_packet->setNextPacket(mpBuf[index]);
+    mpBuf[index] = i_packet;
+
+    return 1;
 }
 
+sortFunc J3DDrawBuffer::sortFuncTable[] = {
+    &J3DDrawBuffer::entryMatSort,
+    &J3DDrawBuffer::entryMatAnmSort,
+    &J3DDrawBuffer::entryZSort,
+    &J3DDrawBuffer::entryModelSort,
+    &J3DDrawBuffer::entryInvalidSort,
+    &J3DDrawBuffer::entryNonSort,
+};
+
+drawFunc J3DDrawBuffer::drawFuncTable[] = {
+    &J3DDrawBuffer::drawHead,
+    &J3DDrawBuffer::drawTail,
+};
+
 /* 802ECCE4-802ECD38       .text draw__13J3DDrawBufferCFv */
 void J3DDrawBuffer::draw() const {
-    /* Nonmatching */
+    drawFunc func = drawFuncTable[mDrawType];
+    (this->*func)();
 }
 
 /* 802ECD38-802ECDB0       .text drawHead__13J3DDrawBufferCFv */
 void J3DDrawBuffer::drawHead() const {
-    /* Nonmatching */
+    u32 size = mBufSize;
+    J3DPacket** buf = mpBuf;
+
+    for (u32 i = 0; i < size; i++) {
+        for (J3DPacket* packet = buf[i]; packet != NULL; packet = packet->getNextPacket()) {
+            packet->draw();
+        }
+    }
 }
 
 /* 802ECDB0-802ECE2C       .text drawTail__13J3DDrawBufferCFv */
 void J3DDrawBuffer::drawTail() const {
-    /* Nonmatching */
+    int num = mBufSize - 1;
+
+    for (int i = num; i >= 0; i--) {
+        for (J3DPacket* packet = mpBuf[i]; packet != NULL; packet = packet->getNextPacket()) {
+            packet->draw();
+        }
+    }
 }
 
 /* 802ECE2C-802ECE5C       .text setCallBackPacket__13J3DDrawBufferFP17J3DCallBackPacket */
-void J3DDrawBuffer::setCallBackPacket(J3DCallBackPacket*) {
-    /* Nonmatching */
+void J3DDrawBuffer::setCallBackPacket(J3DCallBackPacket* pPacket) {
+    mpCallBackPacket = pPacket;
+    if (pPacket != NULL) {
+        pPacket->drawClear();
+        pPacket->setNextPacket(mpBuf[0]);
+        mpBuf[0] = pPacket;
+    }
 }
+
+int J3DDrawBuffer::entryNum;
diff --git a/src/JSystem/J3DGraphBase/J3DPacket.cpp b/src/JSystem/J3DGraphBase/J3DPacket.cpp
index 5ba43ec21..ee5e48a5e 100644
--- a/src/JSystem/J3DGraphBase/J3DPacket.cpp
+++ b/src/JSystem/J3DGraphBase/J3DPacket.cpp
@@ -4,176 +4,402 @@
 //
 
 #include "JSystem/J3DGraphBase/J3DPacket.h"
-#include "dolphin/types.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "JSystem/J3DGraphBase/J3DSys.h"
+#include "JSystem/J3DGraphAnimator/J3DModel.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "MSL_C/string.h"
+#include "dolphin/gx/GX.h"
+#include "dolphin/os/OS.h"
 
 /* 802DAE1C-802DAE9C       .text newDisplayList__17J3DDisplayListObjFUl */
-void J3DDisplayListObj::newDisplayList(unsigned long) {
-    /* Nonmatching */
+J3DError J3DDisplayListObj::newDisplayList(u32 capacity) {
+    mCapacity = ALIGN_NEXT(capacity, 0x20);
+    mpData[0] = new (0x20) char[mCapacity];
+    mpData[1] = new (0x20) char[mCapacity];
+    mSize = 0;
+
+    if (mpData[0] == NULL || mpData[1] == NULL)
+        return kJ3DError_Alloc;
+
+    return kJ3DError_Success;
 }
 
 /* 802DAE9C-802DAF00       .text newSingleDisplayList__17J3DDisplayListObjFUl */
-void J3DDisplayListObj::newSingleDisplayList(unsigned long) {
-    /* Nonmatching */
+J3DError J3DDisplayListObj::newSingleDisplayList(u32 capacity) {
+    mCapacity = ALIGN_NEXT(capacity, 0x20);
+    mpData[0] = new (0x20) char[mCapacity];
+    mpData[1] = mpData[0];
+    mSize = 0;
+
+    if (mpData[0] == NULL)
+        return kJ3DError_Alloc;
+
+    return kJ3DError_Success;
 }
 
 /* 802DAF00-802DAF78       .text single_To_Double__17J3DDisplayListObjFv */
-void J3DDisplayListObj::single_To_Double() {
-    /* Nonmatching */
+J3DError J3DDisplayListObj::single_To_Double() {
+    if (mpData[0] == mpData[1]) {
+        mpData[1] = new (0x20) char[mCapacity];
+
+        if (mpData[1] == NULL)
+            return kJ3DError_Alloc;
+
+        memcpy(mpData[1], mpData[0], mCapacity);
+        DCStoreRange(mpData[1], mCapacity);
+    }
+
+    return kJ3DError_Success;
 }
 
 /* 802DAF78-802DAF98       .text setSingleDisplayList__17J3DDisplayListObjFPvUl */
-void J3DDisplayListObj::setSingleDisplayList(void*, unsigned long) {
-    /* Nonmatching */
+void J3DDisplayListObj::setSingleDisplayList(void* pDLData, u32 size) {
+    mCapacity = ALIGN_NEXT(size, 0x20);
+    mpData[0] = pDLData;
+    mpData[1] = mpData[0];
+    mSize = size;
 }
 
 /* 802DAF98-802DAFAC       .text swapBuffer__17J3DDisplayListObjFv */
 void J3DDisplayListObj::swapBuffer() {
-    /* Nonmatching */
+    void* pTmp = mpData[0];
+    mpData[0] = mpData[1];
+    mpData[1] = pTmp;
 }
 
 /* 802DAFAC-802DAFD8       .text callDL__17J3DDisplayListObjCFv */
 void J3DDisplayListObj::callDL() const {
-    /* Nonmatching */
+    GXCallDisplayList(mpData[0], mSize);
 }
 
+GDLObj J3DDisplayListObj::sGDLObj;
+s32 J3DDisplayListObj::sInterruptFlag;
+
 /* 802DAFD8-802DB02C       .text beginDL__17J3DDisplayListObjFv */
 void J3DDisplayListObj::beginDL() {
-    /* Nonmatching */
+    swapBuffer();
+    sInterruptFlag = OSDisableInterrupts();
+    GDInitGDLObj(&sGDLObj, (u8*)mpData[0], mCapacity);
+    GDSetCurrent(&sGDLObj);
 }
 
 /* 802DB02C-802DB088       .text endDL__17J3DDisplayListObjFv */
-void J3DDisplayListObj::endDL() {
-    /* Nonmatching */
+u32 J3DDisplayListObj::endDL() {
+    GDPadCurr32();
+    OSRestoreInterrupts(sInterruptFlag);
+    mSize = GDGetGDLObjOffset(&sGDLObj);
+    GDFlushCurrToMem();
+    GDSetCurrent(NULL);
+    return mSize;
 }
 
 /* 802DB088-802DB0A8       .text beginPatch__17J3DDisplayListObjFv */
 void J3DDisplayListObj::beginPatch() {
-    /* Nonmatching */
+    beginDL();
 }
 
 /* 802DB0A8-802DB0E4       .text endPatch__17J3DDisplayListObjFv */
-void J3DDisplayListObj::endPatch() {
-    /* Nonmatching */
+u32 J3DDisplayListObj::endPatch() {
+    OSRestoreInterrupts(sInterruptFlag);
+    GDSetCurrent(NULL);
+    return mSize;
 }
 
 /* 802DB0E4-802DB0EC       .text isSame__9J3DPacketCFP12J3DMatPacket */
-void J3DPacket::isSame(J3DMatPacket*) const {
-    /* Nonmatching */
+bool J3DPacket::isSame(J3DMatPacket*) const {
+    return false;
 }
 
 /* 802DB0EC-802DB0F4       .text entry__9J3DPacketFP13J3DDrawBuffer */
-void J3DPacket::entry(J3DDrawBuffer*) {
-    /* Nonmatching */
+int J3DPacket::entry(J3DDrawBuffer*) {
+    return 1;
 }
 
 /* 802DB0F4-802DB114       .text addChildPacket__9J3DPacketFP9J3DPacket */
-void J3DPacket::addChildPacket(J3DPacket*) {
-    /* Nonmatching */
+void J3DPacket::addChildPacket(J3DPacket* pPacket) {
+    if (mpFirstChild == NULL) {
+        mpFirstChild = pPacket;
+    } else {
+        pPacket->mpNextPacket = mpFirstChild;
+        mpFirstChild = pPacket;
+    }
 }
 
 /* 802DB114-802DB1A0       .text draw__17J3DCallBackPacketFv */
 void J3DCallBackPacket::draw() {
-    /* Nonmatching */
+    if (mpCallBack != NULL)
+        mpCallBack(this, 0);
+
+    for (J3DPacket * pPacket = mpFirstChild; pPacket != NULL; pPacket = pPacket->getNextPacket())
+        pPacket->draw();
+
+    if (mpCallBack != NULL)
+        mpCallBack(this, 1);
 }
 
 /* 802DB1A0-802DB1D4       .text __ct__13J3DDrawPacketFv */
 J3DDrawPacket::J3DDrawPacket() {
-    /* Nonmatching */
+    mFlags = 0;
+    mpDisplayListObj = NULL;
 }
 
 /* 802DB1D4-802DB230       .text __dt__13J3DDrawPacketFv */
 J3DDrawPacket::~J3DDrawPacket() {
-    /* Nonmatching */
 }
 
 /* 802DB230-802DB2BC       .text newDisplayList__13J3DDrawPacketFUl */
-void J3DDrawPacket::newDisplayList(unsigned long) {
-    /* Nonmatching */
+J3DError J3DDrawPacket::newDisplayList(u32 size) {
+    mpDisplayListObj = new J3DDisplayListObj();
+
+    if (mpDisplayListObj == NULL)
+        return kJ3DError_Alloc;
+
+    J3DError ret = mpDisplayListObj->newDisplayList(size);
+    if (ret != kJ3DError_Success)
+        return ret;
+
+    return kJ3DError_Success;
 }
 
 /* 802DB2BC-802DB348       .text newSingleDisplayList__13J3DDrawPacketFUl */
-void J3DDrawPacket::newSingleDisplayList(unsigned long) {
-    /* Nonmatching */
+J3DError J3DDrawPacket::newSingleDisplayList(u32 size) {
+    mpDisplayListObj = new J3DDisplayListObj();
+
+    if (mpDisplayListObj == NULL)
+        return kJ3DError_Alloc;
+
+    J3DError ret = mpDisplayListObj->newSingleDisplayList(size);
+    if (ret != kJ3DError_Success)
+        return ret;
+
+    return kJ3DError_Success;
 }
 
 /* 802DB348-802DB36C       .text draw__13J3DDrawPacketFv */
 void J3DDrawPacket::draw() {
-    /* Nonmatching */
+    mpDisplayListObj->callDL();
 }
 
 /* 802DB36C-802DB3C4       .text __ct__12J3DMatPacketFv */
 J3DMatPacket::J3DMatPacket() {
-    /* Nonmatching */
+    mpInitShapePacket = NULL;
+    mpMaterial = NULL;
+    mDiffFlag = -1;
+    mpTexture = NULL;
+    mpMaterialAnm = NULL;
 }
 
 /* 802DB3C4-802DB424       .text __dt__12J3DMatPacketFv */
 J3DMatPacket::~J3DMatPacket() {
-    /* Nonmatching */
 }
 
 /* 802DB424-802DB444       .text addShapePacket__12J3DMatPacketFP14J3DShapePacket */
-void J3DMatPacket::addShapePacket(J3DShapePacket*) {
-    /* Nonmatching */
+void J3DMatPacket::addShapePacket(J3DShapePacket* pShape) {
+    if (mpShapePacket == NULL) {
+        mpShapePacket = pShape;
+    } else {
+        pShape->mpNextPacket = mpShapePacket;
+        mpShapePacket = pShape;
+    }
 }
 
 /* 802DB444-802DB46C       .text beginDiff__12J3DMatPacketFv */
 void J3DMatPacket::beginDiff() {
-    /* Nonmatching */
+    mpInitShapePacket->mpDisplayListObj->beginDL();
 }
 
 /* 802DB46C-802DB494       .text endDiff__12J3DMatPacketFv */
 void J3DMatPacket::endDiff() {
-    /* Nonmatching */
+    mpInitShapePacket->mpDisplayListObj->endDL();
 }
 
 /* 802DB494-802DB524       .text draw__12J3DMatPacketFv */
 void J3DMatPacket::draw() {
-    /* Nonmatching */
+    j3dSys.setTexture(mpTexture);
+    j3dSys.setMatPacket(this);
+
+    mpMaterial->load();
+    J3DShapePacket* packet = getShapePacket();
+
+    J3DShape* shape = packet->getShape();
+    shape->loadPreDrawSetting();
+
+    while (packet != NULL) {
+        if (packet->getDisplayListObj() != NULL) {
+            packet->getDisplayListObj()->callDL();
+        }
+
+        packet->drawFast();
+        packet = (J3DShapePacket*)packet->getNextPacket();
+    }
+
+    shape->resetVcdVatCache();
 }
 
 /* 802DB524-802DB584       .text __ct__14J3DShapePacketFv */
 J3DShapePacket::J3DShapePacket() {
-    /* Nonmatching */
+    mpShape = NULL;
+    mpDrawMtx = NULL;
+    mpNrmMtx = NULL;
+    mpBaseMtxPtr = NULL;
+    mpCurrentViewNo = &j3dDefaultViewNo;
+    mpScaleFlagArray = NULL;
+    mpModel = NULL;
 }
 
 /* 802DB584-802DB5E4       .text __dt__14J3DShapePacketFv */
 J3DShapePacket::~J3DShapePacket() {
-    /* Nonmatching */
 }
 
+u32 sDifferedRegister[] = {
+    0x00000001, 0x00000002, 0x01000000, 0x10000000, 0x20000000, 0x02000000, 0x08000000,
+};
+
+s32 sSizeOfDiffered[] = {
+    13, 21, 120, 55, 15, 19, 45,
+};
+
 /* 802DB5E4-802DB7CC       .text calcDifferedBufferSize__14J3DShapePacketFUl */
-void J3DShapePacket::calcDifferedBufferSize(unsigned long) {
-    /* Nonmatching */
+u32 J3DShapePacket::calcDifferedBufferSize(u32 flag) {
+    int iVar5 = 0;
+    for (int i = 0; i < 7; i++) {
+        if ((flag & sDifferedRegister[i]) != 0) {
+            iVar5 += sSizeOfDiffered[i];
+        }
+    }
+
+    iVar5 += getDiffFlag_LightObjNum(flag) * 0x48;
+    u32 uVar2 = getDiffFlag_TexGenNum(flag);
+    if (uVar2 != 0) {
+        u32 local_4c = mpShape->getMaterial()->getTexGenNum();
+        if (uVar2 > local_4c) {
+            local_4c = uVar2;
+        }
+
+        if ((flag & 0x1000)) {
+            iVar5 += calcDifferedBufferSize_TexGenSize(local_4c);
+        } else {
+            iVar5 += calcDifferedBufferSize_TexMtxSize(local_4c);
+        }
+    }
+
+    uVar2 = getDiffFlag_TexNoNum(flag);
+    if (uVar2 != 0) {
+        u8 local_58;
+        if (mpShape->getMaterial()->getTevStageNum() > 8) {
+            local_58 = 8;
+        } else {
+            local_58 = mpShape->getMaterial()->getTevStageNum();
+        }
+        u32 local_50 = local_58;
+        local_50 = uVar2 > local_50 ? uVar2 : local_50;
+        if ((flag & 0x4000000)) {
+            iVar5 += calcDifferedBufferSize_TexNoAndTexCoordScaleSize(local_50);
+        } else {
+            iVar5 += calcDifferedBufferSize_TexNoSize(local_50);
+        }
+    }
+
+    uVar2 = getDiffFlag_TevStageNum(flag);
+    if (uVar2 != 0) {
+        u8 local_58;
+        if (mpShape->getMaterial()->getTevStageNum() > 8) {
+            local_58 = 8;
+        } else {
+            local_58 = mpShape->getMaterial()->getTevStageNum();
+        }
+        u32 local_50 = local_58;
+        local_50 = uVar2 > local_50 ? uVar2 : local_50;
+        iVar5 += calcDifferedBufferSize_TevStageSize(local_50);
+        if (flag & 0x8000000) {
+            iVar5 += calcDifferedBufferSize_TevStageDirectSize(local_50);
+        }
+    }
+
+    return ALIGN_NEXT(iVar5, 0x20);
 }
 
 /* 802DB7CC-802DB818       .text newDifferedDisplayList__14J3DShapePacketFUl */
-void J3DShapePacket::newDifferedDisplayList(unsigned long) {
-    /* Nonmatching */
+J3DError J3DShapePacket::newDifferedDisplayList(u32 flag) {
+    mDiffFlag = flag;
+    u32 bufSize = calcDifferedBufferSize(flag);
+    J3DError error = newDisplayList(bufSize);
+
+    if (error != kJ3DError_Success) {
+        return error;
+    }
+
+    setDisplayListObj(getDisplayListObj());
+    return kJ3DError_Success;
 }
 
 /* 802DB818-802DB890       .text prepareDraw__14J3DShapePacketCFv */
 void J3DShapePacket::prepareDraw() const {
-    /* Nonmatching */
+    mpModel->getVertexBuffer()->setArray();
+    j3dSys.setModel(mpModel);
+    j3dSys.setShapePacket((J3DShapePacket*)this);
+
+    mpShape->setScaleFlagArray(mpScaleFlagArray);
+    mpShape->setDrawMtx(mpDrawMtx);
+    mpShape->setNrmMtx(mpNrmMtx);
+    mpShape->setCurrentViewNoPtr(mpCurrentViewNo);
 }
 
 /* 802DB890-802DB8F8       .text draw__14J3DShapePacketFv */
 void J3DShapePacket::draw() {
-    /* Nonmatching */
+    if (!checkFlag(J3DShpFlag_Hidden) && mpShape != NULL) {
+        prepareDraw();
+
+#if 0
+        if (mpTexMtxObj != NULL) {
+            J3DMaterial* material = mpShape->getMaterial();
+            J3DDifferedTexMtx::sTexGenBlock = material->getTexGenBlock();
+            J3DDifferedTexMtx::sTexMtxObj = getTexMtxObj();
+        } else {
+            J3DDifferedTexMtx::sTexGenBlock = NULL;
+        }
+#endif
+
+        if (mpDisplayListObj != NULL) {
+            mpDisplayListObj->callDL();
+        }
+
+        mpShape->draw();
+    }
 }
 
 /* 802DB8F8-802DB950       .text drawFast__14J3DShapePacketFv */
 void J3DShapePacket::drawFast() {
-    /* Nonmatching */
+    if (!checkFlag(J3DShpFlag_Hidden) && mpShape != NULL) {
+        prepareDraw();
+
+#if 0
+        if (mpTexMtxObj != NULL) {
+            J3DMaterial* material = mpShape->getMaterial();
+            J3DDifferedTexMtx::sTexGenBlock = material->getTexGenBlock();
+            J3DDifferedTexMtx::sTexMtxObj = getTexMtxObj();
+        } else {
+            J3DDifferedTexMtx::sTexGenBlock = NULL;
+        }
+#endif
+
+        mpShape->drawFast();
+    }
 }
 
 /* 802DB950-802DB978       .text isSame__12J3DMatPacketCFP12J3DMatPacket */
-void J3DMatPacket::isSame(J3DMatPacket*) const {
-    /* Nonmatching */
+bool J3DMatPacket::isSame(J3DMatPacket* pOther) const {
+    bool isSame = false;
+
+    if (mDiffFlag == pOther->mDiffFlag && !(mDiffFlag >> 0x1F)) {
+        isSame = true;
+    }
+    return isSame;
 }
 
 /* 802DB978-802DB97C       .text draw__9J3DPacketFv */
 void J3DPacket::draw() {
-    /* Nonmatching */
 }
 
 /* 802DB97C-802DB9D8       .text __dt__17J3DCallBackPacketFv */
diff --git a/src/JSystem/J3DGraphBase/J3DShape.cpp b/src/JSystem/J3DGraphBase/J3DShape.cpp
index 666ff9e7a..1dcd464de 100644
--- a/src/JSystem/J3DGraphBase/J3DShape.cpp
+++ b/src/JSystem/J3DGraphBase/J3DShape.cpp
@@ -4,79 +4,264 @@
 //
 
 #include "JSystem/J3DGraphBase/J3DShape.h"
+#include "JSystem/J3DGraphBase/J3DPacket.h"
+#include "JSystem/J3DGraphBase/J3DSys.h"
+#include "JSystem/J3DGraphBase/J3DVertex.h"
+#include "dolphin/gd/GDBase.h"
+#include "dolphin/gd/GDGeometry.h"
+#include "dolphin/os/OS.h"
 #include "dolphin/types.h"
 
+extern void J3DGDSetVtxAttrFmtv(_GXVtxFmt, GXVtxAttrFmtList *, bool);
+extern void J3DFifoLoadPosMtxImm(Mtx, u32);
+extern void J3DFifoLoadNrmMtxImm(Mtx, u32);
+
 /* 802DD18C-802DD1FC       .text initialize__8J3DShapeFv */
+
 void J3DShape::initialize() {
-    /* Nonmatching */
+    mMaterial = NULL;
+    mIndex = -1;
+    mMtxGroupNum = 0;
+    mFlags = 0;
+    mRadius = 0.0f;
+    mMin.x = 0.0f;
+    mMin.y = 0.0f;
+    mMin.z = 0.0f;
+    mMax.x = 0.0f;
+    mMax.y = 0.0f;
+    mMax.z = 0.0f;
+    mVtxDesc = NULL;
+    mShapeMtx = NULL;
+    mShapeDraw = NULL;
+    mVertexData = NULL;
+    mDrawMtxData = NULL;
+    mScaleFlagArray = NULL;
+    mDrawMtx = NULL;
+    mNrmMtx = NULL;
+    mCurrentViewNo = &j3dDefaultViewNo;
+    mHasNBT = false;
+    mHasPNMTXIdx = false;
 }
 
 /* 802DD1FC-802DD27C       .text calcNBTScale__8J3DShapeFRC3VecPA3_A3_fPA3_A3_f */
-void J3DShape::calcNBTScale(const Vec&, float(*)[3][3], float(*)[3][3]) {
-    /* Nonmatching */
+void J3DShape::calcNBTScale(Vec const& param_0, Mtx33* param_1, Mtx33* param_2) {
+    for (u16 i = 0; i < getMtxGroupNum(); i++)
+        getShapeMtx(i)->calcNBTScale(param_0, param_1, param_2);
 }
 
 /* 802DD27C-802DD2F0       .text countBumpMtxNum__8J3DShapeCFv */
-void J3DShape::countBumpMtxNum() const {
-    /* Nonmatching */
+u32 J3DShape::countBumpMtxNum() const {
+    u32 num = 0;
+    for (u16 i = 0; i < getMtxGroupNum(); i++)
+        num += getShapeMtx(i)->getUseMtxNum();
+    return num;
 }
 
 /* 802DD2F0-802DD308       .text J3DLoadCPCmd__FUcUl */
-void J3DLoadCPCmd(unsigned char, unsigned long) {
-    /* Nonmatching */
+void J3DLoadCPCmd(u8 cmd, u32 param) {
+    GFX_FIFO(u8) = GX_CMD_LOAD_CP_REG;
+    GFX_FIFO(u8) = cmd;
+    GFX_FIFO(u32) = param;
 }
 
 /* 802DD308-802DD344       .text J3DLoadArrayBasePtr__F7_GXAttrPv */
-void J3DLoadArrayBasePtr(_GXAttr, void*) {
-    /* Nonmatching */
+static void J3DLoadArrayBasePtr(_GXAttr attr, void* data) {
+    u32 idx = (attr == GX_VA_NBT) ? 1 : (attr - GX_VA_POS);
+    J3DLoadCPCmd(0xA0 + idx, ((u32)data & 0x7FFFFFFF));
 }
 
 /* 802DD344-802DD3B4       .text loadVtxArray__8J3DShapeCFv */
 void J3DShape::loadVtxArray() const {
-    /* Nonmatching */
+    J3DLoadArrayBasePtr(GX_VA_POS, j3dSys.getVtxPos());
+    if (!mHasNBT) {
+        J3DLoadArrayBasePtr(GX_VA_NRM, j3dSys.getVtxNrm());
+    }
+    J3DLoadArrayBasePtr(GX_VA_CLR0, j3dSys.getVtxCol());
 }
 
 /* 802DD3B4-802DD3F0       .text isSameVcdVatCmd__8J3DShapeFP8J3DShape */
-void J3DShape::isSameVcdVatCmd(J3DShape*) {
-    /* Nonmatching */
+bool J3DShape::isSameVcdVatCmd(J3DShape* other) {
+    u8* a = other->mVcdVatCmd;
+    u8* b = mVcdVatCmd;
+    for (u32 i = 0; i < kVcdVatDLSize; i++)
+        if (a[i] != b[i])
+            return false;
+    return true;
 }
 
 /* 802DD3F0-802DD6B8       .text makeVtxArrayCmd__8J3DShapeFv */
 void J3DShape::makeVtxArrayCmd() {
-    /* Nonmatching */
+    GXVtxAttrFmtList* vtxAttr = mVertexData->getVtxAttrFmtList();
+
+    u8 stride[0x0C];
+    void* array[0x0C];
+    for (u32 i = 0; i < 0x0C; i++) {
+        stride[i] = 0;
+        array[i] = 0;
+    }
+
+    for (; vtxAttr->mAttrib != GX_VA_NULL; vtxAttr++) {
+        switch (vtxAttr->mAttrib) {
+        case GX_VA_POS: {
+            if (vtxAttr->mCompType == GX_F32)
+                stride[vtxAttr->mAttrib - GX_VA_POS] = 0x0C;
+            else
+                stride[vtxAttr->mAttrib - GX_VA_POS] = 0x06;
+            array[vtxAttr->mAttrib - GX_VA_POS] = mVertexData->getVtxPosArray();
+            mVertexData->setVtxPosFrac(vtxAttr->mCompShift);
+            mVertexData->setVtxPosType((GXCompType)vtxAttr->mCompType);
+        } break;
+        case GX_VA_NRM: {
+            if (vtxAttr->mCompType == GX_F32)
+                stride[vtxAttr->mAttrib - GX_VA_POS] = 0x0C;
+            else
+                stride[vtxAttr->mAttrib - GX_VA_POS] = 0x06;
+            array[vtxAttr->mAttrib - GX_VA_POS] = mVertexData->getVtxNrmArray();
+            mVertexData->setVtxNrmFrac(vtxAttr->mCompShift);
+            mVertexData->setVtxNrmType((GXCompType)vtxAttr->mCompType);
+        } break;
+        case GX_VA_CLR0:
+        case GX_VA_CLR1: {
+            stride[vtxAttr->mAttrib - GX_VA_POS] = 0x04;
+            array[vtxAttr->mAttrib - GX_VA_POS] =
+                mVertexData->getVtxColorArray(vtxAttr->mAttrib - GX_VA_CLR0);
+        } break;
+        case GX_VA_TEX0:
+        case GX_VA_TEX1:
+        case GX_VA_TEX2:
+        case GX_VA_TEX3:
+        case GX_VA_TEX4:
+        case GX_VA_TEX5:
+        case GX_VA_TEX6:
+        case GX_VA_TEX7: {
+            if (vtxAttr->mCompType == GX_F32)
+                stride[vtxAttr->mAttrib - GX_VA_POS] = 0x08;
+            else
+                stride[vtxAttr->mAttrib - GX_VA_POS] = 0x04;
+            array[vtxAttr->mAttrib - GX_VA_POS] = mVertexData->getVtxTexCoordArray(vtxAttr->mAttrib - GX_VA_TEX0);
+        } break;
+        default:
+            break;
+        }
+    }
+
+    GXVtxDescList* vtxDesc = mVtxDesc;
+    mHasPNMTXIdx = false;
+    for (; vtxDesc->attr != GX_VA_NULL; vtxDesc++) {
+        if (vtxDesc->attr == GX_VA_NBT && vtxDesc->type != GX_NONE) {
+            mHasNBT = true;
+            stride[GX_VA_NRM - GX_VA_POS] *= 3;
+            array[GX_VA_NRM - GX_VA_POS] = mVertexData->getVtxNBTArray();
+        } else if (vtxDesc->attr == GX_VA_PNMTXIDX && vtxDesc->type != GX_NONE) {
+            mHasPNMTXIdx = true;
+        }
+    }
+
+    for (s32 i = 0; i < 0x0C; i++) {
+        if (array[i] != 0)
+            GDSetArray((GXAttr)(i + GX_VA_POS), array[i], stride[i]);
+        else
+            GDSetArrayRaw((GXAttr)(i + GX_VA_POS), NULL, stride[i]);
+    }
 }
 
 /* 802DD6B8-802DD72C       .text makeVcdVatCmd__8J3DShapeFv */
 void J3DShape::makeVcdVatCmd() {
-    /* Nonmatching */
+    GDLObj gdl_obj;
+    GDInitGDLObj(&gdl_obj, mVcdVatCmd, kVcdVatDLSize);
+    GDSetCurrent(&gdl_obj);
+    GDSetVtxDescv(mVtxDesc);
+    makeVtxArrayCmd();
+    J3DGDSetVtxAttrFmtv(GX_VTXFMT0, mVertexData->getVtxAttrFmtList(), mHasNBT);
+    GDPadCurr32();
+    GDFlushCurrToMem();
+    GDSetCurrent(NULL);
 }
 
+void* J3DShape::sOldVcdVatCmd;
+
 /* 802DD72C-802DD7CC       .text loadPreDrawSetting__8J3DShapeCFv */
 void J3DShape::loadPreDrawSetting() const {
-    /* Nonmatching */
+    if (sOldVcdVatCmd != mVcdVatCmd) {
+        GXCallDisplayList(mVcdVatCmd, kVcdVatDLSize);
+        sOldVcdVatCmd = mVcdVatCmd;
+    }
+
+    mCurrentMtx.load();
 }
 
+u8 J3DShape::sEnvelopeFlag;
+
 /* 802DD7CC-802DD874       .text setArrayAndBindPipeline__8J3DShapeCFv */
 void J3DShape::setArrayAndBindPipeline() const {
-    /* Nonmatching */
+    J3DShapeMtx::setCurrentPipeline(getPipeline());
+    loadVtxArray();
+    j3dSys.setModelDrawMtx(mDrawMtx[*mCurrentViewNo]);
+    j3dSys.setModelNrmMtx(mNrmMtx[*mCurrentViewNo]);
+    J3DShapeMtx::sCurrentScaleFlag = mScaleFlagArray;
+    J3DShapeMtx::sNBTFlag = mHasNBT;
+    J3DShape::sEnvelopeFlag = mHasPNMTXIdx;
 }
 
 /* 802DD874-802DD9FC       .text drawFast__8J3DShapeCFv */
 void J3DShape::drawFast() const {
-    /* Nonmatching */
+    if (sOldVcdVatCmd != mVcdVatCmd) {
+        GXCallDisplayList(mVcdVatCmd, kVcdVatDLSize);
+        sOldVcdVatCmd = mVcdVatCmd;
+    }
+
+    if (sEnvelopeFlag != 0 && !mHasPNMTXIdx)
+        mCurrentMtx.load();
+
+    setArrayAndBindPipeline();
+    if (!checkFlag(J3DShpFlag_NoMtx)) {
+        for (u16 i = 0; i < getMtxGroupNum(); i++) {
+            if (getShapeMtx(i) != NULL)
+                getShapeMtx(i)->load();
+            if (getShapeDraw(i) != NULL)
+                getShapeDraw(i)->draw();
+        }
+    } else {
+        J3DFifoLoadPosMtxImm(*j3dSys.getShapePacket()->getBaseMtxPtr(), GX_PNMTX0);
+        J3DFifoLoadNrmMtxImm(*j3dSys.getShapePacket()->getBaseMtxPtr(), GX_PNMTX0);
+        for (u16 i = 0; i < getMtxGroupNum(); i++)
+            if (getShapeDraw(i) != NULL)
+                getShapeDraw(i)->draw();
+    }
 }
 
 /* 802DD9FC-802DDA44       .text draw__8J3DShapeCFv */
 void J3DShape::draw() const {
-    /* Nonmatching */
+    sOldVcdVatCmd = NULL;
+    loadPreDrawSetting();
+    drawFast();
 }
 
 /* 802DDA44-802DDAC8       .text simpleDraw__8J3DShapeCFv */
 void J3DShape::simpleDraw() const {
-    /* Nonmatching */
+    resetVcdVatCache();
+    loadPreDrawSetting();
+    J3DShapeMtx::setCurrentPipeline(getPipeline());
+    loadVtxArray();
+    for (u16 i = 0; i < getMtxGroupNum(); i++) {
+        if (getShapeDraw(i) != NULL) {
+            getShapeDraw(i)->draw();
+        }
+    }
 }
 
 /* 802DDAC8-802DDBC4       .text simpleDrawCache__8J3DShapeCFv */
 void J3DShape::simpleDrawCache() const {
-    /* Nonmatching */
+    if (sOldVcdVatCmd != mVcdVatCmd) {
+        GXCallDisplayList(mVcdVatCmd, kVcdVatDLSize);
+        sOldVcdVatCmd = mVcdVatCmd;
+    }
+
+    if (sEnvelopeFlag != 0 && !mHasPNMTXIdx)
+        mCurrentMtx.load();
+
+    loadVtxArray();
+    for (u16 i = 0; i < getMtxGroupNum(); i++)
+        if (getShapeDraw(i) != NULL)
+            getShapeDraw(i)->draw();
 }
diff --git a/src/JSystem/J3DGraphBase/J3DTransform.cpp b/src/JSystem/J3DGraphBase/J3DTransform.cpp
index e9160d514..b231a3378 100644
--- a/src/JSystem/J3DGraphBase/J3DTransform.cpp
+++ b/src/JSystem/J3DGraphBase/J3DTransform.cpp
@@ -17,8 +17,29 @@ void J3DGQRSetup7(unsigned long, unsigned long, unsigned long, unsigned long) {
 }
 
 /* 802DA0E8-802DA120       .text J3DCalcZValue__FPA4_f3Vec */
-void J3DCalcZValue(float(*)[4], Vec) {
-    /* Nonmatching */
+
+// matches debug
+f32 J3DCalcZValue(register MtxP m, register Vec v) {
+    register f32 temp_f4;
+    register f32 out;
+    register f32 temp_f0;
+    register f32 temp_f2;
+    register f32 temp_f1 = 1.0f;
+
+    // clang-format off
+    asm {
+        psq_l temp_f0, 0(v), 0, 0 /* qr0 */
+        lfs temp_f2, 8(v)
+        psq_l temp_f4, 32(m), 0, 0 /* qr0 */
+        psq_l out, 40(m), 0, 0 /* qr0 */
+        ps_merge00 temp_f2, temp_f2, temp_f1
+        ps_mul temp_f4, temp_f0, temp_f4
+        ps_madd out, temp_f2, out, temp_f4
+        ps_sum0 out, out, out, out
+    }
+    // clang-format on
+
+    return out;
 }
 
 /* 802DA120-802DA2E0       .text J3DCalcBBoardMtx__FPA4_f */
diff --git a/src/JSystem/J3DGraphBase/J3DVertex.cpp b/src/JSystem/J3DGraphBase/J3DVertex.cpp
index 7da6788f6..306f895a2 100644
--- a/src/JSystem/J3DGraphBase/J3DVertex.cpp
+++ b/src/JSystem/J3DGraphBase/J3DVertex.cpp
@@ -4,54 +4,132 @@
 //
 
 #include "JSystem/J3DGraphBase/J3DVertex.h"
-#include "dolphin/types.h"
+#include "JSystem/J3DGraphBase/J3DSys.h"
+#include "JSystem/J3DGraphAnimator/J3DJointTree.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "global.h"
 
 /* 802D9D24-802D9D9C       .text __ct__13J3DVertexDataFv */
 J3DVertexData::J3DVertexData() {
-    /* Nonmatching */
+    mVtxNum = 0;
+    mNrmNum = 0;
+    mColNum = 0;
+
+    mVtxAttrFmtList = NULL;
+    mVtxPosArray = NULL;
+    mVtxNrmArray = NULL;
+    mVtxNBTArray = NULL;
+
+    for (int i = 0; i < ARRAY_SIZE(mVtxColorArray); i++)
+        mVtxColorArray[i] = NULL;
+
+    for (int i = 0; i < ARRAY_SIZE(mVtxTexCoordArray); i++)
+        mVtxTexCoordArray[i] = NULL;
+
+    mVtxPosFrac = 0;
+    mVtxPosType = GX_F32;
+    mVtxNrmFrac = 0;
+    mVtxNrmType = GX_F32;
 }
 
 /* 802D9D9C-802D9DD8       .text __dt__13J3DVertexDataFv */
 J3DVertexData::~J3DVertexData() {
-    /* Nonmatching */
 }
 
 /* 802D9DD8-802D9E38       .text setVertexData__15J3DVertexBufferFP13J3DVertexData */
-void J3DVertexBuffer::setVertexData(J3DVertexData*) {
-    /* Nonmatching */
+void J3DVertexBuffer::setVertexData(J3DVertexData* pVtxData) {
+    mVtxData = pVtxData;
+    mVtxPosArray[0] = pVtxData->getVtxPosArray();
+    mVtxNrmArray[0] = pVtxData->getVtxNrmArray();
+    mVtxColArray[0] = pVtxData->getVtxColorArray(0);
+    mVtxPosArray[1] = NULL;
+    mVtxNrmArray[1] = NULL;
+    mVtxColArray[1] = NULL;
+
+    mTransformedVtxPosArray[0] = pVtxData->getVtxPosArray();
+    mTransformedVtxNrmArray[0] = pVtxData->getVtxNrmArray();
+    mTransformedVtxPosArray[1] = NULL;
+    mTransformedVtxNrmArray[1] = NULL;
+
+    frameInit();
 }
 
 /* 802D9E38-802D9E90       .text init__15J3DVertexBufferFv */
 void J3DVertexBuffer::init() {
-    /* Nonmatching */
+    mVtxData = NULL;
+
+    mVtxPosArray[1] = NULL;
+    mVtxPosArray[0] = NULL;
+
+    mVtxNrmArray[1] = NULL;
+    mVtxNrmArray[0] = NULL;
+
+    mVtxColArray[1] = NULL;
+    mVtxColArray[0] = NULL;
+
+    mTransformedVtxPosArray[1] = NULL;
+    mTransformedVtxPosArray[0] = NULL;
+
+    mTransformedVtxNrmArray[1] = NULL;
+    mTransformedVtxNrmArray[0] = NULL;
+
+    mCurrentVtxPos = NULL;
+    mCurrentVtxNrm = NULL;
+    mCurrentVtxCol = NULL;
+
+    frameInit();
 }
 
 /* 802D9E90-802D9ECC       .text __dt__15J3DVertexBufferFv */
 J3DVertexBuffer::~J3DVertexBuffer() {
-    /* Nonmatching */
 }
 
 /* 802D9ECC-802D9EF0       .text setArray__15J3DVertexBufferCFv */
 void J3DVertexBuffer::setArray() const {
-    /* Nonmatching */
+    j3dSys.setVtxPos(mCurrentVtxPos);
+    j3dSys.setVtxNrm(mCurrentVtxNrm);
+    j3dSys.setVtxCol(mCurrentVtxCol);
 }
 
 /* 802D9EF0-802D9FA4       .text allocTransformedVtxPosArray__15J3DVertexBufferFv */
-void J3DVertexBuffer::allocTransformedVtxPosArray() {
-    /* Nonmatching */
+s32 J3DVertexBuffer::allocTransformedVtxPosArray() {
+    if (mTransformedVtxPosArray[0] != NULL && mTransformedVtxPosArray[1] != NULL)
+        return kJ3DError_Success;
+
+    for (int i = 0; i < 2; i++) {
+        if (i == 0 || mTransformedVtxPosArray[i] == NULL) {
+            mTransformedVtxPosArray[i] = new (0x20) Vec[mVtxData->getVtxNum()];
+            if (mTransformedVtxPosArray[i] == NULL)
+                return kJ3DError_Alloc;
+        }
+    }
+
+    return kJ3DError_Success;
 }
 
 /* 802D9FA4-802DA058       .text allocTransformedVtxNrmArray__15J3DVertexBufferFv */
-void J3DVertexBuffer::allocTransformedVtxNrmArray() {
-    /* Nonmatching */
+s32 J3DVertexBuffer::allocTransformedVtxNrmArray() {
+    if (mTransformedVtxNrmArray[0] != NULL && mTransformedVtxNrmArray[1] != NULL)
+        return kJ3DError_Success;
+
+    for (int i = 0; i < 2; i++) {
+        if (i == 0 || mTransformedVtxNrmArray[i] == NULL) {
+            mTransformedVtxNrmArray[i] = new (0x20) VertexNormal[mVtxData->getNrmNum()];
+            if (mTransformedVtxNrmArray[i] == NULL)
+                return kJ3DError_Alloc;
+        }
+    }
+
+    return kJ3DError_Success;
 }
 
 /* 802DA058-802DA06C       .text __ct__14J3DDrawMtxDataFv */
 J3DDrawMtxData::J3DDrawMtxData() {
-    /* Nonmatching */
+    mEntryNum = 0;
+    mDrawMtxFlag = NULL;
+    mDrawMtxIndex = NULL;
 }
 
 /* 802DA06C-802DA0A8       .text __dt__14J3DDrawMtxDataFv */
 J3DDrawMtxData::~J3DDrawMtxData() {
-    /* Nonmatching */
 }
diff --git a/src/SSystem/SComponent/c_bg_s_lin_chk.cpp b/src/SSystem/SComponent/c_bg_s_lin_chk.cpp
index 7a36a650f..e35a2f9fd 100644
--- a/src/SSystem/SComponent/c_bg_s_lin_chk.cpp
+++ b/src/SSystem/SComponent/c_bg_s_lin_chk.cpp
@@ -8,10 +8,11 @@
 
 /* 80247418-80247480       .text ct__11cBgS_LinChkFv */
 void cBgS_LinChk::ct() {
-    mLin.mStart = cXyz::Zero;
-    mLin.mEnd = cXyz::Zero;
-    field_0x40 = cXyz::Zero ;
-    setActorPid(0xFFFFFFFF);
+    cXyz zero = cXyz::Zero;
+    mLin.mStart = zero;
+    mLin.mEnd = zero;
+    field_0x40 = zero;
+    setActorPid(-1);
     field_0x4c = 0;
     mFrontFlag = 1;
     mBackFlag = 0;
@@ -19,7 +20,8 @@ void cBgS_LinChk::ct() {
 
 /* 80247480-80247500       .text Set2__11cBgS_LinChkFP4cXyzP4cXyzUi */
 void cBgS_LinChk::Set2(cXyz* pStart, cXyz* pEnd, unsigned int actorPid) {
-    mLin.SetStartEnd(*pStart, *pEnd);
+    mLin.mStart.set(*pStart);
+    mLin.mEnd.set(*pEnd);
     field_0x40 = *pEnd;
     setActorPid(actorPid);
     field_0x4c &= ~0x10;
diff --git a/src/SSystem/SComponent/c_lib.cpp b/src/SSystem/SComponent/c_lib.cpp
index 9ddb7366e..3678ef251 100644
--- a/src/SSystem/SComponent/c_lib.cpp
+++ b/src/SSystem/SComponent/c_lib.cpp
@@ -4,10 +4,11 @@
 //
 
 #include "SSystem/SComponent/c_lib.h"
-#include "SSystem/SComponent/c_math.h"
 #include "MSL_C/string.h"
+#include "SSystem/SComponent/c_math.h"
 #include "dolphin/mtx/mtxvec.h"
 
+
 /* 802528A4-802528C4       .text cLib_memCpy__FPvPCvUl */
 void cLib_memCpy(void* dst, const void* src, unsigned long size) {
     memcpy(dst, src, size);
@@ -202,35 +203,33 @@ void cLib_addCalcAngleS2(s16* pValue, s16 target, s16 scale, s16 maxStep) {
 }
 
 /* 802532C4-8025335C       .text cLib_addCalcAngleL__FPlllll */
-s16 cLib_addCalcAngleL(s32* pValue, s32 target, s32 scale, s32 maxStep, s32 minStep) {
+s32 cLib_addCalcAngleL(s32* pValue, s32 target, s32 scale, s32 maxStep, s32 minStep) {
     s32 diff = target - *pValue;
     if (*pValue != target) {
-        s32 step = (diff) / scale;
-        if (step > minStep || step < -minStep) {
-            if (step > maxStep) {
-                step = maxStep;
+        scale = (diff) / scale;
+        if (scale > minStep || scale < -minStep) {
+            if (scale > maxStep) {
+                scale = maxStep;
             }
-            if (step < -maxStep) {
-                step = -maxStep;
+            if (scale < -maxStep) {
+                scale = -maxStep;
             }
-            *pValue += step;
+            *pValue += scale;
         } else {
             if (0 <= diff) {
                 *pValue += minStep;
-                diff = target - *pValue;
-                if (0 >= diff) {
+                if (0 >= target - *pValue) {
                     *pValue = target;
                 }
             } else {
                 *pValue -= minStep;
-                diff = target - *pValue;
-                if (0 <= diff) {
+                if (0 <= target - *pValue) {
                     *pValue = target;
                 }
             }
         }
     }
-    return target - *pValue;
+    return diff;
 }
 
 /* 8025335C-802533D0       .text cLib_chaseUC__FPUcUcUc */
diff --git a/src/SSystem/SComponent/c_m3d_g_cyl.cpp b/src/SSystem/SComponent/c_m3d_g_cyl.cpp
index 799db4b59..8fe53520d 100644
--- a/src/SSystem/SComponent/c_m3d_g_cyl.cpp
+++ b/src/SSystem/SComponent/c_m3d_g_cyl.cpp
@@ -8,9 +8,9 @@
 #include "JSystem/JUtility/JUTAssert.h"
 #include "MSL_C/float.h"
 
-#define CHECK_FLOAT_CLASS(line, x) JUT_ASSERT(__FILE__, line, !(((sizeof(x) == sizeof(float)) ? __fpclassifyf((float)(x)) : __fpclassifyd((double)(x)) ) == 1));
-#define CHECK_FLOAT_RANGE(line, x) JUT_ASSERT(__FILE__, line, -1.0e32f < x && x < 1.0e32f);
-#define CHECK_VEC3_RANGE(line, v) JUT_ASSERT(__FILE__, line, -1.0e32f < v.x && v.x < 1.0e32f && -1.0e32f < v.y && v.y < 1.0e32f && -1.0e32f < v.z && v.z < 1.0e32f)
+#define CHECK_FLOAT_CLASS(line, x) JUT_ASSERT(line, !(((sizeof(x) == sizeof(float)) ? __fpclassifyf((float)(x)) : __fpclassifyd((double)(x)) ) == 1));
+#define CHECK_FLOAT_RANGE(line, x) JUT_ASSERT(line, -1.0e32f < x && x < 1.0e32f);
+#define CHECK_VEC3_RANGE(line, v) JUT_ASSERT(line, -1.0e32f < v.x && v.x < 1.0e32f && -1.0e32f < v.y && v.y < 1.0e32f && -1.0e32f < v.z && v.z < 1.0e32f)
 
 /* 80251D88-80252020       .text SetC__8cM3dGCylFRC4cXyz */
 void cM3dGCyl::SetC(const cXyz& pos) {
diff --git a/src/SSystem/SComponent/c_m3d_g_sph.cpp b/src/SSystem/SComponent/c_m3d_g_sph.cpp
index e52590819..cd3bd4ae0 100644
--- a/src/SSystem/SComponent/c_m3d_g_sph.cpp
+++ b/src/SSystem/SComponent/c_m3d_g_sph.cpp
@@ -8,9 +8,9 @@
 #include "JSystem/JUtility/JUTAssert.h"
 #include "MSL_C/float.h"
 
-#define CHECK_FLOAT_CLASS(line, x) JUT_ASSERT(__FILE__, line, !(((sizeof(x) == sizeof(float)) ? __fpclassifyf((float)(x)) : __fpclassifyd((double)(x)) ) == 1));
-#define CHECK_FLOAT_RANGE(line, x) JUT_ASSERT(__FILE__, line, -1.0e32f < x && x < 1.0e32f);
-#define CHECK_VEC3_RANGE(line, v) JUT_ASSERT(__FILE__, line, -1.0e32f < v.x && v.x < 1.0e32f && -1.0e32f < v.y && v.y < 1.0e32f && -1.0e32f < v.z && v.z < 1.0e32f)
+#define CHECK_FLOAT_CLASS(line, x) JUT_ASSERT(line, !(((sizeof(x) == sizeof(float)) ? __fpclassifyf((float)(x)) : __fpclassifyd((double)(x)) ) == 1));
+#define CHECK_FLOAT_RANGE(line, x) JUT_ASSERT(line, -1.0e32f < x && x < 1.0e32f);
+#define CHECK_VEC3_RANGE(line, v) JUT_ASSERT(line, -1.0e32f < v.x && v.x < 1.0e32f && -1.0e32f < v.y && v.y < 1.0e32f && -1.0e32f < v.z && v.z < 1.0e32f)
 
 /* 8025238C-80252624       .text SetC__8cM3dGSphFRC4cXyz */
 void cM3dGSph::SetC(const cXyz& pos) {
diff --git a/src/SSystem/SComponent/c_math.cpp b/src/SSystem/SComponent/c_math.cpp
index 6f6638a60..7f9e190c0 100644
--- a/src/SSystem/SComponent/c_math.cpp
+++ b/src/SSystem/SComponent/c_math.cpp
@@ -10,8 +10,8 @@
 
 /* 80246044-8024609C       .text cM_rad2s__Ff */
 s16 cM_rad2s(float f0) {
-    f32 tmpF = fmod(f0, 6.2831854820251465 /* approx. 2 * PI */);
-    s32 tmp = (tmpF * 10430.378f /* approx. 32768 / PI */);
+    f64 tmpF = fmod(f0, 6.2831854820251465 /* approx. 2 * PI */);
+    s32 tmp = (tmpF * 10430.3779296875 /* approx. 32768 / PI */);
     if (tmp < -0x8000) {
         tmp += 0x10000;
     } else if (tmp > 0x7FFF) {
diff --git a/src/SSystem/SComponent/c_xyz.cpp b/src/SSystem/SComponent/c_xyz.cpp
index 346d984f2..5f2cac9e8 100644
--- a/src/SSystem/SComponent/c_xyz.cpp
+++ b/src/SSystem/SComponent/c_xyz.cpp
@@ -4,9 +4,9 @@
 //
 
 #include "SSystem/SComponent/c_xyz.h"
-#include "SSystem/SComponent/c_math.h"
-#include "MSL_C/float.h"
 #include "JSystem/JUtility/JUTAssert.h"
+#include "MSL_C/float.h"
+#include "SSystem/SComponent/c_math.h"
 
 const cXyz cXyz::Zero(0, 0, 0);
 const cXyz cXyz::BaseX(1, 0, 0);
@@ -150,7 +150,6 @@ bool cXyz::operator!=(const Vec& vec) const {
 
 /* 80245CE4-80245D48       .text isZero__4cXyzCFv */
 bool cXyz::isZero(void) const {
-    return fabsf(this->x) < 3.814697e-06 &&
-           fabsf(this->y) < 3.814697e-06 &&
-           fabsf(this->z) < 3.814697e-06;
+    return fabsf(this->x) < 3.814697e-06f && fabsf(this->y) < 3.814697e-06f &&
+           fabsf(this->z) < 3.814697e-06f;
 }
diff --git a/src/d/actor/d_a_branch.cpp b/src/d/actor/d_a_branch.cpp
index 5048b4d4a..ba3e2f4d8 100644
--- a/src/d/actor/d_a_branch.cpp
+++ b/src/d/actor/d_a_branch.cpp
@@ -9,13 +9,27 @@
 #include "f_op/f_op_actor_mng.h"
 #include "d/d_procname.h"
 #include "m_Do/m_Do_ext.h"
+#include "m_Do/m_Do_mtx.h"
 #include "d/d_com_inf_game.h"
-#include "d/d_resorce.h"
+#include "d/d_kankyo.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "dolphin/mtx/mtx.h"
 #include "dolphin/types.h"
 
 
 class daBranch_c : public fopAc_ac_c {
 public:
+    ~daBranch_c() {
+        for (int i = 0; i < 2; i++) {
+            mDoExt_McaMorf* anim = mAnims[i];
+            if (anim != 0) {
+                anim->stopZelAnime();
+            }
+        }
+
+        dComIfG_resDelete(&mPhs, m_arcname);
+    }
+
     void set_mtx();
     void set_anim(int, int, int);
     void demoPlay(mDoExt_McaMorf*);
@@ -24,9 +38,13 @@ public:
     static s32 solidHeapCB(fopAc_ac_c*);
 
     /* 0x0290 */ request_of_phase_process_class mPhs;
-    /* 0x0294 */ s8 dummy[0x10];
-    // ...
-    /* 0x02A8*/ mDoExt_McaMorf* mAnims[2];
+    /* 0x0298 */ J3DModel* mModels[2];
+    /* 0x02A0 */ u8 dummy2[0x08]; 
+    /* 0x02A8 */ mDoExt_McaMorf* mAnims[2];
+    /* 0x02B0 */ u8 dummy[0x08];
+    /* 0x02B8 */ u32 m02B8;
+    /* 0x02BC */ u8 m02BC;
+    /* 0x02BD */ u8 m02BD;
 
     static char m_arcname[];
 };
@@ -35,20 +53,29 @@ char daBranch_c::m_arcname[] = "Kwood_00";
 
 /* 00000078-00000128       .text set_mtx__10daBranch_cFv */
 void daBranch_c::set_mtx() {
-    /* Nonmatching */
-    //for (int i = 0; i < 2; i ++) {
+    J3DModel* pMdl;
 
-    //}
+    for (int i = 0; i < 2; i ++) {
+        pMdl = mModels[i];
+
+        if (pMdl) {
+            pMdl->setBaseScale(mScale);
+
+            mDoMtx_stack_c::transS(getPosition());
+            mDoMtx_stack_c::XYZrotM(getAngle().x, getAngle().y, getAngle().z);
+            pMdl->i_setBaseTRMtx(mDoMtx_stack_c::get());
+        }
+    }
 }
 
 /* 00000128-000001E4       .text set_anim__10daBranch_cFiii */
 void daBranch_c::set_anim(int i_animIdx, int i_bckIdx, int i_basIdx) {
     if (i_bckIdx > 0 && i_basIdx > 0) {
         void* pSnd = dComIfG_getObjectIDRes(m_arcname, i_basIdx);
-        void* pAnm = dComIfG_getObjectIDRes(m_arcname, i_bckIdx);
+        J3DAnmTransform* pAnm = static_cast<J3DAnmTransform*>(dComIfG_getObjectIDRes(m_arcname, i_bckIdx));
         
         mAnims[i_animIdx]->setAnm(
-            static_cast<J3DAnmTransform*>(pAnm),
+            pAnm,
             -1,
             0.0f,
             1.0f,
@@ -73,31 +100,25 @@ s32 daBranch_c::solidHeapCB(fopAc_ac_c* i_this) {
 /* 00000248-0000049C       .text CreateHeap__10daBranch_cFv */
 s32 daBranch_c::CreateHeap() {
     /* Nonmatching */
+    int basIds[] = { 8, 0 }; 
+    int bckIds[] = { 7, 2 };
+    int bmdIds[] = { 6, 5 };
+    int t[] = {0, 0};
 
     BOOL status = TRUE;
 
-    s32 ids[] = {
-        8, 0, 
-        7, 2, 
-        6, 5 
-    };
-
     for (int i = 0; i < 2; i++) {
-        void* modelRes = dRes_control_c::getIDRes(m_arcname, ids[i + 4], g_dComIfG_gameInfo.mResControl.mObjectInfo, 0x40);
-        void* bckRes = dRes_control_c::getIDRes(m_arcname, ids[i + 2], g_dComIfG_gameInfo.mResControl.mObjectInfo, 0x40);
+        J3DModelData* modelData = static_cast<J3DModelData*>(dComIfG_getObjectIDRes(m_arcname, bmdIds[i]));
+        J3DAnmTransformKey* bck = static_cast<J3DAnmTransformKey*>(dComIfG_getObjectIDRes(m_arcname, bckIds[i]));
 
-        if (!modelRes) {
-            JUT_ASSERT(0x1CC, "modelData != 0");
-        }
-        if (!bckRes) {
-            JUT_ASSERT(0x1CD, "bck != 0");
-        }
+        JUT_ASSERT(0x1CC, modelData != 0);
+        JUT_ASSERT(0x1CD, bck != 0);
 
         mDoExt_McaMorf* newMorf = new mDoExt_McaMorf(
-            (J3DModelData*)dRes_control_c::getIDRes(m_arcname, ids[i + 4], g_dComIfG_gameInfo.mResControl.mObjectInfo, 0x40),
+            static_cast<J3DModelData*>(dComIfG_getObjectIDRes(m_arcname, bmdIds[i])),
             0,
             0,
-            (J3DAnmTransformKey*)dRes_control_c::getIDRes(m_arcname, ids[i + 2], g_dComIfG_gameInfo.mResControl.mObjectInfo, 0x40),
+            static_cast<J3DAnmTransformKey*>(dComIfG_getObjectIDRes(m_arcname, bckIds[i])),
             0,
             1.0f,
             0,
@@ -109,35 +130,81 @@ s32 daBranch_c::CreateHeap() {
         );
 
         mAnims[i] = newMorf;
-        if (mAnims[i] == 0) {
+        if (!mAnims[i]) {
             status = FALSE;
             break;
         }
 
+        mModels[i] = newMorf->mpModel;
+        if (!mModels[i]) {
+            status = FALSE;
+            break;
+        }
 
+        mAnims[i]->setFrame(0.0f);
+        set_anim(i, bckIds[i], basIds[i]);
     }
 
     return status;
 }
 
 /* 0000049C-00000524       .text daBranch_Draw__FP10daBranch_c */
-void daBranch_Draw(daBranch_c*) {
-    /* Nonmatching */
+BOOL daBranch_Draw(daBranch_c* i_this) {
+    int activeIdx = 0;
+    if (i_this->m02B8 == 5) {
+        activeIdx = 1;
+    }
+
+    g_env_light.settingTevStruct(TEV_TYPE_BG0, &i_this->current.pos, &i_this->mTevStr);
+    g_env_light.setLightTevColorType(i_this->mModels[activeIdx], &i_this->mTevStr);
+
+    i_this->mAnims[activeIdx]->updateDL();
+
+    return TRUE;
 }
 
 /* 00000524-0000060C       .text daBranch_Execute__FP10daBranch_c */
-void daBranch_Execute(daBranch_c*) {
+void daBranch_Execute(daBranch_c* i_this) {
     /* Nonmatching */
+    int demoId = i_this->mDemoActorId;
+
+    if (demoId == 0) {
+        if (i_this->m02B8 == 5) {
+            if (i_this->mAnims[1]) {
+                i_this->mAnims[1]->play(0, 0, 0);
+            }
+        }
+        else if (i_this->m02B8 == 6 && i_this->mAnims[0]) {
+            i_this->mAnims[0]->play(0, 0, 0);
+        }
+    }
+    else {
+        void* demoActor = g_dComIfG_gameInfo.play.mDemo;
+
+        if (demoActor) {
+            //i_this->m02B8 = demoActor->mShape;
+
+            if (i_this->m02B8 == 6) {
+                i_this->demoPlay(i_this->mAnims[0]);
+            }
+            else if (i_this->m02B8 == 5) {
+                i_this->demoPlay(i_this->mAnims[1]);
+            }
+        }
+    }
+
+    i_this->set_mtx();
 }
 
 /* 0000060C-00000614       .text daBranch_IsDelete__FP10daBranch_c */
-BOOL daBranch_IsDelete(daBranch_c*) {
+BOOL daBranch_IsDelete(daBranch_c* i_this) {
     return TRUE;
 }
 
 /* 00000614-00000694       .text daBranch_Delete__FP10daBranch_c */
-void daBranch_Delete(daBranch_c*) {
-    /* Nonmatching */
+BOOL daBranch_Delete(daBranch_c* i_this) {
+    i_this->~daBranch_c();
+    return TRUE;
 }
 
 /* 00000694-0000080C       .text daBranch_Create__FP10fopAc_ac_c */
@@ -153,13 +220,30 @@ s32 daBranch_Create(fopAc_ac_c* i_this) {
 
         if (solidHeapResult & 0xFF == 0) {
             for (int i = 0; i < 2; i++) {
-                //branch->mBase.m
+                branch->mAnims[i] = 0;
             }
 
             state = cPhs_ERROR_e;
         }
         else {
+            branch->mCullMtx = branch->mModels[0]->mBaseTransformMtx;
+            fopAcM_setCullSizeBox(i_this, 0.0f, 0.0f, -50.0f, 300.0f, 100.0f, 50.0f);
+            
+            branch->m02B8 = 6;
+            branch->m02BC = 0;
+            branch->m02BD = 0;
 
+            for (int i = 0; i < 2; i++) {
+                J3DModelData* modelData = branch->mModels[i]->mModelData;
+
+                for (int j = 0; j < modelData->getMaterialNum(); j++) {
+                    J3DMaterial* mat = modelData->getMaterialNodePointer(j);
+                    if (mat) {
+                        J3DFog* fog = mat->getPEBlock()->getFog();
+                        fog->field_0x0 = 2;
+                    }
+                }
+            }
         }
     }
 
diff --git a/src/d/actor/d_a_item.cpp b/src/d/actor/d_a_item.cpp
index cf78a68e0..f2b326d6b 100644
--- a/src/d/actor/d_a_item.cpp
+++ b/src/d/actor/d_a_item.cpp
@@ -5,14 +5,44 @@
 
 #include "d/d_item.h"
 #include "d/d_item_data.h"
+#include "d/actor/d_a_itembase_static.h"
 #include "d/actor/d_a_item.h"
 #include "d/actor/d_a_player_link.h"
 #include "d/d_com_inf_game.h"
+#include "JSystem/JKernel/JKRHeap.h"
 #include "d/d_procname.h"
 #include "dolphin/types.h"
 
 class dCcD_GObjInf;
 
+static dCcD_SrcCyl m_cyl_src = {
+    0,
+    0,
+    0,
+    0,
+    0xFFFFFFFF, // Tg damage types
+    9,
+    0x59,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    4,
+    0,
+    
+    // Cylinder
+    0.0, // X
+    0.0, // Y
+    0.0, // Z
+    10.0, // Radius
+    50.0, // Height
+};
+
 /* 800F4BC8-800F4BD4       .text getData__12daItemBase_cFv */
 daItemBase_c_m_data* daItemBase_c::getData() {
     return &daItemBase_c::m_data;
@@ -27,7 +57,25 @@ void setArrowTrans(short, cXyz) {
 float daItem_c::getYOffset() {
     switch (m_itemNo) {
     case HEART:
-        return 0.0;
+        return 0.0f;
+    case SKULL_NECKLACE:
+        return 0.0f;
+    case BOKOBABA_SEED:
+        return 0.0f;
+    case GOLDEN_FEATHER:
+        return 0.0f;
+    case BOKO_BELT:
+        return 0.0f;
+    case RED_JELLY:
+    case GREEN_JELLY:
+    case BLUE_JELLY:
+        return 0.0f;
+    case SWORD:
+        return 20.0f;
+    case SHIELD:
+        return 23.0f;
+    case DROPPED_SWORD:
+        return 10.0f;
     case GREEN_RUPEE:
     case BLUE_RUPEE:
     case YELLOW_RUPEE:
@@ -35,33 +83,15 @@ float daItem_c::getYOffset() {
     case PURPLE_RUPEE:
     case ORANGE_RUPEE:
     case SILVER_RUPEE:
-        return 0.0;
+        return 0.0f;
     case KAKERA_HEART:
     case UTUWA_HEART:
-        return 0.0;
+        return 0.0f;
     case SMALL_KEY:
     case BOSS_KEY:
-        return 0.0;
-    case SWORD:
-        return 20.0;
-    case SHIELD:
-        return 23.0;
-    case DROPPED_SWORD:
-        return 10.0;
-    case SKULL_NECKLACE:
-        return 0.0;
-    case BOKOBABA_SEED:
-        return 0.0;
-    case GOLDEN_FEATHER:
-        return 0.0;
-    case BOKO_BELT:
-        return 0.0;
-    case RED_JELLY:
-    case GREEN_JELLY:
-    case BLUE_JELLY:
-        return 0.0;
+        return 0.0f;
     default:
-        return 0.0;
+        return 0.0f;
     }
 }
 
@@ -83,11 +113,120 @@ void itemGetCallBack(fopAc_ac_c*, dCcD_GObjInf*, fopAc_ac_c*, dCcD_GObjInf*) {
 /* 800F5044-800F53EC       .text CreateInit__8daItem_cFv */
 void daItem_c::CreateInit() {
     /* Nonmatching */
+    mAcchCir.SetWall(30.0, 30.0);
+    cXyz* speedPtr = &speed;
+    mAcch.Set(&current.pos, &next.pos, this, 1, &mAcchCir, speedPtr, NULL, NULL);
+    mAcch.m_flags &= ~0x400;
+    mAcch.m_flags &= ~0x8;
+    mCullMtx = mModel->mBaseTransformMtx;
+    mStts.Init(0, 0xFF, this);
+    mCyl.Set(m_cyl_src);
+    mCyl.SetCoHitCallback(&itemGetCallBack);
+    
+    dItem_data_item_info* item_info = &dItem_data::item_info[m_itemNo];
+    f32 height = item_info->mCollisionH;
+    f32 radius = item_info->mCollisionR;
+    if (mScale.x > 1.0) {
+        height *= mScale.x;
+        radius *= mScale.x;
+    }
+    mCyl.SetR(radius);
+    mCyl.SetH(height);
+    
+    mItemTimer = getData()->mDuration;
+    field7_0x65a = getData()->field7_0x18;
+    mCurState = 0;
+    field3_0x650 = speedPtr->y;
+    mStatusFlags |= 2;
+    
+    mUnknownParam = (fpcM_GetParam(this) & 0x03000000) >> 0x18;
+    mItemAction = (fpcM_GetParam(this) & 0xFC000000) >> 0x1A;
+    
+    show();
+    
+    if (dItem_data::checkSpecialEffect(m_itemNo) && (m_itemNo != SMALL_KEY || (mStatusFlags & 2))) {
+        dItem_data::getSpecialEffect(m_itemNo);
+        // TODO: dPa_control_c::set
+    }
+    
+    switch (m_itemNo) {
+    case BOMB_5:
+    case BOMB_10:
+    case BOMB_20:
+    case BOMB_30:
+        mScaleTarget.x = 0.6;
+        mScaleTarget.y = 0.6;
+        mScaleTarget.z = 0.6;
+        break;
+    default:
+        mScaleTarget.x = 1.0;
+        mScaleTarget.y = 1.0;
+        mScaleTarget.z = 1.0;
+        break;
+    }
+    
+    mSwitchId = (fpcM_GetParam(this) & 0x00FF0000) >> 0x10;
+    if (mSwitchId != 0xFF && i_fopAcM_isSwitch(this, mSwitchId)) {
+        hide();
+        mStatusFlags |= 2;
+    }
+    mActivationSwitch = (orig.angle.z & 0x00FF) >> 0;
+    
+    initAction();
+    
+    switch (m_itemNo) {
+    case SHIELD:
+        mStatus |= 0x4000;
+        break;
+    case DROPPED_SWORD:
+        current.angle.x = 0x4000;
+        break;
+    }
+    
+    set_mtx();
+    animPlay(1.0, 1.0, 1.0, 1.0, 1.0);
+    
+    s16 procname = PROC_BST; // Gohdan
+    if (fopAcIt_Judge(&fpcSch_JudgeForPName, &procname)) {
+        // TODO: dPa_control_c::set
+        mpParticleEmitter = 0;
+    }
 }
 
 /* 800F53EC-800F5668       .text _daItem_create__8daItem_cFv */
 s32 daItem_c::_daItem_create() {
     /* Nonmatching */
+    fopAcM_SetupActor(this, daItem_c);
+    
+    m_itemNo = (fpcM_GetParam(this) & 0x000000FF) >> 0x00;
+    
+    if (!dItem_data::field_item_res[m_itemNo].mModelArcName) {
+        setLoadError();
+        return cPhs_ERROR_e;
+    }
+    
+    mPickupFlag = (fpcM_GetParam(this) & 0x0000FF00) >> 0x08;
+    if (m_itemNo != BLUE_JELLY) { // Blue Chu Jelly uses mPickupFlag as if it was a switch.
+        mPickupFlag &= 0x7F;
+        if (dComIfGs_isItem(mPickupFlag, orig.roomNo) && mPickupFlag != 0x7F) {
+            // Already picked up, don't create the item again.
+            setLoadError();
+            return cPhs_ERROR_e;
+        }
+    }
+    
+    s32 phase_state = dComIfG_resLoad(&mPhs, dItem_data::field_item_res[m_itemNo].mModelArcName);
+    if (phase_state == cPhs_COMPLEATE_e) {
+        u16 heapSize = dItem_data::field_item_res[m_itemNo].mHeapSize;
+        s32 result = fopAcM_entrySolidHeap(this, (heapCallbackFunc)&CheckFieldItemCreateHeap, heapSize);
+        if (!result) {
+            return cPhs_ERROR_e;
+        }
+        
+        CreateInit();
+    }
+    
+    return phase_state;
 }
 
 /* 800F5668-800F5834       .text _daItem_execute__8daItem_cFv */
@@ -103,6 +242,20 @@ void daItem_c::mode_proc_call() {
 /* 800F59CC-800F5AFC       .text execInitNormalDirection__8daItem_cFv */
 void daItem_c::execInitNormalDirection() {
     /* Nonmatching */
+    daPy_getPlayerActorClass()->getHeadTopPos();
+    
+    field8_0x65c = getData()->field45_0x40;
+    
+    f32 speedY = getData()->mPickedUpInitialSpeedY;
+    speed.x = 0;
+    speed.y = speedY;
+    speed.z = 0;
+    mGravity = getData()->mPickedUpGravity;
+    
+    show();
+    
+    // TODO dPa_smokeEcallBack
+    // TODO mpParticleEmitter
 }
 
 /* 800F5AFC-800F5BC8       .text execMainNormalDirection__8daItem_cFv */
@@ -127,7 +280,10 @@ void daItem_c::execMainGetDemoDirection() {
 
 /* 800F5D44-800F5D88       .text execBringNezumi__8daItem_cFv */
 void daItem_c::execBringNezumi() {
-    /* Nonmatching */
+    if (mUnknownParam != 1) {
+        fopAcM_posMoveF(this, mStts.GetCCMoveP());
+    }
+    mode_proc_call();
 }
 
 /* 800F5D88-800F5F40       .text execWaitMain__8daItem_cFv */
@@ -147,17 +303,37 @@ void daItem_c::scaleAnimFromBossItem() {
 
 /* 800F60C0-800F6110       .text _daItem_draw__8daItem_cFv */
 s32 daItem_c::_daItem_draw() {
-    /* Nonmatching */
+    if (chkDraw()) {
+        return DrawBase();
+    }
+    return 1;
 }
 
 /* 800F6110-800F61C8       .text setTevStr__8daItem_cFv */
 void daItem_c::setTevStr() {
-    /* Nonmatching */
+    g_env_light.settingTevStruct(TEV_TYPE_ACTOR, getPositionP(), &mTevStr);
+    
+    mTevStr.mColorC0.r = 0x96;
+    mTevStr.mColorC0.g = 0x96;
+    mTevStr.mColorC0.b = 0x96;
+    mTevStr.mColorK0.r = 0xFF;
+    mTevStr.mColorK0.g = 0xFF;
+    mTevStr.mColorK0.b = 0xFF;
+    g_env_light.setLightTevColorType(mModel, &mTevStr);
+    
+    for (int i = 0; i < 2; i++) {
+        if (!mModelArrow[i]) {
+            continue;
+        }
+        g_env_light.setLightTevColorType(mModelArrow[i], &mTevStr);
+    }
 }
 
 /* 800F61C8-800F6268       .text _daItem_delete__8daItem_cFv */
 s32 daItem_c::_daItem_delete() {
     /* Nonmatching */
+    // TODO: dPa_rippleEcallBack::end()
+    DeleteBase(dItem_data::field_item_res[m_itemNo].mModelArcName);
 }
 
 /* 800F6268-800F6434       .text Reflect__FR4cXyzP4cXyzff */
@@ -181,7 +357,7 @@ void daItem_c::itemDefaultRotateY() {
 /* 800F6D78-800F6E54       .text checkItemDisappear__8daItem_cFv */
 bool daItem_c::checkItemDisappear() {
     bool disappearing = true;
-    if (mCurAction == 3) {
+    if (mCurState == 3) {
         disappearing = false;
         show();
     }
@@ -197,7 +373,7 @@ bool daItem_c::checkItemDisappear() {
     if (g_dComIfG_gameInfo.play.mEvtCtrl.mMode != 0) {
         disappearing = false;
     }
-    if (mCurAction == 4) {
+    if (mCurState == 4) {
         disappearing = false;
     }
     if ((mStatusFlags & 0x08) || (mStatusFlags & 0x40) || (mStatus & 0x100000)) {
@@ -208,13 +384,23 @@ bool daItem_c::checkItemDisappear() {
 }
 
 /* 800F6E54-800F6E74       .text setItemTimer__8daItem_cFi */
-void daItem_c::setItemTimer(int) {
-    /* Nonmatching */
+void daItem_c::setItemTimer(int timer) {
+    if (timer == -1) {
+        mStatusFlags |= 0x10;
+        return;
+    }
+    mItemTimer = timer;
 }
 
 /* 800F6E74-800F6EC8       .text checkPlayerGet__8daItem_cFv */
-bool daItem_c::checkPlayerGet() {
-    /* Nonmatching */
+BOOL daItem_c::checkPlayerGet() {
+    if (field20_0x638 < getData()->field47_0x42) {
+        return FALSE;
+    }
+    if (mCurState == 3) {
+        return FALSE;
+    }
+    return TRUE;
 }
 
 /* 800F6EC8-800F7028       .text itemActionForRupee__8daItem_cFv */
@@ -259,14 +445,23 @@ void daItem_c::set_bound_se() {
 
 /* 800F7DDC-800F7E6C       .text checkGetItem__8daItem_cFv */
 s32 daItem_c::checkGetItem() {
-    /* Nonmatching */
-    if (checkPlayerGet()) {
-        itemGetExecute();
-        
-        return 1;
+    if (!checkPlayerGet()) {
+        return 0;
+    }
+    
+    if (mCyl.ChkTgHit()) {
+        cCcD_Obj* hitObj = mCyl.GetTgHitObj();
+        if (hitObj) {
+            u32 atType = hitObj->GetAtType();
+            if (atType & AT_TYPE_SWORD) {
+                itemGetExecute();
+                return 1;
+            } else if (atType & AT_TYPE_BOOMERANG) {
+                mStatusFlags |= 0x08;
+            }
+        }
     }
     
-    mStatusFlags |= 0x08;
     return 0;
 }
 
@@ -301,8 +496,8 @@ void daItem_c::initAction() {
 }
 
 /* 800F8950-800F8970       .text daItem_Draw__FP8daItem_c */
-void daItem_Draw(daItem_c*) {
-    /* Nonmatching */
+s32 daItem_Draw(daItem_c* i_this) {
+    return i_this->_daItem_draw();
 }
 
 /* 800F8970-800F8990       .text daItem_Execute__FP8daItem_c */
@@ -322,7 +517,7 @@ s32 daItem_Delete(daItem_c* i_this) {
 
 /* 800F89D0-800F89F0       .text daItem_Create__FP10fopAc_ac_c */
 s32 daItem_Create(fopAc_ac_c* i_this) {
-    /* Nonmatching */
+    return ((daItem_c*)i_this)->_daItem_create();
 }
 
 /* 800F89F0-800F89F8       .text _daItem_isdelete__8daItem_cFv */
diff --git a/src/d/actor/d_a_item_static.cpp b/src/d/actor/d_a_item_static.cpp
index 2039aa74b..725e280ba 100644
--- a/src/d/actor/d_a_item_static.cpp
+++ b/src/d/actor/d_a_item_static.cpp
@@ -3,41 +3,44 @@
 // Translation Unit: d_a_item_static.cpp
 //
 
-#include "d_a_item_static.h"
+// #include "d/actor/d_a_item_static.h"
+#include "d/actor/d_a_item.h"
 #include "dolphin/types.h"
 
 /* 80068820-800688A0       .text checkControl__8daItem_cFv */
-void daItem_c::checkControl() {
+s32 daItem_c::checkControl() {
     /* Nonmatching */
 }
 
 /* 800688A0-800688E8       .text startControl__8daItem_cFv */
-void daItem_c::startControl() {
+s32 daItem_c::startControl() {
     /* Nonmatching */
 }
 
 /* 800688E8-800688F8       .text endControl__8daItem_cFv */
-void daItem_c::endControl() {
-    /* Nonmatching */
+s32 daItem_c::endControl() {
+    mCurState = 0;
+    return 1;
 }
 
 /* 800688F8-80068950       .text checkLock__8daItem_cFv */
-void daItem_c::checkLock() {
+s32 daItem_c::checkLock() {
     /* Nonmatching */
 }
 
 /* 80068950-80068998       .text setLock__8daItem_cFv */
-void daItem_c::setLock() {
+s32 daItem_c::setLock() {
     /* Nonmatching */
 }
 
 /* 80068998-800689A8       .text releaseLock__8daItem_cFv */
-void daItem_c::releaseLock() {
-    /* Nonmatching */
+s32 daItem_c::releaseLock() {
+    mCurState = 0;
+    return 1;
 }
 
 /* 800689A8-800689F0       .text checkActionNow__8daItem_cFv */
-void daItem_c::checkActionNow() {
+s32 daItem_c::checkActionNow() {
     /* Nonmatching */
 }
 
diff --git a/src/d/actor/d_a_itembase_static.cpp b/src/d/actor/d_a_itembase_static.cpp
index 5ea11b66a..42448a031 100644
--- a/src/d/actor/d_a_itembase_static.cpp
+++ b/src/d/actor/d_a_itembase_static.cpp
@@ -4,6 +4,7 @@
 //
 
 #include "d/actor/d_a_itembase_static.h"
+#include "d/actor/d_a_itembase.h"
 #include "dolphin/types.h"
 
 /* 80068650-80068658       .text getItemNo__12daItemBase_cFv */
@@ -37,7 +38,7 @@ void daItemBase_c::changeDraw() {
 }
 
 /* 800686F8-80068710       .text chkDraw__12daItemBase_cFv */
-void daItemBase_c::chkDraw() {
+bool daItemBase_c::chkDraw() {
     /* Nonmatching */
 }
 
@@ -62,7 +63,7 @@ void CheckItemCreateHeap(fopAc_ac_c*) {
 }
 
 /* 800687B4-80068820       .text CheckFieldItemCreateHeap__FP10fopAc_ac_c */
-void CheckFieldItemCreateHeap(fopAc_ac_c*) {
+s32 CheckFieldItemCreateHeap(fopAc_ac_c*) {
     /* Nonmatching */
 }
 
diff --git a/src/d/actor/d_a_magma.cpp b/src/d/actor/d_a_magma.cpp
index 7fa484d2d..cf428ba22 100644
--- a/src/d/actor/d_a_magma.cpp
+++ b/src/d/actor/d_a_magma.cpp
@@ -3,21 +3,78 @@
 // Translation Unit: d_a_magma.cpp
 //
 
-#include "d_a_magma.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "f_op/f_op_actor_mng.h"
+#include "d/d_procname.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_magma.h"
 #include "dolphin/types.h"
 
+
+class daMagma_c : public fopAc_ac_c {
+public:
+    ~daMagma_c() {
+        dComIfG_resDelete(&mPhs, "Magma");
+    }
+
+    request_of_phase_process_class mPhs;
+};
+
 /* 00000078-00000080       .text daMagma_IsDelete__FP9daMagma_c */
-void daMagma_IsDelete(daMagma_c*) {
-    /* Nonmatching */
+BOOL daMagma_IsDelete(daMagma_c* i_this) {
+    return TRUE;
 }
 
 /* 00000080-000000CC       .text daMagma_Delete__FP9daMagma_c */
-void daMagma_Delete(daMagma_c*) {
-    /* Nonmatching */
+BOOL daMagma_Delete(daMagma_c* i_this) {
+    i_this->~daMagma_c();
+    return TRUE;
 }
 
 /* 000000CC-00000178       .text daMagma_Create__FP10fopAc_ac_c */
-void daMagma_Create(fopAc_ac_c*) {
-    /* Nonmatching */
+s32 daMagma_Create(fopAc_ac_c* i_this) {
+    daMagma_c* magma = static_cast<daMagma_c*>(i_this);
+
+    fopAcM_SetupActor(magma, daMagma_c);
+
+    int result = dComIfG_resLoad(&magma->mPhs, "Magma");
+    if (result != cPhs_COMPLEATE_e) {
+        return result;
+    }
+
+    if (g_dComIfG_gameInfo.play.createMagma()) {
+        g_dComIfG_gameInfo.play.mpMagmaPacket->newFloor(
+            magma->current.pos,
+            magma->mScale,
+            magma->getRoomNo(),
+            magma->mBase.mParameters
+        );
+    }
+
+    return cPhs_ERROR_e;
 }
 
+static actor_method_class l_daMagma_Method = {
+    (process_method_func)daMagma_Create,
+    (process_method_func)daMagma_Delete,
+    (process_method_func)0,
+    (process_method_func)daMagma_IsDelete,
+    (process_method_func)0,
+};
+
+extern actor_process_profile_definition g_profile_MAGMA = {
+    fpcLy_CURRENT_e,
+    7,
+    fpcPi_CURRENT_e,
+    PROC_MAGMA,
+    &g_fpcLf_Method.mBase,
+    sizeof(daMagma_c),
+    0,
+    0,
+    &g_fopAc_Method.base,
+    0x01BC,
+    &l_daMagma_Method,
+    0x00040180,
+    fopAc_ACTOR_e,
+    fopAc_CULLBOX_0_e
+};
diff --git a/src/d/actor/d_a_swc00.cpp b/src/d/actor/d_a_swc00.cpp
index 992ff3a6d..0bbc99bf1 100644
--- a/src/d/actor/d_a_swc00.cpp
+++ b/src/d/actor/d_a_swc00.cpp
@@ -3,26 +3,91 @@
 // Translation Unit: d_a_swc00.cpp
 //
 
-#include "d_a_swc00.h"
-#include "dolphin/types.h"
+#include "f_op/f_op_actor_mng.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "d/d_procname.h"
+#include "d/d_com_inf_game.h"
 
-/* 00000078-00000180       .text daSwc00_Execute__FP11swc00_class */
-void daSwc00_Execute(swc00_class*) {
-    /* Nonmatching */
+struct swc00_class : public fopAc_ac_c {};
+
+static inline s32 getSwBit(u32 param) {
+    return param & 0xFF;
 }
 
-/* 00000180-00000188       .text daSwc00_IsDelete__FP11swc00_class */
-void daSwc00_IsDelete(swc00_class*) {
+static s32 daSwc00_Execute(swc00_class* i_this) {
     /* Nonmatching */
+    s32 enable_sw = fopAcM_GetParam(i_this) >> 8 & 0xFF;
+    if(enable_sw == 0xFF || dComIfGs_isSwitch(enable_sw, i_this->current.roomNo)) {
+        u8 swBit = fopAcM_GetParam(i_this) & 0xFF;
+
+        f32 xz_dist = fopAcM_searchPlayerDistanceXZ2(i_this);
+        f32 y_diff = dComIfGp_getPlayer(0)->current.pos.y - i_this->current.pos.y;
+        if(xz_dist < i_this->mScale.x && (-100.0f < y_diff && y_diff < i_this->mScale.y)) {
+            dComIfGs_onSwitch(swBit, i_this->current.roomNo);
+
+            if((fopAcM_GetParam(i_this) >> 0x10 & 3) != 0) {
+                fopAcM_delete(i_this);
+            }
+        }
+        else if((fopAcM_GetParam(i_this) >> 0x10 & 3) == 0) {
+            dComIfGs_offSwitch(swBit, i_this->current.roomNo);
+        }
+    }
+
+    return 1;
 }
 
-/* 00000188-00000190       .text daSwc00_Delete__FP11swc00_class */
-void daSwc00_Delete(swc00_class*) {
-    /* Nonmatching */
+static s32 daSwc00_IsDelete(swc00_class* i_this) {
+    return 1;
 }
 
-/* 00000190-00000274       .text daSwc00_Create__FP10fopAc_ac_c */
-void daSwc00_Create(fopAc_ac_c*) {
-    /* Nonmatching */
+static s32 daSwc00_Delete(swc00_class* i_this) {
+    return 1;
 }
 
+static s32 daSwc00_Create(fopAc_ac_c* i_this) {
+    fopAcM_SetupActor(i_this, swc00_class);
+
+    if(dComIfGs_isSwitch(fopAcM_GetParam(i_this) & 0xFF, i_this->current.roomNo)) {
+        if((fopAcM_GetParam(i_this) >> 0x10 & 0x3) == 0) {
+            u32 swBit = getSwBit(fopAcM_GetParam(i_this));
+            dComIfGs_offSwitch(swBit, i_this->current.roomNo);
+        }
+        else {
+            return cPhs_ERROR_e;
+        }
+    }
+
+    i_this->mScale.x *= 100.0f;
+    i_this->mScale.x += 30.0f;
+    i_this->mScale.x *= i_this->mScale.x;
+    i_this->mScale.y *= 100.0f;
+
+    return cPhs_COMPLEATE_e;
+}
+
+
+static actor_method_class l_daSwc00_Method = {
+    (process_method_func)daSwc00_Create,
+    (process_method_func)daSwc00_Delete,
+    (process_method_func)daSwc00_Execute,
+    (process_method_func)daSwc00_IsDelete,
+    (process_method_func)0,
+};
+
+extern actor_process_profile_definition g_profile_SWC00 = {
+    fpcLy_CURRENT_e,
+    7,
+    fpcPi_CURRENT_e,
+    PROC_SWC00,
+    &g_fpcLf_Method.mBase,
+    sizeof(swc00_class),
+    0,
+    0,
+    &g_fopAc_Method.base,
+    0x011A,
+    &l_daSwc00_Method,
+    0x00040000,
+    fopAc_ACTOR_e,
+    fopAc_CULLBOX_0_e,
+};
diff --git a/src/d/actor/d_a_tag_ret.cpp b/src/d/actor/d_a_tag_ret.cpp
index 3c0234003..8817fb7f2 100644
--- a/src/d/actor/d_a_tag_ret.cpp
+++ b/src/d/actor/d_a_tag_ret.cpp
@@ -93,7 +93,7 @@ namespace daTagRet {
         mCyl.SetC(current.pos);
         mCyl.SetR(1000.0f*mScale.x);
         mCyl.SetH(100.0f*mScale.y);
-        g_dComIfG_gameInfo.play.mCcS.Set(&mCyl);
+        dComIfG_Ccsp()->Set(&mCyl);
         
         if (mCyl.ChkCoHit()) {
             u32 playerId = daObj::PrmAbstract(this, PRM_PLAYER_ID_W, PRM_PLAYER_ID_S);
diff --git a/src/d/d_bg_s_movebg_actor.cpp b/src/d/d_bg_s_movebg_actor.cpp
index 1a8e98ce9..b745e0710 100644
--- a/src/d/d_bg_s_movebg_actor.cpp
+++ b/src/d/d_bg_s_movebg_actor.cpp
@@ -3,76 +3,102 @@
 // Translation Unit: d_bg_s_movebg_actor.cpp
 //
 
-#include "d_bg_s_movebg_actor.h"
-#include "dolphin/types.h"
+#include "d/d_bg_s_movebg_actor.h"
+#include "d/d_bg_w.h"
+#include "d/d_com_inf_game.h"
+#include "m_Do/m_Do_mtx.h"
 
 /* 800A56B8-800A56FC       .text __ct__16dBgS_MoveBgActorFv */
 dBgS_MoveBgActor::dBgS_MoveBgActor() {
-    /* Nonmatching */
+    mpBgW = NULL;
 }
 
 /* 800A56FC-800A571C       .text CheckCreateHeap__FP10fopAc_ac_c */
-void CheckCreateHeap(fopAc_ac_c*) {
-    /* Nonmatching */
+static int CheckCreateHeap(fopAc_ac_c* i_actor) {
+    return static_cast<dBgS_MoveBgActor*>(i_actor)->MoveBGCreateHeap();
 }
 
+const char* dBgS_MoveBgActor::m_name;
+
+int dBgS_MoveBgActor::m_dzb_id;
+
+MoveBGActor_SetFunc dBgS_MoveBgActor::m_set_func;
+
 /* 800A571C-800A57F4       .text MoveBGCreateHeap__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::MoveBGCreateHeap() {
-    /* Nonmatching */
+int dBgS_MoveBgActor::MoveBGCreateHeap() {
+    if (!CreateHeap()) {
+        return 0;
+    }
+
+    mpBgW = new dBgW();
+    if (mpBgW != NULL) {
+        cBgD_t* res = (cBgD_t*)dComIfG_getObjectRes(m_name, m_dzb_id);
+        if (!mpBgW->Set(res, cBgW::MOVE_BG_e, &mBgMtx)) {
+            if (m_set_func != NULL) {
+                mpBgW->SetCrrFunc(m_set_func);
+            }
+        } else {
+            goto RET;  // probably fake match, clean up later
+        }
+    } else {
+    RET:
+        mpBgW = NULL;
+        return 0;
+    }
+
+    return 1;
 }
 
-/* 800A57F4-800A58F4       .text MoveBGCreate__16dBgS_MoveBgActorFPCciPFP4dBgWPvR13cBgS_PolyInfobP4cXyzP5csXyzP5csXyz_vUl */
-void dBgS_MoveBgActor::MoveBGCreate(const char*, int, void (*)(dBgW*, void*, cBgS_PolyInfo&, bool, cXyz*, csXyz*, csXyz*), unsigned long) {
-    /* Nonmatching */
+/* 800A57F4-800A58F4       .text
+ * MoveBGCreate__16dBgS_MoveBgActorFPCciPFP4dBgWPvR13cBgS_PolyInfobP4cXyzP5csXyzP5csXyz_vUl */
+int dBgS_MoveBgActor::MoveBGCreate(const char* i_arcName, int i_dzb_id,
+                                   MoveBGActor_SetFunc i_setFunc, u32 i_heapSize) {
+    mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
+    mDoMtx_stack_c::YrotM(shape_angle.y);
+    mDoMtx_stack_c::scaleM(mScale.x, mScale.y, mScale.z);
+    MTXCopy(mDoMtx_stack_c::get(), mBgMtx);
+
+    m_name = i_arcName;
+    m_dzb_id = i_dzb_id;
+    m_set_func = i_setFunc;
+
+    if (!fopAcM_entrySolidHeap(this, CheckCreateHeap, i_heapSize)) {
+        return cPhs_ERROR_e;
+    }
+
+    if (dComIfG_Bgsp()->Regist(mpBgW, this)) {
+        return cPhs_ERROR_e;
+    }
+
+    // return Create() ? cPhs_COMPLEATE_e : cPhs_ERROR_e;  // using enums here changes code gen
+    return Create() ? 4 : 5;
 }
 
 /* 800A58F4-800A5980       .text MoveBGDelete__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::MoveBGDelete() {
-    /* Nonmatching */
+int dBgS_MoveBgActor::MoveBGDelete() {
+    int ret = Delete();
+
+    if (mpBgW != NULL && mpBgW->ChkUsed()) {
+        dComIfG_Bgsp()->Release(mpBgW);
+    }
+    return ret;
 }
 
 /* 800A5980-800A5A3C       .text MoveBGExecute__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::MoveBGExecute() {
-    /* Nonmatching */
-}
+int dBgS_MoveBgActor::MoveBGExecute() {
+    Mtx* new_mtx = NULL;
 
-/* 800A5A3C-800A5A44       .text CreateHeap__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::CreateHeap() {
-    /* Nonmatching */
-}
+    int ret = Execute(&new_mtx);
+    if (new_mtx == NULL) {
+        mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
+        mDoMtx_stack_c::YrotM(shape_angle.y);
+        mDoMtx_stack_c::scaleM(mScale.x, mScale.y, mScale.z);
+        MTXCopy(mDoMtx_stack_c::get(), mBgMtx);
+    } else {
+        MTXCopy(*new_mtx, mBgMtx);
+    }
 
-/* 800A5A44-800A5A4C       .text Create__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::Create() {
-    /* Nonmatching */
-}
+    mpBgW->Move();
 
-/* 800A5A4C-800A5A54       .text Delete__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::Delete() {
-    /* Nonmatching */
+    return ret;
 }
-
-/* 800A5A54-800A5A5C       .text Execute__16dBgS_MoveBgActorFPPA3_A4_f */
-void dBgS_MoveBgActor::Execute(float(**)[3][4]) {
-    /* Nonmatching */
-}
-
-/* 800A5A5C-800A5A64       .text Draw__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::Draw() {
-    /* Nonmatching */
-}
-
-/* 800A5A64-800A5A6C       .text IsDelete__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::IsDelete() {
-    /* Nonmatching */
-}
-
-/* 800A5A6C-800A5A74       .text ToFore__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::ToFore() {
-    /* Nonmatching */
-}
-
-/* 800A5A74-800A5A7C       .text ToBack__16dBgS_MoveBgActorFv */
-void dBgS_MoveBgActor::ToBack() {
-    /* Nonmatching */
-}
-
diff --git a/src/d/d_item.cpp b/src/d/d_item.cpp
index 152bd200a..ef7a27e6e 100644
--- a/src/d/d_item.cpp
+++ b/src/d/d_item.cpp
@@ -7,12 +7,12 @@
 #include "dolphin/types.h"
 
 /* 800C2DFC-800C2E30       .text execItemGet__FUc */
-void execItemGet(unsigned char) {
+void execItemGet(u8 itemNo) {
     /* Nonmatching */
 }
 
 /* 800C2E30-800C2E7C       .text checkItemGet__FUci */
-void checkItemGet(unsigned char, int) {
+BOOL checkItemGet(u8, BOOL defaultVal) {
     /* Nonmatching */
 }
 
diff --git a/src/d/d_item_data.cpp b/src/d/d_item_data.cpp
index d8a9b5c9e..63d1b6353 100644
--- a/src/d/d_item_data.cpp
+++ b/src/d/d_item_data.cpp
@@ -7,22 +7,22 @@
 #include "dolphin/types.h"
 
 /* 800C12F4-800C1334       .text checkAppearEffect__10dItem_dataFUc */
-void dItem_data::checkAppearEffect(unsigned char) {
+bool dItem_data::checkAppearEffect(u8 itemNo) {
     /* Nonmatching */
 }
 
 /* 800C1334-800C13B4       .text getAppearEffect__10dItem_dataFUc */
-void dItem_data::getAppearEffect(unsigned char) {
+s16 dItem_data::getAppearEffect(u8 itemNo) {
     /* Nonmatching */
 }
 
 /* 800C13B4-800C13F8       .text checkSpecialEffect__10dItem_dataFUc */
-void dItem_data::checkSpecialEffect(unsigned char) {
+bool dItem_data::checkSpecialEffect(u8 itemNo) {
     /* Nonmatching */
 }
 
 /* 800C13F8-800C1474       .text getSpecialEffect__10dItem_dataFUc */
-void dItem_data::getSpecialEffect(unsigned char) {
+u16 dItem_data::getSpecialEffect(u8 itemNo) {
     /* Nonmatching */
 }
 
diff --git a/src/f_op/f_op_kankyo_mng.cpp b/src/f_op/f_op_kankyo_mng.cpp
index 1ef8dc9d8..c91869174 100644
--- a/src/f_op/f_op_kankyo_mng.cpp
+++ b/src/f_op/f_op_kankyo_mng.cpp
@@ -48,7 +48,7 @@ void fopKyM_Delete(void* i_process) {
 }
 
 /* 8002A988-8002A9D8       .text fopKyM_Create__FsPFPv_iPv */
-static int fopKyM_Create(s16 i_procName, fopKyM_CreateFunc i_createFunc, void* i_process) {
+int fopKyM_Create(s16 i_procName, fopKyM_CreateFunc i_createFunc, void* i_process) {
     return fpcM_Create(i_procName, i_createFunc, i_process);
 }