diff --git a/decompiler/analysis/mips2c.cpp b/decompiler/analysis/mips2c.cpp
index d83469d5b2..77eff6f4b6 100644
--- a/decompiler/analysis/mips2c.cpp
+++ b/decompiler/analysis/mips2c.cpp
@@ -1076,6 +1076,7 @@ Mips2C_Line handle_normal_instr(Mips2C_Output& output,
     case InstructionKind::PMULTH:
     case InstructionKind::PMADDH:
     case InstructionKind::PADDH:
+    case InstructionKind::PSUBH:
     case InstructionKind::PMINH:
     case InstructionKind::MOVZ:
     case InstructionKind::MULT3:
diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc
index 23bfcdea1f..4463618329 100644
--- a/decompiler/config/jak2/all-types.gc
+++ b/decompiler/config/jak2/all-types.gc
@@ -3919,6 +3919,14 @@
   :flag-assert #x900000008
   )
 
+;; hack - added for warp.
+(deftype gs-uv2 (uint64)
+  ((u  int16 :offset 0  :size 16) ;; Q4 fixed point
+   (v  int16 :offset 16 :size 16) ;; Q4 fixed point
+   )
+  :flag-assert #x900000008
+  )
+
 ;; the GS's ST register sets the S and T values of the vertex texture coordinates.
 ;; The value Q is specified by the RGBAQ register.
 (deftype gs-st (uint64)
@@ -4999,7 +5007,8 @@
 
 (declare-type adgif-shader structure)
 (deftype shader-ptr (uint32)
-  ((shader uint32 :offset 8 :size 24))
+  ((first-8 uint8 :offset 0 :size 8) ;; added
+   (shader uint32 :offset 8 :size 24))
   :method-count-assert 9
   :size-assert         #x4
   :flag-assert         #x900000004
@@ -11803,12 +11812,12 @@
   :type uint8
   :bitfield #t
   (texscroll 0)
-  (no-fade-out 1)
+  (no-fade-out 1) ;; translucent.
   (ripple 2)
   (emerc 3) ;; envmap??
   (ignore-tod-for-envmap-tint 4) ;; color thing
   (force-mercneric 5) ;; some mercneric-only effect
-  (cross-fade 6)
+  (cross-fade 6) ;; WARP?
   (ignore-alpha 7)
   )
 
@@ -11922,7 +11931,7 @@
    (use-isometric          uint8                        :offset 41)
    (use-attached-shader    uint8                        :offset 42)
    (display-triangles      uint8                        :offset 43)
-   (death-vertex-skip      uint16                       :offset 44)
+   (death-vertex-skip      uint16                       :offset 44) ;; 172
    (death-start-vertex     uint16                       :offset 46)
    (death-effect           uint32                       :offset 48)
    (use-translucent        uint8                        :offset 52)
@@ -24445,8 +24454,8 @@
 (define-extern foreground-wrapup (function none))
 (define-extern *default-shadow-settings* shadow-settings)
 (define-extern foreground-shadow (function draw-control (inline-array pris-mtx) pointer pointer))
-(define-extern foreground-generic-merc-death (function object object none))
-(define-extern foreground-generic-merc-add-fragments (function object object object none))
+(define-extern foreground-generic-merc-death (function draw-control generic-merc-ctrl none))
+(define-extern foreground-generic-merc-add-fragments (function merc-effect pointer mercneric-chain pointer))
 (define-extern foreground-generic-merc (function draw-control pointer int pointer))
 (define-extern foreground-merc (function draw-control (inline-array pris-mtx) pointer int int object pointer))
 (define-extern foreground-emerc (function draw-control (inline-array pris-mtx) pointer object int int pointer))
@@ -24460,7 +24469,7 @@
 ;; generic-vu0                    ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern generic-vu0-block object) ;; vu-function
+(define-extern generic-vu0-block vu-function)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; generic-vu1                    ;;
@@ -24480,14 +24489,14 @@
 ;; generic-effect                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *target-lock* object) ;; symbol
+(define-extern *target-lock* object) ;; symbol
 (define-extern *generic-consts* generic-consts)
-;; (define-extern generic-work-init function) ;; (function generic-dma-foreground-sink none)
-;; (define-extern generic-upload-vu0 function) ;; (function none)
+(define-extern generic-work-init (function generic-bucket-state none))
+(define-extern generic-upload-vu0 (function none))
 (define-extern upload-vu0-program (function vu-function pointer none))
-;; (define-extern generic-initialize-without-sync function)
-;; (define-extern generic-initialize function) ;; (function generic-dma-foreground-sink matrix vu-lights none)
-;; (define-extern generic-wrapup function) ;; (function generic-dma-foreground-sink none)
+(define-extern generic-initialize-without-sync (function matrix vu-lights none))
+(define-extern generic-initialize (function generic-bucket-state matrix vu-lights none))
+(define-extern generic-wrapup (function generic-bucket-state none))
 ;; (define-extern generic-dma-from-spr function) ;; function
 ;; (define-extern generic-light-proc function) ;; function
 ;; (define-extern generic-envmap-proc function) ;; function
@@ -24505,9 +24514,9 @@
 ;; (define-extern generic-copy-vtx-dclr-dtex function) ;; function
 ;; (define-extern generic-none function) ;; function
 ;; (define-extern generic-none-dma-wait function) ;; function
-;; (define-extern *warp-data* object)
-;; (define-extern generic-warp-source-proc function)
-;; (define-extern generic-warp-source function)
+(define-extern *warp-data* object)
+(define-extern generic-warp-source-proc (function none))
+(define-extern generic-warp-source (function gsf-buffer none))
 ;; (define-extern generic-warp-dest-proc function)
 ;; (define-extern generic-warp-dest function)
 ;; (define-extern generic-warp-envmap-dest function)
@@ -24518,31 +24527,30 @@
 ;; generic-merc                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype invinitdata (structure)
   ((count     uint8   :offset-assert 0)
    (init-data uint8   :offset-assert 1)
    (init-addr uint16  :offset-assert 2)
    )
+  :pack-me
   :method-count-assert 9
   :size-assert         #x4
   :flag-assert         #x900000004
   )
-|#
 
-;; (define-extern mercneric-vu0-block object) ;; vu-function
-;; (define-extern *inv-init-table* object) ;; (inline-array invinitdata)
-;; (define-extern generic-merc-init-asm function) ;; (function none)
+(define-extern mercneric-vu0-block vu-function)
+(define-extern *inv-init-table* (inline-array invinitdata))
+(define-extern generic-merc-init-asm (function none))
 ;; (define-extern mercneric-matrix-asm function) ;; function
 ;; (define-extern mercneric-shader-asm function) ;; function
 ;; (define-extern mercneric-bittable-asm function) ;; function
 ;; (define-extern mercneric-convert function) ;; function
 ;; (define-extern high-speed-reject function) ;; (function none)
-;; (define-extern generic-translucent function)
+(define-extern generic-translucent (function gsf-buffer none))
 ;; (define-extern generic-merc-query function)
 ;; (define-extern generic-merc-death function)
 ;; (define-extern generic-merc-execute-asm function) ;; (function none)
-;; (define-extern generic-merc-do-chain function)
+(define-extern generic-merc-do-chain (function mercneric-chain dma-buffer pointer))
 (define-extern generic-merc-execute-all (function dma-buffer none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/decompiler/config/jak2/ntsc_v1/hacks.jsonc b/decompiler/config/jak2/ntsc_v1/hacks.jsonc
index c8001e287d..c506a63b2e 100644
--- a/decompiler/config/jak2/ntsc_v1/hacks.jsonc
+++ b/decompiler/config/jak2/ntsc_v1/hacks.jsonc
@@ -526,7 +526,8 @@
     "(anon-function 39 kidesc-states)": [4, 5],
     "(anon-function 56 hal2-course)": [4, 5],
     "(anon-function 58 hal2-course)": [74],
-    "(method 142 gun-buoy)": [0, 2]
+    "(method 142 gun-buoy)": [0, 2],
+    "generic-merc-execute-all": [7, 15]
   },
 
   // Sometimes the game might use format strings that are fetched dynamically,
@@ -721,7 +722,26 @@
     "(method 53 squid)",
     "init-vortex-regs",
     "render-vortex-quad",
-    "draw-large-polygon-vortex"
+    "draw-large-polygon-vortex",
+    "foreground-generic-merc",
+    "generic-merc-init-asm",
+    "mercneric-convert",
+    "high-speed-reject",
+    "generic-translucent",
+    "generic-merc-query",
+    "generic-merc-death",
+    "generic-merc-execute-asm",
+    "generic-merc-do-chain",
+    "generic-light-proc",
+    "generic-envmap-proc",
+    "generic-prepare-dma-double",
+    "generic-prepare-dma-single",
+    "generic-warp-source-proc",
+    "generic-warp-dest-proc",
+    "generic-warp-dest",
+    "generic-warp-envmap-dest",
+    "generic-no-light-proc"
+
   ],
 
   "mips2c_jump_table_functions": {},
diff --git a/decompiler/config/jak2/ntsc_v1/label_types.jsonc b/decompiler/config/jak2/ntsc_v1/label_types.jsonc
index d6db52cdd9..a7779e4a1e 100644
--- a/decompiler/config/jak2/ntsc_v1/label_types.jsonc
+++ b/decompiler/config/jak2/ntsc_v1/label_types.jsonc
@@ -1903,5 +1903,6 @@
     ["L348", "vector"],
     ["L337", "vector"]
   ],
-  "bigmap": [["L127", "(pointer int64)", 16]]
+  "bigmap": [["L127", "(pointer int64)", 16]],
+  "generic-merc": [["L172", "(inline-array invinitdata)", 8]]
 }
diff --git a/decompiler/config/jak2/ntsc_v1/type_casts.jsonc b/decompiler/config/jak2/ntsc_v1/type_casts.jsonc
index e24a08a918..7c92d02b09 100644
--- a/decompiler/config/jak2/ntsc_v1/type_casts.jsonc
+++ b/decompiler/config/jak2/ntsc_v1/type_casts.jsonc
@@ -670,10 +670,64 @@
     [[324, 327], "v1", "dma-packet"]
   ],
   "fx-copy-buf": [
-    [[17, 22], "t3", "dma-packet"],
     [[2, 8], "a2", "dma-packet"],
-    [[122, 127], "t0", "dma-packet"],
-    [[24, 66], "t3", "dma-packet"]
+    [[17, 23], "t3", "gs-gif-tag"],
+    [27, "t3", "(pointer gs-reg)"],
+    [30, "t3", "(pointer gs-reg)"],
+    [32, "t3", "(pointer gs-frame)"],
+    [34, "t3", "(pointer gs-reg)"],
+    [36, "t3", "(pointer gs-zbuf)"],
+    [38, "t3", "(pointer gs-reg)"],
+    [40, "t3", "(pointer gs-test)"],
+    [42, "t3", "(pointer gs-reg)"],
+    [43, "t3", "(pointer gs-alpha)"],
+    [44, "t3", "(pointer gs-reg)"],
+    [46, "t3", "(pointer gs-prim)"],
+    [48, "t3", "(pointer gs-reg)"],
+    [50, "t3", "(pointer gs-rgbaq)"],
+    [52, "t3", "(pointer gs-reg)"],
+    [54, "t3", "(pointer gs-tex0)"],
+    [56, "t3", "(pointer gs-reg)"],
+    [57, "t3", "(pointer gs-tex1)"],
+    [59, "t3", "(pointer gs-reg)"],
+    [60, "t3", "(pointer gs-miptbp)"],
+    [62, "t3", "(pointer gs-reg)"],
+    [64, "t3", "(pointer gs-clamp)"],
+    [[69, 78], "t4", "gs-gif-tag"], // uv, xyz2
+    [87, "t6", "(pointer gs-uv2)"],
+    [96, "t6", "(pointer gs-xyz)"],
+    [103, "t6", "(pointer gs-uv2)"],
+    [113, "t6", "(pointer gs-xyz)"],
+    [[122, 128], "t0", "gs-gif-tag"],
+    [132, "a3", "(pointer gs-reg)"], // 63, texflush
+    [135, "a3", "(pointer gs-reg)"], // 76, frame
+    [137, "a3", "(pointer gs-frame)"],
+    [139, "a3", "(pointer gs-reg)"], // 78, zbuf
+    [141, "a3", "(pointer gs-zbuf)"],
+    [143, "a3", "(pointer gs-reg)"], // 71, test
+    [145, "a3", "(pointer gs-test)"],
+    [147, "a3", "(pointer gs-reg)"], // 66, alpha
+    [148, "a3", "(pointer gs-alpha)"],
+    [150, "a3", "(pointer gs-reg)"], // 1, rgbaq
+    [152, "a3", "(pointer gs-rgbaq)"],
+    [154, "a3", "(pointer gs-reg)"], // 6, tex0
+    [156, "a3", "(pointer gs-tex0)"],
+    [158, "a3", "(pointer gs-reg)"], // 20, tex1
+    [160, "a3", "(pointer gs-tex1)"],
+    [162, "a3", "(pointer gs-reg)"], // 52, miptbp
+    [163, "a3", "(pointer gs-miptbp)"],
+    [165, "a3", "(pointer gs-reg)"], // 8, clamp
+    [174, "a3", "(pointer gs-clamp)"],
+    [[192, 199], "v1", "(pointer uint64)"]
+  ],
+  "foreground-generic-merc-add-fragments": [
+    [[5, 54], "a3", "merc-fragment-control"],
+    [[5, 57], "v1", "merc-fragment"],
+    [28, "t4", "foreground-work"],
+    [[16, 19], "a1", "dma-packet"],
+    [21, "t3", "(pointer int32)"],
+    [[38, 41], "a1", "dma-packet"],
+    [[49, 52], "a1", "dma-packet"]
   ],
   "(method 12 setting-control)": [[17, "s4", "connection"]],
   "(method 14 setting-control)": [[6, "v1", "connection"]],
@@ -9804,6 +9858,8 @@
     [[47, 57], "v1", "(pointer uint32)"]
   ],
   "generic-vu1-init-buf": [[[24, 32], "v1", "dma-packet"]],
+  "generic-vu1-init-buf-special": [[[27, 37], "v1", "dma-packet"]],
+
   "(method 11 drill-wall)": [
     [159, "v0", "(pointer actor-group)"],
     ["_stack_", 16, "res-tag"]
@@ -11207,5 +11263,39 @@
     [[12, 20], "a0", "vector4w"],
     [[20, 27], "a0", "vector4w"],
     [[29, 35], "v1", "vector4w"]
+  ],
+  "generic-merc-execute-all": [
+    [76, "v1", "generic-work"],
+    [78, "v1", "generic-work"],
+    [80, "v1", "generic-work"],
+    [95, "a0", "generic-work"],
+
+    [143, "v1", "generic-work"],
+    [145, "v1", "generic-work"],
+    [147, "v1", "generic-work"]
+  ],
+
+  "generic-work-init": [
+    [4, "a0", "generic-work"],
+    [[9, 19], "a0", "generic-work"],
+    [23, "a1", "generic-work"]
+  ],
+
+  "generic-initialize-without-sync": [
+    [8, "a0", "generic-work"],
+    [21, "a0", "generic-work"]
+  ],
+  "generic-initialize": [
+    [8, "a0", "generic-work"],
+    [21, "a0", "generic-work"]
+  ],
+  "generic-wrapup": [
+    [1, "v1", "generic-work"],
+    [4, "v1", "generic-work"]
+  ],
+  "generic-warp-source": [
+    [2, "at", "generic-work"]
   ]
+
+
 }
diff --git a/decompiler/level_extractor/MercData.h b/decompiler/level_extractor/MercData.h
index 5597ffff09..d004347e4a 100644
--- a/decompiler/level_extractor/MercData.h
+++ b/decompiler/level_extractor/MercData.h
@@ -181,8 +181,8 @@ struct MercExtraInfo {
 };
 
 constexpr int kTextureScrollEffectBit = 1;
-constexpr int kTransEffectBitJak1 = 2;  // so far only confirmed for jak 1
-constexpr int kRippleEffectBit = 4;     // true in jak 1 and jak 2
+constexpr int kTransEffectBit = 2;   // true in 1 and 2
+constexpr int kRippleEffectBit = 4;  // true in jak 1 and jak 2
 
 struct MercEffect {
   //((frag-geo         merc-fragment          :offset-assert 0) ;; ?
diff --git a/decompiler/level_extractor/extract_merc.cpp b/decompiler/level_extractor/extract_merc.cpp
index ee0f69c437..5c3bf854b2 100644
--- a/decompiler/level_extractor/extract_merc.cpp
+++ b/decompiler/level_extractor/extract_merc.cpp
@@ -885,7 +885,7 @@ ConvertedMercEffect convert_merc_effect(const MercEffect& input_effect,
       can_be_modified = true;
     }
 
-    if (version == GameVersion::Jak1 && (input_effect.effect_bits & kTransEffectBitJak1)) {
+    if (input_effect.effect_bits & kTransEffectBit) {
       use_alpha_blend = true;
     }
 
diff --git a/game/CMakeLists.txt b/game/CMakeLists.txt
index d9e3e33b0a..4e8833498e 100644
--- a/game/CMakeLists.txt
+++ b/game/CMakeLists.txt
@@ -91,6 +91,8 @@ set(RUNTIME_SOURCE
         mips2c/jak2_functions/debug.cpp
         mips2c/jak2_functions/font.cpp
         mips2c/jak2_functions/foreground.cpp
+        mips2c/jak2_functions/generic_merc.cpp
+        mips2c/jak2_functions/generic_effect.cpp
         mips2c/jak2_functions/joint.cpp
         mips2c/jak2_functions/lights.cpp
         mips2c/jak2_functions/nav_control.cpp
@@ -151,6 +153,7 @@ set(RUNTIME_SOURCE
         graphics/opengl_renderer/BucketRenderer.cpp
         graphics/opengl_renderer/CollideMeshRenderer.cpp
         graphics/opengl_renderer/debug_gui.cpp
+        graphics/opengl_renderer/DepthCue.cpp
         graphics/opengl_renderer/DirectRenderer.cpp
         graphics/opengl_renderer/DirectRenderer2.cpp
         graphics/opengl_renderer/EyeRenderer.cpp
@@ -168,7 +171,7 @@ set(RUNTIME_SOURCE
         graphics/opengl_renderer/SkyRenderer.cpp
         graphics/opengl_renderer/TextureUploadHandler.cpp
         graphics/opengl_renderer/VisDataHandler.cpp
-        graphics/opengl_renderer/DepthCue.cpp
+        graphics/opengl_renderer/Warp.cpp
         graphics/texture/jak1_tpage_dir.cpp
         graphics/texture/jak2_tpage_dir.cpp
         graphics/texture/TextureConverter.cpp
diff --git a/game/graphics/opengl_renderer/OpenGLRenderer.cpp b/game/graphics/opengl_renderer/OpenGLRenderer.cpp
index b4bc6513e3..f9d3d9e2bd 100644
--- a/game/graphics/opengl_renderer/OpenGLRenderer.cpp
+++ b/game/graphics/opengl_renderer/OpenGLRenderer.cpp
@@ -13,6 +13,7 @@
 #include "game/graphics/opengl_renderer/SkyRenderer.h"
 #include "game/graphics/opengl_renderer/TextureUploadHandler.h"
 #include "game/graphics/opengl_renderer/VisDataHandler.h"
+#include "game/graphics/opengl_renderer/Warp.h"
 #include "game/graphics/opengl_renderer/background/Shrub.h"
 #include "game/graphics/opengl_renderer/background/TFragment.h"
 #include "game/graphics/opengl_renderer/background/Tie3.h"
@@ -154,6 +155,9 @@ void OpenGLRenderer::init_bucket_renderers_jak2() {
     init_bucket_renderer<Merc2>(
         fmt::format("merc-l{}-pris", i), BucketCategory::MERC,
         GET_BUCKET_ID_FOR_LIST(BucketId::MERC_L0_PRIS, BucketId::MERC_L1_PRIS, i));
+    init_bucket_renderer<Generic2>(
+        fmt::format("gmerc-l{}-pris", i), BucketCategory::GENERIC,
+        GET_BUCKET_ID_FOR_LIST(BucketId::GMERC_L0_PRIS, BucketId::GMERC_L1_PRIS, i));
 
     init_bucket_renderer<TextureUploadHandler>(
         fmt::format("tex-l{}-pris2", i), BucketCategory::TEX,
@@ -207,6 +211,7 @@ void OpenGLRenderer::init_bucket_renderers_jak2() {
   init_bucket_renderer<LightningRenderer>("effects", BucketCategory::OTHER, BucketId::EFFECTS);
   init_bucket_renderer<TextureUploadHandler>("tex-all-warp", BucketCategory::TEX,
                                              BucketId::TEX_ALL_WARP);
+  init_bucket_renderer<Warp>("warp", BucketCategory::GENERIC, BucketId::GMERC_WARP);
   init_bucket_renderer<DirectRenderer>("debug-no-zbuf1", BucketCategory::OTHER,
                                        BucketId::DEBUG_NO_ZBUF1, 0x8000);
   init_bucket_renderer<TextureUploadHandler>("tex-all-map", BucketCategory::TEX,
diff --git a/game/graphics/opengl_renderer/Warp.cpp b/game/graphics/opengl_renderer/Warp.cpp
new file mode 100644
index 0000000000..a996a4e842
--- /dev/null
+++ b/game/graphics/opengl_renderer/Warp.cpp
@@ -0,0 +1,35 @@
+#include "Warp.h"
+
+Warp::Warp(const std::string& name, int id) : BucketRenderer(name, id), m_generic(name, id) {}
+
+Warp::~Warp() {}
+
+void Warp::draw_debug_window() {
+  m_generic.draw_debug_window();
+}
+
+void Warp::render(DmaFollower& dma, SharedRenderState* render_state, ScopedProfilerNode& prof) {
+  m_fb_copier.copy_now(render_state->render_fb_w, render_state->render_fb_h,
+                       render_state->render_fb_x, render_state->render_fb_y,
+                       render_state->render_fb);
+  render_state->texture_pool->move_existing_to_vram(m_warp_src_tex, m_tbp);
+  m_generic.render_in_mode(dma, render_state, prof, Generic2::Mode::NORMAL);
+}
+
+void Warp::init_shaders(ShaderLibrary& shaders) {
+  m_generic.init_shaders(shaders);
+}
+
+void Warp::init_textures(TexturePool& tex_pool, GameVersion version) {
+  TextureInput in;
+  // point to fb copier's texture.
+  in.gpu_texture = m_fb_copier.texture();
+  in.w = 32;
+  in.h = 32;
+  in.debug_page_name = "PC-WARP";
+  in.debug_name = "PC-WARP";
+  in.id = tex_pool.allocate_pc_port_texture(version);
+  m_warp_src_tex = tex_pool.give_texture_and_load_to_vram(in, m_tbp);
+
+  m_generic.init_textures(tex_pool, version);
+}
\ No newline at end of file
diff --git a/game/graphics/opengl_renderer/Warp.h b/game/graphics/opengl_renderer/Warp.h
new file mode 100644
index 0000000000..c9287e70fa
--- /dev/null
+++ b/game/graphics/opengl_renderer/Warp.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "game/graphics/opengl_renderer/BucketRenderer.h"
+#include "game/graphics/opengl_renderer/Warp.h"
+#include "game/graphics/opengl_renderer/foreground/Generic2.h"
+#include "game/graphics/opengl_renderer/opengl_utils.h"
+
+class Warp : public BucketRenderer {
+ public:
+  Warp(const std::string& name, int id);
+  ~Warp();
+  void render(DmaFollower& dma, SharedRenderState* render_state, ScopedProfilerNode& prof) override;
+  void draw_debug_window() override;
+  void init_shaders(ShaderLibrary& shaders) override;
+  void init_textures(TexturePool& tex_pool, GameVersion version) override;
+
+ private:
+  Generic2 m_generic;
+  FramebufferCopier m_fb_copier;
+  GpuTexture* m_warp_src_tex = nullptr;
+  u32 m_tbp = 1216;  // hack, jak 2
+};
diff --git a/game/graphics/opengl_renderer/foreground/Generic2.cpp b/game/graphics/opengl_renderer/foreground/Generic2.cpp
index 7d6b1694e0..9a2bd156b3 100644
--- a/game/graphics/opengl_renderer/foreground/Generic2.cpp
+++ b/game/graphics/opengl_renderer/foreground/Generic2.cpp
@@ -80,7 +80,11 @@ void Generic2::render_in_mode(DmaFollower& dma,
     auto p = prof.make_scoped_child("dma");
     switch (mode) {
       case Mode::NORMAL:
-        process_dma(dma, render_state->next_bucket);
+        if (render_state->version == GameVersion::Jak1) {
+          process_dma_jak1(dma, render_state->next_bucket);
+        } else {
+          process_dma_jak2(dma, render_state->next_bucket);
+        }
         break;
       case Mode::LIGHTNING:
         process_dma_lightning(dma, render_state->next_bucket);
diff --git a/game/graphics/opengl_renderer/foreground/Generic2.h b/game/graphics/opengl_renderer/foreground/Generic2.h
index 8b30d0fbdf..67e7510707 100644
--- a/game/graphics/opengl_renderer/foreground/Generic2.h
+++ b/game/graphics/opengl_renderer/foreground/Generic2.h
@@ -13,10 +13,7 @@ class Generic2 : public BucketRenderer {
   ~Generic2();
   void render(DmaFollower& dma, SharedRenderState* render_state, ScopedProfilerNode& prof) override;
 
-  enum class Mode {
-    NORMAL,
-    LIGHTNING,
-  };
+  enum class Mode { NORMAL, LIGHTNING };
 
   void render_in_mode(DmaFollower& dma,
                       SharedRenderState* render_state,
@@ -45,8 +42,9 @@ class Generic2 : public BucketRenderer {
   void draws_to_buckets();
   void reset_buffers();
   void process_matrices();
-  void process_dma(DmaFollower& dma, u32 next_bucket);
+  void process_dma_jak1(DmaFollower& dma, u32 next_bucket);
   void process_dma_lightning(DmaFollower& dma, u32 next_bucket);
+  void process_dma_jak2(DmaFollower& dma, u32 next_bucket);
   void setup_draws(bool enable_at);
   void do_draws(SharedRenderState* render_state, ScopedProfilerNode& prof);
   void do_draws_for_alpha(SharedRenderState* render_state,
@@ -211,5 +209,6 @@ class Generic2 : public BucketRenderer {
     GLuint alpha_reject, color_mult, fog_color, scale, mat_23, mat_32, mat_33, fog_consts,
         hvdf_offset;
     GLuint gfx_hack_no_tex;
+    GLuint warp_sample_mode;
   } m_ogl;
 };
diff --git a/game/graphics/opengl_renderer/foreground/Generic2_DMA.cpp b/game/graphics/opengl_renderer/foreground/Generic2_DMA.cpp
index 1c5a3274e7..aa4cdb013d 100644
--- a/game/graphics/opengl_renderer/foreground/Generic2_DMA.cpp
+++ b/game/graphics/opengl_renderer/foreground/Generic2_DMA.cpp
@@ -312,7 +312,7 @@ u32 Generic2::handle_fragments_after_unpack_v4_32(const u8* data,
   return off;
 }
 
-void Generic2::process_dma(DmaFollower& dma, u32 next_bucket) {
+void Generic2::process_dma_jak1(DmaFollower& dma, u32 next_bucket) {
   reset_buffers();
 
   // handle the stuff at the beginning.
@@ -391,6 +391,137 @@ bool is_nop_zero(const DmaTransfer& xf) {
          xf.vifcode1().kind == VifCode::Kind::NOP;
 }
 
+bool is_jak2_end(const DmaTransfer& xf) {
+  return xf.size_bytes == 160 && xf.vifcode0().kind == VifCode::Kind::FLUSHA &&
+         xf.vifcode1().kind == VifCode::Kind::DIRECT;
+}
+
+void Generic2::process_dma_jak2(DmaFollower& dma, u32 next_bucket) {
+  reset_buffers();
+  auto first_data = dma.read_and_advance();
+
+  // handle the stuff at the beginning.
+  // if the engine didn't run the generic renderer setup function, this bucket will end here.
+  if (is_nop_zero(first_data) && next_bucket == dma.current_tag_offset()) {
+    return;
+  }
+
+  // next, the generic setup.  This reads the data generated by generic-init-buf.
+  auto v0k = first_data.vifcode0().kind;
+  ASSERT((v0k == VifCode::Kind::MARK || v0k == VifCode::Kind::NOP) &&
+         first_data.vifcode1().kind == VifCode::Kind::NOP);
+
+  // setup packet 1 is GS settings
+  auto direct_setup = dma.read_and_advance();
+  ASSERT(direct_setup.size_bytes == 32 && direct_setup.vifcode0().kind == VifCode::Kind::NOP &&
+         direct_setup.vifcode1().kind == VifCode::Kind::DIRECT);
+  u64 zbuf_val;
+  memcpy(&zbuf_val, direct_setup.data + 16, 8);
+  m_drawing_config.zmsk = GsZbuf(zbuf_val).zmsk();
+
+  auto constants = dma.read_and_advance();
+  ASSERT(constants.size_bytes == 128);
+  ASSERT(constants.vifcode0().kind == VifCode::Kind::STCYCL);
+  ASSERT(constants.vifcode1().kind == VifCode::Kind::UNPACK_V4_32);
+  memcpy(&m_drawing_config.pfog0, constants.data + 0, 4);
+  memcpy(&m_drawing_config.fog_min, constants.data + 4, 4);
+  memcpy(&m_drawing_config.fog_max, constants.data + 8, 4);
+  memcpy(m_drawing_config.hvdf_offset.data(), constants.data + 32, 16);
+
+  auto vu_setup = dma.read_and_advance();
+  ASSERT(vu_setup.size_bytes == 32);
+  // this sets offset/base to 0, sets row to 0 and runs program 0 to set up VU regs
+  // todo: any setup required from running this program.
+
+  // if there was nothing rendered by generic on this frame in this bucket, the bucket will end
+  // here.
+  if (is_nop_zero(first_data) && next_bucket == dma.current_tag_offset()) {
+    return;
+  }
+
+  //  0: NOP NOP
+
+  // loop over "fragments"
+  // each "fragment" consists of a series of uploads, followed by a MSCAL VIFCODE that runs
+  // VU program that does vertex transformation and sends to the GS.
+  Fragment* continued_fragment = nullptr;
+
+  auto vif_transfer = dma.read_and_advance();
+  while (is_nop_zero(vif_transfer)) {
+    vif_transfer = dma.read_and_advance();
+  }
+
+  while (!is_jak2_end(vif_transfer)) {
+    if (continued_fragment) {
+      ASSERT(vif_transfer.vifcode0().kind == VifCode::Kind::NOP);
+      auto up = vif_transfer.vifcode1();
+      ASSERT(up.kind == VifCode::Kind::UNPACK_V3_32);
+      ASSERT(vif_transfer.size_bytes * 4 / 48 == up.num);
+      ASSERT(up.num == continued_fragment->vtx_count);
+      unpack_vtx_positions(&m_verts[continued_fragment->vtx_idx], vif_transfer.data,
+                           continued_fragment->vtx_count);
+      continued_fragment = nullptr;
+      auto call = dma.read_and_advance();
+      ASSERT(call.size_bytes == 0);
+      ASSERT(call.vifcode1().kind == VifCode::Kind::MSCAL);
+
+      if (check_for_end_of_generic_data(dma, next_bucket)) {
+        return;
+      }
+
+    } else {
+      auto v1 = vif_transfer.vifcode1();
+      if (vif_transfer.vifcode0().kind != VifCode::Kind::STCYCL ||
+          vif_transfer.vifcode1().kind != VifCode::Kind::UNPACK_V4_32) {
+        fmt::print("failing tag: {} {} {}\n", vif_transfer.vifcode0().print(),
+                   vif_transfer.vifcode1().print(), vif_transfer.size_bytes);
+      }
+      ASSERT(vif_transfer.vifcode0().kind == VifCode::Kind::STCYCL);
+      ASSERT(v1.kind == VifCode::Kind::UNPACK_V4_32);
+      u32 unpack_bytes = v1.num * 16;
+      auto& frag = next_frag();
+      u32 off = handle_fragments_after_unpack_v4_32(vif_transfer.data, 0, unpack_bytes,
+                                                    vif_transfer.size_bytes, &frag, false);
+
+      if (check_for_end_of_generic_data(dma, next_bucket)) {
+        return;
+      }
+
+      if (off < vif_transfer.size_bytes) {
+        u32 stcycl_reset;
+        memcpy(&stcycl_reset, vif_transfer.data + off, 4);
+        ASSERT(VifCode(stcycl_reset).kind == VifCode::Kind::STCYCL);
+        off += 4;
+        //    while (off < vif_transfer.size_bytes) {
+        u32 next;
+        memcpy(&next, vif_transfer.data + off, 4);
+        VifCode next_unpack(next);
+
+        ASSERT(next_unpack.kind == VifCode::Kind::UNPACK_V4_32);
+
+        auto& continue_frag = next_frag();
+        off = handle_fragments_after_unpack_v4_32(vif_transfer.data, off, next_unpack.num * 16,
+                                                  vif_transfer.size_bytes, &continue_frag, true);
+        continued_fragment = &continue_frag;
+        ASSERT(off == vif_transfer.size_bytes);
+        //    }
+      }
+    }
+    vif_transfer = dma.read_and_advance();
+    while (is_nop_zero(vif_transfer)) {
+      vif_transfer = dma.read_and_advance();
+    }
+  }
+
+  // ending:
+  //  0: NOP NOP
+  //  160: FLUSHA DIRECT
+  //  0: NOP NOP
+  auto end = dma.read_and_advance();
+  (void)end;
+  ASSERT(next_bucket == dma.current_tag_offset());
+}
+
 void unpack_vertex(Generic2::Vertex* out, const u8* in, int count) {
   for (int i = 0; i < count; i++) {
     // st:
diff --git a/game/graphics/opengl_renderer/foreground/Generic2_OpenGL.cpp b/game/graphics/opengl_renderer/foreground/Generic2_OpenGL.cpp
index b1bf087422..9e89403922 100644
--- a/game/graphics/opengl_renderer/foreground/Generic2_OpenGL.cpp
+++ b/game/graphics/opengl_renderer/foreground/Generic2_OpenGL.cpp
@@ -80,6 +80,7 @@ void Generic2::init_shaders(ShaderLibrary& shaders) {
   m_ogl.fog_consts = glGetUniformLocation(id, "fog_constants");
   m_ogl.hvdf_offset = glGetUniformLocation(id, "hvdf_offset");
   m_ogl.gfx_hack_no_tex = glGetUniformLocation(id, "gfx_hack_no_tex");
+  m_ogl.warp_sample_mode = glGetUniformLocation(id, "warp_sample_mode");
 }
 
 void Generic2::opengl_bind_and_setup_proj(SharedRenderState* render_state) {
@@ -256,6 +257,12 @@ void Generic2::setup_opengl_tex(u16 unit,
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   }
+
+  if (render_state->version == GameVersion::Jak2 && tbp_to_lookup == 1216) {
+    glUniform1ui(m_ogl.warp_sample_mode, 1);
+  } else {
+    glUniform1ui(m_ogl.warp_sample_mode, 0);
+  }
 }
 
 void Generic2::do_draws_for_alpha(SharedRenderState* render_state,
diff --git a/game/graphics/opengl_renderer/opengl_utils.cpp b/game/graphics/opengl_renderer/opengl_utils.cpp
index e322a8cf88..8183bb7386 100644
--- a/game/graphics/opengl_renderer/opengl_utils.cpp
+++ b/game/graphics/opengl_renderer/opengl_utils.cpp
@@ -149,3 +149,65 @@ void FullScreenDraw::draw(const math::Vector4f& color,
   prof.add_draw_call();
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 }
+
+FramebufferCopier::FramebufferCopier() {
+  glGenFramebuffers(1, &m_fbo);
+  glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+
+  glGenTextures(1, &m_fbo_texture);
+  glBindTexture(GL_TEXTURE_2D, m_fbo_texture);
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_fbo_width, m_fbo_height, 0, GL_RGB, GL_UNSIGNED_BYTE,
+               NULL);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_fbo_texture, 0);
+
+  ASSERT(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
+
+  glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+FramebufferCopier::~FramebufferCopier() {
+  glDeleteTextures(1, &m_fbo_texture);
+  glDeleteFramebuffers(1, &m_fbo);
+}
+
+void FramebufferCopier::copy_now(int render_fb_w,
+                                 int render_fb_h,
+                                 int render_fb_x,
+                                 int render_fb_y,
+                                 GLuint render_fb) {
+  if (m_fbo_width != render_fb_w || m_fbo_height != render_fb_h) {
+    m_fbo_width = render_fb_w;
+    m_fbo_height = render_fb_h;
+
+    glBindTexture(GL_TEXTURE_2D, m_fbo_texture);
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_fbo_width, m_fbo_height, 0, GL_RGB, GL_UNSIGNED_BYTE,
+                 NULL);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+  }
+
+  glBindFramebuffer(GL_READ_FRAMEBUFFER, render_fb);
+  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo);
+
+  glBlitFramebuffer(render_fb_x,                // srcX0
+                    render_fb_y,                // srcY0
+                    render_fb_x + render_fb_w,  // srcX1
+                    render_fb_y + render_fb_h,  // srcY1
+                    0,                          // dstX0
+                    0,                          // dstY0
+                    m_fbo_width,                // dstX1
+                    m_fbo_height,               // dstY1
+                    GL_COLOR_BUFFER_BIT,        // mask
+                    GL_NEAREST                  // filter
+  );
+
+  glBindFramebuffer(GL_FRAMEBUFFER, render_fb);
+}
\ No newline at end of file
diff --git a/game/graphics/opengl_renderer/opengl_utils.h b/game/graphics/opengl_renderer/opengl_utils.h
index 2f0bcd9d5d..d5be2d8add 100644
--- a/game/graphics/opengl_renderer/opengl_utils.h
+++ b/game/graphics/opengl_renderer/opengl_utils.h
@@ -56,4 +56,22 @@ class FullScreenDraw {
  private:
   GLuint m_vao;
   GLuint m_vertex_buffer;
+};
+
+class FramebufferCopier {
+ public:
+  FramebufferCopier();
+  ~FramebufferCopier();
+  FramebufferCopier(const FramebufferCopier&) = delete;
+  FramebufferCopier& operator=(const FramebufferCopier&) = delete;
+  void copy_now(int render_fb_w,
+                int render_fb_h,
+                int render_fb_x,
+                int render_fb_y,
+                GLuint render_fb);
+  u64 texture() const { return m_fbo_texture; }
+
+ private:
+  GLuint m_fbo = 0, m_fbo_texture = 0;
+  int m_fbo_width = 640, m_fbo_height = 480;
 };
\ No newline at end of file
diff --git a/game/graphics/opengl_renderer/shaders/generic.vert b/game/graphics/opengl_renderer/shaders/generic.vert
index 35a178a827..17228a6031 100644
--- a/game/graphics/opengl_renderer/shaders/generic.vert
+++ b/game/graphics/opengl_renderer/shaders/generic.vert
@@ -11,6 +11,7 @@ uniform vec4 scale;
 uniform float mat_23;
 uniform float mat_33;
 uniform vec4 hvdf_offset;
+uniform uint warp_sample_mode;
 
 out vec2 tex_coord;
 
@@ -19,6 +20,9 @@ out float fog;
 
 out flat uvec2 tex_info;
 
+const float warp_off = 1.f - (416.f/512.f);
+const float warp_mult = 512.f/416.f;
+
 void main() {
     // lq.xy vf22, 0(vi10)          texture load?
     // lq_buffer(Mask::xy, vu.vf22, vu.vi10);
@@ -50,7 +54,11 @@ void main() {
 
     // itof12.xyz vf18, vf22        texture int to float
     // vu.vf18.itof12(Mask::xyz, vu.vf22);
-    tex_coord = tex_coord_in / 4096.f; // TODO, more and wrong.
+    tex_coord = tex_coord_in / 4096.f;
+
+    if (warp_sample_mode == 1) {
+        tex_coord = vec2(tex_coord.x, (1.0f - tex_coord.y - warp_off) * warp_mult);
+    }
 
     // mul.xyz vf12, vf12, Q        persepective divide
     // gen.vtx_p0.mul(Mask::xyz, gen.vtx_p0, vu.Q);
diff --git a/game/mips2c/jak2_functions/foreground.cpp b/game/mips2c/jak2_functions/foreground.cpp
index 9b2089e193..112aae6e2b 100644
--- a/game/mips2c/jak2_functions/foreground.cpp
+++ b/game/mips2c/jak2_functions/foreground.cpp
@@ -679,4 +679,667 @@ void link() {
 } // namespace Mips2C
 
 
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace foreground_generic_merc {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* foreground; // *foreground*
+  void* merc_global_stats; // *merc-global-stats*
+  void* foreground_generic_merc_add_fragments; // foreground-generic-merc-add-fragments
+  void* foreground_generic_merc_death; // foreground-generic-merc-death
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -112);                          // daddiu sp, sp, -112
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->sq(s1, 16, sp);                                // sq s1, 16(sp)
+  c->sq(s2, 32, sp);                                // sq s2, 32(sp)
+  c->sq(s3, 48, sp);                                // sq s3, 48(sp)
+  c->sq(s4, 64, sp);                                // sq s4, 64(sp)
+  c->sq(s5, 80, sp);                                // sq s5, 80(sp)
+  c->sq(gp, 96, sp);                                // sq gp, 96(sp)
+  c->mov64(gp, a0);                                 // or gp, a0, r0
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->daddu(v1, r0, v1);                             // daddu v1, r0, v1
+  c->sw(a2, 16, v1);                                // sw a2, 16(v1)
+  c->sw(a1, 20, v1);                                // sw a1, 20(v1)
+  c->lb(v1, 78, gp);                                // lb v1, 78(gp)
+  c->dsll(v1, v1, 3);                               // dsll v1, v1, 3
+  c->daddu(v1, gp, v1);                             // daddu v1, gp, v1
+  c->lwu(s5, 28, v1);                               // lwu s5, 28(v1)
+  c->daddiu(s3, a1, 16);                            // daddiu s3, a1, 16
+  c->addiu(s4, r0, 0);                              // addiu s4, r0, 0
+  //beq r0, r0, L153                                // beq r0, r0, L153
+  // nop                                            // sll r0, r0, 0
+  goto block_77;                                    // branch always
+
+
+  block_1:
+  c->load_symbol2(v1, cache.foreground);            // lw v1, *foreground*(s7)
+  c->daddiu(v1, v1, 2384);                          // daddiu v1, v1, 2384
+  c->dsll(a0, s4, 3);                               // dsll a0, s4, 3
+  c->daddu(a0, v1, a0);                             // daddu a0, v1, a0
+  c->lbu(a0, 130, a0);                              // lbu a0, 130(a0)
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->daddiu(a1, s7, 4);                             // daddiu a1, s7, 4
+  c->movz(a1, s7, a0);                              // movz a1, s7, a0
+  if (((s64)c->sgpr64(s7)) == ((s64)c->sgpr64(a1))) {// beql s7, a1, L120
+    c->mov64(v1, a1);                               // or v1, a1, r0
+    goto block_4;
+  }
+
+  c->dsll(a0, s4, 3);                               // dsll a0, s4, 3
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+  c->lbu(v1, 128, v1);                              // lbu v1, 128(v1)
+  c->daddiu(a0, v1, -2);                            // daddiu a0, v1, -2
+  c->daddiu(v1, s7, 4);                             // daddiu v1, s7, 4
+  c->movn(v1, s7, a0);                              // movn v1, s7, a0
+
+  block_4:
+  bc = c->sgpr64(s7) == c->sgpr64(v1);              // beq s7, v1, L152
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_76;}                          // branch non-likely
+
+  c->mov64(s1, s3);                                 // or s1, s3, r0
+  c->dsll(v1, s4, 5);                               // dsll v1, s4, 5
+  c->daddiu(v1, v1, 156);                           // daddiu v1, v1, 156
+  c->daddu(s2, v1, s5);                             // daddu s2, v1, s5
+  c->load_symbol2(v1, cache.merc_global_stats);     // lw v1, *merc-global-stats*(s7)
+  c->daddiu(v1, v1, 32);                            // daddiu v1, v1, 32
+  c->lhu(a0, 2, v1);                                // lhu a0, 2(v1)
+  c->lhu(a1, 18, s2);                               // lhu a1, 18(s2)
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  c->sh(a0, 2, v1);                                 // sh a0, 2(v1)
+  c->lwu(a0, 4, v1);                                // lwu a0, 4(v1)
+  c->lhu(a1, 22, s2);                               // lhu a1, 22(s2)
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  c->sw(a0, 4, v1);                                 // sw a0, 4(v1)
+  c->lwu(a0, 8, v1);                                // lwu a0, 8(v1)
+  c->lhu(a1, 24, s2);                               // lhu a1, 24(s2)
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  c->sw(a0, 8, v1);                                 // sw a0, 8(v1)
+  c->load_symbol2(v1, cache.foreground);            // lw v1, *foreground*(s7)
+  c->daddiu(v1, v1, 2384);                          // daddiu v1, v1, 2384
+  c->daddiu(a1, s1, 16);                            // daddiu a1, s1, 16
+  c->daddu(a2, r0, v1);                             // daddu a2, r0, v1
+  c->addiu(a0, r0, 7);                              // addiu a0, r0, 7
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(a3, a0, -4);                            // daddiu a3, a0, -4
+  c->mov64(a1, a1);                                 // or a1, a1, r0
+  bc = ((s64)c->sgpr64(a3)) < 0;                    // bltz a3, L122
+  c->mov64(a2, a2);                                 // or a2, a2, r0
+  if (bc) {goto block_7;}                           // branch non-likely
+
+
+  block_6:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 0, a2);                                 // lq t2, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 16, a2);                                // lq a3, 16(a2)
+  c->daddiu(a0, a0, -4);                            // daddiu a0, a0, -4
+  c->lq(t0, 32, a2);                                // lq t0, 32(a2)
+  c->daddiu(a1, a1, 64);                            // daddiu a1, a1, 64
+  c->lq(t1, 48, a2);                                // lq t1, 48(a2)
+  c->daddiu(a2, a2, 64);                            // daddiu a2, a2, 64
+  c->sq(t2, -64, a1);                               // sq t2, -64(a1)
+  c->daddiu(t2, a0, -4);                            // daddiu t2, a0, -4
+  c->sq(a3, -48, a1);                               // sq a3, -48(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, -32, a1);                               // sq t0, -32(a1)
+  bc = ((s64)c->sgpr64(t2)) >= 0;                   // bgez t2, L121
+  c->sq(t1, -16, a1);                               // sq t1, -16(a1)
+  if (bc) {goto block_6;}                           // branch non-likely
+
+
+  block_7:
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L123
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_12;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L123
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_12;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L123
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_12;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L123
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_12;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+
+  block_12:
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->daddiu(a1, s1, 128);                           // daddiu a1, s1, 128
+  c->daddiu(a2, s5, 28);                            // daddiu a2, s5, 28
+  c->addiu(a0, r0, 8);                              // addiu a0, r0, 8
+  c->daddiu(a3, a0, -4);                            // daddiu a3, a0, -4
+  c->mov64(a1, a1);                                 // or a1, a1, r0
+  bc = ((s64)c->sgpr64(a3)) < 0;                    // bltz a3, L125
+  c->mov64(a2, a2);                                 // or a2, a2, r0
+  if (bc) {goto block_14;}                          // branch non-likely
+
+
+  block_13:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 0, a2);                                 // lq t2, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 16, a2);                                // lq a3, 16(a2)
+  c->daddiu(a0, a0, -4);                            // daddiu a0, a0, -4
+  c->lq(t0, 32, a2);                                // lq t0, 32(a2)
+  c->daddiu(a1, a1, 64);                            // daddiu a1, a1, 64
+  c->lq(t1, 48, a2);                                // lq t1, 48(a2)
+  c->daddiu(a2, a2, 64);                            // daddiu a2, a2, 64
+  c->sq(t2, -64, a1);                               // sq t2, -64(a1)
+  c->daddiu(t2, a0, -4);                            // daddiu t2, a0, -4
+  c->sq(a3, -48, a1);                               // sq a3, -48(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, -32, a1);                               // sq t0, -32(a1)
+  bc = ((s64)c->sgpr64(t2)) >= 0;                   // bgez t2, L124
+  c->sq(t1, -16, a1);                               // sq t1, -16(a1)
+  if (bc) {goto block_13;}                          // branch non-likely
+
+
+  block_14:
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L126
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_19;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L126
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_19;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L126
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_19;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L126
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_19;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+
+  block_19:
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->lbu(a0, 17, s2);                               // lbu a0, 17(s2)
+  c->andi(a1, a0, 32);                              // andi a1, a0, 32
+  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L127
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_21;}                          // branch non-likely
+
+  c->addiu(a0, r0, 1);                              // addiu a0, r0, 1
+  c->sb(a0, 182, s1);                               // sb a0, 182(s1)
+  //beq r0, r0, L129                                // beq r0, r0, L129
+  // nop                                            // sll r0, r0, 0
+  goto block_24;                                    // branch always
+
+
+  block_21:
+  c->andi(a0, a0, 64);                              // andi a0, a0, 64
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L128
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_23;}                          // branch non-likely
+
+  c->addiu(a0, r0, 2);                              // addiu a0, r0, 2
+  c->sb(a0, 182, s1);                               // sb a0, 182(s1)
+  //beq r0, r0, L129                                // beq r0, r0, L129
+  // nop                                            // sll r0, r0, 0
+  goto block_24;                                    // branch always
+
+
+  block_23:
+  c->sb(r0, 182, s1);                               // sb r0, 182(s1)
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+
+  block_24:
+  c->lbu(a0, 26, s2);                               // lbu a0, 26(s2)
+  c->lbu(a1, 182, s1);                              // lbu a1, 182(s1)
+  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L130
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_26;}                          // branch non-likely
+
+  c->addiu(a0, r0, 2432);                           // addiu a0, r0, 2432
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  //beq r0, r0, L131                                // beq r0, r0, L131
+  // nop                                            // sll r0, r0, 0
+  goto block_27;                                    // branch always
+
+
+  block_26:
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->lwu(a1, 52, a1);                               // lwu a1, 52(a1)
+  c->daddiu(a1, a1, 24);                            // daddiu a1, a1, 24
+  c->addiu(a2, r0, 48);                             // addiu a2, r0, 48
+  c->multu3(a0, a2, a0);                            // multu3 a0, a2, a0
+  c->daddu(a0, a1, a0);                             // daddu a0, a1, a0
+
+  block_27:
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->sw(a0, 48, a1);                                // sw a0, 48(a1)
+  c->lwu(a1, 4, a0);                                // lwu a1, 4(a0)
+  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L132
+  c->mov64(a2, s7);                                 // or a2, s7, r0
+  if (bc) {goto block_29;}                          // branch non-likely
+
+  c->sw(s1, 0, a1);                                 // sw s1, 0(a1)
+  c->mov64(a1, s1);                                 // or a1, s1, r0
+
+  block_29:
+  c->lwu(a1, 0, a0);                                // lwu a1, 0(a0)
+  bc = c->sgpr64(a1) != 0;                          // bne a1, r0, L133
+  c->mov64(a1, s7);                                 // or a1, s7, r0
+  if (bc) {goto block_31;}                          // branch non-likely
+
+  c->sw(s1, 0, a0);                                 // sw s1, 0(a0)
+  c->mov64(a1, s1);                                 // or a1, s1, r0
+
+  block_31:
+  c->daddiu(a1, s1, 12);                            // daddiu a1, s1, 12
+  c->sw(a1, 4, a0);                                 // sw a1, 4(a0)
+  c->dsll(a0, s4, 3);                               // dsll a0, s4, 3
+  c->daddiu(a0, a0, 124);                           // daddiu a0, a0, 124
+  c->daddu(a0, a0, v1);                             // daddu a0, a0, v1
+  c->lwu(a1, 0, a0);                                // lwu a1, 0(a0)
+  c->sw(a1, 160, s1);                               // sw a1, 160(s1)
+  c->lbu(a1, 5, a0);                                // lbu a1, 5(a0)
+  c->sb(a1, 183, s1);                               // sb a1, 183(s1)
+  c->lbu(a0, 7, a0);                                // lbu a0, 7(a0)
+  c->sb(a0, 186, s1);                               // sb a0, 186(s1)
+  c->lw(v1, 112, v1);                               // lw v1, 112(v1)
+  c->sb(v1, 168, s1);                               // sb v1, 168(s1)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(v1, 16, v1);                               // lwu v1, 16(v1)
+  c->sb(v1, 169, s1);                               // sb v1, 169(s1)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L134
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_33;}                          // branch non-likely
+
+  c->sb(r0, 168, s1);                               // sb r0, 168(s1)
+  c->gprs[v1].du64[0] = 0;                          // or v1, r0, r0
+
+  block_33:
+  c->sb(r0, 170, s1);                               // sb r0, 170(s1)
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  c->sb(v1, 171, s1);                               // sb v1, 171(s1)
+  c->sh(r0, 172, s1);                               // sh r0, 172(s1)
+  c->addiu(v1, r0, 255);                            // addiu v1, r0, 255
+  c->sb(v1, 184, s1);                               // sb v1, 184(s1)
+  c->addiu(v1, r0, 0);                              // addiu v1, r0, 0
+  c->lbu(a0, 17, s2);                               // lbu a0, 17(s2)
+  c->andi(a0, a0, 2);                               // andi a0, a0, 2
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L135
+  c->mov64(a0, s7);                                 // or a0, s7, r0
+  if (bc) {goto block_35;}                          // branch non-likely
+
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  c->mov64(a0, v1);                                 // or a0, v1, r0
+
+  block_35:
+  c->lhu(a0, 4, gp);                                // lhu a0, 4(gp)
+  c->andi(a0, a0, 1024);                            // andi a0, a0, 1024
+  if (((s64)c->sgpr64(a0)) != ((s64)0)) {           // bnel a0, r0, L136
+    c->daddiu(a0, s7, 4);                           // daddiu a0, s7, 4
+    goto block_40;
+  }
+
+  c->lhu(a0, 4, gp);                                // lhu a0, 4(gp)
+  c->andi(a0, a0, 2048);                            // andi a0, a0, 2048
+  if (((s64)c->sgpr64(a0)) == ((s64)0)) {           // beql a0, r0, L136
+    c->mov64(a0, s7);                               // or a0, s7, r0
+    goto block_40;
+  }
+
+  c->daddiu(a0, s7, 4);                             // daddiu a0, s7, 4
+  c->lbu(a1, 17, s2);                               // lbu a1, 17(s2)
+  c->andi(a1, a1, 64);                              // andi a1, a1, 64
+  c->movz(a0, s7, a1);                              // movz a0, s7, a1
+
+  block_40:
+  bc = c->sgpr64(s7) == c->sgpr64(a0);              // beq s7, a0, L137
+  c->mov64(a0, s7);                                 // or a0, s7, r0
+  if (bc) {goto block_42;}                          // branch non-likely
+
+  c->lbu(v1, 206, gp);                              // lbu v1, 206(gp)
+  c->sb(v1, 184, s1);                               // sb v1, 184(s1)
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  c->mov64(a0, v1);                                 // or a0, v1, r0
+
+  block_42:
+  c->sb(v1, 180, s1);                               // sb v1, 180(s1)
+  c->lbu(v1, 17, s2);                               // lbu v1, 17(s2)
+  c->andi(v1, v1, 64);                              // andi v1, v1, 64
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L138
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_44;}                          // branch non-likely
+
+  c->addiu(v1, r0, 4);                              // addiu v1, r0, 4
+  c->sb(v1, 185, s1);                               // sb v1, 185(s1)
+  //beq r0, r0, L140                                // beq r0, r0, L140
+  // nop                                            // sll r0, r0, 0
+  goto block_47;                                    // branch always
+
+
+  block_44:
+  c->lhu(v1, 4, gp);                                // lhu v1, 4(gp)
+  c->andi(v1, v1, 8192);                            // andi v1, v1, 8192
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L139
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_46;}                          // branch non-likely
+
+  c->addiu(v1, r0, 4);                              // addiu v1, r0, 4
+  c->sb(v1, 185, s1);                               // sb v1, 185(s1)
+  //beq r0, r0, L140                                // beq r0, r0, L140
+  // nop                                            // sll r0, r0, 0
+  goto block_47;                                    // branch always
+
+
+  block_46:
+  c->sb(r0, 185, s1);                               // sb r0, 185(s1)
+  c->gprs[v1].du64[0] = 0;                          // or v1, r0, r0
+
+  block_47:
+  c->lbu(v1, 92, gp);                               // lbu v1, 92(gp)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L141
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_49;}                          // branch non-likely
+
+  c->load_symbol2(t9, cache.foreground_generic_merc_death);// lw t9, foreground-generic-merc-death(s7)
+  c->mov64(a0, gp);                                 // or a0, gp, r0
+  c->mov64(a1, s1);                                 // or a1, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+
+  block_49:
+  c->sw(r0, 164, s1);                               // sw r0, 164(s1)
+  c->lbu(v1, 17, s2);                               // lbu v1, 17(s2)
+  c->andi(v1, v1, 4);                               // andi v1, v1, 4
+  if (((s64)c->sgpr64(v1)) == ((s64)0)) {           // beql v1, r0, L142
+    c->mov64(v1, s7);                               // or v1, s7, r0
+    goto block_54;
+  }
+
+  c->lwu(v1, 80, gp);                               // lwu v1, 80(gp)
+  if (((s64)c->sgpr64(s7)) == ((s64)c->sgpr64(v1))) {// beql s7, v1, L142
+    c->mov64(v1, v1);                               // or v1, v1, r0
+    goto block_54;
+  }
+
+  c->lwu(v1, 80, gp);                               // lwu v1, 80(gp)
+  c->lwu(v1, 28, v1);                               // lwu v1, 28(v1)
+
+  block_54:
+  bc = c->sgpr64(s7) == c->sgpr64(v1);              // beq s7, v1, L143
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_56;}                          // branch non-likely
+
+  c->lwu(v1, 80, gp);                               // lwu v1, 80(gp)
+  c->lwu(v1, 32, v1);                               // lwu v1, 32(v1)
+  c->sw(v1, 164, s1);                               // sw v1, 164(s1)
+
+  block_56:
+  c->daddiu(a0, s1, 256);                           // daddiu a0, s1, 256
+  c->mov64(a1, s2);                                 // or a1, s2, r0
+  c->addiu(v1, r0, 2);                              // addiu v1, r0, 2
+  c->daddiu(a2, v1, -4);                            // daddiu a2, v1, -4
+  c->mov64(a0, a0);                                 // or a0, a0, r0
+  bc = ((s64)c->sgpr64(a2)) < 0;                    // bltz a2, L145
+  c->mov64(a1, a1);                                 // or a1, a1, r0
+  if (bc) {goto block_58;}                          // branch non-likely
+
+
+  block_57:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t1, 0, a1);                                 // lq t1, 0(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a2, 16, a1);                                // lq a2, 16(a1)
+  c->daddiu(v1, v1, -4);                            // daddiu v1, v1, -4
+  c->lq(a3, 32, a1);                                // lq a3, 32(a1)
+  c->daddiu(a0, a0, 64);                            // daddiu a0, a0, 64
+  c->lq(t0, 48, a1);                                // lq t0, 48(a1)
+  c->daddiu(a1, a1, 64);                            // daddiu a1, a1, 64
+  c->sq(t1, -64, a0);                               // sq t1, -64(a0)
+  c->daddiu(t1, v1, -4);                            // daddiu t1, v1, -4
+  c->sq(a2, -48, a0);                               // sq a2, -48(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, -32, a0);                               // sq a3, -32(a0)
+  bc = ((s64)c->sgpr64(t1)) >= 0;                   // bgez t1, L144
+  c->sq(t0, -16, a0);                               // sq t0, -16(a0)
+  if (bc) {goto block_57;}                          // branch non-likely
+
+
+  block_58:
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L146
+  c->lq(a2, 0, a1);                                 // lq a2, 0(a1)
+  if (bc) {goto block_63;}                          // branch non-likely
+
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, 16);                            // daddiu a0, a0, 16
+  c->daddiu(v1, v1, -1);                            // daddiu v1, v1, -1
+  c->sq(a2, -16, a0);                               // sq a2, -16(a0)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L146
+  c->lq(a2, 0, a1);                                 // lq a2, 0(a1)
+  if (bc) {goto block_63;}                          // branch non-likely
+
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, 16);                            // daddiu a0, a0, 16
+  c->daddiu(v1, v1, -1);                            // daddiu v1, v1, -1
+  c->sq(a2, -16, a0);                               // sq a2, -16(a0)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L146
+  c->lq(a2, 0, a1);                                 // lq a2, 0(a1)
+  if (bc) {goto block_63;}                          // branch non-likely
+
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, 16);                            // daddiu a0, a0, 16
+  c->daddiu(v1, v1, -1);                            // daddiu v1, v1, -1
+  c->sq(a2, -16, a0);                               // sq a2, -16(a0)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L146
+  c->lq(a2, 0, a1);                                 // lq a2, 0(a1)
+  if (bc) {goto block_63;}                          // branch non-likely
+
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, 16);                            // daddiu a0, a0, 16
+  c->daddiu(v1, v1, -1);                            // daddiu v1, v1, -1
+  c->sq(a2, -16, a0);                               // sq a2, -16(a0)
+
+  block_63:
+  c->gprs[v1].du64[0] = 0;                          // or v1, r0, r0
+  c->addiu(v1, r0, 18);                             // addiu v1, r0, 18
+  c->lwu(a0, 28, s2);                               // lwu a0, 28(s2)
+  if (((s64)c->sgpr64(a0)) == ((s64)0)) {           // beql a0, r0, L147
+    c->mov64(a0, s7);                               // or a0, s7, r0
+    goto block_66;
+  }
+
+  c->daddiu(a0, s7, 4);                             // daddiu a0, s7, 4
+  c->lwu(a1, 28, s2);                               // lwu a1, 28(s2)
+  c->lbu(a1, 1, a1);                                // lbu a1, 1(a1)
+  c->movz(a0, s7, a1);                              // movz a0, s7, a1
+
+  block_66:
+  bc = c->sgpr64(s7) == c->sgpr64(a0);              // beq s7, a0, L151
+  c->mov64(a0, s7);                                 // or a0, s7, r0
+  if (bc) {goto block_75;}                          // branch non-likely
+
+  c->addiu(a0, r0, 1);                              // addiu a0, r0, 1
+  c->sb(a0, 170, s1);                               // sb a0, 170(s1)
+  c->daddiu(a1, s1, 288);                           // daddiu a1, s1, 288
+  c->lwu(a0, 28, s2);                               // lwu a0, 28(s2)
+  c->lwu(a2, 28, s2);                               // lwu a2, 28(s2)
+  c->lbu(a2, 1, a2);                                // lbu a2, 1(a2)
+  c->dsll(a2, a2, 4);                               // dsll a2, a2, 4
+  c->daddu(a2, a0, a2);                             // daddu a2, a0, a2
+  c->addiu(a0, r0, 5);                              // addiu a0, r0, 5
+  c->daddiu(a3, a0, -4);                            // daddiu a3, a0, -4
+  c->mov64(a1, a1);                                 // or a1, a1, r0
+  bc = ((s64)c->sgpr64(a3)) < 0;                    // bltz a3, L149
+  c->mov64(a2, a2);                                 // or a2, a2, r0
+  if (bc) {goto block_69;}                          // branch non-likely
+
+
+  block_68:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 0, a2);                                 // lq t2, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 16, a2);                                // lq a3, 16(a2)
+  c->daddiu(a0, a0, -4);                            // daddiu a0, a0, -4
+  c->lq(t0, 32, a2);                                // lq t0, 32(a2)
+  c->daddiu(a1, a1, 64);                            // daddiu a1, a1, 64
+  c->lq(t1, 48, a2);                                // lq t1, 48(a2)
+  c->daddiu(a2, a2, 64);                            // daddiu a2, a2, 64
+  c->sq(t2, -64, a1);                               // sq t2, -64(a1)
+  c->daddiu(t2, a0, -4);                            // daddiu t2, a0, -4
+  c->sq(a3, -48, a1);                               // sq a3, -48(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, -32, a1);                               // sq t0, -32(a1)
+  bc = ((s64)c->sgpr64(t2)) >= 0;                   // bgez t2, L148
+  c->sq(t1, -16, a1);                               // sq t1, -16(a1)
+  if (bc) {goto block_68;}                          // branch non-likely
+
+
+  block_69:
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L150
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_74;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L150
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_74;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L150
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_74;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L150
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_74;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+
+  block_74:
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->daddiu(v1, v1, 5);                             // daddiu v1, v1, 5
+  c->mov64(a0, v1);                                 // or a0, v1, r0
+
+  block_75:
+  c->lui(a0, 4096);                                 // lui a0, 4096
+  c->daddiu(a1, v1, -1);                            // daddiu a1, v1, -1
+  c->dsll32(a1, a1, 16);                            // dsll32 a1, a1, 16
+  c->dsrl32(a1, a1, 16);                            // dsrl32 a1, a1, 16
+  c->or_(a0, a0, a1);                               // or a0, a0, a1
+  c->sd(a0, 0, s1);                                 // sd a0, 0(s1)
+  c->sw(v1, 8, s1);                                 // sw v1, 8(s1)
+  c->sw(r0, 12, s1);                                // sw r0, 12(s1)
+  c->dsll(v1, v1, 4);                               // dsll v1, v1, 4
+  c->daddu(a1, s3, v1);                             // daddu a1, s3, v1
+  c->mov64(v1, a1);                                 // or v1, a1, r0
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(a2, 48, v1);                               // lwu a2, 48(v1)
+  c->load_symbol2(t9, cache.foreground_generic_merc_add_fragments);// lw t9, foreground-generic-merc-add-fragments(s7)
+  c->mov64(a0, s2);                                 // or a0, s2, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(s3, v0);                                 // or s3, v0, r0
+  c->mov64(v1, s3);                                 // or v1, s3, r0
+
+  block_76:
+  c->daddiu(s4, s4, 1);                             // daddiu s4, s4, 1
+
+  block_77:
+  c->lwu(v1, 52, s5);                               // lwu v1, 52(s5)
+  c->slt(v1, s4, v1);                               // slt v1, s4, v1
+  bc = c->sgpr64(v1) != 0;                          // bne v1, r0, L119
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  c->mov64(v0, s3);                                 // or v0, s3, r0
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->lq(gp, 96, sp);                                // lq gp, 96(sp)
+  c->lq(s5, 80, sp);                                // lq s5, 80(sp)
+  c->lq(s4, 64, sp);                                // lq s4, 64(sp)
+  c->lq(s3, 48, sp);                                // lq s3, 48(sp)
+  c->lq(s2, 32, sp);                                // lq s2, 32(sp)
+  c->lq(s1, 16, sp);                                // lq s1, 16(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 112);                           // daddiu sp, sp, 112
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.foreground = intern_from_c("*foreground*").c();
+  cache.merc_global_stats = intern_from_c("*merc-global-stats*").c();
+  cache.foreground_generic_merc_add_fragments = intern_from_c("foreground-generic-merc-add-fragments").c();
+  cache.foreground_generic_merc_death = intern_from_c("foreground-generic-merc-death").c();
+  gLinkedFunctionTable.reg("foreground-generic-merc", execute, 256);
+}
+
+} // namespace foreground_generic_merc
+} // namespace Mips2C
 
diff --git a/game/mips2c/jak2_functions/generic_effect.cpp b/game/mips2c/jak2_functions/generic_effect.cpp
new file mode 100644
index 0000000000..6b449c97e7
--- /dev/null
+++ b/game/mips2c/jak2_functions/generic_effect.cpp
@@ -0,0 +1,2646 @@
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_light_proc {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+void vcallms0(ExecutionContext* c) {
+  // move.xyzw vf21, vf17       |  mulax.xyzw ACC, vf10, vf01
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf10).vf, c->vf_src(vf01).vf.x());   c->vfs[vf21].vf.move(Mask::xyzw, c->vf_src(vf17).vf);
+  // move.xyzw vf22, vf18       |  madday.xyzw ACC, vf11, vf01
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf11].vf, c->vfs[vf01].vf.y());   c->vfs[vf22].vf.move(Mask::xyzw, c->vf_src(vf18).vf);
+  // move.xyzw vf23, vf19       |  maddz.xyzw vf01, vf12, vf01
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf01].vf, c->vf_src(vf12).vf, c->vf_src(vf01).vf.z());   c->vfs[vf23].vf.move(Mask::xyzw, c->vf_src(vf19).vf);
+  // move.xyzw vf24, vf20       |  mulax.xyzw ACC, vf10, vf02
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf10).vf, c->vf_src(vf02).vf.x());   c->vfs[vf24].vf.move(Mask::xyzw, c->vf_src(vf20).vf);
+  // nop                        |  itof0.xyzw vf17, vf05
+  c->vfs[vf17].vf.itof0(Mask::xyzw, c->vf_src(vf05).vf);
+  // nop                        |  itof0.xyzw vf18, vf06
+  c->vfs[vf18].vf.itof0(Mask::xyzw, c->vf_src(vf06).vf);
+  // nop                        |  itof0.xyzw vf19, vf07
+  c->vfs[vf19].vf.itof0(Mask::xyzw, c->vf_src(vf07).vf);
+  // nop                        |  itof0.xyzw vf20, vf08
+  c->vfs[vf20].vf.itof0(Mask::xyzw, c->vf_src(vf08).vf);
+
+  // nop                        |  madday.xyzw ACC, vf11, vf02
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf11].vf, c->vfs[vf02].vf.y());
+  // nop                        |  maddz.xyzw vf02, vf12, vf02
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf02].vf, c->vf_src(vf12).vf, c->vf_src(vf02).vf.z());
+  // nop                        |  mulax.xyzw ACC, vf10, vf03
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf10).vf, c->vf_src(vf03).vf.x());
+  // nop                        |  madday.xyzw ACC, vf11, vf03
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf11].vf, c->vfs[vf03].vf.y());
+  // nop                        |  maddz.xyzw vf03, vf12, vf03
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf03].vf, c->vf_src(vf12).vf, c->vf_src(vf03).vf.z());
+  // nop                        |  mulax.xyzw ACC, vf10, vf04
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf10).vf, c->vf_src(vf04).vf.x());
+  // nop                        |  madday.xyzw ACC, vf11, vf04
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf11].vf, c->vfs[vf04].vf.y());
+  // nop                        |  maddz.xyzw vf04, vf12, vf04
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf04].vf, c->vf_src(vf12).vf, c->vf_src(vf04).vf.z());
+  // nop                        |  maxx.xyzw vf01, vf01, vf00
+  c->vfs[vf01].vf.max(Mask::xyzw, c->vf_src(vf01).vf, c->vf_src(vf00).vf.x());
+  // nop                        |  maxx.xyzw vf02, vf02, vf00
+  c->vfs[vf02].vf.max(Mask::xyzw, c->vf_src(vf02).vf, c->vf_src(vf00).vf.x());
+  // nop                        |  maxx.xyzw vf03, vf03, vf00
+  c->vfs[vf03].vf.max(Mask::xyzw, c->vf_src(vf03).vf, c->vf_src(vf00).vf.x());
+  // nop                        |  maxx.xyzw vf04, vf04, vf00
+  c->vfs[vf04].vf.max(Mask::xyzw, c->vf_src(vf04).vf, c->vf_src(vf00).vf.x());
+  // nop                        |  mulaw.xyzw ACC, vf13, vf00
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf13).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  maddax.xyzw ACC, vf14, vf01
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf14].vf, c->vfs[vf01].vf.x());
+  // nop                        |  madday.xyzw ACC, vf15, vf01
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf15].vf, c->vfs[vf01].vf.y());
+  // nop                        |  maddz.xyzw vf01, vf16, vf01
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf01].vf, c->vf_src(vf16).vf, c->vf_src(vf01).vf.z());
+  // nop                        |  mulaw.xyzw ACC, vf13, vf00
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf13).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  maddax.xyzw ACC, vf14, vf02
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf14].vf, c->vfs[vf02].vf.x());
+  // nop                        |  madday.xyzw ACC, vf15, vf02
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf15].vf, c->vfs[vf02].vf.y());
+  // nop                        |  maddz.xyzw vf02, vf16, vf02
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf02].vf, c->vf_src(vf16).vf, c->vf_src(vf02).vf.z());
+  // nop                        |  mulaw.xyzw ACC, vf13, vf00
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf13).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  maddax.xyzw ACC, vf14, vf03
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf14].vf, c->vfs[vf03].vf.x());
+  // nop                        |  madday.xyzw ACC, vf15, vf03
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf15].vf, c->vfs[vf03].vf.y());
+  // nop                        |  maddz.xyzw vf03, vf16, vf03
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf03].vf, c->vf_src(vf16).vf, c->vf_src(vf03).vf.z());
+  // nop                        |  mulaw.xyzw ACC, vf13, vf00
+  c->acc.vf.mula(Mask::xyzw, c->vf_src(vf13).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  maddax.xyzw ACC, vf14, vf04
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf14].vf, c->vfs[vf04].vf.x());
+  // nop                        |  madday.xyzw ACC, vf15, vf04
+  c->acc.vf.madda(Mask::xyzw, c->vfs[vf15].vf, c->vfs[vf04].vf.y());
+  // nop                        |  maddz.xyzw vf04, vf16, vf04
+  c->acc.vf.madd(Mask::xyzw, c->vfs[vf04].vf, c->vf_src(vf16).vf, c->vf_src(vf04).vf.z());
+  // nop                        |  mul.xyzw vf17, vf17, vf01
+  c->vfs[vf17].vf.mul(Mask::xyzw, c->vf_src(vf17).vf, c->vf_src(vf01).vf);
+  // nop                        |  mul.xyzw vf18, vf18, vf02
+  c->vfs[vf18].vf.mul(Mask::xyzw, c->vf_src(vf18).vf, c->vf_src(vf02).vf);
+  // nop                        |  mul.xyzw vf19, vf19, vf03
+  c->vfs[vf19].vf.mul(Mask::xyzw, c->vf_src(vf19).vf, c->vf_src(vf03).vf);
+  // nop                        |  mul.xyzw vf20, vf20, vf04
+  c->vfs[vf20].vf.mul(Mask::xyzw, c->vf_src(vf20).vf, c->vf_src(vf04).vf);
+  // nop                        |  minix.xyzw vf17, vf17, vf09
+  c->vfs[vf17].vf.mini(Mask::xyzw, c->vf_src(vf17).vf, c->vf_src(vf09).vf.x());
+  // nop                        |  minix.xyzw vf18, vf18, vf09
+  c->vfs[vf18].vf.mini(Mask::xyzw, c->vf_src(vf18).vf, c->vf_src(vf09).vf.x());
+  // nop                        |  minix.xyzw vf19, vf19, vf09
+  c->vfs[vf19].vf.mini(Mask::xyzw, c->vf_src(vf19).vf, c->vf_src(vf09).vf.x());
+  // nop                        |  minix.xyzw vf20, vf20, vf09
+  c->vfs[vf20].vf.mini(Mask::xyzw, c->vf_src(vf20).vf, c->vf_src(vf09).vf.x());
+  //fmt::print("light:\n {}\n {}\n {}\n {}\n\n", c->vf_src(vf17).vf.print(), c->vf_src(vf18).vf.print(), c->vf_src(vf19).vf.print(), c->vf_src(vf20).vf.print());
+
+
+
+  // nop                        |  ftoi0.xyzw vf17, vf17
+  c->vfs[vf17].vf.ftoi0(Mask::xyzw, c->vf_src(vf17).vf);
+  // nop                        |  ftoi0.xyzw vf18, vf18
+  c->vfs[vf18].vf.ftoi0(Mask::xyzw, c->vf_src(vf18).vf);
+  // nop                        |  ftoi0.xyzw vf19, vf19 :e
+  c->vfs[vf19].vf.ftoi0(Mask::xyzw, c->vf_src(vf19).vf);
+  // nop                        |  ftoi0.xyzw vf20, vf20
+  c->vfs[vf20].vf.ftoi0(Mask::xyzw, c->vf_src(vf20).vf);
+}
+
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  c->daddiu(sp, sp, -96);                           // daddiu sp, sp, -96
+  c->sd(ra, 12432, at);                             // sd ra, 12432(at)
+  c->sq(s2, 12448, at);                             // sq s2, 12448(at)
+  c->sq(s3, 12464, at);                             // sq s3, 12464(at)
+  c->sq(s4, 12480, at);                             // sq s4, 12480(at)
+  c->sq(s5, 12496, at);                             // sq s5, 12496(at)
+  c->sq(gp, 12512, at);                             // sq gp, 12512(at)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->lw(v1, 44, at);                                // lw v1, 44(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a1, 36, at);                                // lw a1, 36(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a0, 4, v1);                                 // lw a0, 4(v1)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t0, 0, v1);                                 // lw t0, 0(v1)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t3, 4, at);                                 // lw t3, 4(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(v1, 8, at);                                 // lw v1, 8(at)
+  c->addiu(a3, r0, 255);                            // addiu a3, r0, 255
+  c->lw(t2, 12, at);                                // lw t2, 12(at)
+  c->addiu(a2, r0, 256);                            // addiu a2, r0, 256
+  c->lui(t1, -2);                                   // lui t1, -2
+  c->mov64(t4, a1);                                 // or t4, a1, r0
+  c->lqc2(vf10, 12688, at);                         // lqc2 vf10, 12688(at)
+  c->ori(a1, t1, 65534);                            // ori a1, t1, 65534
+  c->lqc2(vf11, 12704, at);                         // lqc2 vf11, 12704(at)
+  c->pextlw(a1, a1, a1);                            // pextlw a1, a1, a1
+  c->lqc2(vf12, 12720, at);                         // lqc2 vf12, 12720(at)
+  c->pextlw(t1, a0, a0);                            // pextlw t1, a0, a0
+  c->lqc2(vf15, 12752, at);                         // lqc2 vf15, 12752(at)
+  c->pextlw(a0, a1, a1);                            // pextlw a0, a1, a1
+  c->lqc2(vf14, 12736, at);                         // lqc2 vf14, 12736(at)
+  c->pextlw(a1, t1, t1);                            // pextlw a1, t1, t1
+  c->lqc2(vf16, 12768, at);                         // lqc2 vf16, 12768(at)
+  c->pcpyh(a3, a3);                                 // pcpyh a3, a3
+  c->lqc2(vf13, 12784, at);                         // lqc2 vf13, 12784(at)
+  c->pcpyh(t1, a2);                                 // pcpyh t1, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(a2, a3, a3);                            // pcpyld a2, a3, a3
+  c->lqc2(vf9, 12144, at);                          // lqc2 vf9, 12144(at)
+  c->pcpyld(a3, t1, t1);                            // pcpyld a3, t1, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->ldr(t1, 0, t0);                                // ldr t1, 0(t0)
+  // nop                                            // sll r0, r0, 0
+  c->ldl(t1, 7, t0);                                // ldl t1, 7(t0)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, t0, 8);                             // daddiu t0, t0, 8
+  c->pextlh(t1, r0, t1);                            // pextlh t1, r0, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t5, t1, a2);                              // pand t5, t1, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->psllw(t5, t5, 5);                              // psllw t5, t5, 5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->paddw(s5, t5, a1);                             // paddw s5, t5, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->dsrl32(t9, s5, 0);                             // dsrl32 t9, s5, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyud(s4, s5, r0);                            // pcpyud s4, s5, r0
+  c->lq(t6, 0, s5);                                 // lq t6, 0(s5)
+  c->dsrl32(ra, s4, 0);                             // dsrl32 ra, s4, 0
+  c->lq(t7, 0, t9);                                 // lq t7, 0(t9)
+  c->pand(t8, t1, a3);                              // pand t8, t1, a3
+  c->lq(t5, 0, s4);                                 // lq t5, 0(s4)
+  c->psraw(gp, t8, 8);                              // psraw gp, t8, 8
+  c->lq(t8, 0, ra);                                 // lq t8, 0(ra)
+  c->pextuw(s3, t7, t6);                            // pextuw s3, t7, t6
+  c->lq(s5, 16, s5);                                // lq s5, 16(s5)
+  c->pextuw(s2, t8, t5);                            // pextuw s2, t8, t5
+  c->lq(t9, 16, t9);                                // lq t9, 16(t9)
+  c->pcpyud(s3, s3, s2);                            // pcpyud s3, s3, s2
+  c->lq(s4, 16, s4);                                // lq s4, 16(s4)
+  c->pand(s3, s3, a0);                              // pand s3, s3, a0
+  c->lq(ra, 16, ra);                                // lq ra, 16(ra)
+  c->por(s3, s3, gp);                               // por s3, s3, gp
+  c->mov128_vf_gpr(vf1, s5);                        // qmtc2.ni vf1, s5
+  c->pextub(gp, r0, s5);                            // pextub gp, r0, s5
+  c->sq(s3, 0, t2);                                 // sq s3, 0(t2)
+  c->pextub(s5, r0, t9);                            // pextub s5, r0, t9
+  c->mov128_vf_gpr(vf2, t9);                        // qmtc2.ni vf2, t9
+  c->pextub(t9, r0, s4);                            // pextub t9, r0, s4
+  c->mov128_vf_gpr(vf3, s4);                        // qmtc2.ni vf3, s4
+  c->pextub(s4, r0, ra);                            // pextub s4, r0, ra
+  c->mov128_vf_gpr(vf4, ra);                        // qmtc2.ni vf4, ra
+  c->pextuh(ra, r0, gp);                            // pextuh ra, r0, gp
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextuh(gp, r0, s5);                            // pextuh gp, r0, s5
+  c->mov128_vf_gpr(vf5, ra);                        // qmtc2.ni vf5, ra
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  c->mov128_vf_gpr(vf6, gp);                        // qmtc2.ni vf6, gp
+  c->pextuh(ra, r0, s4);                            // pextuh ra, r0, s4
+  c->mov128_vf_gpr(vf7, t9);                        // qmtc2.ni vf7, t9
+  c->prot3w(t8, t8);                                // prot3w t8, t8
+  c->mov128_vf_gpr(vf8, ra);                        // qmtc2.ni vf8, ra
+  c->prot3w(t7, t7);                                // prot3w t7, t7
+  // Unknown instr: vcallms 0
+  vcallms0(c);
+  c->pextuw(t9, t7, t6);                            // pextuw t9, t7, t6
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(t7, t5, t7);                            // pcpyld t7, t5, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(t6, t9, t6);                            // pcpyld t6, t9, t6
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->daddiu(t2, t2, 16);                            // daddiu t2, t2, 16
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextuw(t5, t8, t5);                            // pextuw t5, t8, t5
+  c->sq(t7, 16, t3);                                // sq t7, 16(t3)
+  c->pcpyld(t5, t8, t5);                            // pcpyld t5, t8, t5
+  c->sq(t6, 0, t3);                                 // sq t6, 0(t3)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t5, 32, t3);                                // sq t5, 32(t3)
+  c->daddiu(t3, t3, 48);                            // daddiu t3, t3, 48
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->daddiu(t4, t4, -4);                            // daddiu t4, t4, -4
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  bc = ((s64)c->sgpr64(t4)) <= 0;                   // blez t4, L91
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  if (bc) {goto block_2;}                           // branch non-likely
+
+
+  block_1:
+  // nop                                            // sll r0, r0, 0
+  c->ldr(t1, 0, t0);                                // ldr t1, 0(t0)
+  // nop                                            // sll r0, r0, 0
+  c->ldl(t1, 7, t0);                                // ldl t1, 7(t0)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, t0, 8);                             // daddiu t0, t0, 8
+  c->pextlh(t1, r0, t1);                            // pextlh t1, r0, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t5, t1, a2);                              // pand t5, t1, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->psllw(t5, t5, 5);                              // psllw t5, t5, 5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->paddw(s5, t5, a1);                             // paddw s5, t5, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->dsrl32(t9, s5, 0);                             // dsrl32 t9, s5, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyud(s4, s5, r0);                            // pcpyud s4, s5, r0
+  c->lq(t6, 0, s5);                                 // lq t6, 0(s5)
+  c->dsrl32(ra, s4, 0);                             // dsrl32 ra, s4, 0
+  c->lq(t7, 0, t9);                                 // lq t7, 0(t9)
+  c->pand(t8, t1, a3);                              // pand t8, t1, a3
+  c->lq(t5, 0, s4);                                 // lq t5, 0(s4)
+  c->psraw(gp, t8, 8);                              // psraw gp, t8, 8
+  c->lq(t8, 0, ra);                                 // lq t8, 0(ra)
+  c->pextuw(s3, t7, t6);                            // pextuw s3, t7, t6
+  c->lq(s5, 16, s5);                                // lq s5, 16(s5)
+  c->pextuw(s2, t8, t5);                            // pextuw s2, t8, t5
+  c->lq(t9, 16, t9);                                // lq t9, 16(t9)
+  c->pcpyud(s3, s3, s2);                            // pcpyud s3, s3, s2
+  c->lq(s4, 16, s4);                                // lq s4, 16(s4)
+  c->pand(s3, s3, a0);                              // pand s3, s3, a0
+  c->lq(ra, 16, ra);                                // lq ra, 16(ra)
+  c->por(s3, s3, gp);                               // por s3, s3, gp
+  c->mov128_vf_gpr(vf1, s5);                        // qmtc2.ni vf1, s5
+  c->pextub(gp, r0, s5);                            // pextub gp, r0, s5
+  c->sq(s3, 0, t2);                                 // sq s3, 0(t2)
+  c->pextub(s5, r0, t9);                            // pextub s5, r0, t9
+  c->mov128_vf_gpr(vf2, t9);                        // qmtc2.ni vf2, t9
+  c->pextub(t9, r0, s4);                            // pextub t9, r0, s4
+  c->mov128_vf_gpr(vf3, s4);                        // qmtc2.ni vf3, s4
+  c->pextub(s4, r0, ra);                            // pextub s4, r0, ra
+  c->mov128_vf_gpr(vf4, ra);                        // qmtc2.ni vf4, ra
+  c->pextuh(ra, r0, gp);                            // pextuh ra, r0, gp
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextuh(gp, r0, s5);                            // pextuh gp, r0, s5
+  c->mov128_vf_gpr(vf5, ra);                        // qmtc2.ni vf5, ra
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  c->mov128_vf_gpr(vf6, gp);                        // qmtc2.ni vf6, gp
+  c->pextuh(ra, r0, s4);                            // pextuh ra, r0, s4
+  c->mov128_vf_gpr(vf7, t9);                        // qmtc2.ni vf7, t9
+  c->prot3w(t8, t8);                                // prot3w t8, t8
+  c->mov128_vf_gpr(vf8, ra);                        // qmtc2.ni vf8, ra
+  c->prot3w(t7, t7);                                // prot3w t7, t7
+  // Unknown instr: vcallms 0
+  vcallms0(c);
+  c->pextuw(t9, t7, t6);                            // pextuw t9, t7, t6
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(t7, t5, t7);                            // pcpyld t7, t5, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(t6, t9, t6);                            // pcpyld t6, t9, t6
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextuw(t5, t8, t5);                            // pextuw t5, t8, t5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(t5, t8, t5);                            // pcpyld t5, t8, t5
+  c->sq(t6, 0, t3);                                 // sq t6, 0(t3)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t7, 16, t3);                                // sq t7, 16(t3)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t5, 32, t3);                                // sq t5, 32(t3)
+  c->daddiu(t2, t2, 16);                            // daddiu t2, t2, 16
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->daddiu(t3, t3, 48);                            // daddiu t3, t3, 48
+  c->mov128_gpr_vf(t7, vf21);                       // qmfc2.ni t7, vf21
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t8, vf22);                       // qmfc2.ni t8, vf22
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t5, vf23);                       // qmfc2.ni t5, vf23
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t6, vf24);                       // qmfc2.ni t6, vf24
+  c->ppach(t7, t8, t7);                             // ppach t7, t8, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->ppach(t5, t6, t5);                             // ppach t5, t6, t5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->ppacb(t5, t5, t7);                             // ppacb t5, t5, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->sq(t5, 0, v1);                                 // sq t5, 0(v1)
+  c->daddiu(t4, t4, -4);                            // daddiu t4, t4, -4
+  c->daddiu(v1, v1, 16);                            // daddiu v1, v1, 16
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  bc = ((s64)c->sgpr64(t4)) > 0;                    // bgtz t4, L90
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_1;}                           // branch non-likely
+
+
+  block_2:
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // vnop
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(a2, vf17);                       // qmfc2.ni a2, vf17
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(a3, vf18);                       // qmfc2.ni a3, vf18
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(a0, vf19);                       // qmfc2.ni a0, vf19
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(a1, vf20);                       // qmfc2.ni a1, vf20
+  c->ppach(a2, a3, a2);                             // ppach a2, a3, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->ppach(a0, a1, a0);                             // ppach a0, a1, a0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->ppacb(a0, a0, a2);                             // ppacb a0, a0, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->sq(a0, 0, v1);                                 // sq a0, 0(v1)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 12432, at);                             // ld ra, 12432(at)
+  c->lq(gp, 12512, at);                             // lq gp, 12512(at)
+  c->lq(s5, 12496, at);                             // lq s5, 12496(at)
+  c->lq(s4, 12480, at);                             // lq s4, 12480(at)
+  c->lq(s3, 12464, at);                             // lq s3, 12464(at)
+  c->lq(s2, 12448, at);                             // lq s2, 12448(at)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 96);                            // daddiu sp, sp, 96
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("generic-light-proc", execute, 128);
+}
+
+} // namespace generic_light_proc
+} // namespace Mips2C
+// add generic_light_proc::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_envmap_proc {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+
+void vcallms48(ExecutionContext* c) {
+  // nop                        |  mulx.xyzw vf13, vf09, vf31
+  c->vfs[vf13].vf.mul(Mask::xyzw, c->vf_src(vf09).vf, c->vf_src(vf31).vf.x());
+  // nop                        |  subw.z vf21, vf21, vf00
+  c->vfs[vf21].vf.sub(Mask::z, c->vf_src(vf21).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  addy.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
+  // nop                        |  mulx.xyz vf08, vf08, vf30
+  c->vfs[vf08].vf.mul(Mask::xyz, c->vf_src(vf08).vf, c->vf_src(vf30).vf.x());
+  // nop                        |  addw.xy vf05, vf05, vf31
+  c->vfs[vf05].vf.add(Mask::xy, c->vf_src(vf05).vf, c->vf_src(vf31).vf.w());
+  // nop                        |  mul.xyz vf30, vf21, vf13
+  c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf21).vf, c->vf_src(vf13).vf);
+  // nop                        |  addz.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
+  // nop                        |  add.xyz vf08, vf08, vf16
+  c->vfs[vf08].vf.add(Mask::xyz, c->vf_src(vf08).vf, c->vf_src(vf16).vf);
+  // move.xyzw vf28, vf27       |  ftoi12.xy vf17, vf05
+  c->vfs[vf17].vf.ftoi12(Mask::xy, c->vf_src(vf05).vf);   c->vfs[vf28].vf.move(Mask::xyzw, c->vf_src(vf27).vf);
+  // move.xyzw vf02, vf22       |  addy.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y());   c->vfs[vf02].vf.move(Mask::xyzw, c->vf_src(vf22).vf);
+  // rsqrt Q, vf31.z, vf29.x    |  mul.xyz vf06, vf06, Q
+  c->vfs[vf06].vf.mul(Mask::xyz, c->vf_src(vf06).vf, c->Q);   c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
+  // nop                        |  mul.xyz vf29, vf08, vf08
+  c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf08).vf, c->vf_src(vf08).vf);
+  // nop                        |  mulx.xyz vf01, vf21, vf28
+  c->vfs[vf01].vf.mul(Mask::xyz, c->vf_src(vf21).vf, c->vf_src(vf28).vf.x());
+  // nop                        |  addz.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
+  // nop                        |  mulx.xyzw vf14, vf10, vf31
+  c->vfs[vf14].vf.mul(Mask::xyzw, c->vf_src(vf10).vf, c->vf_src(vf31).vf.x());
+  // nop                        |  subw.z vf02, vf02, vf00
+  c->vfs[vf02].vf.sub(Mask::z, c->vf_src(vf02).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  addy.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
+  // nop                        |  mulx.xyz vf01, vf01, vf30
+  c->vfs[vf01].vf.mul(Mask::xyz, c->vf_src(vf01).vf, c->vf_src(vf30).vf.x());
+  // nop                        |  addw.xy vf06, vf06, vf31
+  c->vfs[vf06].vf.add(Mask::xy, c->vf_src(vf06).vf, c->vf_src(vf31).vf.w());
+  // nop                        |  mul.xyz vf30, vf02, vf14
+  c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf14).vf);
+  // nop                        |  addz.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
+  // nop                        |  add.xyz vf01, vf01, vf13
+  c->vfs[vf01].vf.add(Mask::xyz, c->vf_src(vf01).vf, c->vf_src(vf13).vf);
+  // nop                        |  ftoi12.xy vf18, vf06
+  c->vfs[vf18].vf.ftoi12(Mask::xy, c->vf_src(vf06).vf);
+  // nop                        |  addy.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y());
+  // rsqrt Q, vf31.z, vf29.x    |  mul.xyz vf07, vf07, Q
+  c->vfs[vf07].vf.mul(Mask::xyz, c->vf_src(vf07).vf, c->Q);   c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
+  // move.xyzw vf03, vf23       |  mul.xyz vf29, vf01, vf01
+  c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf01).vf, c->vf_src(vf01).vf);   c->vfs[vf03].vf.move(Mask::xyzw, c->vf_src(vf23).vf);
+  // nop                        |  muly.xyz vf02, vf02, vf28
+  c->vfs[vf02].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf28).vf.y());
+  // nop                        |  addz.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
+  // nop                        |  mulx.xyzw vf15, vf11, vf31
+  c->vfs[vf15].vf.mul(Mask::xyzw, c->vf_src(vf11).vf, c->vf_src(vf31).vf.x());
+  // nop                        |  subw.z vf03, vf03, vf00
+  c->vfs[vf03].vf.sub(Mask::z, c->vf_src(vf03).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  addy.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
+  // nop                        |  mulx.xyz vf02, vf02, vf30
+  c->vfs[vf02].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf30).vf.x());
+  // nop                        |  addw.xy vf07, vf07, vf31
+  c->vfs[vf07].vf.add(Mask::xy, c->vf_src(vf07).vf, c->vf_src(vf31).vf.w());
+  // nop                        |  mul.xyz vf30, vf03, vf15
+  c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf15).vf);
+  // nop                        |  addz.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
+  // nop                        |  add.xyz vf02, vf02, vf14
+  c->vfs[vf02].vf.add(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf14).vf);
+  // nop                        |  ftoi12.xy vf19, vf07
+  c->vfs[vf19].vf.ftoi12(Mask::xy, c->vf_src(vf07).vf);
+  // nop                        |  addy.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y());
+  // rsqrt Q, vf31.z, vf29.x    |  mul.xyz vf08, vf08, Q
+  c->vfs[vf08].vf.mul(Mask::xyz, c->vf_src(vf08).vf, c->Q);   c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
+  // move.xyzw vf04, vf24       |  mul.xyz vf29, vf02, vf02
+  c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf02).vf);   c->vfs[vf04].vf.move(Mask::xyzw, c->vf_src(vf24).vf);
+  // nop                        |  mulz.xyz vf03, vf03, vf28
+  c->vfs[vf03].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf28).vf.z());
+  // nop                        |  addz.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
+  // nop                        |  mulx.xyzw vf16, vf12, vf31
+  c->vfs[vf16].vf.mul(Mask::xyzw, c->vf_src(vf12).vf, c->vf_src(vf31).vf.x());
+  // nop                        |  subw.z vf04, vf04, vf00
+  c->vfs[vf04].vf.sub(Mask::z, c->vf_src(vf04).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  addy.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
+  // nop                        |  mulx.xyz vf03, vf03, vf30
+  c->vfs[vf03].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf30).vf.x());
+  // nop                        |  addw.xy vf08, vf08, vf31
+  c->vfs[vf08].vf.add(Mask::xy, c->vf_src(vf08).vf, c->vf_src(vf31).vf.w());
+  // nop                        |  mul.xyz vf30, vf04, vf16
+  c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf04).vf, c->vf_src(vf16).vf);
+  // nop                        |  addz.x vf29, vf29, vf29
+  c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
+  // nop                        |  add.xyz vf03, vf03, vf15
+  c->vfs[vf03].vf.add(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf15).vf);
+  // nop                        |  ftoi12.xy vf20, vf08
+  c->vfs[vf20].vf.ftoi12(Mask::xy, c->vf_src(vf08).vf);
+  // nop                        |  addy.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y());
+  // rsqrt Q, vf31.z, vf29.x    |  mul.xyz vf05, vf01, Q
+  c->vfs[vf05].vf.mul(Mask::xyz, c->vf_src(vf01).vf, c->Q);   c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
+  // move.xyzw vf06, vf02       |  mul.xyz vf29, vf03, vf03
+  c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf03).vf);   c->vfs[vf06].vf.move(Mask::xyzw, c->vf_src(vf02).vf);
+  // move.xyzw vf07, vf03       |  mulw.xyz vf08, vf04, vf28 :e
+  c->vfs[vf08].vf.mul(Mask::xyz, c->vf_src(vf04).vf, c->vf_src(vf28).vf.w());   c->vfs[vf07].vf.move(Mask::xyzw, c->vf_src(vf03).vf);
+  // nop                        |  addz.x vf30, vf30, vf30
+  c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
+
+}
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  c->daddiu(sp, sp, -128);                          // daddiu sp, sp, -128
+  c->sd(ra, 12432, at);                             // sd ra, 12432(at)
+  c->sq(s0, 12448, at);                             // sq s0, 12448(at)
+  c->sq(s1, 12464, at);                             // sq s1, 12464(at)
+  c->sq(s2, 12480, at);                             // sq s2, 12480(at)
+  c->sq(s3, 12496, at);                             // sq s3, 12496(at)
+  c->sq(s4, 12512, at);                             // sq s4, 12512(at)
+  c->sq(s5, 12528, at);                             // sq s5, 12528(at)
+  c->sq(gp, 12544, at);                             // sq gp, 12544(at)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  // nop                                            // sll r0, r0, 0
+  c->lw(v1, 44, at);                                // lw v1, 44(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a0, 36, at);                                // lw a0, 36(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t0, 0, v1);                                 // lw t0, 0(v1)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a2, 4, v1);                                 // lw a2, 4(v1)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t3, 16, at);                                // lw t3, 16(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(v1, 20, at);                                // lw v1, 20(at)
+  // nop                                            // sll r0, r0, 0
+  c->addiu(t1, r0, 255);                            // addiu t1, r0, 255
+  c->addiu(a3, r0, 256);                            // addiu a3, r0, 256
+  c->lui(a1, -2);                                   // lui a1, -2
+  c->lui(t2, 16256);                                // lui t2, 16256
+  c->ori(a1, a1, 65534);                            // ori a1, a1, 65534
+  c->mtc1(f0, t2);                                  // mtc1 f0, t2
+  c->daddiu(t2, a0, 3);                             // daddiu t2, a0, 3
+  c->sra(t5, t2, 2);                                // sra t5, t2, 2
+  c->lq(t2, 12048, at);                             // lq t2, 12048(at)
+  c->sra(t4, t5, 2);                                // sra t4, t5, 2
+  c->andi(t5, t5, 3);                               // andi t5, t5, 3
+  bc = c->sgpr64(t4) == 0;                          // beq t4, r0, L85
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_2;}                           // branch non-likely
+
+
+  block_1:
+  c->daddiu(t3, t3, 64);                            // daddiu t3, t3, 64
+  c->sq(t2, -64, t3);                               // sq t2, -64(t3)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t2, -48, t3);                               // sq t2, -48(t3)
+  c->daddiu(t4, t4, -1);                            // daddiu t4, t4, -1
+  c->sq(t2, -32, t3);                               // sq t2, -32(t3)
+  bc = ((s64)c->sgpr64(t4)) > 0;                    // bgtz t4, L84
+  c->sq(t2, -16, t3);                               // sq t2, -16(t3)
+  if (bc) {goto block_1;}                           // branch non-likely
+
+
+  block_2:
+  bc = c->sgpr64(t5) == 0;                          // beq t5, r0, L86
+  c->daddiu(t4, t5, -1);                            // daddiu t4, t5, -1
+  if (bc) {goto block_6;}                           // branch non-likely
+
+  bc = c->sgpr64(t4) == 0;                          // beq t4, r0, L86
+  c->sq(t2, 0, t3);                                 // sq t2, 0(t3)
+  if (bc) {goto block_6;}                           // branch non-likely
+
+  c->daddiu(t3, t3, 16);                            // daddiu t3, t3, 16
+  c->daddiu(t4, t4, -1);                            // daddiu t4, t4, -1
+  bc = c->sgpr64(t4) == 0;                          // beq t4, r0, L86
+  c->sq(t2, 0, t3);                                 // sq t2, 0(t3)
+  if (bc) {goto block_6;}                           // branch non-likely
+
+  c->daddiu(t3, t3, 16);                            // daddiu t3, t3, 16
+  c->daddiu(t4, t4, -1);                            // daddiu t4, t4, -1
+  // nop                                            // sll r0, r0, 0
+  c->sq(t2, 0, t3);                                 // sq t2, 0(t3)
+
+  block_6:
+  c->daddiu(a0, a0, -4);                            // daddiu a0, a0, -4
+  c->lqc2(vf31, 12016, at);                         // lqc2 vf31, 12016(at)
+  c->pextlw(a1, a1, a1);                            // pextlw a1, a1, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlw(a1, a1, a1);                            // pextlw a1, a1, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlw(a2, a2, a2);                            // pextlw a2, a2, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlw(a2, a2, a2);                            // pextlw a2, a2, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyh(t2, t1);                                 // pcpyh t2, t1
+  c->ld(t1, 0, t0);                                 // ld t1, 0(t0)
+  c->pcpyld(t2, t2, t2);                            // pcpyld t2, t2, t2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyh(a3, a3);                                 // pcpyh a3, a3
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(a3, a3, a3);                            // pcpyld a3, a3, a3
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->daddiu(t0, t0, 8);                             // daddiu t0, t0, 8
+  c->sq(t2, 96, at);                                // sq t2, 96(at)
+  c->pextlh(t1, r0, t1);                            // pextlh t1, r0, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t2, t1, t2);                              // pand t2, t1, t2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->psllw(t2, t2, 5);                              // psllw t2, t2, 5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->paddw(t5, t2, a2);                             // paddw t5, t2, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->dsrl32(t6, t5, 0);                             // dsrl32 t6, t5, 0
+  c->lwc1(f4, 24, t5);                              // lwc1 f4, 24(t5)
+  c->pcpyud(t7, t5, r0);                            // pcpyud t7, t5, r0
+  c->lwc1(f3, 24, t6);                              // lwc1 f3, 24(t6)
+  c->dsrl32(t8, t7, 0);                             // dsrl32 t8, t7, 0
+  c->lwc1(f2, 24, t7);                              // lwc1 f2, 24(t7)
+  c->pand(t1, t1, a3);                              // pand t1, t1, a3
+  c->lwc1(f1, 24, t8);                              // lwc1 f1, 24(t8)
+  c->psraw(t2, t1, 8);                              // psraw t2, t1, 8
+  c->lq(t1, 16, t5);                                // lq t1, 16(t5)
+  c->mov128_gpr_gpr(s0, t2);                        // por s0, t2, r0
+  c->subs(f4, f4, f0);                              // sub.s f4, f4, f0
+  c->divs(f4, f0, f4);                              // div.s f4, f0, f4
+  c->lq(t2, 16, t6);                                // lq t2, 16(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 16, t7);                                // lq t3, 16(t7)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 16, t8);                                // lq t4, 16(t8)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 0, t5);                                 // lq t5, 0(t5)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t6, 0, t6);                                 // lq t6, 0(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 0, t7);                                 // lq t7, 0(t7)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t8, 0, t8);                                 // lq t8, 0(t8)
+  c->muls(f4, f4, f0);                              // mul.s f4, f4, f0
+  // nop                                            // sll r0, r0, 0
+  c->subs(f3, f3, f0);                              // sub.s f3, f3, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f3, f0, f3);                              // div.s f3, f0, f3
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(t9, f4);                                  // mfc1 t9, f4
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f3, f3, f0);                              // mul.s f3, f3, f0
+  // nop                                            // sll r0, r0, 0
+  c->subs(f2, f2, f0);                              // sub.s f2, f2, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f2, f0, f2);                              // div.s f2, f0, f2
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(ra, f3);                                  // mfc1 ra, f3
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f2, f2, f0);                              // mul.s f2, f2, f0
+  // nop                                            // sll r0, r0, 0
+  c->subs(f1, f1, f0);                              // sub.s f1, f1, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f1, f0, f1);                              // div.s f1, f0, f1
+  // nop                                            // sll r0, r0, 0
+  c->pextlw(t9, ra, t9);                            // pextlw t9, ra, t9
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(ra, f2);                                  // mfc1 ra, f2
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(gp, f1);                                  // mfc1 gp, f1
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->pextlw(ra, gp, ra);                            // pextlw ra, gp, ra
+  // nop                                            // sll r0, r0, 0
+  c->pcpyld(t9, ra, t9);                            // pcpyld t9, ra, t9
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf21, t1);                       // qmtc2.ni vf21, t1
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf22, t2);                       // qmtc2.ni vf22, t2
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf23, t3);                       // qmtc2.ni vf23, t3
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf24, t4);                       // qmtc2.ni vf24, t4
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf9, t5);                        // qmtc2.ni vf9, t5
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf10, t6);                       // qmtc2.ni vf10, t6
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf11, t7);                       // qmtc2.ni vf11, t7
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf12, t8);                       // qmtc2.ni vf12, t8
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf27, t9);                       // qmtc2.ni vf27, t9
+  c->lq(t2, 96, at);                                // lq t2, 96(at)
+  // Unknown instr: vcallms 48
+  vcallms48(c);
+  // nop                                            // sll r0, r0, 0
+  c->ld(t1, 0, t0);                                 // ld t1, 0(t0)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, t0, 8);                             // daddiu t0, t0, 8
+  c->pextlh(t1, r0, t1);                            // pextlh t1, r0, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t2, t1, t2);                              // pand t2, t1, t2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->psllw(t2, t2, 5);                              // psllw t2, t2, 5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->paddw(t5, t2, a2);                             // paddw t5, t2, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->dsrl32(t6, t5, 0);                             // dsrl32 t6, t5, 0
+  c->lwc1(f3, 24, t5);                              // lwc1 f3, 24(t5)
+  c->pcpyud(t7, t5, r0);                            // pcpyud t7, t5, r0
+  c->lwc1(f2, 24, t6);                              // lwc1 f2, 24(t6)
+  c->dsrl32(t8, t7, 0);                             // dsrl32 t8, t7, 0
+  c->lwc1(f1, 24, t7);                              // lwc1 f1, 24(t7)
+  c->pand(t1, t1, a3);                              // pand t1, t1, a3
+  c->lwc1(f4, 24, t8);                              // lwc1 f4, 24(t8)
+  c->psraw(t2, t1, 8);                              // psraw t2, t1, 8
+  c->lq(t1, 16, t5);                                // lq t1, 16(t5)
+  c->mov128_gpr_gpr(s1, t2);                        // por s1, t2, r0
+  c->subs(f5, f3, f0);                              // sub.s f5, f3, f0
+  c->subs(f3, f2, f0);                              // sub.s f3, f2, f0
+  // nop                                            // sll r0, r0, 0
+  c->subs(f2, f1, f0);                              // sub.s f2, f1, f0
+  // nop                                            // sll r0, r0, 0
+  c->subs(f1, f4, f0);                              // sub.s f1, f4, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f4, f0, f5);                              // div.s f4, f0, f5
+  c->lq(t2, 16, t6);                                // lq t2, 16(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 16, t7);                                // lq t3, 16(t7)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 16, t8);                                // lq t4, 16(t8)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 0, t5);                                 // lq t5, 0(t5)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t6, 0, t6);                                 // lq t6, 0(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 0, t7);                                 // lq t7, 0(t7)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t8, 0, t8);                                 // lq t8, 0(t8)
+  c->muls(f4, f4, f0);                              // mul.s f4, f4, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f3, f0, f3);                              // div.s f3, f0, f3
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(t9, f4);                                  // mfc1 t9, f4
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f3, f3, f0);                              // mul.s f3, f3, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f2, f0, f2);                              // div.s f2, f0, f2
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(ra, f3);                                  // mfc1 ra, f3
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f2, f2, f0);                              // mul.s f2, f2, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f1, f0, f1);                              // div.s f1, f0, f1
+  // nop                                            // sll r0, r0, 0
+  c->pextlw(t9, ra, t9);                            // pextlw t9, ra, t9
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(ra, f2);                                  // mfc1 ra, f2
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(gp, f1);                                  // mfc1 gp, f1
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf21, t1);                       // qmtc2.ni vf21, t1
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf9, t5);                        // qmtc2.ni vf9, t5
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf10, t6);                       // qmtc2.ni vf10, t6
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf11, t7);                       // qmtc2.ni vf11, t7
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf12, t8);                       // qmtc2.ni vf12, t8
+  c->pextlw(t1, gp, ra);                            // pextlw t1, gp, ra
+  // nop                                            // sll r0, r0, 0
+  c->pcpyld(t1, t1, t9);                            // pcpyld t1, t1, t9
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf22, t2);                       // qmtc2.ni vf22, t2
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf23, t3);                       // qmtc2.ni vf23, t3
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf24, t4);                       // qmtc2.ni vf24, t4
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf27, t1);                       // qmtc2.ni vf27, t1
+  c->lq(t2, 96, at);                                // lq t2, 96(at)
+  // Unknown instr: vcallms 48
+  vcallms48(c);
+  // nop                                            // sll r0, r0, 0
+  c->ld(t1, 0, t0);                                 // ld t1, 0(t0)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, t0, 8);                             // daddiu t0, t0, 8
+  c->pextlh(t1, r0, t1);                            // pextlh t1, r0, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t2, t1, t2);                              // pand t2, t1, t2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->psllw(t2, t2, 5);                              // psllw t2, t2, 5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->paddw(t2, t2, a2);                             // paddw t2, t2, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->dsrl32(t3, t2, 0);                             // dsrl32 t3, t2, 0
+  c->lwc1(f3, 24, t2);                              // lwc1 f3, 24(t2)
+  c->pcpyud(t7, t2, r0);                            // pcpyud t7, t2, r0
+  c->lwc1(f2, 24, t3);                              // lwc1 f2, 24(t3)
+  c->dsrl32(t8, t7, 0);                             // dsrl32 t8, t7, 0
+  c->lwc1(f1, 24, t7);                              // lwc1 f1, 24(t7)
+  c->pand(t1, t1, a3);                              // pand t1, t1, a3
+  c->lwc1(f4, 24, t8);                              // lwc1 f4, 24(t8)
+  c->psraw(t4, t1, 8);                              // psraw t4, t1, 8
+  c->lq(t1, 16, t2);                                // lq t1, 16(t2)
+  c->mov128_gpr_gpr(s2, t4);                        // por s2, t4, r0
+  c->subs(f5, f3, f0);                              // sub.s f5, f3, f0
+  c->subs(f3, f2, f0);                              // sub.s f3, f2, f0
+  // nop                                            // sll r0, r0, 0
+  c->subs(f2, f1, f0);                              // sub.s f2, f1, f0
+  // nop                                            // sll r0, r0, 0
+  c->subs(f1, f4, f0);                              // sub.s f1, f4, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f4, f0, f5);                              // div.s f4, f0, f5
+  c->lq(t4, 16, t3);                                // lq t4, 16(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 16, t7);                                // lq t5, 16(t7)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t6, 16, t8);                                // lq t6, 16(t8)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 0, t2);                                 // lq t2, 0(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 0, t3);                                 // lq t3, 0(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 0, t7);                                 // lq t7, 0(t7)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t8, 0, t8);                                 // lq t8, 0(t8)
+  c->muls(f4, f4, f0);                              // mul.s f4, f4, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f3, f0, f3);                              // div.s f3, f0, f3
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(t9, f4);                                  // mfc1 t9, f4
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f3, f3, f0);                              // mul.s f3, f3, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f2, f0, f2);                              // div.s f2, f0, f2
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(ra, f3);                                  // mfc1 ra, f3
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f2, f2, f0);                              // mul.s f2, f2, f0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f1, f0, f1);                              // div.s f1, f0, f1
+  // nop                                            // sll r0, r0, 0
+  c->pextlw(t9, ra, t9);                            // pextlw t9, ra, t9
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(ra, f2);                                  // mfc1 ra, f2
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf21, t1);                       // qmtc2.ni vf21, t1
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf22, t4);                       // qmtc2.ni vf22, t4
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf23, t5);                       // qmtc2.ni vf23, t5
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf24, t6);                       // qmtc2.ni vf24, t6
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(t1, f1);                                  // mfc1 t1, f1
+  c->pextlw(t1, t1, ra);                            // pextlw t1, t1, ra
+  // nop                                            // sll r0, r0, 0
+  c->pcpyld(t1, t1, t9);                            // pcpyld t1, t1, t9
+  c->mov128_vf_gpr(vf9, t2);                        // qmtc2.ni vf9, t2
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf10, t3);                       // qmtc2.ni vf10, t3
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf11, t7);                       // qmtc2.ni vf11, t7
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf12, t8);                       // qmtc2.ni vf12, t8
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf27, t1);                       // qmtc2.ni vf27, t1
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t4, vf17);                       // qmfc2.ni t4, vf17
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t5, vf18);                       // qmfc2.ni t5, vf18
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t6, vf19);                       // qmfc2.ni t6, vf19
+  bc = ((s64)c->sgpr64(a0)) <= 0;                   // blez a0, L88
+  c->mov128_gpr_vf(t7, vf20);                       // qmfc2.ni t7, vf20
+  if (bc) {goto block_8;}                           // branch non-likely
+
+
+  block_7:
+  c->lq(t2, 96, at);                                // lq t2, 96(at)
+  // Unknown instr: vcallms 48
+  vcallms48(c);
+  c->daddiu(a0, a0, -4);                            // daddiu a0, a0, -4
+  c->ld(t1, 0, t0);                                 // ld t1, 0(t0)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(v1, v1, 16);                            // daddiu v1, v1, 16
+  c->daddiu(t0, t0, 8);                             // daddiu t0, t0, 8
+  c->pextlh(t1, r0, t1);                            // pextlh t1, r0, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t2, t1, t2);                              // pand t2, t1, t2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->psllw(t2, t2, 5);                              // psllw t2, t2, 5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->paddw(t9, t2, a2);                             // paddw t9, t2, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->dsrl32(ra, t9, 0);                             // dsrl32 ra, t9, 0
+  c->lwc1(f1, 24, t9);                              // lwc1 f1, 24(t9)
+  c->pcpyud(s4, t9, r0);                            // pcpyud s4, t9, r0
+  c->lwc1(f4, 24, ra);                              // lwc1 f4, 24(ra)
+  c->subs(f3, f1, f0);                              // sub.s f3, f1, f0
+  // nop                                            // sll r0, r0, 0
+  c->dsrl32(s3, s4, 0);                             // dsrl32 s3, s4, 0
+  c->lwc1(f1, 24, s4);                              // lwc1 f1, 24(s4)
+  c->pand(t1, t1, a3);                              // pand t1, t1, a3
+  c->lwc1(f2, 24, s3);                              // lwc1 f2, 24(s3)
+  c->psraw(s5, t1, 8);                              // psraw s5, t1, 8
+  c->lq(t1, 16, t9);                                // lq t1, 16(t9)
+  c->divs(f3, f0, f3);                              // div.s f3, f0, f3
+  c->lq(t2, 16, ra);                                // lq t2, 16(ra)
+  c->mov128_gpr_gpr(gp, s0);                        // por gp, s0, r0
+  c->subs(f4, f4, f0);                              // sub.s f4, f4, f0
+  c->ppach(t4, r0, t4);                             // ppach t4, r0, t4
+  c->lq(t3, 16, s4);                                // lq t3, 16(s4)
+  c->ppach(t5, r0, t5);                             // ppach t5, r0, t5
+  c->lq(t8, 16, s3);                                // lq t8, 16(s3)
+  c->ppach(t6, r0, t6);                             // ppach t6, r0, t6
+  c->lq(t9, 0, t9);                                 // lq t9, 0(t9)
+  c->ppach(t7, r0, t7);                             // ppach t7, r0, t7
+  c->lq(ra, 0, ra);                                 // lq ra, 0(ra)
+  c->pextlw(t4, t5, t4);                            // pextlw t4, t5, t4
+  c->lq(t5, 0, s4);                                 // lq t5, 0(s4)
+  c->pextlw(t6, t7, t6);                            // pextlw t6, t7, t6
+  c->lq(t7, 0, s3);                                 // lq t7, 0(s3)
+  c->mov128_gpr_gpr(s0, s1);                        // por s0, s1, r0
+  c->muls(f5, f3, f0);                              // mul.s f5, f3, f0
+  c->mov128_gpr_gpr(s1, s2);                        // por s1, s2, r0
+  c->divs(f3, f0, f4);                              // div.s f3, f0, f4
+  c->pcpyld(t4, t6, t4);                            // pcpyld t4, t6, t4
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t4, t4, a1);                              // pand t4, t4, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->mov128_gpr_gpr(s2, s5);                        // por s2, s5, r0
+  c->mfc1(t6, f5);                                  // mfc1 t6, f5
+  c->subs(f4, f1, f0);                              // sub.s f4, f1, f0
+  // nop                                            // sll r0, r0, 0
+  c->por(t4, t4, gp);                               // por t4, t4, gp
+  // nop                                            // sll r0, r0, 0
+  c->subs(f1, f2, f0);                              // sub.s f1, f2, f0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f2, f3, f0);                              // mul.s f2, f3, f0
+  c->sq(t4, -16, v1);                               // sq t4, -16(v1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f3, f0, f4);                              // div.s f3, f0, f4
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(t4, f2);                                  // mfc1 t4, f2
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->muls(f2, f3, f0);                              // mul.s f2, f3, f0
+  // nop                                            // sll r0, r0, 0
+  c->pextlw(t4, t4, t6);                            // pextlw t4, t4, t6
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->divs(f1, f0, f1);                              // div.s f1, f0, f1
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(t6, f2);                                  // mfc1 t6, f2
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf21, t1);                       // qmtc2.ni vf21, t1
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf22, t2);                       // qmtc2.ni vf22, t2
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf23, t3);                       // qmtc2.ni vf23, t3
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf24, t8);                       // qmtc2.ni vf24, t8
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(t1, f1);                                  // mfc1 t1, f1
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf9, t9);                        // qmtc2.ni vf9, t9
+  c->pextlw(t1, t1, t6);                            // pextlw t1, t1, t6
+  c->mov128_vf_gpr(vf10, ra);                       // qmtc2.ni vf10, ra
+  c->pcpyld(t1, t1, t4);                            // pcpyld t1, t1, t4
+  c->mov128_vf_gpr(vf11, t5);                       // qmtc2.ni vf11, t5
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf12, t7);                       // qmtc2.ni vf12, t7
+  // nop                                            // sll r0, r0, 0
+  c->mov128_vf_gpr(vf27, t1);                       // qmtc2.ni vf27, t1
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t4, vf17);                       // qmfc2.ni t4, vf17
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t5, vf18);                       // qmfc2.ni t5, vf18
+  // nop                                            // sll r0, r0, 0
+  c->mov128_gpr_vf(t6, vf19);                       // qmfc2.ni t6, vf19
+  bc = ((s64)c->sgpr64(a0)) > 0;                    // bgtz a0, L87
+  c->mov128_gpr_vf(t7, vf20);                       // qmfc2.ni t7, vf20
+  if (bc) {goto block_7;}                           // branch non-likely
+
+
+  block_8:
+  c->daddiu(v1, v1, 16);                            // daddiu v1, v1, 16
+  // nop                                            // sll r0, r0, 0
+  c->ppach(t4, r0, t4);                             // ppach t4, r0, t4
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->ppach(t5, r0, t5);                             // ppach t5, r0, t5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->ppach(t6, r0, t6);                             // ppach t6, r0, t6
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->ppach(t7, r0, t7);                             // ppach t7, r0, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlw(t4, t5, t4);                            // pextlw t4, t5, t4
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlw(t6, t7, t6);                            // pextlw t6, t7, t6
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(t4, t6, t4);                            // pcpyld t4, t6, t4
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t4, t4, a1);                              // pand t4, t4, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->por(t4, t4, s0);                               // por t4, t4, s0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->sq(t4, -16, v1);                               // sq t4, -16(v1)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 12432, at);                             // ld ra, 12432(at)
+  c->lq(gp, 12544, at);                             // lq gp, 12544(at)
+  c->lq(s5, 12528, at);                             // lq s5, 12528(at)
+  c->lq(s4, 12512, at);                             // lq s4, 12512(at)
+  c->lq(s3, 12496, at);                             // lq s3, 12496(at)
+  c->lq(s2, 12480, at);                             // lq s2, 12480(at)
+  c->lq(s1, 12464, at);                             // lq s1, 12464(at)
+  c->lq(s0, 12448, at);                             // lq s0, 12448(at)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 128);                           // daddiu sp, sp, 128
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("generic-envmap-proc", execute, 256);
+}
+
+} // namespace generic_envmap_proc
+} // namespace Mips2C
+// add generic_envmap_proc::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_prepare_dma_double {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  c->daddiu(sp, sp, -128);                          // daddiu sp, sp, -128
+  c->sd(ra, 12432, at);                             // sd ra, 12432(at)
+  c->sq(s0, 12448, at);                             // sq s0, 12448(at)
+  c->sq(s1, 12464, at);                             // sq s1, 12464(at)
+  c->sq(s2, 12480, at);                             // sq s2, 12480(at)
+  c->sq(s3, 12496, at);                             // sq s3, 12496(at)
+  c->sq(s4, 12512, at);                             // sq s4, 12512(at)
+  c->sq(s5, 12528, at);                             // sq s5, 12528(at)
+  c->sq(gp, 12544, at);                             // sq gp, 12544(at)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->lw(a3, 44, at);                                // lw a3, 44(at)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(v1, 16, a3);                               // lbu v1, 16(a3)
+  // nop                                            // sll r0, r0, 0
+  c->lh(a0, 18, a3);                                // lh a0, 18(a3)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t7, 24, at);                                // lw t7, 24(at)
+  c->sll(a2, v1, 2);                                // sll a2, v1, 2
+  c->daddiu(a1, a0, 3);                             // daddiu a1, a0, 3
+  c->daddu(a2, a2, v1);                             // daddu a2, a2, v1
+  c->addiu(t0, r0, -4);                             // addiu t0, r0, -4
+  c->and_(t6, a1, t0);                              // and t6, a1, t0
+  c->sll(a1, a2, 4);                                // sll a1, a2, 4
+  c->daddu(a2, t6, t6);                             // daddu a2, t6, t6
+  c->daddiu(a1, a1, 112);                           // daddiu a1, a1, 112
+  c->daddu(a2, a2, t6);                             // daddu a2, a2, t6
+  c->dsll(t0, t6, 2);                               // dsll t0, t6, 2
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, t0, 15);                            // daddiu t0, t0, 15
+  c->dsll(a2, a2, 2);                               // dsll a2, a2, 2
+  c->dsra(t0, t0, 4);                               // dsra t0, t0, 4
+  c->daddiu(a2, a2, 15);                            // daddiu a2, a2, 15
+  c->dsll(t4, t0, 4);                               // dsll t4, t0, 4
+  c->dsra(t9, a2, 4);                               // dsra t9, a2, 4
+  c->dsll(t1, t9, 4);                               // dsll t1, t9, 4
+  c->mov64(a2, t7);                                 // or a2, t7, r0
+  c->dsra(t8, a1, 4);                               // dsra t8, a1, 4
+  c->lq(t0, 11744, at);                             // lq t0, 11744(at)
+  c->daddu(t2, a2, a1);                             // daddu t2, a2, a1
+  c->lq(t5, 11760, at);                             // lq t5, 11760(at)
+  c->daddu(t1, t2, t1);                             // daddu t1, t2, t1
+  c->sq(t0, 0, a2);                                 // sq t0, 0(a2)
+  c->daddiu(t0, t2, 32);                            // daddiu t0, t2, 32
+  c->lq(ra, 11776, at);                             // lq ra, 11776(at)
+  c->daddu(t2, t1, t4);                             // daddu t2, t1, t4
+  c->sq(r0, -16, t0);                               // sq r0, -16(t0)
+  c->daddiu(t1, t1, 64);                            // daddiu t1, t1, 64
+  c->lq(gp, 11792, at);                             // lq gp, 11792(at)
+  c->daddu(t3, t2, t4);                             // daddu t3, t2, t4
+  c->sq(r0, -32, t1);                               // sq r0, -32(t1)
+  c->daddiu(t2, t2, 80);                            // daddiu t2, t2, 80
+  c->sq(r0, -16, t1);                               // sq r0, -16(t1)
+  c->daddu(s5, t3, a1);                             // daddu s5, t3, a1
+  c->sq(r0, -32, t2);                               // sq r0, -32(t2)
+  c->daddiu(a1, t3, 80);                            // daddiu a1, t3, 80
+  c->sq(r0, -16, t2);                               // sq r0, -16(t2)
+  c->daddu(s4, s5, t4);                             // daddu s4, s5, t4
+  c->sq(r0, -16, a1);                               // sq r0, -16(a1)
+  c->daddiu(t3, s5, 112);                           // daddiu t3, s5, 112
+  c->lw(s5, 11984, at);                             // lw s5, 11984(at)
+  c->daddu(s3, s4, t4);                             // daddu s3, s4, t4
+  c->sq(r0, -16, t3);                               // sq r0, -16(t3)
+  c->daddiu(t4, s4, 128);                           // daddiu t4, s4, 128
+  c->sq(t5, 0, a1);                                 // sq t5, 0(a1)
+  c->daddiu(t5, s3, 128);                           // daddiu t5, s3, 128
+  c->sq(r0, -32, t4);                               // sq r0, -32(t4)
+  c->subu(s4, t5, t7);                              // subu s4, t5, t7
+  c->sq(r0, -16, t4);                               // sq r0, -16(t4)
+  c->sra(s4, s4, 4);                                // sra s4, s4, 4
+  c->sq(r0, -16, t5);                               // sq r0, -16(t5)
+  c->daddiu(s4, s4, -1);                            // daddiu s4, s4, -1
+  c->sq(ra, 0, t5);                                 // sq ra, 0(t5)
+  c->sh(t9, 0, t5);                                 // sh t9, 0(t5)
+  c->sq(gp, 16, t5);                                // sq gp, 16(t5)
+  c->sw(s5, 24, t5);                                // sw s5, 24(t5)
+  c->sh(s4, 0, t7);                                 // sh s4, 0(t7)
+  c->daddiu(t7, s4, 3);                             // daddiu t7, s4, 3
+  c->sw(t7, 40, at);                                // sw t7, 40(at)
+  c->lw(t7, 60, at);                                // lw t7, 60(at)
+  c->dsubu(t9, t0, a2);                             // dsubu t9, t0, a2
+  c->daddu(t7, t7, t9);                             // daddu t7, t7, t9
+  c->lw(t9, 12, a2);                                // lw t9, 12(a2)
+  c->sll(ra, t8, 16);                               // sll ra, t8, 16
+  c->lw(t8, 68, at);                                // lw t8, 68(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(gp, 12, a1);                                // lw gp, 12(a1)
+  c->or_(s4, t9, t8);                               // or s4, t9, t8
+  c->lw(t9, 72, at);                                // lw t9, 72(at)
+  c->xori(s5, t8, 38);                              // xori s5, t8, 38
+  // nop                                            // sll r0, r0, 0
+  c->or_(s4, s4, ra);                               // or s4, s4, ra
+  c->lw(t8, 11968, at);                             // lw t8, 11968(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(s3, 11988, at);                             // lw s3, 11988(at)
+  c->or_(gp, gp, s5);                               // or gp, gp, s5
+  c->sw(s4, 12, a2);                                // sw s4, 12(a2)
+  c->or_(s5, gp, ra);                               // or s5, gp, ra
+  c->lw(ra, 11972, at);                             // lw ra, 11972(at)
+  c->daddiu(gp, t9, 1);                             // daddiu gp, t9, 1
+  c->sw(s5, 12, a1);                                // sw s5, 12(a1)
+  c->daddiu(s4, t9, 2);                             // daddiu s4, t9, 2
+  c->lw(s3, 11976, at);                             // lw s3, 11976(at)
+  c->dsll(t6, t6, 16);                              // dsll t6, t6, 16
+  c->lw(s5, 11980, at);                             // lw s5, 11980(at)
+  c->or_(s4, ra, s4);                               // or s4, ra, s4
+  c->lw(ra, 11984, at);                             // lw ra, 11984(at)
+  c->or_(s3, s3, gp);                               // or s3, s3, gp
+  c->lw(gp, 11992, at);                             // lw gp, 11992(at)
+  c->mov64(s2, t9);                                 // or s2, t9, r0
+  c->sw(t8, -8, t0);                                // sw t8, -8(t0)
+  c->or_(s5, s5, s2);                               // or s5, s5, s2
+  c->sw(gp, 4, a1);                                 // sw gp, 4(a1)
+  c->or_(s4, s4, t6);                               // or s4, s4, t6
+  c->sw(ra, 0, a1);                                 // sw ra, 0(a1)
+  c->or_(s3, s3, t6);                               // or s3, s3, t6
+  c->sw(s4, -4, t0);                                // sw s4, -4(t0)
+  c->or_(s5, s5, t6);                               // or s5, s5, t6
+  c->sw(s3, -4, t1);                                // sw s3, -4(t1)
+  c->addiu(s4, r0, 567);                            // addiu s4, r0, 567
+  c->sw(s5, -4, t2);                                // sw s5, -4(t2)
+  bc = c->sgpr64(t9) != c->sgpr64(s4);              // bne t9, s4, L74
+  c->daddiu(t9, t9, 279);                           // daddiu t9, t9, 279
+  if (bc) {goto block_2;}                           // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->addiu(t9, r0, 9);                              // addiu t9, r0, 9
+
+  block_2:
+  c->daddiu(s1, t9, 1);                             // daddiu s1, t9, 1
+  c->lw(s0, 11976, at);                             // lw s0, 11976(at)
+  c->mov64(s3, t9);                                 // or s3, t9, r0
+  c->lw(s2, 11980, at);                             // lw s2, 11980(at)
+  c->daddiu(s5, t9, 2);                             // daddiu s5, t9, 2
+  c->lw(s4, 11972, at);                             // lw s4, 11972(at)
+  c->or_(s1, s0, s1);                               // or s1, s0, s1
+  c->sw(t8, -8, t3);                                // sw t8, -8(t3)
+  c->or_(t8, s2, s3);                               // or t8, s2, s3
+  c->sw(gp, 24, t5);                                // sw gp, 24(t5)
+  c->or_(gp, s4, s5);                               // or gp, s4, s5
+  // nop                                            // sll r0, r0, 0
+  c->or_(s5, s1, t6);                               // or s5, s1, t6
+  c->sw(ra, 28, t5);                                // sw ra, 28(t5)
+  c->or_(t8, t8, t6);                               // or t8, t8, t6
+  c->sw(s5, -4, t3);                                // sw s5, -4(t3)
+  c->or_(ra, gp, t6);                               // or ra, gp, t6
+  c->sw(t8, -4, t4);                                // sw t8, -4(t4)
+  c->addiu(t6, r0, 567);                            // addiu t6, r0, 567
+  c->sw(t7, 4, t5);                                 // sw t7, 4(t5)
+  // nop                                            // sll r0, r0, 0
+  c->sw(ra, 12, t5);                                // sw ra, 12(t5)
+  bc = c->sgpr64(t9) != c->sgpr64(t6);              // bne t9, t6, L75
+  c->daddiu(t5, t9, 279);                           // daddiu t5, t9, 279
+  if (bc) {goto block_4;}                           // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->addiu(t5, r0, 9);                              // addiu t5, r0, 9
+
+  block_4:
+  // nop                                            // sll r0, r0, 0
+  c->sw(t5, 72, at);                                // sw t5, 72(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t0, 4, at);                                 // sw t0, 4(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t1, 8, at);                                 // sw t1, 8(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t2, 12, at);                                // sw t2, 12(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t3, 16, at);                                // sw t3, 16(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t4, 20, at);                                // sw t4, 20(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t0, 48, at);                                // lw t0, 48(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t1, 11808, at);                             // lq t1, 11808(at)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L80
+  c->lq(t2, 11824, at);                             // lq t2, 11824(at)
+  if (bc) {goto block_13;}                          // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 11840, at);                             // lq t3, 11840(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 11856, at);                             // lq t4, 11856(at)
+  // nop                                            // sll r0, r0, 0
+  c->lh(t5, 58, at);                                // lh t5, 58(at)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t1, 16, a2);                                // sq t1, 16(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t2, 32, a2);                                // sq t2, 32(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t3, 48, a2);                                // sq t3, 48(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t4, 64, a2);                                // sq t4, 64(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t1, 16, a1);                                // sq t1, 16(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t2, 32, a1);                                // sq t2, 32(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t3, 48, a1);                                // sq t3, 48(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t4, 64, a1);                                // sq t4, 64(a1)
+  bc = c->sgpr64(t5) == 0;                          // beq t5, r0, L76
+  c->lq(t1, 11872, at);                             // lq t1, 11872(at)
+  if (bc) {goto block_7;}                           // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 11904, at);                             // lq t2, 11904(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 11936, at);                             // lq t3, 11936(at)
+  //beq r0, r0, L77                                 // beq r0, r0, L77
+  c->lq(t4, 12032, at);                             // lq t4, 12032(at)
+  goto block_8;                                     // branch always
+
+
+  block_7:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 11888, at);                             // lq t2, 11888(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 11936, at);                             // lq t3, 11936(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 12032, at);                             // lq t4, 12032(at)
+
+  block_8:
+  // nop                                            // sll r0, r0, 0
+  c->sq(t1, 80, a2);                                // sq t1, 80(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t2, 96, a2);                                // sq t2, 96(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t3, 112, a2);                               // sq t3, 112(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t4, 80, a1);                                // sq t4, 80(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t3, 96, a1);                                // sq t3, 96(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t3, 112, a1);                               // sq t3, 112(a1)
+  c->daddiu(t2, a3, 22);                            // daddiu t2, a3, 22
+  c->addiu(t3, r0, 0);                              // addiu t3, r0, 0
+  c->mov64(t4, v1);                                 // or t4, v1, r0
+  c->addiu(t6, r0, 128);                            // addiu t6, r0, 128
+  c->mov64(t1, a2);                                 // or t1, a2, r0
+
+  block_9:
+  c->daddu(t1, t1, t6);                             // daddu t1, t1, t6
+  c->lq(t6, 0, t0);                                 // lq t6, 0(t0)
+  c->daddiu(t4, t4, -1);                            // daddiu t4, t4, -1
+  c->lbu(t5, 0, t2);                                // lbu t5, 0(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 16, t0);                                // lq t7, 16(t0)
+  c->daddu(t9, t5, t5);                             // daddu t9, t5, t5
+  c->lq(t8, 32, t0);                                // lq t8, 32(t0)
+  c->daddu(ra, t9, t5);                             // daddu ra, t9, t5
+  c->lq(t9, 48, t0);                                // lq t9, 48(t0)
+  c->daddiu(gp, ra, 9);                             // daddiu gp, ra, 9
+  c->lq(ra, 64, t0);                                // lq ra, 64(t0)
+  c->daddiu(t0, t0, 80);                            // daddiu t0, t0, 80
+  c->sq(t6, 0, t1);                                 // sq t6, 0(t1)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t3, 12, t1);                                // sw t3, 12(t1)
+  c->daddiu(t2, t2, 1);                             // daddiu t2, t2, 1
+  c->sq(t7, 16, t1);                                // sq t7, 16(t1)
+  c->daddu(t3, t3, gp);                             // daddu t3, t3, gp
+  c->sw(t5, 28, t1);                                // sw t5, 28(t1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t8, 32, t1);                                // sq t8, 32(t1)
+  c->addiu(t6, r0, 80);                             // addiu t6, r0, 80
+  c->sq(t9, 48, t1);                                // sq t9, 48(t1)
+  bc = ((s64)c->sgpr64(t4)) > 0;                    // bgtz t4, L78
+  c->sq(ra, 64, t1);                                // sq ra, 64(t1)
+  if (bc) {goto block_9;}                           // branch non-likely
+
+  c->ori(t0, t5, 32768);                            // ori t0, t5, 32768
+  c->sw(a0, 36, at);                                // sw a0, 36(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t0, 28, t1);                                // sw t0, 28(t1)
+  // nop                                            // sll r0, r0, 0
+  c->sw(v1, 92, a2);                                // sw v1, 92(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 108, a2);                               // sw a0, 108(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sw(r0, 124, a2);                               // sw r0, 124(a2)
+  c->daddiu(a3, a3, 22);                            // daddiu a3, a3, 22
+  c->addiu(t0, r0, 0);                              // addiu t0, r0, 0
+  c->mov64(t1, v1);                                 // or t1, v1, r0
+  c->lw(t6, 52, at);                                // lw t6, 52(at)
+  c->mov64(a2, a1);                                 // or a2, a1, r0
+  c->addiu(t8, r0, 128);                            // addiu t8, r0, 128
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 0, t6);                                 // lq t2, 0(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 16, t6);                                // lq t3, 16(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 32, t6);                                // lq t4, 32(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 48, t6);                                // lq t5, 48(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t6, 64, t6);                                // lq t6, 64(t6)
+
+  block_11:
+  c->daddu(a2, a2, t8);                             // daddu a2, a2, t8
+  c->lbu(t7, 0, a3);                                // lbu t7, 0(a3)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->sq(t2, 0, a2);                                 // sq t2, 0(a2)
+  c->daddu(t8, t7, t7);                             // daddu t8, t7, t7
+  c->sw(t0, 12, a2);                                // sw t0, 12(a2)
+  c->daddu(t8, t8, t7);                             // daddu t8, t8, t7
+  c->sq(t3, 16, a2);                                // sq t3, 16(a2)
+  c->daddiu(t8, t8, 9);                             // daddiu t8, t8, 9
+  c->sw(t7, 28, a2);                                // sw t7, 28(a2)
+  c->daddiu(a3, a3, 1);                             // daddiu a3, a3, 1
+  // nop                                            // sll r0, r0, 0
+  c->daddu(t0, t0, t8);                             // daddu t0, t0, t8
+  c->sq(t4, 32, a2);                                // sq t4, 32(a2)
+  c->addiu(t8, r0, 80);                             // addiu t8, r0, 80
+  c->sq(t5, 48, a2);                                // sq t5, 48(a2)
+  bc = ((s64)c->sgpr64(t1)) > 0;                    // bgtz t1, L79
+  c->sq(t6, 64, a2);                                // sq t6, 64(a2)
+  if (bc) {goto block_11;}                          // branch non-likely
+
+  c->ori(a3, t7, 32768);                            // ori a3, t7, 32768
+  c->sw(a0, 36, at);                                // sw a0, 36(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a3, 28, a2);                                // sw a3, 28(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sw(v1, 92, a1);                                // sw v1, 92(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 108, a1);                               // sw a0, 108(a1)
+  //beq r0, r0, L82                                 // beq r0, r0, L82
+  c->sw(r0, 124, a1);                               // sw r0, 124(a1)
+  goto block_16;                                    // branch always
+
+
+  block_13:
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 16, a2);                                // lq a3, 16(a2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t0, 32, a2);                                // lq t0, 32(a2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t1, 48, a2);                                // lq t1, 48(a2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 64, a2);                                // lq t2, 64(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 16, a1);                                // sq a3, 16(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, 32, a1);                                // sq t0, 32(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t1, 48, a1);                                // sq t1, 48(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t2, 64, a1);                                // sq t2, 64(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 12032, at);                             // lq a3, 12032(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t0, 11936, at);                             // lq t0, 11936(at)
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 80, a1);                                // sq a3, 80(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, 96, a1);                                // sq t0, 96(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, 112, a1);                               // sq t0, 112(a1)
+  c->mov64(a3, v1);                                 // or a3, v1, r0
+  c->lw(t5, 52, at);                                // lw t5, 52(at)
+  c->mov64(t0, a1);                                 // or t0, a1, r0
+  c->addiu(t7, r0, 128);                            // addiu t7, r0, 128
+  // nop                                            // sll r0, r0, 0
+  c->lq(t1, 0, t5);                                 // lq t1, 0(t5)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 16, t5);                                // lq t2, 16(t5)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 32, t5);                                // lq t3, 32(t5)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 48, t5);                                // lq t4, 48(t5)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 64, t5);                                // lq t5, 64(t5)
+  c->daddu(a2, a2, t7);                             // daddu a2, a2, t7
+  // nop                                            // sll r0, r0, 0
+
+  block_14:
+  c->daddu(t0, t0, t7);                             // daddu t0, t0, t7
+  c->lwu(t8, 12, a2);                               // lwu t8, 12(a2)
+  c->daddiu(a3, a3, -1);                            // daddiu a3, a3, -1
+  c->lwu(t7, 28, a2);                               // lwu t7, 28(a2)
+  c->daddiu(a2, a2, 80);                            // daddiu a2, a2, 80
+  c->sq(t1, 0, t0);                                 // sq t1, 0(t0)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t8, 12, t0);                                // sw t8, 12(t0)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t2, 16, t0);                                // sq t2, 16(t0)
+  c->daddu(t8, t8, t6);                             // daddu t8, t8, t6
+  c->sw(t7, 28, t0);                                // sw t7, 28(t0)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t3, 32, t0);                                // sq t3, 32(t0)
+  c->addiu(t7, r0, 80);                             // addiu t7, r0, 80
+  c->sq(t4, 48, t0);                                // sq t4, 48(t0)
+  bc = ((s64)c->sgpr64(a3)) > 0;                    // bgtz a3, L81
+  c->sq(t5, 64, t0);                                // sq t5, 64(t0)
+  if (bc) {goto block_14;}                          // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 36, at);                                // sw a0, 36(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(v1, 92, a1);                                // sw v1, 92(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 108, a1);                               // sw a0, 108(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sw(r0, 124, a1);                               // sw r0, 124(a1)
+
+  block_16:
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 12432, at);                             // ld ra, 12432(at)
+  c->lq(gp, 12544, at);                             // lq gp, 12544(at)
+  c->lq(s5, 12528, at);                             // lq s5, 12528(at)
+  c->lq(s4, 12512, at);                             // lq s4, 12512(at)
+  c->lq(s3, 12496, at);                             // lq s3, 12496(at)
+  c->lq(s2, 12480, at);                             // lq s2, 12480(at)
+  c->lq(s1, 12464, at);                             // lq s1, 12464(at)
+  c->lq(s0, 12448, at);                             // lq s0, 12448(at)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 128);                           // daddiu sp, sp, 128
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("generic-prepare-dma-double", execute, 256);
+}
+
+} // namespace generic_prepare_dma_double
+} // namespace Mips2C
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_prepare_dma_single {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+u64 execute(void* ctxt) {
+  ASSERT(false);
+  return 0;
+}
+
+u64 execute_real(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  c->daddiu(sp, sp, -32);                           // daddiu sp, sp, -32
+  // get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c); // another guess
+  c->sq(gp, 12448, at);                             // sq gp, 12448(at)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  // nop                                            // sll r0, r0, 0
+  c->lw(t1, 44, at);                                // lw t1, 44(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t8, 48, at);                                // lw t8, 48(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(v1, 24, at);                                // lw v1, 24(at)
+  // nop                                            // sll r0, r0, 0
+  c->lh(t3, 56, at);                                // lh t3, 56(at)
+  // nop                                            // sll r0, r0, 0
+  c->lh(a1, 18, t1);                                // lh a1, 18(t1)
+  c->mov64(a0, v1);                                 // or a0, v1, r0
+  c->lbu(a2, 16, t1);                               // lbu a2, 16(t1)
+  bc = c->sgpr64(t8) == 0;                          // beq t8, r0, L70
+  c->lq(t4, 11744, at);                             // lq t4, 11744(at)
+  if (bc) {goto block_10;}                          // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->lq(t9, 11808, at);                             // lq t9, 11808(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(gp, 11824, at);                             // lq gp, 11824(at)
+  c->mov64(a3, a2);                                 // or a3, a2, r0
+  c->lq(t7, 11840, at);                             // lq t7, 11840(at)
+  bc = c->sgpr64(t3) != 0;                          // bne t3, r0, L64
+  c->lq(t2, 11856, at);                             // lq t2, 11856(at)
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->lq(t0, 11872, at);                             // lq t0, 11872(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 11888, at);                             // lq t5, 11888(at)
+  //beq r0, r0, L65                                 // beq r0, r0, L65
+  c->lq(t6, 11936, at);                             // lq t6, 11936(at)
+  goto block_4;                                     // branch always
+
+
+  block_3:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t0, 12032, at);                             // lq t0, 12032(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 11936, at);                             // lq t5, 11936(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t6, 11936, at);                             // lq t6, 11936(at)
+
+  block_4:
+  // nop                                            // sll r0, r0, 0
+  c->sq(t4, 0, a0);                                 // sq t4, 0(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t9, 16, a0);                                // sq t9, 16(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sq(gp, 32, a0);                                // sq gp, 32(a0)
+  c->mov64(t4, t8);                                 // or t4, t8, r0
+  c->sq(t7, 48, a0);                                // sq t7, 48(a0)
+  c->daddiu(t1, t1, 22);                            // daddiu t1, t1, 22
+  c->sq(t2, 64, a0);                                // sq t2, 64(a0)
+  c->addiu(t2, r0, 0);                              // addiu t2, r0, 0
+  c->sq(t0, 80, a0);                                // sq t0, 80(a0)
+  c->addiu(t0, r0, 128);                            // addiu t0, r0, 128
+  c->sq(t5, 96, a0);                                // sq t5, 96(a0)
+  bc = c->sgpr64(t3) != 0;                          // bne t3, r0, L67
+  c->sq(t6, 112, a0);                               // sq t6, 112(a0)
+  if (bc) {goto block_7;}                           // branch non-likely
+
+
+  block_5:
+  c->daddu(a0, a0, t0);                             // daddu a0, a0, t0
+  c->lq(t0, 0, t4);                                 // lq t0, 0(t4)
+  c->daddiu(a3, a3, -1);                            // daddiu a3, a3, -1
+  c->lbu(t3, 0, t1);                                // lbu t3, 0(t1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 16, t4);                                // lq t5, 16(t4)
+  c->daddu(t7, t3, t3);                             // daddu t7, t3, t3
+  c->lq(t6, 32, t4);                                // lq t6, 32(t4)
+  c->daddu(t8, t7, t3);                             // daddu t8, t7, t3
+  c->lq(t7, 48, t4);                                // lq t7, 48(t4)
+  c->daddiu(t9, t8, 9);                             // daddiu t9, t8, 9
+  c->lq(t8, 64, t4);                                // lq t8, 64(t4)
+  c->daddiu(t4, t4, 80);                            // daddiu t4, t4, 80
+  c->sq(t0, 0, a0);                                 // sq t0, 0(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sw(t2, 12, a0);                                // sw t2, 12(a0)
+  c->daddiu(t1, t1, 1);                             // daddiu t1, t1, 1
+  c->sq(t5, 16, a0);                                // sq t5, 16(a0)
+  c->daddu(t2, t2, t9);                             // daddu t2, t2, t9
+  c->sw(t3, 28, a0);                                // sw t3, 28(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t6, 32, a0);                                // sq t6, 32(a0)
+  c->addiu(t0, r0, 80);                             // addiu t0, r0, 80
+  c->sq(t7, 48, a0);                                // sq t7, 48(a0)
+  bc = ((s64)c->sgpr64(a3)) > 0;                    // bgtz a3, L66
+  c->sq(t8, 64, a0);                                // sq t8, 64(a0)
+  if (bc) {goto block_5;}                           // branch non-likely
+
+  //beq r0, r0, L69                                 // beq r0, r0, L69
+  // nop                                            // sll r0, r0, 0
+  goto block_9;                                     // branch always
+
+
+  block_7:
+  // nop                                            // sll r0, r0, 0
+  c->lw(t3, 52, at);                                // lw t3, 52(at)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 0, t3);                                 // lq t4, 0(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t5, 16, t3);                                // lq t5, 16(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t6, 32, t3);                                // lq t6, 32(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 48, t3);                                // lq t7, 48(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t8, 64, t3);                                // lq t8, 64(t3)
+
+  block_8:
+  c->daddu(a0, a0, t0);                             // daddu a0, a0, t0
+  c->lbu(t3, 0, t1);                                // lbu t3, 0(t1)
+  c->daddiu(a3, a3, -1);                            // daddiu a3, a3, -1
+  c->sq(t4, 0, a0);                                 // sq t4, 0(a0)
+  c->daddu(t0, t3, t3);                             // daddu t0, t3, t3
+  c->sw(t2, 12, a0);                                // sw t2, 12(a0)
+  c->daddu(t0, t0, t3);                             // daddu t0, t0, t3
+  c->sq(t5, 16, a0);                                // sq t5, 16(a0)
+  c->daddiu(t0, t0, 9);                             // daddiu t0, t0, 9
+  c->sw(t3, 28, a0);                                // sw t3, 28(a0)
+  c->daddiu(t1, t1, 1);                             // daddiu t1, t1, 1
+  // nop                                            // sll r0, r0, 0
+  c->daddu(t2, t2, t0);                             // daddu t2, t2, t0
+  c->sq(t6, 32, a0);                                // sq t6, 32(a0)
+  c->addiu(t0, r0, 80);                             // addiu t0, r0, 80
+  c->sq(t7, 48, a0);                                // sq t7, 48(a0)
+  bc = ((s64)c->sgpr64(a3)) > 0;                    // bgtz a3, L68
+  c->sq(t8, 64, a0);                                // sq t8, 64(a0)
+  if (bc) {goto block_8;}                           // branch non-likely
+
+
+  block_9:
+  c->ori(a3, t3, 32768);                            // ori a3, t3, 32768
+  c->sw(a1, 36, at);                                // sw a1, 36(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a3, 28, a0);                                // sw a3, 28(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a2, 92, a0);                                // sw a2, 92(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a1, 108, v1);                               // sw a1, 108(v1)
+  //beq r0, r0, L71                                 // beq r0, r0, L71
+  c->sw(r0, 124, v1);                               // sw r0, 124(v1)
+  goto block_11;                                    // branch always
+
+
+  block_10:
+  c->dsll(a3, a2, 2);                               // dsll a3, a2, 2
+  c->sq(t4, 0, a0);                                 // sq t4, 0(a0)
+  c->daddu(a3, a3, a2);                             // daddu a3, a3, a2
+  c->sw(a1, 108, v1);                               // sw a1, 108(v1)
+  c->dsll(a3, a3, 4);                               // dsll a3, a3, 4
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, a3, 128);                           // daddiu t0, a3, 128
+  c->sw(a1, 36, at);                                // sw a1, 36(at)
+
+  block_11:
+  c->dsll(t1, a2, 2);                               // dsll t1, a2, 2
+  c->lw(a3, 12, v1);                                // lw a3, 12(v1)
+  c->daddu(a2, t1, a2);                             // daddu a2, t1, a2
+  c->lw(t1, 68, at);                                // lw t1, 68(at)
+  c->daddiu(a2, a2, 7);                             // daddiu a2, a2, 7
+  // nop                                            // sll r0, r0, 0
+  c->or_(t2, a3, t1);                               // or t2, a3, t1
+  // nop                                            // sll r0, r0, 0
+  c->sll(t3, a2, 16);                               // sll t3, a2, 16
+  c->xori(a3, t1, 38);                              // xori a3, t1, 38
+  c->or_(t1, t2, t3);                               // or t1, t2, t3
+  c->daddiu(a2, a2, 1);                             // daddiu a2, a2, 1
+  // nop                                            // sll r0, r0, 0
+  c->sw(t1, 12, v1);                                // sw t1, 12(v1)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a3, 68, at);                                // sw a3, 68(at)
+  c->daddiu(a1, a1, 3);                             // daddiu a1, a1, 3
+  c->daddu(a0, a0, t0);                             // daddu a0, a0, t0
+  c->dsra(a1, a1, 2);                               // dsra a1, a1, 2
+  c->daddiu(a2, a0, 32);                            // daddiu a2, a0, 32
+  c->dsll(t0, a1, 2);                               // dsll t0, a1, 2
+  // nop                                            // sll r0, r0, 0
+  c->daddu(a3, t0, t0);                             // daddu a3, t0, t0
+  c->dsll(a1, t0, 2);                               // dsll a1, t0, 2
+  c->daddu(a3, a3, t0);                             // daddu a3, a3, t0
+  c->daddiu(a1, a1, 15);                            // daddiu a1, a1, 15
+  c->dsll(a3, a3, 2);                               // dsll a3, a3, 2
+  c->dsra(a1, a1, 4);                               // dsra a1, a1, 4
+  c->daddiu(a3, a3, 15);                            // daddiu a3, a3, 15
+  c->dsll(t1, a1, 4);                               // dsll t1, a1, 4
+  c->dsra(a3, a3, 4);                               // dsra a3, a3, 4
+  c->lw(a1, 72, at);                                // lw a1, 72(at)
+  c->dsll(a3, a3, 4);                               // dsll a3, a3, 4
+  // nop                                            // sll r0, r0, 0
+  c->daddu(a3, a2, a3);                             // daddu a3, a2, a3
+  c->lw(t2, 11968, at);                             // lw t2, 11968(at)
+  c->daddu(a2, a3, t1);                             // daddu a2, a3, t1
+  c->sq(r0, 0, a3);                                 // sq r0, 0(a3)
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->sq(r0, -16, a3);                               // sq r0, -16(a3)
+  c->daddu(t1, a2, t1);                             // daddu t1, a2, t1
+  c->sq(r0, -32, a3);                               // sq r0, -32(a3)
+  c->daddiu(t1, t1, 16);                            // daddiu t1, t1, 16
+  c->sq(r0, 0, a2);                                 // sq r0, 0(a2)
+  c->subu(t3, t1, v1);                              // subu t3, t1, v1
+  c->sq(r0, -16, a2);                               // sq r0, -16(a2)
+  c->sra(t3, t3, 4);                                // sra t3, t3, 4
+  c->sq(r0, 0, a0);                                 // sq r0, 0(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sh(t3, 0, v1);                                 // sh t3, 0(v1)
+  c->daddiu(v1, t3, 1);                             // daddiu v1, t3, 1
+  c->sq(r0, 0, t1);                                 // sq r0, 0(t1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(r0, -16, t1);                               // sq r0, -16(t1)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t5, a1, 1);                             // daddiu t5, a1, 1
+  c->daddiu(t4, a1, 2);                             // daddiu t4, a1, 2
+  c->lw(t3, 11988, at);                             // lw t3, 11988(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t7, 11972, at);                             // lw t7, 11972(at)
+  c->dsll(t0, t0, 16);                              // dsll t0, t0, 16
+  c->lw(t6, 11976, at);                             // lw t6, 11976(at)
+  c->or_(t4, t7, t4);                               // or t4, t7, t4
+  c->lw(t7, 11980, at);                             // lw t7, 11980(at)
+  c->or_(t5, t6, t5);                               // or t5, t6, t5
+  c->lw(t6, 11984, at);                             // lw t6, 11984(at)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t8, 11992, at);                             // lw t8, 11992(at)
+  c->mov64(t9, a1);                                 // or t9, a1, r0
+  c->sw(t2, 8, a0);                                 // sw t2, 8(a0)
+  c->or_(t2, t7, t9);                               // or t2, t7, t9
+  c->sw(t8, 0, t1);                                 // sw t8, 0(t1)
+  c->daddiu(a0, a0, 16);                            // daddiu a0, a0, 16
+  c->sw(r0, 4, t1);                                 // sw r0, 4(t1)
+  c->or_(t4, t4, t0);                               // or t4, t4, t0
+  c->sw(t6, 8, t1);                                 // sw t6, 8(t1)
+  c->daddiu(a3, a3, 16);                            // daddiu a3, a3, 16
+  c->sw(t3, 12, t1);                                // sw t3, 12(t1)
+  c->or_(t1, t5, t0);                               // or t1, t5, t0
+  c->sw(t4, -4, a0);                                // sw t4, -4(a0)
+  c->or_(t0, t2, t0);                               // or t0, t2, t0
+  c->sw(t1, -4, a3);                                // sw t1, -4(a3)
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->sw(t0, -4, a2);                                // sw t0, -4(a2)
+  c->addiu(t0, r0, 567);                            // addiu t0, r0, 567
+  c->sw(v1, 40, at);                                // sw v1, 40(at)
+  bc = c->sgpr64(a1) != c->sgpr64(t0);              // bne a1, t0, L72
+  c->daddiu(v1, a1, 279);                           // daddiu v1, a1, 279
+  if (bc) {goto block_13;}                          // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->addiu(v1, r0, 9);                              // addiu v1, r0, 9
+
+  block_13:
+  // nop                                            // sll r0, r0, 0
+  c->sw(v1, 72, at);                                // sw v1, 72(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 4, at);                                 // sw a0, 4(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a3, 8, at);                                 // sw a3, 8(at)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a2, 12, at);                                // sw a2, 12(at)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->lq(gp, 12448, at);                             // lq gp, 12448(at)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 32);                            // daddiu sp, sp, 32
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("generic-prepare-dma-single", execute, 128);
+}
+
+} // namespace generic_prepare_dma_single
+} // namespace Mips2C
+// add generic_prepare_dma_single::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_warp_source_proc {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* math_camera; // *math-camera*
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  c->daddiu(sp, sp, -16);                           // daddiu sp, sp, -16
+// annoyingly, a aguess...
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);
+  c->sd(fp, 12440, at);                             // sd fp, 12440(at)
+  c->mov64(fp, t9);                                 // or fp, t9, r0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lw(a1, 44, at);                                // lw a1, 44(at)
+  c->lw(v1, 8, a1);                                 // lw v1, 8(a1)
+  c->lw(a0, 4, a1);                                 // lw a0, 4(a1)
+  c->lh(a1, 20, a1);                                // lh a1, 20(a1)
+  c->load_symbol2(t0, cache.math_camera);           // lw t0, *math-camera*(s7)
+  c->lhu(a3, 6820, at);                             // lhu a3, 6820(at)
+  c->lhu(a2, 6822, at);                             // lhu a2, 6822(at)
+  c->dsll(t1, a3, 16);                              // dsll t1, a3, 16
+  c->or_(a3, a3, t1);                               // or a3, a3, t1
+  c->lqc2(vf5, 7520, at);                           // lqc2 vf5, 7520(at)
+  c->lqc2(vf1, 7136, at);                           // lqc2 vf1, 7136(at)
+  c->lqc2(vf2, 7152, at);                           // lqc2 vf2, 7152(at)
+  c->lqc2(vf3, 7168, at);                           // lqc2 vf3, 7168(at)
+  c->lqc2(vf4, 7184, at);                           // lqc2 vf4, 7184(at)
+  c->lui(t1, -16966);                               // lui t1, -16966
+  c->ori(t1, t1, 24117);                            // ori t1, t1, 24117
+  c->lwc1(f0, 0, t0);                               // lwc1 f0, 0(t0)
+  c->mfc1(t0, f0);                                  // mfc1 t0, f0
+  c->dsll32(t1, t1, 0);                             // dsll32 t1, t1, 0
+  c->or_(t0, t1, t0);                               // or t0, t1, t0
+  c->mov128_vf_gpr(vf6, t0);                        // qmtc2.i vf6, t0
+  // Unknown instr: ld t0, L111(fp)
+  c->gprs[t0].du64[0] = 0xffff'ffff;
+  // nop                                            // sll r0, r0, 0
+
+  block_1:
+  c->lqc2(vf9, 0, a0);                              // lqc2 vf9, 0(a0)
+  c->lwu(t1, 12, a0);                               // lwu t1, 12(a0)
+  c->vmax_bc(DEST::z, BC::x, vf9, vf9, vf6);        // vmaxx.z vf9, vf9, vf6
+  // nop                                            // vnop
+  c->vmula_bc(DEST::xyzw, BC::w, vf4, vf0);         // vmulaw.xyzw acc, vf4, vf0
+  c->vmadda_bc(DEST::xyzw, BC::x, vf1, vf9);        // vmaddax.xyzw acc, vf1, vf9
+  c->vmadda_bc(DEST::xyzw, BC::y, vf2, vf9);        // vmadday.xyzw acc, vf2, vf9
+  c->vmadd_bc(DEST::xyzw, BC::z, vf9, vf3, vf9);    // vmaddz.xyzw vf9, vf3, vf9
+  // nop                                            // vnop
+  c->vdiv(vf5, BC::w, vf9, BC::w);                  // vdiv Q, vf5.w, vf9.w
+  // nop                                            // vnop
+  c->vwaitq();                                      // vwaitq
+  c->vmulq(DEST::xyz, vf9, vf9);                    // vmulq.xyz vf9, vf9, Q
+  c->vmul(DEST::xy, vf9, vf9, vf5);                 // vmul.xy vf9, vf9, vf5
+  c->vadd_bc(DEST::xy, BC::z, vf9, vf9, vf5);       // vaddz.xy vf9, vf9, vf5
+  c->vadd_bc(DEST::y, BC::y, vf9, vf9, vf6);        // vaddy.y vf9, vf9, vf6
+  c->vftoi12(DEST::xyzw, vf10, vf9);                // vftoi12.xyzw vf10, vf9
+  c->psubh(t1, t1, a3);
+  c->dsrav(t1, t1, a2);                             // dsrav t1, t1, a2
+  c->ppacb(t1, r0, t1);                             // ppacb t1, r0, t1
+  c->and_(t1, t1, t0);                              // and t1, t1, t0
+  bc = ((s64)c->sgpr64(t1)) < 0;                    // bltz t1, L20
+  c->daddiu(t2, t1, -394);                          // daddiu t2, t1, -394
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  bc = ((s64)c->sgpr64(t2)) < 0;                    // bltz t2, L21
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_4;}                           // branch non-likely
+
+
+  block_3:
+  // nop                                            // sll r0, r0, 0
+
+  block_4:
+  c->sll(t1, t1, 2);                                // sll t1, t1, 2
+  c->daddu(t1, v1, t1);                             // daddu t1, v1, t1
+  c->mov128_gpr_vf(t2, vf10);                       // qmfc2.i t2, vf10
+  c->ppach(t2, r0, t2);                             // ppach t2, r0, t2
+  c->daddiu(a1, a1, -1);                            // daddiu a1, a1, -1
+  c->sw(t2, 0, t1);                                 // sw t2, 0(t1)
+  bc = ((s64)c->sgpr64(a1)) > 0;                    // bgtz a1, L19
+  c->daddiu(a0, a0, 32);                            // daddiu a0, a0, 32
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(fp, 12440, at);                             // ld fp, 12440(at)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 16);                            // daddiu sp, sp, 16
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.math_camera = intern_from_c("*math-camera*").c();
+  gLinkedFunctionTable.reg("generic-warp-source-proc", execute, 128);
+}
+
+} // namespace generic_warp_source_proc
+} // namespace Mips2C
+// add generic_warp_source_proc::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_warp_dest_proc {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  c->daddiu(sp, sp, -16);                           // daddiu sp, sp, -16
+  c->sd(fp, 12440, at);                             // sd fp, 12440(at)
+  c->mov64(fp, t9);                                 // or fp, t9, r0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lw(a1, 44, at);                                // lw a1, 44(at)
+  c->lw(v1, 8, a1);                                 // lw v1, 8(a1)
+  c->lw(a0, 4, a1);                                 // lw a0, 4(a1)
+  c->lbu(a1, 17, a1);                               // lbu a1, 17(a1)
+  c->lhu(a3, 6820, at);                             // lhu a3, 6820(at)
+  c->lhu(a2, 6822, at);                             // lhu a2, 6822(at)
+  c->dsll(t0, a3, 16);                              // dsll t0, a3, 16
+  c->or_(a3, a3, t0);                               // or a3, a3, t0
+  // Unknown instr: ld t0, L111(fp)
+  c->gprs[t0].du64[0] = 0xffff'ffff;
+
+  block_1:
+  c->lwu(t1, 12, a0);                               // lwu t1, 12(a0)
+  // Unknown instr: psubh t1, t1, a3
+  c->psubh(t1, t1, a3);
+  c->dsrav(t1, t1, a2);                             // dsrav t1, t1, a2
+  c->ppacb(t1, r0, t1);                             // ppacb t1, r0, t1
+  c->and_(t1, t1, t0);                              // and t1, t1, t0
+  c->sll(t1, t1, 2);                                // sll t1, t1, 2
+  c->daddu(t1, v1, t1);                             // daddu t1, v1, t1
+  c->lw(t1, 0, t1);                                 // lw t1, 0(t1)
+  c->sw(t1, 12, a0);                                // sw t1, 12(a0)
+  c->daddiu(a1, a1, -1);                            // daddiu a1, a1, -1
+  bc = ((s64)c->sgpr64(a1)) > 0;                    // bgtz a1, L16
+  c->daddiu(a0, a0, 32);                            // daddiu a0, a0, 32
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(fp, 12440, at);                             // ld fp, 12440(at)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 16);                            // daddiu sp, sp, 16
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("generic-warp-dest-proc", execute, 128);
+}
+
+} // namespace generic_warp_dest_proc
+} // namespace Mips2C
+// add generic_warp_dest_proc::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_no_light_proc {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -96);                           // daddiu sp, sp, -96
+  c->sd(ra, 12432, at);                             // sd ra, 12432(at)
+  c->sq(s2, 12448, at);                             // sq s2, 12448(at)
+  c->sq(s3, 12464, at);                             // sq s3, 12464(at)
+  c->sq(s4, 12480, at);                             // sq s4, 12480(at)
+  c->sq(s5, 12496, at);                             // sq s5, 12496(at)
+  c->sq(gp, 12512, at);                             // sq gp, 12512(at)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  // nop                                            // sll r0, r0, 0
+  c->addiu(t1, r0, 256);                            // addiu t1, r0, 256
+  c->lw(v1, 36, at);                                // lw v1, 36(at)
+  c->lui(a0, -2);                                   // lui a0, -2
+  c->lw(a1, 44, at);                                // lw a1, 44(at)
+  c->daddiu(v1, v1, 3);                             // daddiu v1, v1, 3
+  c->addiu(a3, r0, 255);                            // addiu a3, r0, 255
+  c->dsra(a2, v1, 2);                               // dsra a2, v1, 2
+  c->lw(v1, 0, a1);                                 // lw v1, 0(a1)
+  c->dsll(t0, a2, 3);                               // dsll t0, a2, 3
+  c->lw(a2, 4, a1);                                 // lw a2, 4(a1)
+  c->ori(a1, a0, 65534);                            // ori a1, a0, 65534
+  c->daddu(a0, v1, t0);                             // daddu a0, v1, t0
+  c->pextlw(a1, a1, a1);                            // pextlw a1, a1, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlw(a1, a1, a1);                            // pextlw a1, a1, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlw(a2, a2, a2);                            // pextlw a2, a2, a2
+  c->lw(t2, 4, at);                                 // lw t2, 4(at)
+  c->pextlw(a2, a2, a2);                            // pextlw a2, a2, a2
+  c->lw(t3, 8, at);                                 // lw t3, 8(at)
+  c->pcpyh(a3, a3);                                 // pcpyh a3, a3
+  c->lw(t4, 12, at);                                // lw t4, 12(at)
+  c->pcpyld(a3, a3, a3);                            // pcpyld a3, a3, a3
+  c->lq(t0, 12160, at);                             // lq t0, 12160(at)
+  c->pcpyh(t1, t1);                                 // pcpyh t1, t1
+  c->ld(t5, 0, v1);                                 // ld t5, 0(v1)
+  c->pcpyld(t1, t1, t1);                            // pcpyld t1, t1, t1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlh(t6, r0, t5);                            // pextlh t6, r0, t5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t5, t6, a3);                              // pand t5, t6, a3
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->psllw(t5, t5, 5);                              // psllw t5, t5, 5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->daddiu(t2, t2, -48);                           // daddiu t2, t2, -48
+  c->daddiu(t3, t3, -16);                           // daddiu t3, t3, -16
+  //beq r0, r0, L55                                 // beq r0, r0, L55
+  c->daddiu(t4, t4, -16);                           // daddiu t4, t4, -16
+  goto block_2;                                     // branch always
+
+
+  block_1:
+  c->pextlh(t6, r0, ra);                            // pextlh t6, r0, ra
+  c->sq(t5, 0, t2);                                 // sq t5, 0(t2)
+  c->pand(t5, t6, a3);                              // pand t5, t6, a3
+  c->sq(t7, 16, t2);                                // sq t7, 16(t2)
+  c->psllw(t5, t5, 5);                              // psllw t5, t5, 5
+  c->sq(t8, 32, t2);                                // sq t8, 32(t2)
+
+  block_2:
+  c->paddw(gp, t5, a2);                             // paddw gp, t5, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->dsrl32(s4, gp, 0);                             // dsrl32 s4, gp, 0
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->pcpyud(s5, gp, r0);                            // pcpyud s5, gp, r0
+  c->lq(t5, 0, gp);                                 // lq t5, 0(gp)
+  c->dsrl32(t8, s5, 0);                             // dsrl32 t8, s5, 0
+  c->daddiu(t3, t3, 16);                            // daddiu t3, t3, 16
+  c->pand(t6, t6, t1);                              // pand t6, t6, t1
+  c->lq(t7, 0, s4);                                 // lq t7, 0(s4)
+  c->psraw(ra, t6, 8);                              // psraw ra, t6, 8
+  c->lq(t6, 0, s5);                                 // lq t6, 0(s5)
+  c->pextuw(s3, t7, t5);                            // pextuw s3, t7, t5
+  c->lq(t9, 0, t8);                                 // lq t9, 0(t8)
+  c->daddiu(t4, t4, 16);                            // daddiu t4, t4, 16
+  c->daddiu(v1, v1, 8);                             // daddiu v1, v1, 8
+  c->pextuw(s2, t9, t6);                            // pextuw s2, t9, t6
+  c->lw(gp, 28, gp);                                // lw gp, 28(gp)
+  c->pcpyud(s3, s3, s2);                            // pcpyud s3, s3, s2
+  c->lw(s4, 28, s4);                                // lw s4, 28(s4)
+  c->paddh(s3, s3, t0);                             // paddh s3, s3, t0
+  c->lw(s5, 28, s5);                                // lw s5, 28(s5)
+  c->pand(s3, s3, a1);                              // pand s3, s3, a1
+  c->lw(t8, 28, t8);                                // lw t8, 28(t8)
+  c->por(ra, s3, ra);                               // por ra, s3, ra
+  c->sw(gp, 0, t3);                                 // sw gp, 0(t3)
+  c->prot3w(t9, t9);                                // prot3w t9, t9
+  c->sq(ra, 0, t4);                                 // sq ra, 0(t4)
+  c->prot3w(t7, t7);                                // prot3w t7, t7
+  c->sw(s4, 4, t3);                                 // sw s4, 4(t3)
+  c->pextuw(gp, t7, t5);                            // pextuw gp, t7, t5
+  c->sw(s5, 8, t3);                                 // sw s5, 8(t3)
+  c->pcpyld(t7, t6, t7);                            // pcpyld t7, t6, t7
+  c->ld(ra, 0, v1);                                 // ld ra, 0(v1)
+  c->pcpyld(t5, gp, t5);                            // pcpyld t5, gp, t5
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextuw(t6, t9, t6);                            // pextuw t6, t9, t6
+  c->sw(t8, 12, t3);                                // sw t8, 12(t3)
+  bc = c->sgpr64(v1) != c->sgpr64(a0);              // bne v1, a0, L54
+  c->pcpyld(t8, t9, t6);                            // pcpyld t8, t9, t6
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->sq(t5, 0, t2);                                 // sq t5, 0(t2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t7, 16, t2);                                // sq t7, 16(t2)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t8, 32, t2);                                // sq t8, 32(t2)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 12432, at);                             // ld ra, 12432(at)
+  c->lq(gp, 12512, at);                             // lq gp, 12512(at)
+  c->lq(s5, 12496, at);                             // lq s5, 12496(at)
+  c->lq(s4, 12480, at);                             // lq s4, 12480(at)
+  c->lq(s3, 12464, at);                             // lq s3, 12464(at)
+  c->lq(s2, 12448, at);                             // lq s2, 12448(at)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 96);                            // daddiu sp, sp, 96
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("generic-no-light-proc", execute, 128);
+}
+
+} // namespace generic_no_light_proc
+} // namespace Mips2C
+// add generic_no_light_proc::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_warp_dest {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* warp_shader; // *warp-shader*
+  void* generic_no_light_proc; // generic-no-light-proc
+  void* generic_warp_dest_proc; // generic-warp-dest-proc
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 madr, sadr, qwc;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -32);                           // daddiu sp, sp, -32
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->sq(gp, 16, sp);                                // sq gp, 16(sp)
+  c->daddiu(v1, s7, 4);                             // daddiu v1, s7, #t
+  bc = c->sgpr64(s7) == c->sgpr64(v1);              // beq s7, v1, L14
+  c->mov64(v0, s7);                                 // or v0, s7, r0
+  if (bc) {goto block_8;}                           // branch non-likely
+
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->mov64(v1, a0);                                 // or v1, a0, r0
+  c->load_symbol2(gp, cache.warp_shader);           // lw gp, *warp-shader*(s7)
+  c->addiu(a0, r0, 14);                             // addiu a0, r0, 14
+  c->sh(a0, 11984, at);                             // sh a0, 11984(at)
+  c->sw(r0, 48, at);                                // sw r0, 48(at)
+  c->sw(v1, 44, at);                                // sw v1, 44(at)
+  c->sh(r0, 56, at);                                // sh r0, 56(at)
+  c->daddiu(v1, at, 12064);                         // daddiu v1, at, 12064
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6842, a0);                             // lbu a0, 6842(a0)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L11
+  c->mov64(a0, s7);                                 // or a0, s7, r0
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  c->addiu(v1, r0, 6960);                           // addiu v1, r0, 6960
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+  c->mov64(v1, v1);                                 // or v1, v1, r0
+  c->mov64(a0, v1);                                 // or a0, v1, r0
+
+  block_3:
+  c->sw(v1, 52, at);                                // sw v1, 52(at)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7464, v1);                             // lwu t9, 7464(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_prepare_dma_single::execute_real(c);
+  c->ld(v1, 0, gp);                                 // ld v1, 0(gp)
+  c->ld(a0, 16, gp);                                // ld a0, 16(gp)
+  c->ld(a1, 32, gp);                                // ld a1, 32(gp)
+  c->ld(a2, 48, gp);                                // ld a2, 48(gp)
+  c->ld(a3, 64, gp);                                // ld a3, 64(gp)
+  c->ld(t0, 11936, at);                             // ld t0, 11936(at)
+  c->lw(t1, 24, at);                                // lw t1, 24(at)
+  c->sd(v1, 128, t1);                               // sd v1, 128(t1)
+  c->sd(a0, 144, t1);                               // sd a0, 144(t1)
+  c->sd(a1, 160, t1);                               // sd a1, 160(t1)
+  c->sd(a2, 176, t1);                               // sd a2, 176(t1)
+  c->sd(a3, 192, t1);                               // sd a3, 192(t1)
+  c->sd(t0, 96, t1);                                // sd t0, 96(t1)
+  c->load_symbol2(t9, cache.generic_warp_dest_proc);// lw t9, generic-warp-dest-proc(s7)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_warp_dest_proc::execute(c);
+  c->load_symbol2(t9, cache.generic_no_light_proc); // lw t9, generic-no-light-proc(s7)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_no_light_proc::execute(c);
+  c->lw(v1, 24, at);                                // lw v1, 24(at)
+  c->lw(a0, 40, at);                                // lw a0, 40(at)
+  c->mov64(a3, v1);                                 // or a3, v1, r0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lui(a2, 4096);                                 // lui a2, 4096
+  c->lwu(a1, 60, at);                               // lwu a1, 60(at)
+  c->ori(a2, a2, 53248);                            // ori a2, a2, 53248
+  // c->lw(t1, 0, a2);                                 // lw t1, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, at, 92);                            // daddiu t0, at, 92
+  c->andi(a3, a3, 16383);                           // andi a3, a3, 16383
+  c->andi(t1, t1, 256);                             // andi t1, t1, 256
+  // nop                                            // sll r0, r0, 0
+//  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L13
+//  // nop                                            // sll r0, r0, 0
+//  if (bc) {goto block_7;}                           // branch non-likely
+
+  c->mov64(t1, a2);                                 // or t1, a2, r0
+  // nop                                            // sll r0, r0, 0
+
+//  block_5:
+//  c->lw(t2, 0, t0);                                 // lw t2, 0(t0)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(t3, 0, t1);                                 // lw t3, 0(t1)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(t3, t3, 256);                             // andi t3, t3, 256
+//  c->daddiu(t2, t2, 1);                             // daddiu t2, t2, 1
+//  bc = c->sgpr64(t3) != 0;                          // bne t3, r0, L12
+//  c->sw(t2, 0, t0);                                 // sw t2, 0(t0)
+//  if (bc) {goto block_5;}                           // branch non-likely
+//
+//  c->gprs[t0].du64[0] = 0;                          // or t0, r0, r0
+
+  // block_7:
+  c->dsll(t0, a0, 4);                               // dsll t0, a0, 4
+  // c->sw(a3, 128, a2);                               // sw a3, 128(a2)
+  sadr = c->sgpr64(a3);
+  // nop                                            // sll r0, r0, 0
+  // c->sw(a1, 16, a2);                                // sw a1, 16(a2)
+  madr = c->sgpr64(a1);
+  c->addiu(a3, r0, 256);                            // addiu a3, r0, 256
+  // c->sw(a0, 32, a2);                                // sw a0, 32(a2)
+  qwc = c->sgpr64(a0);
+  c->daddu(a0, a1, t0);                             // daddu a0, a1, t0
+  // c->sw(a3, 0, a2);                                 // sw a3, 0(a2)
+  spad_from_dma_no_sadr_off(cache.fake_scratchpad_data, madr, sadr, qwc);
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 60, at);                                // sw a0, 60(at)
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->xori(v0, v1, 4608);                            // xori v0, v1, 4608
+  c->sw(v0, 24, at);                                // sw v0, 24(at)
+
+  block_8:
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->lq(gp, 16, sp);                                // lq gp, 16(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 32);                            // daddiu sp, sp, 32
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.warp_shader = intern_from_c("*warp-shader*").c();
+  cache.generic_no_light_proc = intern_from_c("generic-no-light-proc").c();
+  cache.generic_warp_dest_proc = intern_from_c("generic-warp-dest-proc").c();
+  gLinkedFunctionTable.reg("generic-warp-dest", execute, 128);
+}
+
+} // namespace generic_warp_dest
+} // namespace Mips2C
+// add generic_warp_dest::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_warp_envmap_dest {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* warp_shader; // *warp-shader*
+  void* generic_envmap_proc; // generic-envmap-proc
+  void* generic_no_light_proc; // generic-no-light-proc
+  void* generic_warp_dest_proc; // generic-warp-dest-proc
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  u32 qwc = 0;
+  u32 madr = 0;
+  u32 sadr = 0;
+  c->daddiu(sp, sp, -32);                           // daddiu sp, sp, -32
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->sq(gp, 16, sp);                                // sq gp, 16(sp)
+  c->daddiu(v1, s7, 4);                             // daddiu v1, s7, #t
+  bc = c->sgpr64(s7) == c->sgpr64(v1);              // beq s7, v1, L9
+  c->mov64(v0, s7);                                 // or v0, s7, r0
+  if (bc) {goto block_11;}                          // branch non-likely
+
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->mov64(v1, a0);                                 // or v1, a0, r0
+  c->load_symbol2(gp, cache.warp_shader);           // lw gp, *warp-shader*(s7)
+  c->addiu(a0, r0, 14);                             // addiu a0, r0, 14
+  c->sh(a0, 11984, at);                             // sh a0, 11984(at)
+  c->sw(r0, 48, at);                                // sw r0, 48(at)
+  c->sw(v1, 44, at);                                // sw v1, 44(at)
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  c->sh(v1, 56, at);                                // sh v1, 56(at)
+  c->daddiu(v1, at, 12064);                         // daddiu v1, at, 12064
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6842, a0);                             // lbu a0, 6842(a0)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L4
+  c->mov64(a0, s7);                                 // or a0, s7, r0
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  c->addiu(v1, r0, 6960);                           // addiu v1, r0, 6960
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+  c->mov64(v1, v1);                                 // or v1, v1, r0
+  c->mov64(a0, v1);                                 // or a0, v1, r0
+
+  block_3:
+  c->sw(v1, 52, at);                                // sw v1, 52(at)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7468, v1);                             // lwu t9, 7468(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_prepare_dma_double::execute(c);
+  c->ld(v1, 0, gp);                                 // ld v1, 0(gp)
+  c->ld(a0, 16, gp);                                // ld a0, 16(gp)
+  c->ld(a1, 32, gp);                                // ld a1, 32(gp)
+  c->ld(a2, 48, gp);                                // ld a2, 48(gp)
+  c->ld(t0, 64, gp);                                // ld t0, 64(gp)
+  c->ld(a3, 11936, at);                             // ld a3, 11936(at)
+  get_fake_spad_addr2(t1, cache.fake_scratchpad_data, 0, c);// lui t1, 28672
+  c->lbu(t1, 6856, t1);                             // lbu t1, 6856(t1)
+  c->addiu(t2, r0, 128);                            // addiu t2, r0, 128
+  c->sltu(t2, t2, t1);                              // sltu t2, t2, t1
+  bc = c->sgpr64(t2) != 0;                          // bne t2, r0, L5
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_5;}                           // branch non-likely
+
+  c->addiu(t2, r0, 128);                            // addiu t2, r0, 128
+  c->dsubu(t1, t2, t1);                             // dsubu t1, t2, t1
+  c->dsll32(t1, t1, 24);                            // dsll32 t1, t1, 24
+  c->dsrl(t1, t1, 24);                              // dsrl t1, t1, 24
+  c->ori(t1, t1, 100);                              // ori t1, t1, 100
+  c->mov64(t1, t1);                                 // or t1, t1, r0
+  c->mov64(t2, t1);                                 // or t2, t1, r0
+  //beq r0, r0, L6                                  // beq r0, r0, L6
+  // nop                                            // sll r0, r0, 0
+  goto block_6;                                     // branch always
+
+
+  block_5:
+  c->ld(t1, 11904, at);                             // ld t1, 11904(at)
+  c->mov64(t2, t1);                                 // or t2, t1, r0
+
+  block_6:
+  c->lw(t2, 24, at);                                // lw t2, 24(at)
+  c->sd(v1, 128, t2);                               // sd v1, 128(t2)
+  c->sd(a0, 144, t2);                               // sd a0, 144(t2)
+  c->sd(a1, 160, t2);                               // sd a1, 160(t2)
+  c->sd(a2, 176, t2);                               // sd a2, 176(t2)
+  c->sd(t0, 192, t2);                               // sd t0, 192(t2)
+  c->addiu(v1, r0, 71);                             // addiu v1, r0, 71
+  c->sd(a3, 96, t2);                                // sd a3, 96(t2)
+  c->addiu(a0, r0, 66);                             // addiu a0, r0, 66
+  c->sd(t1, 112, t2);                               // sd t1, 112(t2)
+  c->sw(v1, 104, t2);                               // sw v1, 104(t2)
+  c->sw(a0, 120, t2);                               // sw a0, 120(t2)
+  c->load_symbol2(t9, cache.generic_warp_dest_proc);// lw t9, generic-warp-dest-proc(s7)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_warp_dest_proc::execute(c);
+  c->load_symbol2(t9, cache.generic_no_light_proc); // lw t9, generic-no-light-proc(s7)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_no_light_proc::execute(c);
+  c->load_symbol2(t9, cache.generic_envmap_proc);   // lw t9, generic-envmap-proc(s7)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_envmap_proc::execute(c);
+  c->lw(v1, 24, at);                                // lw v1, 24(at)
+  c->lw(a0, 40, at);                                // lw a0, 40(at)
+  c->mov64(a3, v1);                                 // or a3, v1, r0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lui(a2, 4096);                                 // lui a2, 4096
+  c->lwu(a1, 60, at);                               // lwu a1, 60(at)
+  c->ori(a2, a2, 53248);                            // ori a2, a2, 53248
+  // c->lw(t1, 0, a2);                                 // lw t1, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, at, 92);                            // daddiu t0, at, 92
+  c->andi(a3, a3, 16383);                           // andi a3, a3, 16383
+  c->andi(t1, t1, 256);                             // andi t1, t1, 256
+  // nop                                            // sll r0, r0, 0
+//  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L8
+//  // nop                                            // sll r0, r0, 0
+//  if (bc) {goto block_10;}                          // branch non-likely
+//
+//  c->mov64(t1, a2);                                 // or t1, a2, r0
+//  // nop                                            // sll r0, r0, 0
+//
+//  block_8:
+//  c->lw(t2, 0, t0);                                 // lw t2, 0(t0)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(t3, 0, t1);                                 // lw t3, 0(t1)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(t3, t3, 256);                             // andi t3, t3, 256
+//  c->daddiu(t2, t2, 1);                             // daddiu t2, t2, 1
+//  bc = c->sgpr64(t3) != 0;                          // bne t3, r0, L7
+//  c->sw(t2, 0, t0);                                 // sw t2, 0(t0)
+//  if (bc) {goto block_8;}                           // branch non-likely
+
+  // c->gprs[t0].du64[0] = 0;                          // or t0, r0, r0
+
+  block_10:
+  c->dsll(t0, a0, 4);                               // dsll t0, a0, 4
+  // c->sw(a3, 128, a2);                               // sw a3, 128(a2)
+  sadr = c->sgpr64(a3);
+  // nop                                            // sll r0, r0, 0
+  // c->sw(a1, 16, a2);                                // sw a1, 16(a2)
+  madr = c->sgpr64(a1);
+  c->addiu(a3, r0, 256);                            // addiu a3, r0, 256
+  // c->sw(a0, 32, a2);                                // sw a0, 32(a2)
+  qwc = c->sgpr64(a0);
+  c->daddu(a0, a1, t0);                             // daddu a0, a1, t0
+  // c->sw(a3, 0, a2);                                 // sw a3, 0(a2)
+  spad_from_dma_no_sadr_off(cache.fake_scratchpad_data, madr, sadr, qwc);
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 60, at);                                // sw a0, 60(at)
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->xori(v0, v1, 4608);                            // xori v0, v1, 4608
+  c->sw(v0, 24, at);                                // sw v0, 24(at)
+
+  block_11:
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->lq(gp, 16, sp);                                // lq gp, 16(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 32);                            // daddiu sp, sp, 32
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.warp_shader = intern_from_c("*warp-shader*").c();
+  cache.generic_envmap_proc = intern_from_c("generic-envmap-proc").c();
+  cache.generic_no_light_proc = intern_from_c("generic-no-light-proc").c();
+  cache.generic_warp_dest_proc = intern_from_c("generic-warp-dest-proc").c();
+  gLinkedFunctionTable.reg("generic-warp-envmap-dest", execute, 128);
+}
+
+} // namespace generic_warp_envmap_dest
+} // namespace Mips2C
+// add generic_warp_envmap_dest::link to the link callback table for the object file.
+// FWD DEC:
diff --git a/game/mips2c/jak2_functions/generic_merc.cpp b/game/mips2c/jak2_functions/generic_merc.cpp
new file mode 100644
index 0000000000..24f36e2da3
--- /dev/null
+++ b/game/mips2c/jak2_functions/generic_merc.cpp
@@ -0,0 +1,3552 @@
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+namespace Mips2C::jak2 {
+namespace generic_warp_dest {
+u64 execute(void* c);
+}
+namespace generic_prepare_dma_single {
+u64 execute_real(void* c);
+}
+namespace generic_prepare_dma_double {
+u64 execute(void* c);
+}
+
+namespace generic_light_proc {
+u64 execute(void* c);
+}
+
+namespace generic_envmap_proc {
+u64 execute(void* c);
+}
+}
+
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_merc_init_asm {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* gsf_buffer; // *gsf-buffer*
+  void* inv_init_table; // *inv-init-table*
+  void* math_camera; // *math-camera*
+  void* generic_envmap_proc; // generic-envmap-proc
+  void* generic_light_proc; // generic-light-proc
+  void* generic_prepare_dma_double; // generic-prepare-dma-double
+  void* generic_prepare_dma_single; // generic-prepare-dma-single
+  void* high_speed_reject; // high-speed-reject
+  void* mercneric_convert; // mercneric-convert
+  void* mercneric_vu0_block; // mercneric-vu0-block
+  void* upload_vu0_program; // upload-vu0-program
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -16);                           // daddiu sp, sp, -16
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->load_symbol2(t9, cache.upload_vu0_program);    // lw t9, upload-vu0-program(s7)
+  c->load_symbol2(a0, cache.mercneric_vu0_block);   // lw a0, mercneric-vu0-block(s7)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->ori(a1, v1, 84);                               // ori a1, v1, 84
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->load_symbol2(v1, cache.math_camera);           // lw v1, *math-camera*(s7)
+  c->addiu(a0, r0, 7136);                           // addiu a0, r0, 7136
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  c->load_symbol2(a1, cache.mercneric_convert);     // lw a1, mercneric-convert(s7)
+  c->sw(a1, 324, a0);                               // sw a1, 324(a0)
+  c->load_symbol2(a1, cache.generic_prepare_dma_single);// lw a1, generic-prepare-dma-single(s7)
+  c->sw(a1, 328, a0);                               // sw a1, 328(a0)
+  c->load_symbol2(a1, cache.generic_prepare_dma_double);// lw a1, generic-prepare-dma-double(s7)
+  c->sw(a1, 332, a0);                               // sw a1, 332(a0)
+  c->load_symbol2(a1, cache.generic_light_proc);    // lw a1, generic-light-proc(s7)
+  c->sw(a1, 336, a0);                               // sw a1, 336(a0)
+  c->load_symbol2(a1, cache.generic_envmap_proc);   // lw a1, generic-envmap-proc(s7)
+  c->sw(a1, 340, a0);                               // sw a1, 340(a0)
+  c->load_symbol2(a1, cache.high_speed_reject);     // lw a1, high-speed-reject(s7)
+  c->sw(a1, 344, a0);                               // sw a1, 344(a0)
+  c->sw(r0, 320, a0);                               // sw r0, 320(a0)
+  c->daddu(t0, r0, a0);                             // daddu t0, r0, a0
+  c->daddiu(t1, v1, 156);                           // daddiu t1, v1, 156
+  c->lq(a1, 0, t1);                                 // lq a1, 0(t1)
+  c->lq(a2, 16, t1);                                // lq a2, 16(t1)
+  c->lq(a3, 32, t1);                                // lq a3, 32(t1)
+  c->lq(t1, 48, t1);                                // lq t1, 48(t1)
+  c->sq(a1, 0, t0);                                 // sq a1, 0(t0)
+  c->sq(a2, 16, t0);                                // sq a2, 16(t0)
+  c->sq(a3, 32, t0);                                // sq a3, 32(t0)
+  c->sq(t1, 48, t0);                                // sq t1, 48(t0)
+  c->daddiu(t0, a0, 64);                            // daddiu t0, a0, 64
+  c->daddiu(t1, v1, 220);                           // daddiu t1, v1, 220
+  c->lq(a1, 0, t1);                                 // lq a1, 0(t1)
+  c->lq(a2, 16, t1);                                // lq a2, 16(t1)
+  c->lq(a3, 32, t1);                                // lq a3, 32(t1)
+  c->lq(t1, 48, t1);                                // lq t1, 48(t1)
+  c->sq(a1, 0, t0);                                 // sq a1, 0(t0)
+  c->sq(a2, 16, t0);                                // sq a2, 16(t0)
+  c->sq(a3, 32, t0);                                // sq a3, 32(t0)
+  c->sq(t1, 48, t0);                                // sq t1, 48(t0)
+  c->daddiu(t0, a0, 128);                           // daddiu t0, a0, 128
+  c->daddiu(t1, v1, 428);                           // daddiu t1, v1, 428
+  c->lq(a1, 0, t1);                                 // lq a1, 0(t1)
+  c->lq(a2, 16, t1);                                // lq a2, 16(t1)
+  c->lq(a3, 32, t1);                                // lq a3, 32(t1)
+  c->lq(t1, 48, t1);                                // lq t1, 48(t1)
+  c->sq(a1, 0, t0);                                 // sq a1, 0(t0)
+  c->sq(a2, 16, t0);                                // sq a2, 16(t0)
+  c->sq(a3, 32, t0);                                // sq a3, 32(t0)
+  c->sq(t1, 48, t0);                                // sq t1, 48(t0)
+  c->lui(a1, 16256);                                // lui a1, 16256
+  c->mtc1(f0, a1);                                  // mtc1 f0, a1
+  c->lwc1(f1, 12, v1);                              // lwc1 f1, 12(v1)
+  c->divs(f1, f0, f1);                              // div.s f1, f0, f1
+  c->lui(a1, 16256);                                // lui a1, 16256
+  c->mtc1(f0, a1);                                  // mtc1 f0, a1
+  c->lwc1(f2, 16, v1);                              // lwc1 f2, 16(v1)
+  c->divs(f0, f0, f2);                              // div.s f0, f0, f2
+  c->daddiu(a2, a0, 352);                           // daddiu a2, a0, 352
+  c->daddiu(a1, a0, 368);                           // daddiu a1, a0, 368
+  c->daddiu(a0, a0, 384);                           // daddiu a0, a0, 384
+  c->swc1(f1, 0, a2);                               // swc1 f1, 0(a2)
+  c->negs(f1, f1);                                  // neg.s f1, f1
+  c->swc1(f1, 4, a2);                               // swc1 f1, 4(a2)
+  c->mtc1(f1, r0);                                  // mtc1 f1, r0
+  c->swc1(f1, 8, a2);                               // swc1 f1, 8(a2)
+  c->mtc1(f1, r0);                                  // mtc1 f1, r0
+  c->swc1(f1, 12, a2);                              // swc1 f1, 12(a2)
+  c->mtc1(f1, r0);                                  // mtc1 f1, r0
+  c->swc1(f1, 0, a1);                               // swc1 f1, 0(a1)
+  c->mtc1(f1, r0);                                  // mtc1 f1, r0
+  c->swc1(f1, 4, a1);                               // swc1 f1, 4(a1)
+  c->swc1(f0, 8, a1);                               // swc1 f0, 8(a1)
+  c->negs(f0, f0);                                  // neg.s f0, f0
+  c->swc1(f0, 12, a1);                              // swc1 f0, 12(a1)
+  c->lui(a1, 15104);                                // lui a1, 15104
+  c->mtc1(f0, a1);                                  // mtc1 f0, a1
+  c->swc1(f0, 0, a0);                               // swc1 f0, 0(a0)
+  c->lui(a1, 15104);                                // lui a1, 15104
+  c->mtc1(f0, a1);                                  // mtc1 f0, a1
+  c->swc1(f0, 4, a0);                               // swc1 f0, 4(a0)
+  c->lui(a1, 16128);                                // lui a1, 16128
+  c->mtc1(f0, a1);                                  // mtc1 f0, a1
+  c->swc1(f0, 8, a0);                               // swc1 f0, 8(a0)
+  c->lwc1(f0, 908, v1);                             // lwc1 f0, 908(v1)
+  c->swc1(f0, 12, a0);                              // swc1 f0, 12(a0)
+  c->load_symbol2(v1, cache.gsf_buffer);            // lw v1, *gsf-buffer*(s7)
+  c->daddiu(a0, v1, 32);                            // daddiu a0, v1, 32
+  c->sw(a0, 0, v1);                                 // sw a0, 0(v1)
+  c->daddiu(a0, v1, 448);                           // daddiu a0, v1, 448
+  c->sw(a0, 4, v1);                                 // sw a0, 4(v1)
+  c->daddiu(a0, v1, 6608);                          // daddiu a0, v1, 6608
+  c->sw(a0, 8, v1);                                 // sw a0, 8(v1)
+  c->daddiu(a0, v1, 2784);                          // daddiu a0, v1, 2784
+  c->sw(a0, 2752, v1);                              // sw a0, 2752(v1)
+  c->daddiu(a0, v1, 3200);                          // daddiu a0, v1, 3200
+  c->sw(a0, 2756, v1);                              // sw a0, 2756(v1)
+  c->daddiu(a0, v1, 6608);                          // daddiu a0, v1, 6608
+  c->sw(a0, 2760, v1);                              // sw a0, 2760(v1)
+  c->load_symbol2(v1, cache.gsf_buffer);            // lw v1, *gsf-buffer*(s7)
+  c->daddiu(a0, v1, 5504);                          // daddiu a0, v1, 5504
+  c->mov64(a0, a0);                                 // or a0, a0, r0
+  c->load_symbol2(a1, cache.inv_init_table);        // lw a1, *inv-init-table*(s7)
+  c->mov64(a1, a1);                                 // or a1, a1, r0
+  c->sq(r0, 0, a0);                                 // sq r0, 0(a0)
+  c->sq(r0, 544, a0);                               // sq r0, 544(a0)
+  c->sq(r0, 16, a0);                                // sq r0, 16(a0)
+  c->sq(r0, 560, a0);                               // sq r0, 560(a0)
+  c->sq(r0, 208, a0);                               // sq r0, 208(a0)
+  c->sq(r0, 752, a0);                               // sq r0, 752(a0)
+  c->sq(r0, 224, a0);                               // sq r0, 224(a0)
+  c->sq(r0, 768, a0);                               // sq r0, 768(a0)
+  c->sq(r0, 240, a0);                               // sq r0, 240(a0)
+  c->sq(r0, 784, a0);                               // sq r0, 784(a0)
+  c->sq(r0, 384, a0);                               // sq r0, 384(a0)
+  c->sq(r0, 800, a0);                               // sq r0, 800(a0)
+  c->sq(r0, 400, a0);                               // sq r0, 400(a0)
+  c->sq(r0, 944, a0);                               // sq r0, 944(a0)
+  c->sq(r0, 416, a0);                               // sq r0, 416(a0)
+  c->sq(r0, 960, a0);                               // sq r0, 960(a0)
+  c->sq(r0, 432, a0);                               // sq r0, 432(a0)
+  c->sq(r0, 976, a0);                               // sq r0, 976(a0)
+  c->sq(r0, 448, a0);                               // sq r0, 448(a0)
+  c->sq(r0, 992, a0);                               // sq r0, 992(a0)
+  c->sq(r0, 464, a0);                               // sq r0, 464(a0)
+  c->sq(r0, 1008, a0);                              // sq r0, 1008(a0)
+  c->sq(r0, 480, a0);                               // sq r0, 480(a0)
+  c->sq(r0, 1024, a0);                              // sq r0, 1024(a0)
+  c->sq(r0, 496, a0);                               // sq r0, 496(a0)
+  c->sq(r0, 1040, a0);                              // sq r0, 1040(a0)
+  c->sq(r0, 512, a0);                               // sq r0, 512(a0)
+  c->sq(r0, 1056, a0);                              // sq r0, 1056(a0)
+  c->sq(r0, 528, a0);                               // sq r0, 528(a0)
+  c->sq(r0, 1072, a0);                              // sq r0, 1072(a0)
+  c->addiu(a2, r0, 8);                              // addiu a2, r0, 8
+  // nop                                            // sll r0, r0, 0
+
+block_1:
+  c->lhu(t1, 2, a1);                                // lhu t1, 2(a1)
+  c->daddiu(a2, a2, -1);                            // daddiu a2, a2, -1
+  c->lbu(a3, 0, a1);                                // lbu a3, 0(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(t0, 1, a1);                                // lbu t0, 1(a1)
+  // nop                                            // sll r0, r0, 0
+  c->daddu(t1, t1, a0);                             // daddu t1, t1, a0
+  c->daddiu(a1, a1, 4);                             // daddiu a1, a1, 4
+
+block_2:
+  c->sb(t0, 0, t1);                                 // sb t0, 0(t1)
+  c->daddiu(a3, a3, -1);                            // daddiu a3, a3, -1
+  c->sb(t0, 550, t1);                               // sb t0, 550(t1)
+  c->daddiu(t0, t0, 2);                             // daddiu t0, t0, 2
+  c->daddiu(t1, t1, 3);                             // daddiu t1, t1, 3
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(a3) != 0;                          // bne a3, r0, L167
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_2;}                           // branch non-likely
+
+  bc = c->sgpr64(a2) != 0;                          // bne a2, r0, L166
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  c->daddu(a0, r0, v1);                             // daddu a0, r0, v1
+  c->mov64(a0, a0);                                 // or a0, a0, r0
+  c->sq(r0, 416, a0);                               // sq r0, 416(a0)
+  c->sq(r0, 432, a0);                               // sq r0, 432(a0)
+  c->daddiu(v1, v1, 2752);                          // daddiu v1, v1, 2752
+  c->mov64(v1, v1);                                 // or v1, v1, r0
+  c->sq(r0, 416, v1);                               // sq r0, 416(v1)
+  c->sq(r0, 432, v1);                               // sq r0, 432(v1)
+  c->gprs[v1].du64[0] = 0;                          // or v1, r0, r0
+  c->lui(v1, 4096);                                 // lui v1, 4096
+  c->ori(v1, v1, 32768);                            // ori v1, v1, 32768
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->ori(a0, a0, 84);                               // ori a0, a0, 84
+
+// just a dma sync.
+//  c->lw(a1, 0, v1);                                 // lw a1, 0(v1)
+//  c->andi(a1, a1, 256);                             // andi a1, a1, 256
+//  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L169
+//  DANGER jump to delay slot, this MUST be fixed manually!
+//  c->lw(a1, 0, a0);                                 // lw a1, 0(a0)
+//  if (bc) {goto block_-1;}                          // branch non-likely
+//
+//
+//block_5:
+//  c->lw(a1, 0, a0);                                 // lw a1, 0(a0)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(a2, 0, v1);                                 // lw a2, 0(v1)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(a2, a2, 256);                             // andi a2, a2, 256
+//  c->daddiu(a1, a1, 1);                             // daddiu a1, a1, 1
+//  bc = c->sgpr64(a2) != 0;                          // bne a2, r0, L168
+//  c->sw(a1, 0, a0);                                 // sw a1, 0(a0)
+//  if (bc) {goto block_5;}                           // branch non-likely
+
+  c->gprs[v1].du64[0] = 0;                          // or v1, r0, r0
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 16);                            // daddiu sp, sp, 16
+  goto end_of_function;                             // return
+
+end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.gsf_buffer = intern_from_c("*gsf-buffer*").c();
+  cache.inv_init_table = intern_from_c("*inv-init-table*").c();
+  cache.math_camera = intern_from_c("*math-camera*").c();
+  cache.generic_envmap_proc = intern_from_c("generic-envmap-proc").c();
+  cache.generic_light_proc = intern_from_c("generic-light-proc").c();
+  cache.generic_prepare_dma_double = intern_from_c("generic-prepare-dma-double").c();
+  cache.generic_prepare_dma_single = intern_from_c("generic-prepare-dma-single").c();
+  cache.high_speed_reject = intern_from_c("high-speed-reject").c();
+  cache.mercneric_convert = intern_from_c("mercneric-convert").c();
+  cache.mercneric_vu0_block = intern_from_c("mercneric-vu0-block").c();
+  cache.upload_vu0_program = intern_from_c("upload-vu0-program").c();
+  gLinkedFunctionTable.reg("generic-merc-init-asm", execute, 128);
+}
+
+} // namespace generic_merc_init_asm
+} // namespace Mips2C
+
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace mercneric_convert {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+
+u8 vu0_data_mem[1024 * 4];
+
+void sq_buffer(Mask mask, const Vf& data, u32 qw) {
+  ASSERT(qw * 16 < sizeof(vu0_data_mem));
+  for (int i = 0; i < 4; i++) {
+    if ((u64)mask & (1 << i)) {
+      memcpy(vu0_data_mem + qw * 16 + i * 4, data.data + i, 4);
+    }
+  }
+}
+
+void sq_xyzw(const Vf& data, u32 qw) {
+  memcpy(vu0_data_mem + qw * 16, data.data, 16);
+}
+
+void lq_buffer(Mask mask, Vf& data, u32 qw) {
+  ASSERT(qw * 16 < sizeof(vu0_data_mem));
+  for (int i = 0; i < 4; i++) {
+    if ((u64)mask & (1 << i)) {
+      memcpy(data.data + i, vu0_data_mem + qw * 16 + i * 4, 4);
+    }
+  }
+}
+
+void lq_xyzw(Vf& data, u32 qw) {
+  memcpy(data.data, vu0_data_mem + qw * 16, 16);
+}
+
+void vcallms_280(ExecutionContext* c, u16* vis) {
+  bool bc;
+  // 0.003921569                |  maxw.x vf17, vf00, vf00 :i
+  c->vfs[vf17].vf.max(Mask::x, c->vf_src(vf00).vf, c->vf_src(vf00).vf.w());   c->I = 0.003921569;
+  // -65537.0                   |  maxi.y vf17, vf00, I :i
+  c->vfs[vf17].vf.maxi(Mask::y, c->vf_src(vf00).vf, c->I);   c->I = -65537.0;
+  // iaddiu vi10, vi10, 0x88    |  minii.z vf05, vf00, I
+  c->vfs[vf05].vf.minii(Mask::z, c->vf_src(vf00).vf, c->I);   vis[vi10] = vis[vi10] + 0x88; /* 136 */
+  // iaddiu vi08, vi00, 0x8c    |  minii.z vf06, vf00, I
+  c->vfs[vf06].vf.minii(Mask::z, c->vf_src(vf00).vf, c->I);   vis[vi08] = 0x8c; /* 140 */
+  // sqi.xyzw vf01, vi08        |  minii.z vf07, vf00, I
+
+  c->vfs[vf07].vf.minii(Mask::z, c->vf_src(vf00).vf, c->I);   sq_xyzw(c->vf_src(vf01).vf, vis[vi08]++);
+  // sqi.xyzw vf02, vi08        |  minix.w vf05, vf00, vf27
+  c->vfs[vf05].vf.mini(Mask::w, c->vf_src(vf00).vf, c->vf_src(vf27).vf.x());   sq_xyzw(c->vf_src(vf02).vf, vis[vi08]++);
+  // sqi.xyzw vf03, vi08        |  miniy.w vf06, vf00, vf27
+  c->vfs[vf06].vf.mini(Mask::w, c->vf_src(vf00).vf, c->vf_src(vf27).vf.y());   sq_xyzw(c->vf_src(vf03).vf, vis[vi08]++);
+  // sqi.xyzw vf04, vi08        |  miniz.w vf07, vf00, vf27
+  c->vfs[vf07].vf.mini(Mask::w, c->vf_src(vf00).vf, c->vf_src(vf27).vf.z());   sq_xyzw(c->vf_src(vf04).vf, vis[vi08]++);
+
+  // BRANCH!
+  // ibne vi00, vi13, L1        |  nop
+  bc = (vis[vi13] != 0);
+  // iaddiu vi05, vi00, 0x182   |  nop
+  vis[vi05] = 0x182; /* 386 */
+  if (bc) { goto L1; }
+
+  // iaddiu vi05, vi00, 0x1ab   |  nop
+  vis[vi05] = 0x1ab; /* 427 */
+  L1:
+  // BRANCH!
+  // ibne vi00, vi12, L2        |  nop
+  bc = (vis[vi12] != 0);
+  // iaddiu vi03, vi00, 0x146   |  nop
+  vis[vi03] = 0x146; /* 326 */
+  if (bc) { goto L2; }
+
+  // ior vi03, vi05, vi00       |  nop
+  vis[vi03] = vis[vi05];
+  L2:
+  // BRANCH!
+  // ibne vi00, vi11, L3        |  nop
+  bc = (vis[vi11] != 0);
+  // iaddiu vi01, vi00, 0x13a   |  nop
+  vis[vi01] = 0x13a; /* 314 */
+  if (bc) { goto L3; }
+
+  // ior vi01, vi03, vi00       |  nop
+  vis[vi01] = vis[vi03];
+  L3:
+  // lqi.xyzw vf29, vi10        |  nop
+  lq_xyzw(c->vfs[vf29].vf, vis[vi10]++);
+  // iadd vi02, vi08, vi11      |  nop
+  vis[vi02] = vis[vi08] + vis[vi11];
+  // iadd vi04, vi02, vi12      |  nop
+  vis[vi04] = vis[vi02] + vis[vi12];
+  // iadd vi06, vi04, vi13      |  nop
+  vis[vi06] = vis[vi04] + vis[vi13];
+  // mtir vi13, vf29.w          |  itof0.xyzw vf18, vf29 :e
+  c->vfs[vf18].vf.itof0(Mask::xyzw, c->vf_src(vf29).vf);   vis[vi13] = c->vf_src(vf29).vf.w_as_u16();
+  // iaddiu vi09, vi00, 0x7f    |  nop
+  vis[vi09] = 0x7f; /* 127 */
+
+
+}
+
+void vcallms_303(ExecutionContext* c, u16* vis) {
+  // vf21.x coming into here is bad (should be < 1, I think)
+  // sq.xyzw vf23, 3(vi14)      |  mulx.xyzw vf11, vf20, vf19
+  c->vfs[vf11].vf.mul_xyzw(c->vf_src(vf20).vf, c->vf_src(vf19).vf.x());   sq_xyzw(c->vf_src(vf23).vf, vis[vi14] + 3);
+  // sq.xyzw vf24, 4(vi14)      |  mulx.xyzw vf12, vf21, vf19
+  c->vfs[vf12].vf.mul_xyzw(c->vf_src(vf21).vf, c->vf_src(vf19).vf.x());   sq_xyzw(c->vf_src(vf24).vf, vis[vi14] + 4);
+  // sq.xyzw vf25, 5(vi14)      |  mulx.xyzw vf13, vf22, vf19
+  c->vfs[vf13].vf.mul_xyzw(c->vf_src(vf22).vf, c->vf_src(vf19).vf.x());   sq_xyzw(c->vf_src(vf25).vf, vis[vi14] + 5);
+
+  // sq.xyzw vf26, 6(vi14)      |  nop
+  sq_xyzw(c->vf_src(vf26).vf, vis[vi14] + 6);
+  // sq.xyzw vf11, 0(vi14)      |  nop
+  sq_xyzw(c->vf_src(vf11).vf, vis[vi14]);
+  // sq.xyzw vf12, 1(vi14)      |  nop
+  sq_xyzw(c->vf_src(vf12).vf, vis[vi14] + 1);
+  // sq.xyzw vf13, 2(vi14)      |  nop :e
+  sq_xyzw(c->vf_src(vf13).vf, vis[vi14] + 2);
+  // nop                        |  nop
+
+}
+
+void vcallms_311_case_314(ExecutionContext* c, u16* vis) {
+  // this is one of the most expensive operations.
+
+  // 00 mtir vi11, vf01.x          |  maddz.xyzw vf11, vf26, vf10
+  // 01 jr vi01                    |  mul.xyzw vf14, vf13, Q
+  // 02 sqi.xyzw vf04, vi08        |  mulaw.xyzw ACC, vf20, vf08
+  // 03 rsqrt Q, vf00.w, vf16.x    |  maddaw.xyzw ACC, vf21, vf09
+  // 04 lq.xyzw vf24, -124(vi11)   |  maddaw.xyzw ACC, vf22, vf10
+  // 05 lq.xyzw vf25, -123(vi11)   |  maddw.xyzw vf15, vf23, vf00
+  // 06 lq.xyzw vf26, -122(vi11)   |  mul.xyzw vf16, vf11, vf11
+  // 07 lq.xyzw vf20, -128(vi11)   |  add.xyzw vf08, vf01, vf05
+  // 08 lq.xyzw vf21, -127(vi11)   |  add.xyzw vf09, vf02, vf06
+  // 09 lq.xyzw vf22, -126(vi11)   |  add.xyzw vf10, vf03, vf07
+  // 10 ibne vi08, vi02, L4        |  adday.xyzw vf16, vf16
+  // 11 lq.xyzw vf23, -125(vi11)   |  maddz.xyzw vf16, vf17, vf16
+  // 12 ior vi01, vi03, vi00       |  nop
+  // L4:
+  // 13 move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  // 14 move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+
+  // we've got:
+  // - mul by Q
+  // - calculate next Q
+  // - accumulated multiply part
+  // - lots of loading
+  // - adding part
+
+  c->acc.vf.madd_xyzw(c->vfs[vf11].vf, c->vf_src(vf26).vf, c->vf_src(vf10).vf.z());
+  vis[vi11] = c->vf_src(vf01).vf.x_as_u16();
+  c->vfs[vf14].vf.mul_xyzw(c->vf_src(vf13).vf, c->Q);
+  sq_xyzw(c->vf_src(vf04).vf, vis[vi08]++);
+  c->Q = 1.f / std::sqrt(c->vf_src(vf16).vf.x());
+
+
+
+  //  c->acc.vf.mula_xyzw(c->vf_src(vf20).vf, c->vf_src(vf08).vf.w());
+  //  c->acc.vf.madda_xyzw(c->vfs[vf21].vf, c->vfs[vf09].vf.w());
+  //  c->acc.vf.madda_xyzw(c->vfs[vf22].vf, c->vfs[vf10].vf.w());
+  //  c->acc.vf.madd_xyzw(c->vfs[vf15].vf, c->vf_src(vf23).vf, c->vf_src(vf00).vf.w());
+
+  __m128 acc = _mm_mul_ps(_mm_load_ps(c->vf_src(vf20).vf.data), _mm_set1_ps(c->vf_src(vf08).vf.w()));
+  acc = _mm_add_ps(_mm_mul_ps(_mm_load_ps(c->vf_src(vf21).vf.data), _mm_set1_ps(c->vf_src(vf09).vf.w())), acc);
+  acc = _mm_add_ps(_mm_mul_ps(_mm_load_ps(c->vf_src(vf22).vf.data), _mm_set1_ps(c->vf_src(vf10).vf.w())), acc);
+  acc = _mm_add_ps(_mm_load_ps(c->vf_src(vf23).vf.data), acc);
+  _mm_store_ps(c->vfs[vf15].vf.data, acc);
+
+
+  //  lq_xyzw(c->vfs[vf20].vf, vis[vi11] + -128);
+  //  lq_xyzw(c->vfs[vf21].vf, vis[vi11] + -127);
+  //  lq_xyzw(c->vfs[vf22].vf, vis[vi11] + -126);
+  //  lq_xyzw(c->vfs[vf23].vf, vis[vi11] + -125);
+  //  lq_xyzw(c->vfs[vf24].vf, vis[vi11] + -124);
+  //  lq_xyzw(c->vfs[vf25].vf, vis[vi11] + -123);
+  //  lq_xyzw(c->vfs[vf26].vf, vis[vi11] + -122);
+  memcpy(c->vfs[vf20].vf.data, vu0_data_mem + (vis[vi11] - 128) * 16, 7 * 16);
+
+
+  c->vfs[vf16].vf.mul_xyzw(c->vf_src(vf11).vf, c->vf_src(vf11).vf);
+  c->vfs[vf08].vf.add_xyzw(c->vf_src(vf01).vf, c->vf_src(vf05).vf);
+  c->vfs[vf09].vf.add_xyzw(c->vf_src(vf02).vf, c->vf_src(vf06).vf);
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);
+
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());
+
+  c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+
+  // end integer thing.
+  if (vis[vi08] == vis[vi02]) {
+    vis[vi01] = vis[vi03];
+  }
+}
+
+void vcallms_311_case_326(ExecutionContext* c, u16* vis) {
+  bool bc;
+  // mtir vi11, vf01.x          |  maddz.xyzw vf11, vf26, vf10
+  c->acc.vf.madd_xyzw(c->vfs[vf11].vf, c->vf_src(vf26).vf, c->vf_src(vf10).vf.z());   vis[vi11] = c->vf_src(vf01).vf.x_as_u16();
+  // jr vi01                    |  mul.xyzw vf14, vf13, Q
+  c->vfs[vf14].vf.mul_xyzw(c->vf_src(vf13).vf, c->Q);
+  // sqi.xyzw vf04, vi08        |  mulaw.xyzw ACC, vf20, vf08
+  c->acc.vf.mula_xyzw(c->vf_src(vf20).vf, c->vf_src(vf08).vf.w());   sq_xyzw(c->vf_src(vf04).vf, vis[vi08]++);
+// rsqrt Q, vf00.w, vf16.x    |  maddaw.xyzw ACC, vf21, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf21].vf, c->vfs[vf09].vf.w());   c->Q = c->vf_src(vf00).vf.w() / std::sqrt(c->vf_src(vf16).vf.x());
+  // mtir vi12, vf01.y          |  maddaw.xyzw ACC, vf22, vf10
+  c->acc.vf.madda_xyzw(c->vfs[vf22].vf, c->vfs[vf10].vf.w());   vis[vi12] = c->vf_src(vf01).vf.y_as_u16();
+  // iand vi11, vi11, vi09      |  maddw.xyzw vf15, vf23, vf00
+  c->acc.vf.madd_xyzw(c->vfs[vf15].vf, c->vf_src(vf23).vf, c->vf_src(vf00).vf.w());   vis[vi11] = vis[vi11] & vis[vi09];
+  // lq.xyzw vf19, 4(vi11)      |  mul.xyzw vf16, vf11, vf11
+  c->vfs[vf16].vf.mul_xyzw(c->vf_src(vf11).vf, c->vf_src(vf11).vf);   lq_xyzw(c->vfs[vf19].vf, vis[vi11] + 4);
+  // BRANCH!
+  // ibeq vi09, vi11, L7        |  add.xyzw vf08, vf01, vf05
+  c->vfs[vf08].vf.add_xyzw(c->vf_src(vf01).vf, c->vf_src(vf05).vf);   bc = (vis[vi09] == vis[vi11]);
+  // iand vi12, vi12, vi09      |  add.xyzw vf09, vf02, vf06
+  c->vfs[vf09].vf.add_xyzw(c->vf_src(vf02).vf, c->vf_src(vf06).vf);   vis[vi12] = vis[vi12] & vis[vi09];
+  if (bc) { goto L7; }
+
+  // nop                        |  muly.xyzw vf18, vf18, vf17
+  c->vfs[vf18].vf.mul_xyzw(c->vf_src(vf18).vf, c->vf_src(vf17).vf.y());
+  // lq.xyzw vf24, 4(vi12)      |  add.xyzw vf10, vf03, vf07
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);   lq_xyzw(c->vfs[vf24].vf, vis[vi12] + 4);
+  // lq.xyzw vf27, 5(vi11)      |  adday.xyzw vf16, vf16
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());   lq_xyzw(c->vfs[vf27].vf, vis[vi11] + 5);
+  // lq.xyzw vf25, 5(vi12)      |  maddz.xyzw vf16, vf17, vf16
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());   lq_xyzw(c->vfs[vf25].vf, vis[vi12] + 5);
+  // lq.xyzw vf28, 6(vi11)      |  mulax.xyzw ACC, vf19, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf19).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf28].vf, vis[vi11] + 6);
+  // lq.xyzw vf26, 6(vi12)      |  maddy.xyzw vf24, vf24, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf24].vf, c->vf_src(vf24).vf, c->vf_src(vf18).vf.y());   lq_xyzw(c->vfs[vf26].vf, vis[vi12] + 6);
+  // lq.xyzw vf29, 0(vi11)      |  mulax.xyzw ACC, vf27, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf27).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf29].vf, vis[vi11]);
+  // lq.xyzw vf20, 0(vi12)      |  maddy.xyzw vf25, vf25, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf25].vf, c->vf_src(vf25).vf, c->vf_src(vf18).vf.y());   lq_xyzw(c->vfs[vf20].vf, vis[vi12]);
+  // lq.xyzw vf19, 1(vi11)      |  mulax.xyzw ACC, vf28, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf28).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf19].vf, vis[vi11] + 1);
+  // lq.xyzw vf21, 1(vi12)      |  maddy.xyzw vf26, vf26, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf26].vf, c->vf_src(vf26).vf, c->vf_src(vf18).vf.y());   lq_xyzw(c->vfs[vf21].vf, vis[vi12] + 1);
+  // lq.xyzw vf27, 2(vi11)      |  mulax.xyzw ACC, vf29, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf29).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf27].vf, vis[vi11] + 2);
+  // lq.xyzw vf22, 2(vi12)      |  maddy.xyzw vf20, vf20, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf20].vf, c->vf_src(vf20).vf, c->vf_src(vf18).vf.y());   lq_xyzw(c->vfs[vf22].vf, vis[vi12] + 2);
+  // lq.xyzw vf28, 3(vi11)      |  mulax.xyzw ACC, vf19, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf19).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf28].vf, vis[vi11] + 3);
+  // lq.xyzw vf23, 3(vi12)      |  maddy.xyzw vf21, vf21, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf21].vf, c->vf_src(vf21).vf, c->vf_src(vf18).vf.y());   lq_xyzw(c->vfs[vf23].vf, vis[vi12] + 3);
+  // nop                        |  mulax.xyzw ACC, vf27, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf27).vf, c->vf_src(vf18).vf.x());
+  // iaddiu vi01, vi00, 0x161   |  maddy.xyzw vf22, vf22, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf22].vf, c->vf_src(vf22).vf, c->vf_src(vf18).vf.y());   vis[vi01] = 0x161; /* 353 */
+  // BRANCH!
+  // ibne vi08, vi04, L5        |  mulax.xyzw ACC, vf28, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf28).vf, c->vf_src(vf18).vf.x());   bc = (vis[vi08] != vis[vi04]);
+  // nop                        |  maddy.xyzw vf23, vf23, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf23].vf, c->vf_src(vf23).vf, c->vf_src(vf18).vf.y());
+  if (bc) { goto L5; }
+
+  // ior vi01, vi05, vi00       |  nop
+  vis[vi01] = vis[vi05];
+  L5:
+  // move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());   c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  // move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());   c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+  return;
+  L7:
+  // nop                        |  add.xyzw vf10, vf03, vf07
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);
+  // BRANCH!
+  // ibne vi08, vi04, L8        |  adday.xyzw vf16, vf16
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());   bc = (vis[vi08] != vis[vi04]);
+  // nop                        |  maddz.xyzw vf16, vf17, vf16
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());
+  if (bc) { goto L8; }
+
+  // ior vi01, vi05, vi00       |  nop
+  vis[vi01] = vis[vi05];
+  L8:
+  // move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());   c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  // move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());   c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+  return;
+}
+
+void vcallms_311_case_353(ExecutionContext* c, u16* vis) {
+  bool bc;
+  // mtir vi11, vf01.x          |  maddz.xyzw vf11, vf26, vf10
+  c->acc.vf.madd_xyzw(c->vfs[vf11].vf, c->vf_src(vf26).vf, c->vf_src(vf10).vf.z());   vis[vi11] = c->vf_src(vf01).vf.x_as_u16();
+  // jr vi01                    |  mul.xyzw vf14, vf13, Q
+  c->vfs[vf14].vf.mul_xyzw(c->vf_src(vf13).vf, c->Q);
+  // sqi.xyzw vf04, vi08        |  mulaw.xyzw ACC, vf20, vf08
+  c->acc.vf.mula_xyzw(c->vf_src(vf20).vf, c->vf_src(vf08).vf.w());   sq_xyzw(c->vf_src(vf04).vf, vis[vi08]++);
+  // rsqrt Q, vf00.w, vf16.x    |  maddaw.xyzw ACC, vf21, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf21].vf, c->vfs[vf09].vf.w());   c->Q = c->vf_src(vf00).vf.w() / std::sqrt(c->vf_src(vf16).vf.x());
+  // mtir vi12, vf01.y          |  maddaw.xyzw ACC, vf22, vf10
+  c->acc.vf.madda_xyzw(c->vfs[vf22].vf, c->vfs[vf10].vf.w());   vis[vi12] = c->vf_src(vf01).vf.y_as_u16();
+  // iand vi11, vi11, vi09      |  maddw.xyzw vf15, vf23, vf00
+  c->acc.vf.madd_xyzw(c->vfs[vf15].vf, c->vf_src(vf23).vf, c->vf_src(vf00).vf.w());   vis[vi11] = vis[vi11] & vis[vi09];
+  // lq.xyzw vf19, 4(vi11)      |  mul.xyzw vf16, vf11, vf11
+  c->vfs[vf16].vf.mul_xyzw(c->vf_src(vf11).vf, c->vf_src(vf11).vf);   lq_xyzw(c->vfs[vf19].vf, vis[vi11] + 4);
+  // BRANCH!
+  // ibeq vi09, vi11, L7        |  add.xyzw vf08, vf01, vf05
+  c->vfs[vf08].vf.add_xyzw(c->vf_src(vf01).vf, c->vf_src(vf05).vf);   bc = (vis[vi09] == vis[vi11]);
+  // iand vi12, vi12, vi09      |  add.xyzw vf09, vf02, vf06
+  c->vfs[vf09].vf.add_xyzw(c->vf_src(vf02).vf, c->vf_src(vf06).vf);   vis[vi12] = vis[vi12] & vis[vi09];
+  if (bc) { goto L7; }
+
+  // lq.xyzw vf24, 4(vi12)      |  add.xyzw vf10, vf03, vf07
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);   lq_xyzw(c->vfs[vf24].vf, vis[vi12] + 4);
+  // lq.xyzw vf27, 5(vi11)      |  adday.xyzw vf16, vf16
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());   lq_xyzw(c->vfs[vf27].vf, vis[vi11] + 5);
+  // lq.xyzw vf25, 5(vi12)      |  maddz.xyzw vf16, vf17, vf16
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());   lq_xyzw(c->vfs[vf25].vf, vis[vi12] + 5);
+  // lq.xyzw vf28, 6(vi11)      |  mulaz.xyzw ACC, vf19, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf19).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf28].vf, vis[vi11] + 6);
+  // lq.xyzw vf26, 6(vi12)      |  maddw.xyzw vf24, vf24, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf24].vf, c->vf_src(vf24).vf, c->vf_src(vf18).vf.w());   lq_xyzw(c->vfs[vf26].vf, vis[vi12] + 6);
+  // lq.xyzw vf29, 0(vi11)      |  mulaz.xyzw ACC, vf27, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf27).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf29].vf, vis[vi11]);
+  // lq.xyzw vf20, 0(vi12)      |  maddw.xyzw vf25, vf25, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf25].vf, c->vf_src(vf25).vf, c->vf_src(vf18).vf.w());   lq_xyzw(c->vfs[vf20].vf, vis[vi12]);
+  // lq.xyzw vf19, 1(vi11)      |  mulaz.xyzw ACC, vf28, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf28).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf19].vf, vis[vi11] + 1);
+  // lq.xyzw vf21, 1(vi12)      |  maddw.xyzw vf26, vf26, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf26].vf, c->vf_src(vf26).vf, c->vf_src(vf18).vf.w());   lq_xyzw(c->vfs[vf21].vf, vis[vi12] + 1);
+  // lq.xyzw vf27, 2(vi11)      |  mulaz.xyzw ACC, vf29, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf29).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf27].vf, vis[vi11] + 2);
+  // lq.xyzw vf22, 2(vi12)      |  maddw.xyzw vf20, vf20, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf20].vf, c->vf_src(vf20).vf, c->vf_src(vf18).vf.w());   lq_xyzw(c->vfs[vf22].vf, vis[vi12] + 2);
+  // lq.xyzw vf28, 3(vi11)      |  mulaz.xyzw ACC, vf19, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf19).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf28].vf, vis[vi11] + 3);
+  // lq.xyzw vf23, 3(vi12)      |  maddw.xyzw vf21, vf21, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf21].vf, c->vf_src(vf21).vf, c->vf_src(vf18).vf.w());   lq_xyzw(c->vfs[vf23].vf, vis[vi12] + 3);
+  // lqi.xyzw vf29, vi10        |  mulaz.xyzw ACC, vf27, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf27).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf29].vf, vis[vi10]++);
+  // iaddiu vi01, vi00, 0x146   |  maddw.xyzw vf22, vf22, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf22].vf, c->vf_src(vf22).vf, c->vf_src(vf18).vf.w());   vis[vi01] = 0x146; /* 326 */
+  // BRANCH!
+  // ibne vi08, vi04, L6        |  mulaz.xyzw ACC, vf28, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf28).vf, c->vf_src(vf18).vf.z());   bc = (vis[vi08] != vis[vi04]);
+  // nop                        |  maddw.xyzw vf23, vf23, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf23].vf, c->vf_src(vf23).vf, c->vf_src(vf18).vf.w());
+  if (bc) { goto L6; }
+
+  // ior vi01, vi05, vi00       |  nop
+  vis[vi01] = vis[vi05];
+  L6:
+  // mtir vi13, vf29.w          |  itof0.xyzw vf18, vf29
+  c->vfs[vf18].vf.itof0(Mask::xyzw, c->vf_src(vf29).vf);   vis[vi13] = c->vf_src(vf29).vf.w_as_u16();
+  // move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());   c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  // move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());   c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+  return;
+  L7:
+  // nop                        |  add.xyzw vf10, vf03, vf07
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);
+  // BRANCH!
+  // ibne vi08, vi04, L8        |  adday.xyzw vf16, vf16
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());   bc = (vis[vi08] != vis[vi04]);
+  // nop                        |  maddz.xyzw vf16, vf17, vf16
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());
+  if (bc) { goto L8; }
+
+  // ior vi01, vi05, vi00       |  nop
+  vis[vi01] = vis[vi05];
+  L8:
+  // move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());   c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  // move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());   c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+  return;
+}
+
+void vcallms_311_case_386(ExecutionContext* c, u16* vis) {
+  bool bc;
+  // mtir vi11, vf01.x          |  maddz.xyzw vf11, vf26, vf10
+  c->acc.vf.madd_xyzw(c->vfs[vf11].vf, c->vf_src(vf26).vf, c->vf_src(vf10).vf.z());   vis[vi11] = c->vf_src(vf01).vf.x_as_u16();
+  // jr vi01                    |  mul.xyzw vf14, vf13, Q
+  c->vfs[vf14].vf.mul_xyzw(c->vf_src(vf13).vf, c->Q);
+  // sqi.xyzw vf04, vi08        |  mulaw.xyzw ACC, vf20, vf08
+  c->acc.vf.mula_xyzw(c->vf_src(vf20).vf, c->vf_src(vf08).vf.w());   sq_xyzw(c->vf_src(vf04).vf, vis[vi08]++);
+  // rsqrt Q, vf00.w, vf16.x    |  maddaw.xyzw ACC, vf21, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf21].vf, c->vfs[vf09].vf.w());   c->Q = c->vf_src(vf00).vf.w() / std::sqrt(c->vf_src(vf16).vf.x());
+  // mtir vi12, vf01.y          |  maddaw.xyzw ACC, vf22, vf10
+  c->acc.vf.madda_xyzw(c->vfs[vf22].vf, c->vfs[vf10].vf.w());   vis[vi12] = c->vf_src(vf01).vf.y_as_u16();
+  // iand vi11, vi11, vi09      |  maddw.xyzw vf15, vf23, vf00
+  c->acc.vf.madd_xyzw(c->vfs[vf15].vf, c->vf_src(vf23).vf, c->vf_src(vf00).vf.w());   vis[vi11] = vis[vi11] & vis[vi09];
+  // lq.xyzw vf19, 4(vi11)      |  mul.xyzw vf16, vf11, vf11
+  c->vfs[vf16].vf.mul_xyzw(c->vf_src(vf11).vf, c->vf_src(vf11).vf);   lq_xyzw(c->vfs[vf19].vf, vis[vi11] + 4);
+  // BRANCH!
+  // ibeq vi09, vi11, L10       |  add.xyzw vf08, vf01, vf05
+  c->vfs[vf08].vf.add_xyzw(c->vf_src(vf01).vf, c->vf_src(vf05).vf);   bc = (vis[vi09] == vis[vi11]);
+  // iand vi12, vi12, vi09      |  add.xyzw vf09, vf02, vf06
+  c->vfs[vf09].vf.add_xyzw(c->vf_src(vf02).vf, c->vf_src(vf06).vf);   vis[vi12] = vis[vi12] & vis[vi09];
+  if (bc) { goto L10; }
+
+  // nop                        |  muly.xyzw vf18, vf18, vf17
+  c->vfs[vf18].vf.mul_xyzw(c->vf_src(vf18).vf, c->vf_src(vf17).vf.y());
+  // lq.xyzw vf27, 4(vi12)      |  add.xyzw vf10, vf03, vf07
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);   lq_xyzw(c->vfs[vf27].vf, vis[vi12] + 4);
+  // lq.xyzw vf24, 4(vi13)      |  adday.xyzw vf16, vf16
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());   lq_xyzw(c->vfs[vf24].vf, vis[vi13] + 4);
+  // lq.xyzw vf28, 5(vi11)      |  maddz.xyzw vf16, vf17, vf16
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());   lq_xyzw(c->vfs[vf28].vf, vis[vi11] + 5);
+  // lq.xyzw vf19, 5(vi12)      |  mulax.xyzw ACC, vf19, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf19).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf19].vf, vis[vi12] + 5);
+  // lq.xyzw vf25, 5(vi13)      |  madday.xyzw ACC, vf27, vf18
+  c->acc.vf.madda_xyzw(c->vfs[vf27].vf, c->vfs[vf18].vf.y());   lq_xyzw(c->vfs[vf25].vf, vis[vi13] + 5);
+  // lq.xyzw vf27, 6(vi11)      |  maddz.xyzw vf24, vf24, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf24].vf, c->vf_src(vf24).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf27].vf, vis[vi11] + 6);
+  // lq.xyzw vf28, 6(vi12)      |  mulax.xyzw ACC, vf28, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf28).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf28].vf, vis[vi12] + 6);
+  // lq.xyzw vf26, 6(vi13)      |  madday.xyzw ACC, vf19, vf18
+  c->acc.vf.madda_xyzw(c->vfs[vf19].vf, c->vfs[vf18].vf.y());   lq_xyzw(c->vfs[vf26].vf, vis[vi13] + 6);
+  // lq.xyzw vf19, 0(vi11)      |  maddz.xyzw vf25, vf25, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf25].vf, c->vf_src(vf25).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf19].vf, vis[vi11]);
+  // lq.xyzw vf27, 0(vi12)      |  mulax.xyzw ACC, vf27, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf27).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf27].vf, vis[vi12]);
+  // lq.xyzw vf20, 0(vi13)      |  madday.xyzw ACC, vf28, vf18
+  c->acc.vf.madda_xyzw(c->vfs[vf28].vf, c->vfs[vf18].vf.y());   lq_xyzw(c->vfs[vf20].vf, vis[vi13]);
+  // lq.xyzw vf28, 1(vi11)      |  maddz.xyzw vf26, vf26, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf26].vf, c->vf_src(vf26).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf28].vf, vis[vi11] + 1);
+  // lq.xyzw vf19, 1(vi12)      |  mulax.xyzw ACC, vf19, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf19).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf19].vf, vis[vi12] + 1);
+  // lq.xyzw vf21, 1(vi13)      |  madday.xyzw ACC, vf27, vf18
+  c->acc.vf.madda_xyzw(c->vfs[vf27].vf, c->vfs[vf18].vf.y());   lq_xyzw(c->vfs[vf21].vf, vis[vi13] + 1);
+  // lq.xyzw vf27, 2(vi11)      |  maddz.xyzw vf20, vf20, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf20].vf, c->vf_src(vf20).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf27].vf, vis[vi11] + 2);
+  // lq.xyzw vf28, 2(vi12)      |  mulax.xyzw ACC, vf28, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf28).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf28].vf, vis[vi12] + 2);
+  // lq.xyzw vf22, 2(vi13)      |  madday.xyzw ACC, vf19, vf18
+  c->acc.vf.madda_xyzw(c->vfs[vf19].vf, c->vfs[vf18].vf.y());   lq_xyzw(c->vfs[vf22].vf, vis[vi13] + 2);
+  // lq.xyzw vf19, 3(vi11)      |  maddz.xyzw vf21, vf21, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf21].vf, c->vf_src(vf21).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf19].vf, vis[vi11] + 3);
+  // lq.xyzw vf27, 3(vi12)      |  mulax.xyzw ACC, vf27, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf27).vf, c->vf_src(vf18).vf.x());   lq_xyzw(c->vfs[vf27].vf, vis[vi12] + 3);
+  // lq.xyzw vf23, 3(vi13)      |  madday.xyzw ACC, vf28, vf18
+  c->acc.vf.madda_xyzw(c->vfs[vf28].vf, c->vfs[vf18].vf.y());   lq_xyzw(c->vfs[vf23].vf, vis[vi13] + 3);
+  // lqi.xyzw vf29, vi10        |  maddz.xyzw vf22, vf22, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf22].vf, c->vf_src(vf22).vf, c->vf_src(vf18).vf.z());   lq_xyzw(c->vfs[vf29].vf, vis[vi10]++);
+  // BRANCH!
+  // ibne vi08, vi06, L9        |  mulax.xyzw ACC, vf19, vf18
+  c->acc.vf.mula_xyzw(c->vf_src(vf19).vf, c->vf_src(vf18).vf.x());   bc = (vis[vi08] != vis[vi06]);
+  // nop                        |  madday.xyzw ACC, vf27, vf18
+  c->acc.vf.madda_xyzw(c->vfs[vf27].vf, c->vfs[vf18].vf.y());
+  if (bc) { goto L9; }
+
+  // iaddiu vi01, vi00, 0x1ab   |  nop
+  vis[vi01] = 0x1ab; /* 427 */
+  L9:
+  // nop                        |  maddz.xyzw vf23, vf23, vf18
+  c->acc.vf.madd_xyzw(c->vfs[vf23].vf, c->vf_src(vf23).vf, c->vf_src(vf18).vf.z());
+  // mtir vi13, vf29.w          |  itof0.xyz vf18, vf29
+  c->vfs[vf18].vf.itof0(Mask::xyz, c->vf_src(vf29).vf);   vis[vi13] = c->vf_src(vf29).vf.w_as_u16();
+  // move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());   c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  // move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());   c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+  return;
+  L10:
+  // nop                        |  add.xyzw vf10, vf03, vf07
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);
+  // BRANCH!
+  // ibne vi08, vi06, L11       |  adday.xyzw vf16, vf16
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());   bc = (vis[vi08] != vis[vi06]);
+  // nop                        |  maddz.xyzw vf16, vf17, vf16
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());
+  if (bc) { goto L11; }
+
+  // iaddiu vi01, vi00, 0x1ab   |  nop
+  vis[vi01] = 0x1ab; /* 427 */
+  L11:
+  // move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());   c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  // move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());   c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+  return;
+}
+
+void vcallms_311_case_427(ExecutionContext* c, u16* vis) {
+  // mtir vi11, vf01.x          |  maddz.xyzw vf11, vf26, vf10
+  c->acc.vf.madd_xyzw(c->vfs[vf11].vf, c->vf_src(vf26).vf, c->vf_src(vf10).vf.z());   vis[vi11] = c->vf_src(vf01).vf.x_as_u16();
+  // jr vi01                    |  mul.xyzw vf14, vf13, Q
+  c->vfs[vf14].vf.mul_xyzw(c->vf_src(vf13).vf, c->Q);
+  // sqi.xyzw vf04, vi08        |  mulaw.xyzw ACC, vf20, vf08
+  c->acc.vf.mula_xyzw(c->vf_src(vf20).vf, c->vf_src(vf08).vf.w());   sq_xyzw(c->vf_src(vf04).vf, vis[vi08]++);
+  c->acc.vf.madda_xyzw(c->vfs[vf21].vf, c->vfs[vf09].vf.w());   c->Q = c->vf_src(vf00).vf.w() / std::sqrt(c->vf_src(vf16).vf.x());
+  // nop                        |  maddaw.xyzw ACC, vf22, vf10
+  c->acc.vf.madda_xyzw(c->vfs[vf22].vf, c->vfs[vf10].vf.w());
+  // nop                        |  maddw.xyzw vf15, vf23, vf00
+  c->acc.vf.madd_xyzw(c->vfs[vf15].vf, c->vf_src(vf23).vf, c->vf_src(vf00).vf.w());
+  // nop                        |  mul.xyzw vf16, vf11, vf11
+  c->vfs[vf16].vf.mul_xyzw(c->vf_src(vf11).vf, c->vf_src(vf11).vf);
+  // nop                        |  add.xyzw vf08, vf01, vf05
+  c->vfs[vf08].vf.add_xyzw(c->vf_src(vf01).vf, c->vf_src(vf05).vf);
+  // nop                        |  add.xyzw vf09, vf02, vf06
+  c->vfs[vf09].vf.add_xyzw(c->vf_src(vf02).vf, c->vf_src(vf06).vf);
+  // nop                        |  add.xyzw vf10, vf03, vf07
+  c->vfs[vf10].vf.add_xyzw(c->vf_src(vf03).vf, c->vf_src(vf07).vf);
+  // nop                        |  adday.xyzw vf16, vf16
+  c->acc.vf.adda(Mask::xyzw, c->vfs[vf16].vf, c->vfs[vf16].vf.y());
+  // nop                        |  maddz.xyzw vf16, vf17, vf16
+  c->acc.vf.madd_xyzw(c->vfs[vf16].vf, c->vf_src(vf17).vf, c->vf_src(vf16).vf.z());
+  // move.xyzw vf13, vf12       |  mulaz.xyzw ACC, vf24, vf08 :e
+  c->acc.vf.mula_xyzw(c->vf_src(vf24).vf, c->vf_src(vf08).vf.z());   c->vfs[vf13].vf.move(Mask::xyzw, c->vf_src(vf12).vf);
+  // move.xyzw vf12, vf11       |  maddaz.xyzw ACC, vf25, vf09
+  c->acc.vf.madda_xyzw(c->vfs[vf25].vf, c->vfs[vf09].vf.z());   c->vfs[vf12].vf.move(Mask::xyzw, c->vf_src(vf11).vf);
+  return;
+}
+
+void vcallms_311(ExecutionContext* c, u16* vis) {
+  switch(vis[vi01]) {
+    case 314:
+      vcallms_311_case_314(c, vis);
+      break;
+    case 326:
+      vcallms_311_case_326(c, vis);
+      break;
+    case 353:
+      vcallms_311_case_353(c, vis);
+      break;
+    case 386:
+      vcallms_311_case_386(c, vis);
+      break;
+    case 427:
+      vcallms_311_case_427(c, vis);
+      break;
+    default:
+      ASSERT_MSG(false, fmt::format("BAD JUMP {}", vis[vi01]));
+  }
+}
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u16 vis[16];
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->sq(s0, 7536, at);                              // sq s0, 7536(at)
+  c->sq(s1, 7552, at);                              // sq s1, 7552(at)
+  c->sq(s2, 7568, at);                              // sq s2, 7568(at)
+  c->sq(s3, 7584, at);                              // sq s3, 7584(at)
+  c->sq(s4, 7600, at);                              // sq s4, 7600(at)
+  c->sq(s5, 7616, at);                              // sq s5, 7616(at)
+  c->sq(s6, 7632, at);                              // sq s6, 7632(at)
+  c->sq(t8, 7648, at);                              // sq t8, 7648(at)
+  c->sq(t9, 7664, at);                              // sq t9, 7664(at)
+  c->sq(gp, 7680, at);                              // sq gp, 7680(at)
+  c->sq(sp, 7696, at);                              // sq sp, 7696(at)
+  c->sq(fp, 7712, at);                              // sq fp, 7712(at)
+  c->sq(ra, 7728, at);                              // sq ra, 7728(at)
+  // nop                                            // sll r0, r0, 0
+  get_fake_spad_addr2(t4, cache.fake_scratchpad_data, 0, c);// lui t4, 28672
+  c->addiu(a0, r0, 0);                              // addiu a0, r0, 0
+  c->lbu(a1, 6955, t4);                             // lbu a1, 6955(t4)
+  c->addiu(a2, r0, 4);                              // addiu a2, r0, 4
+  c->lw(t0, 7444, t4);                              // lw t0, 7444(t4)
+  c->addiu(a3, r0, 1);                              // addiu a3, r0, 1
+  c->lw(v1, 7448, t4);                              // lw v1, 7448(t4)
+  c->and_(a3, a1, a3);                              // and a3, a1, a3
+  c->lw(a1, 24, t4);                                // lw a1, 24(t4)
+  c->movn(a0, a2, a3);                              // movn a0, a2, a3
+  c->lbu(a3, 6855, t4);                             // lbu a3, 6855(t4)
+  c->daddu(t1, a0, t4);                             // daddu t1, a0, t4
+  c->lbu(t2, 6852, t4);                             // lbu t2, 6852(t4)
+  c->daddiu(a2, a1, 128);                           // daddiu a2, a1, 128
+  c->lw(a0, 7428, t4);                              // lw a0, 7428(t4)
+  c->dsll(t3, a3, 3);                               // dsll t3, a3, 3
+  c->lbu(a3, 10, t0);                               // lbu a3, 10(t0)
+  c->dsll(t5, t2, 1);                               // dsll t5, t2, 1
+  c->lbu(t2, 9, t0);                                // lbu t2, 9(t0)
+  c->daddu(t1, t1, t5);                             // daddu t1, t1, t5
+  // nop                                            // sll r0, r0, 0
+  c->daddu(t3, t1, t3);                             // daddu t3, t1, t3
+  c->lbu(t1, 11953, t3);                            // lbu t1, 11953(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(t5, 11952, t3);                            // lbu t5, 11952(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t3, 7432, t4);                              // lw t3, 7432(t4)
+  c->sll(t6, a3, 4);                                // sll t6, a3, 4
+  c->daddu(t5, t5, t4);                             // daddu t5, t5, t4
+  c->daddu(t7, t1, t4);                             // daddu t7, t1, t4
+  c->lw(a3, 7436, t4);                              // lw a3, 7436(t4)
+  c->daddu(t1, t6, t0);                             // daddu t1, t6, t0
+  c->sw(t1, 7452, t4);                              // sw t1, 7452(t4)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(t0, 12, t1);                               // lbu t0, 12(t1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 11888, t7);                             // lq t7, 11888(t7)
+  // nop                                            // sll r0, r0, 0
+  c->lq(s0, 11888, t5);                             // lq s0, 11888(t5)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t7, 96, a1);                                // sq t7, 96(a1)
+  c->daddiu(t5, v1, 5504);                          // daddiu t5, v1, 5504
+  c->sq(s0, 112, a1);                               // sq s0, 112(a1)
+  c->daddiu(v1, v1, 6048);                          // daddiu v1, v1, 6048
+  c->lbu(ra, 6857, t4);                             // lbu ra, 6857(t4)
+  c->movn(v1, t5, t2);                              // movn v1, t5, t2
+  c->sw(r0, 124, a1);                               // sw r0, 124(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 11744, t4);                             // lq t7, 11744(t4)
+  c->daddiu(t6, t1, 16);                            // daddiu t6, t1, 16
+  c->lq(s0, 11808, t4);                             // lq s0, 11808(t4)
+  c->addiu(t9, r0, 0);                              // addiu t9, r0, 0
+  c->lq(s4, 11824, t4);                             // lq s4, 11824(t4)
+  c->addiu(t5, r0, 0);                              // addiu t5, r0, 0
+  c->lq(gp, 11840, t4);                             // lq gp, 11840(t4)
+  c->addiu(t1, r0, -3);                             // addiu t1, r0, -3
+  c->lq(s5, 11856, t4);                             // lq s5, 11856(t4)
+  c->addiu(t8, r0, 6);                              // addiu t8, r0, 6
+  c->lq(t4, 11872, t4);                             // lq t4, 11872(t4)
+  c->andi(s3, ra, 4);                               // andi s3, ra, 4
+  c->sq(t7, 0, a1);                                 // sq t7, 0(a1)
+  c->movz(t8, r0, t2);                              // movz t8, r0, t2
+  c->sq(s0, 16, a1);                                // sq s0, 16(a1)
+  c->addiu(ra, r0, 0);                              // addiu ra, r0, 0
+  c->sq(s4, 32, a1);                                // sq s4, 32(a1)
+  c->addiu(t7, r0, -32768);                         // addiu t7, r0, -32768
+  c->sq(gp, 48, a1);                                // sq gp, 48(a1)
+  c->movz(ra, t7, t0);                              // movz ra, t7, t0
+  c->sq(s5, 64, a1);                                // sq s5, 64(a1)
+  c->dsll(t7, s3, 18);                              // dsll t7, s3, 18
+  c->pextlw(t7, t7, t7);                            // pextlw t7, t7, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // Unknown instr: pnor t7, r0, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t4, t4, t7);                              // pand t4, t4, t7
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  bc = c->sgpr64(t2) == 0;                          // beq t2, r0, L84
+  c->sq(t4, 80, a1);                                // sq t4, 80(a1)
+  if (bc) {goto block_4;}                           // branch non-likely
+
+  c->lq(t7, 2944, t3);                              // lq t7, 2944(t3)
+  c->daddu(ra, t2, ra);                             // daddu ra, t2, ra
+  c->lq(s0, 2960, t3);                              // lq s0, 2960(t3)
+  c->addiu(gp, r0, -6);                             // addiu gp, r0, -6
+  c->lq(t4, 2976, t3);                              // lq t4, 2976(t3)
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  c->lq(t2, 2992, t3);                              // lq t2, 2992(t3)
+  c->daddiu(s5, t0, -3);                            // daddiu s5, t0, -3
+  bc = ((s64)c->sgpr64(s5)) <= 0;                   // blez s5, L86
+  c->lq(t3, 3008, t3);                              // lq t3, 3008(t3)
+  if (bc) {goto block_8;}                           // branch non-likely
+
+  c->daddiu(t9, t0, -5);                            // daddiu t9, t0, -5
+  // nop                                            // sll r0, r0, 0
+  bc = ((s64)c->sgpr64(t9)) <= 0;                   // blez t9, L86
+  c->lh(t9, 172, t6);                               // lh t9, 172(t6)
+  if (bc) {goto block_8;}                           // branch non-likely
+
+  //beq r0, r0, L86                                 // beq r0, r0, L86
+  c->lh(t5, 332, t6);                               // lh t5, 332(t6)
+  goto block_8;                                     // branch always
+
+
+  block_4:
+  c->daddiu(t2, t0, -3);                            // daddiu t2, t0, -3
+  // nop                                            // sll r0, r0, 0
+  bc = ((s64)c->sgpr64(t2)) <= 0;                   // blez t2, L85
+  c->daddiu(t2, t0, -5);                            // daddiu t2, t0, -5
+  if (bc) {goto block_7;}                           // branch non-likely
+
+  bc = ((s64)c->sgpr64(t2)) <= 0;                   // blez t2, L85
+  c->lh(t9, 252, t6);                               // lh t9, 252(t6)
+  if (bc) {goto block_7;}                           // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->lh(t5, 412, t6);                               // lh t5, 412(t6)
+
+  block_7:
+  c->lh(gp, 12, t6);                                // lh gp, 12(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lh(ra, 28, t6);                                // lh ra, 28(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t7, 0, t6);                                 // lq t7, 0(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(s0, 16, t6);                                // lq s0, 16(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t4, 32, t6);                                // lq t4, 32(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 48, t6);                                // lq t2, 48(t6)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 64, t6);                                // lq t3, 64(t6)
+  c->daddiu(t6, t6, 80);                            // daddiu t6, t6, 80
+
+  block_8:
+  c->sq(t7, 0, a2);                                 // sq t7, 0(a2)
+  c->daddu(gp, gp, t8);                             // daddu gp, gp, t8
+  c->sq(s0, 16, a2);                                // sq s0, 16(a2)
+  c->daddiu(t8, t8, 2);                             // daddiu t8, t8, 2
+  c->sq(t4, 32, a2);                                // sq t4, 32(a2)
+  c->daddu(t1, t1, ra);                             // daddu t1, t1, ra
+  c->sq(t2, 48, a2);                                // sq t2, 48(a2)
+  c->daddiu(t1, t1, 3);                             // daddiu t1, t1, 3
+  c->sq(t3, 64, a2);                                // sq t3, 64(a2)
+  c->andi(t1, t1, 255);                             // andi t1, t1, 255
+  c->sw(gp, 12, a2);                                // sw gp, 12(a2)
+  c->daddiu(a2, a2, 80);                            // daddiu a2, a2, 80
+  bc = ((s64)c->sgpr64(ra)) > 0;                    // bgtz ra, L85
+  c->sw(ra, -52, a2);                               // sw ra, -52(a2)
+  if (bc) {goto block_7;}                           // branch non-likely
+
+  c->sw(t1, 108, a1);                               // sw t1, 108(a1)
+  c->daddiu(a1, t9, 7);                             // daddiu a1, t9, 7
+  c->sq(t7, 2944, a0);                              // sq t7, 2944(a0)
+  c->daddiu(t5, t5, 7);                             // daddiu t5, t5, 7
+  c->sq(s0, 2960, a0);                              // sq s0, 2960(a0)
+  c->sra(a2, a1, 4);                                // sra a2, a1, 4
+  c->sq(t4, 2976, a0);                              // sq t4, 2976(a0)
+  c->sra(t4, t5, 4);                                // sra t4, t5, 4
+  c->sq(t2, 2992, a0);                              // sq t2, 2992(a0)
+  c->daddiu(a1, a3, 192);                           // daddiu a1, a3, 192
+  c->sq(t3, 3008, a0);                              // sq t3, 3008(a0)
+  c->dsll(a0, t0, 2);                               // dsll a0, t0, 2
+  c->sh(t1, 18, a3);                                // sh t1, 18(a3)
+  c->daddu(a0, a0, t0);                             // daddu a0, a0, t0
+  c->sb(t0, 16, a3);                                // sb t0, 16(a3)
+  c->daddiu(a0, a0, 7);                             // daddiu a0, a0, 7
+  c->dsubu(a0, t4, a2);                             // dsubu a0, t4, a2
+  c->lq(t0, 0, v1);                                 // lq t0, 0(v1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t1, a2, -3);                            // daddiu t1, a2, -3
+  c->lq(a3, 16, v1);                                // lq a3, 16(v1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, 0, a1);                                 // sq t0, 0(a1)
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L87
+  c->lq(a2, 32, v1);                                // lq a2, 32(v1)
+  if (bc) {goto block_21;}                          // branch non-likely
+
+  c->daddiu(t0, t1, -1);                            // daddiu t0, t1, -1
+  c->sq(a3, 16, a1);                                // sq a3, 16(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L88
+  c->lq(a3, 48, v1);                                // lq a3, 48(v1)
+  if (bc) {goto block_22;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a2, 32, a1);                                // sq a2, 32(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L89
+  c->lq(a2, 64, v1);                                // lq a2, 64(v1)
+  if (bc) {goto block_23;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a3, 48, a1);                                // sq a3, 48(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L90
+  c->lq(a3, 80, v1);                                // lq a3, 80(v1)
+  if (bc) {goto block_24;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a2, 64, a1);                                // sq a2, 64(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L91
+  c->lq(a2, 96, v1);                                // lq a2, 96(v1)
+  if (bc) {goto block_25;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a3, 80, a1);                                // sq a3, 80(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L92
+  c->lq(a3, 112, v1);                               // lq a3, 112(v1)
+  if (bc) {goto block_26;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a2, 96, a1);                                // sq a2, 96(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L93
+  c->lq(a2, 128, v1);                               // lq a2, 128(v1)
+  if (bc) {goto block_27;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a3, 112, a1);                               // sq a3, 112(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L94
+  c->lq(a3, 144, v1);                               // lq a3, 144(v1)
+  if (bc) {goto block_28;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a2, 128, a1);                               // sq a2, 128(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L95
+  c->lq(a2, 160, v1);                               // lq a2, 160(v1)
+  if (bc) {goto block_29;}                          // branch non-likely
+
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(a3, 144, a1);                               // sq a3, 144(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L96
+  c->lq(a3, 176, v1);                               // lq a3, 176(v1)
+  if (bc) {goto block_30;}                          // branch non-likely
+
+  c->daddiu(a0, t0, -1);                            // daddiu a0, t0, -1
+  c->sq(a2, 160, a1);                               // sq a2, 160(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L97
+  c->lq(a0, 192, v1);                               // lq a0, 192(v1)
+  if (bc) {goto block_31;}                          // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 176, a1);                               // sq a3, 176(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(v1, 208, v1);                               // lq v1, 208(v1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(a0, 192, a1);                               // sq a0, 192(a1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->sq(v1, 208, a1);                               // sq v1, 208(a1)
+  //beq r0, r0, L107                                // beq r0, r0, L107
+  // nop                                            // sll r0, r0, 0
+  goto block_41;                                    // branch always
+
+
+  block_21:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, 16, a1);                                // sq a3, 16(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 224, v1);                               // lq a3, 224(v1)
+
+  block_22:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a2, 32, a1);                                // sq a2, 32(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L98
+  c->lq(a2, 240, v1);                               // lq a2, 240(v1)
+  if (bc) {goto block_32;}                          // branch non-likely
+
+
+  block_23:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, 48, a1);                                // sq a3, 48(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L99
+  c->lq(a3, 256, v1);                               // lq a3, 256(v1)
+  if (bc) {goto block_33;}                          // branch non-likely
+
+
+  block_24:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a2, 64, a1);                                // sq a2, 64(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L100
+  c->lq(a2, 272, v1);                               // lq a2, 272(v1)
+  if (bc) {goto block_34;}                          // branch non-likely
+
+
+  block_25:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, 80, a1);                                // sq a3, 80(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L101
+  c->lq(a3, 288, v1);                               // lq a3, 288(v1)
+  if (bc) {goto block_35;}                          // branch non-likely
+
+
+  block_26:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a2, 96, a1);                                // sq a2, 96(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L102
+  c->lq(a2, 304, v1);                               // lq a2, 304(v1)
+  if (bc) {goto block_36;}                          // branch non-likely
+
+
+  block_27:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, 112, a1);                               // sq a3, 112(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L103
+  c->lq(a3, 320, v1);                               // lq a3, 320(v1)
+  if (bc) {goto block_37;}                          // branch non-likely
+
+
+  block_28:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a2, 128, a1);                               // sq a2, 128(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L104
+  c->lq(a2, 336, v1);                               // lq a2, 336(v1)
+  if (bc) {goto block_38;}                          // branch non-likely
+
+
+  block_29:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, 144, a1);                               // sq a3, 144(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L105
+  c->lq(a3, 352, v1);                               // lq a3, 352(v1)
+  if (bc) {goto block_39;}                          // branch non-likely
+
+
+  block_30:
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a2, 160, a1);                               // sq a2, 160(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L106
+  c->lq(a0, 368, v1);                               // lq a0, 368(v1)
+  if (bc) {goto block_40;}                          // branch non-likely
+
+
+  block_31:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 176, a1);                               // sq a3, 176(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(v1, 384, v1);                               // lq v1, 384(v1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(a0, 192, a1);                               // sq a0, 192(a1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->sq(v1, 208, a1);                               // sq v1, 208(a1)
+  //beq r0, r0, L107                                // beq r0, r0, L107
+  // nop                                            // sll r0, r0, 0
+  goto block_41;                                    // branch always
+
+
+  block_32:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 48, a1);                                // sq a3, 48(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 400, v1);                               // lq a3, 400(v1)
+
+  block_33:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a2, 64, a1);                                // sq a2, 64(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a2, 416, v1);                               // lq a2, 416(v1)
+
+  block_34:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 80, a1);                                // sq a3, 80(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 432, v1);                               // lq a3, 432(v1)
+
+  block_35:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a2, 96, a1);                                // sq a2, 96(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a2, 448, v1);                               // lq a2, 448(v1)
+
+  block_36:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 112, a1);                               // sq a3, 112(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 464, v1);                               // lq a3, 464(v1)
+
+  block_37:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a2, 128, a1);                               // sq a2, 128(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a2, 480, v1);                               // lq a2, 480(v1)
+
+  block_38:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 144, a1);                               // sq a3, 144(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 496, v1);                               // lq a3, 496(v1)
+
+  block_39:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a2, 160, a1);                               // sq a2, 160(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a0, 512, v1);                               // lq a0, 512(v1)
+
+  block_40:
+  // nop                                            // sll r0, r0, 0
+  c->sq(a3, 176, a1);                               // sq a3, 176(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lq(v1, 528, v1);                               // lq v1, 528(v1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(a0, 192, a1);                               // sq a0, 192(a1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->sq(v1, 208, a1);                               // sq v1, 208(a1)
+
+  block_41:
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  // nop                                            // sll r0, r0, 0
+  c->lw(a1, 7452, v1);                              // lw a1, 7452(v1)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a0, 7436, v1);                              // lw a0, 7436(v1)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(a2, 13, a1);                               // lbu a2, 13(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(v1, 14, a1);                               // lbu v1, 14(a1)
+  c->daddiu(a0, a0, 32);                            // daddiu a0, a0, 32
+  c->lbu(a3, 15, a1);                               // lbu a3, 15(a1)
+  c->daddu(a1, a1, a2);                             // daddu a1, a1, a2
+  c->mult3(a3, v1, a3);                             // mult3 a3, v1, a3
+  c->mov64(a1, a1);                                 // or a1, a1, r0
+  c->mov64(v1, v1);                                 // or v1, v1, r0
+  c->mov64(a0, a0);                                 // or a0, a0, r0
+  c->addiu(a2, r0, 513);                            // addiu a2, r0, 513
+  c->addiu(t0, r0, 257);                            // addiu t0, r0, 257
+  c->dsll(t2, a2, 18);                              // dsll t2, a2, 18
+  c->dsll(t1, t0, 16);                              // dsll t1, t0, 16
+  c->or_(a2, a2, t2);                               // or a2, a2, t2
+  c->or_(t0, t0, t1);                               // or t0, t0, t1
+  c->dsll32(t2, a2, 4);                             // dsll32 t2, a2, 4
+  c->dsll32(t1, t0, 0);                             // dsll32 t1, t0, 0
+  c->or_(a2, a2, t2);                               // or a2, a2, t2
+  c->or_(t0, t0, t1);                               // or t0, t0, t1
+  c->pcpyld(a2, a2, a2);                            // pcpyld a2, a2, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyld(t0, t0, t0);                            // pcpyld t0, t0, t0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->daddu(a3, a3, a1);                             // daddu a3, a3, a1
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->lhu(t1, 0, a1);                                // lhu t1, 0(a1)
+  c->daddu(a1, a1, v1);                             // daddu a1, a1, v1
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  // nop                                            // sll r0, r0, 0
+  c->pextlb(t1, t1, t1);                            // pextlb t1, t1, t1
+  //beq r0, r0, L109                                // beq r0, r0, L109
+  c->pextlb(t2, t1, t1);                            // pextlb t2, t1, t1
+  goto block_43;                                    // branch always
+
+
+  block_42:
+  c->daddu(a1, a1, v1);                             // daddu a1, a1, v1
+  c->daddiu(a0, a0, 32);                            // daddiu a0, a0, 32
+  c->pextlb(t2, t2, t2);                            // pextlb t2, t2, t2
+  c->sq(t1, -16, a0);                               // sq t1, -16(a0)
+
+  block_43:
+  c->pextlb(t1, t2, t2);                            // pextlb t1, t2, t2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t1, t1, a2);                              // pand t1, t1, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pceqb(t1, t1, a2);                             // pceqb t1, t1, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pand(t1, t1, t0);                              // pand t1, t1, t0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlb(t2, t1, r0);                            // pextlb t2, t1, r0
+  c->lhu(t3, 0, a1);                                // lhu t3, 0(a1)
+  c->pextub(t1, t1, r0);                            // pextub t1, t1, r0
+  c->sq(t2, 0, a0);                                 // sq t2, 0(a0)
+  bc = c->sgpr64(a1) != c->sgpr64(a3);              // bne a1, a3, L108
+  c->pextlb(t2, t3, t3);                            // pextlb t2, t3, t3
+  if (bc) {goto block_42;}                          // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->sq(t1, 16, a0);                                // sq t1, 16(a0)
+  get_fake_spad_addr2(s4, cache.fake_scratchpad_data, 0, c);// lui s4, 28672
+  // nop                                            // sll r0, r0, 0
+  c->lw(a0, 7444, s4);                              // lw a0, 7444(s4)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a1, 7436, s4);                              // lw a1, 7436(s4)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t8, 16, a0);                                // lq t8, 16(a0)
+  c->daddiu(s6, a0, 48);                            // daddiu s6, a0, 48
+  c->lbu(a3, 12, a0);                               // lbu a3, 12(a0)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(t2, 10, a0);                               // lbu t2, 10(a0)
+  c->pextlb(t9, r0, t8);                            // pextlb t9, r0, t8
+  vis[10] = c->gpr_src(a3).du16[0];                    // ctc2.ni vi10, a3
+  c->pextlh(gp, r0, t9);                            // pextlh gp, r0, t9
+  c->mov128_vf_gpr(vf1, gp);                        // qmtc2.ni vf1, gp
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  c->mov128_vf_gpr(vf2, t9);                        // qmtc2.ni vf2, t9
+  c->pextub(t9, r0, t8);                            // pextub t9, r0, t8
+  c->lbu(a3, 4, a0);                                // lbu a3, 4(a0)
+  c->pextlh(gp, r0, t9);                            // pextlh gp, r0, t9
+  c->mov128_vf_gpr(vf3, gp);                        // qmtc2.ni vf3, gp
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  c->mov128_vf_gpr(vf4, t9);                        // qmtc2.ni vf4, t9
+  c->sll(t2, t2, 4);                                // sll t2, t2, 4
+  c->lbu(t0, 5, a0);                                // lbu t0, 5(a0)
+  c->daddu(t2, t2, a0);                             // daddu t2, t2, a0
+  c->lbu(t1, 6, a0);                                // lbu t1, 6(a0)
+  c->daddiu(s5, a3, -1);                            // daddiu s5, a3, -1
+  vis[11] = c->gpr_src(a3).du16[0];                    // ctc2.ni vi11, a3
+  c->daddu(s5, s5, t0);                             // daddu s5, s5, t0
+  vis[12] = c->gpr_src(t0).du16[0];                    // ctc2.ni vi12, t0
+  c->daddu(s5, s5, t1);                             // daddu s5, s5, t1
+  vis[13] = c->gpr_src(t1).du16[0];                    // ctc2.ni vi13, t1
+  c->daddiu(t4, a1, 32);                            // daddiu t4, a1, 32
+  c->lqc2(vf27, 0, t2);                             // lqc2 vf27, 0(t2)
+  c->daddiu(t3, a1, 192);                           // daddiu t3, a1, 192
+  // Unknown instr: vcallms 280
+  vcallms_280(c, vis);
+  c->daddiu(v1, a1, 448);                           // daddiu v1, a1, 448
+  c->lhu(s1, 6820, s4);                             // lhu s1, 6820(s4)
+  c->pextlw(t3, t3, t3);                            // pextlw t3, t3, t3
+  c->lhu(s2, 6822, s4);                             // lhu s2, 6822(s4)
+  c->pcpyld(t3, t3, t3);                            // pcpyld t3, t3, t3
+  c->lqc2(vf19, 6800, s4);                          // lqc2 vf19, 6800(s4)
+  c->pcpyh(s1, s1);                                 // pcpyh s1, s1
+  c->lbu(v0, 2, a0);                                // lbu v0, 2(a0)
+  c->addiu(t5, r0, 0);                              // addiu t5, r0, 0
+  c->lbu(at, 1, a0);                                // lbu at, 1(a0)
+  c->addiu(s4, r0, -1);                             // addiu s4, r0, -1
+  c->lui(a1, 19201);                                // lui a1, 19201
+  c->daddiu(v0, v0, 3);                             // daddiu v0, v0, 3
+  c->daddiu(a1, a1, 18304);                         // daddiu a1, a1, 18304
+  c->andi(v0, v0, 252);                             // andi v0, v0, 252
+  c->sll(at, at, 2);                                // sll at, at, 2
+  c->sll(v0, v0, 2);                                // sll v0, v0, 2
+  c->lq(t8, 32, a0);                                // lq t8, 32(a0)
+  c->daddu(v0, v0, a0);                             // daddu v0, v0, a0
+  c->lbu(t0, 13, a0);                               // lbu t0, 13(a0)
+  c->daddu(at, at, a0);                             // daddu at, at, a0
+  c->lbu(t2, 11, a0);                               // lbu t2, 11(a0)
+  c->pextlw(a1, a1, r0);                            // pextlw a1, a1, r0
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L112
+  c->pcpyld(a1, a1, a1);                            // pcpyld a1, a1, a1
+  if (bc) {goto block_49;}                          // branch non-likely
+
+  c->sll(t2, t2, 4);                                // sll t2, t2, 4
+  c->daddiu(a3, a0, 14);                            // daddiu a3, a0, 14
+  //beq r0, r0, L111                                // beq r0, r0, L111
+  c->daddu(t2, t2, a0);                             // daddu t2, t2, a0
+  goto block_47;                                    // branch always
+
+
+  block_46:
+  // Unknown instr: vcallms 303
+  vcallms_303(c, vis);
+  c->mov64(t0, t1);                                 // or t0, t1, r0
+
+  block_47:
+  c->lbu(t1, 0, a3);                                // lbu t1, 0(a3)
+  c->daddiu(a3, a3, 1);                             // daddiu a3, a3, 1
+  c->lqc2(vf23, 64, t2);                            // lqc2 vf23, 64(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf24, 80, t2);                            // lqc2 vf24, 80(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf25, 96, t2);                            // lqc2 vf25, 96(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf26, 112, t2);                           // lqc2 vf26, 112(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf20, 16, t2);                            // lqc2 vf20, 16(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf21, 32, t2);                            // lqc2 vf21, 32(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf22, 48, t2);                            // lqc2 vf22, 48(t2)
+  c->daddiu(t2, t2, 128);                           // daddiu t2, t2, 128
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L110
+  vis[14] = c->gpr_src(t0).du16[0];                    // ctc2.ni vi14, t0
+  if (bc) {goto block_46;}                          // branch non-likely
+
+  // Unknown instr: vcallms 303
+  vcallms_303(c, vis);
+  // nop                                            // sll r0, r0, 0
+
+  block_49:
+  c->lq(a2, 0, v0);                                 // lq a2, 0(v0)
+  c->pextlb(t9, r0, t8);                            // pextlb t9, r0, t8
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlh(gp, r0, t9);                            // pextlh gp, r0, t9
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlb(a3, r0, a2);                            // pextlb a3, r0, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextub(a2, r0, a2);                            // pextub a2, r0, a2
+  c->mov128_vf_gpr(vf4, gp);                        // qmtc2.ni vf4, gp
+  c->pextlh(t0, a1, a3);                            // pextlh t0, a1, a3
+  c->mov128_vf_gpr(vf1, t0);                        // qmtc2.ni vf1, t0
+  c->pextuh(a3, a1, a3);                            // pextuh a3, a1, a3
+  c->mov128_vf_gpr(vf2, a3);                        // qmtc2.ni vf2, a3
+  c->pextlh(t1, a1, a2);                            // pextlh t1, a1, a2
+  c->mov128_vf_gpr(vf3, t1);                        // qmtc2.ni vf3, t1
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 16, v0);                                // lq t2, 16(v0)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(at, at, -16);                           // daddiu at, at, -16
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextuh(a2, a1, a2);                            // pextuh a2, a1, a2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlb(t0, r0, t2);                            // pextlb t0, r0, t2
+  c->mov128_vf_gpr(vf4, t9);                        // qmtc2.ni vf4, t9
+  c->pextlh(t1, a1, t0);                            // pextlh t1, a1, t0
+  c->mov128_vf_gpr(vf1, a2);                        // qmtc2.ni vf1, a2
+  c->pextuh(t0, a1, t0);                            // pextuh t0, a1, t0
+  c->mov128_vf_gpr(vf2, t1);                        // qmtc2.ni vf2, t1
+  c->pextub(t9, r0, t8);                            // pextub t9, r0, t8
+  c->mov128_vf_gpr(vf3, t0);                        // qmtc2.ni vf3, t0
+  c->pextlh(gp, r0, t9);                            // pextlh gp, r0, t9
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(v0, v0, -48);                           // daddiu v0, v0, -48
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+  // nop                                            // sll r0, r0, 0
+  c->addiu(t6, r0, 0);                              // addiu t6, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->lwl(t6, 53, v0);                               // lwl t6, 53(v0)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlb(t6, r0, t6);                            // pextlb t6, r0, t6
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlb(t6, r0, t6);                            // pextlb t6, r0, t6
+  c->lq(a3, 80, v0);                                // lq a3, 80(v0)
+  c->paddw(t6, t6, t3);                             // paddw t6, t6, t3
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextub(t2, r0, t2);                            // pextub t2, r0, t2
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlh(t0, a1, t2);                            // pextlh t0, a1, t2
+  c->mov128_vf_gpr(vf4, gp);                        // qmtc2.ni vf4, gp
+  c->pextuh(t2, a1, t2);                            // pextuh t2, a1, t2
+  c->mov128_vf_gpr(vf1, t0);                        // qmtc2.ni vf1, t0
+  c->pextlb(t1, r0, a3);                            // pextlb t1, r0, a3
+  c->mov128_vf_gpr(vf2, t2);                        // qmtc2.ni vf2, t2
+  c->pextlh(a2, a1, t1);                            // pextlh a2, a1, t1
+  c->mov128_vf_gpr(vf3, a2);                        // qmtc2.ni vf3, a2
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(v1, v1, -64);                           // daddiu v1, v1, -64
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf15, 64, v1);                            // sqc2 vf15, 64(v1)
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+
+  // nop                                            // sll r0, r0, 0
+  c->lwr(s3, 56, v0);                               // lwr s3, 56(v0)
+  // nop                                            // sll r0, r0, 0
+  c->lwl(s3, 69, v0);                               // lwl s3, 69(v0)
+  // nop                                            // sll r0, r0, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pcpyud(t6, t6, r0);                            // pcpyud t6, t6, r0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextlb(s3, r0, s3);                            // pextlb s3, r0, s3
+  // nop                                            // sll r0, r0, 0
+  c->dsllv(s3, s3, s2);                             // dsllv s3, s3, s2
+  c->lq(t8, 0, s6);                                 // lq t8, 0(s6)
+  c->paddh(s3, s3, s1);                             // paddh s3, s3, s1
+  c->lbu(t7, 0, t6);                                // lbu t7, 0(t6)
+  c->dsrl32(t6, t6, 0);                             // dsrl32 t6, t6, 0
+  c->mfc1(r0, f31);                                 // mfc1 r0, f31
+  c->pextuh(t0, a1, t1);                            // pextuh t0, a1, t1
+  c->lbu(s0, 0, t6);                                // lbu s0, 0(t6)
+  c->pextub(a3, r0, a3);                            // pextub a3, r0, a3
+  c->mov128_vf_gpr(vf4, t9);                        // qmtc2.ni vf4, t9
+  c->pextlh(t2, a1, a3);                            // pextlh t2, a1, a3
+  c->mov128_vf_gpr(vf1, t0);                        // qmtc2.ni vf1, t0
+  c->pextuh(a3, a1, a3);                            // pextuh a3, a1, a3
+  c->mov128_vf_gpr(vf2, t2);                        // qmtc2.ni vf2, t2
+  c->pextlb(t9, r0, t8);                            // pextlb t9, r0, t8
+  c->mov128_vf_gpr(vf3, a3);                        // qmtc2.ni vf3, a3
+  c->pextlh(gp, r0, t9);                            // pextlh gp, r0, t9
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(s6, s6, 16);                            // daddiu s6, s6, 16
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf15, 96, v1);                            // sqc2 vf15, 96(v1)
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+
+  c->sw(s3, 76, v1);                                // sw s3, 76(v1)
+  c->lwr(t6, 64, v0);                               // lwr t6, 64(v0)
+  c->daddu(t7, t7, t4);                             // daddu t7, t7, t4
+  c->lwl(t6, 77, v0);                               // lwl t6, 77(v0)
+  c->daddu(s0, s0, t4);                             // daddu s0, s0, t4
+  //beq r0, r0, L114                                // beq r0, r0, L114
+  c->dsrl32(s3, s3, 0);                             // dsrl32 s3, s3, 0
+  goto block_51;                                    // branch always
+
+
+  block_50:
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+
+  c->sw(s3, 76, v1);                                // sw s3, 76(v1)
+  c->lwr(t6, 64, v0);                               // lwr t6, 64(v0)
+  c->daddu(t7, t7, t4);                             // daddu t7, t7, t4
+  c->lwl(t6, 77, v0);                               // lwl t6, 77(v0)
+  c->daddu(s0, s0, t4);                             // daddu s0, s0, t4
+  c->sw(a0, 60, v1);                                // sw a0, 60(v1)
+  c->dsrl32(s3, s3, 0);                             // dsrl32 s3, s3, 0
+
+  block_51:
+  c->sb(t5, 0, t7);                                 // sb t5, 0(t7)
+  c->pextlb(t6, r0, t6);                            // pextlb t6, r0, t6
+  c->sb(t5, 0, s0);                                 // sb t5, 0(s0)
+  c->pextlb(t6, r0, t6);                            // pextlb t6, r0, t6
+  c->lq(a2, 96, v0);                                // lq a2, 96(v0)
+  c->paddw(t6, t6, t3);                             // paddw t6, t6, t3
+  c->lbu(t7, 0, t6);                                // lbu t7, 0(t6)
+  c->dsrl32(t6, t6, 0);                             // dsrl32 t6, t6, 0
+  c->lw(a0, 16, at);                                // lw a0, 16(at)
+  c->pextlb(a3, r0, a2);                            // pextlb a3, r0, a2
+  c->lbu(s0, 0, t6);                                // lbu s0, 0(t6)
+  c->pextub(a2, r0, a2);                            // pextub a2, r0, a2
+  c->mov128_vf_gpr(vf4, gp);                        // qmtc2.ni vf4, gp
+  c->pextlh(t0, a1, a3);                            // pextlh t0, a1, a3
+  c->mov128_vf_gpr(vf1, t0);                        // qmtc2.ni vf1, t0
+  c->pextuh(a3, a1, a3);                            // pextuh a3, a1, a3
+  c->mov128_vf_gpr(vf2, a3);                        // qmtc2.ni vf2, a3
+  c->pextlh(t1, a1, a2);                            // pextlh t1, a1, a2
+  c->mov128_vf_gpr(vf3, t1);                        // qmtc2.ni vf3, t1
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  c->sqc2(vf14, 80, v1);                            // sqc2 vf14, 80(v1)
+  c->daddiu(at, at, 16);                            // daddiu at, at, 16
+  c->addiu(s4, s4, 2);                              // addiu s4, s4, 2
+  c->sqc2(vf15, 128, v1);                           // sqc2 vf15, 128(v1)
+  bc = c->sgpr64(t5) == c->sgpr64(s5);              // beq t5, s5, L115
+  c->daddiu(t5, t5, 2);                             // daddiu t5, t5, 2
+  if (bc) {goto block_56;}                          // branch non-likely
+
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+
+  c->sw(s3, 108, v1);                               // sw s3, 108(v1)
+  c->lwr(s3, 80, v0);                               // lwr s3, 80(v0)
+  c->daddu(t7, t7, t4);                             // daddu t7, t7, t4
+  c->lwl(s3, 93, v0);                               // lwl s3, 93(v0)
+  c->daddu(s0, s0, t4);                             // daddu s0, s0, t4
+  c->sw(a0, 92, v1);                                // sw a0, 92(v1)
+  c->pcpyud(t6, t6, r0);                            // pcpyud t6, t6, r0
+  c->sb(s4, 0, t7);                                 // sb s4, 0(t7)
+  c->pextlb(s3, r0, s3);                            // pextlb s3, r0, s3
+  c->sb(s4, 0, s0);                                 // sb s4, 0(s0)
+  c->dsllv(s3, s3, s2);                             // dsllv s3, s3, s2
+  c->lq(t2, 112, v0);                               // lq t2, 112(v0)
+  c->paddh(s3, s3, s1);                             // paddh s3, s3, s1
+  c->lbu(t7, 0, t6);                                // lbu t7, 0(t6)
+  c->dsrl32(t6, t6, 0);                             // dsrl32 t6, t6, 0
+  c->lw(a0, 4, at);                                 // lw a0, 4(at)
+  c->pextuh(a2, a1, a2);                            // pextuh a2, a1, a2
+  c->lbu(s0, 0, t6);                                // lbu s0, 0(t6)
+  c->pextlb(t0, r0, t2);                            // pextlb t0, r0, t2
+  c->mov128_vf_gpr(vf4, t9);                        // qmtc2.ni vf4, t9
+  c->pextlh(t1, a1, t0);                            // pextlh t1, a1, t0
+  c->mov128_vf_gpr(vf1, a2);                        // qmtc2.ni vf1, a2
+  c->pextuh(t0, a1, t0);                            // pextuh t0, a1, t0
+  c->mov128_vf_gpr(vf2, t1);                        // qmtc2.ni vf2, t1
+  c->pextub(t9, r0, t8);                            // pextub t9, r0, t8
+  c->mov128_vf_gpr(vf3, t0);                        // qmtc2.ni vf3, t0
+  c->pextlh(gp, r0, t9);                            // pextlh gp, r0, t9
+  c->sqc2(vf14, 112, v1);                           // sqc2 vf14, 112(v1)
+  c->daddiu(v0, v0, 48);                            // daddiu v0, v0, 48
+  bc = c->sgpr64(s4) == c->sgpr64(s5);              // beq s4, s5, L116
+  c->sqc2(vf15, 160, v1);                           // sqc2 vf15, 160(v1)
+  if (bc) {goto block_57;}                          // branch non-likely
+
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+
+  c->sw(s3, 140, v1);                               // sw s3, 140(v1)
+  c->lwr(t6, 40, v0);                               // lwr t6, 40(v0)
+  c->daddu(t7, t7, t4);                             // daddu t7, t7, t4
+  c->lwl(t6, 53, v0);                               // lwl t6, 53(v0)
+  c->daddu(s0, s0, t4);                             // daddu s0, s0, t4
+  c->sw(a0, 124, v1);                               // sw a0, 124(v1)
+  c->dsrl32(s3, s3, 0);                             // dsrl32 s3, s3, 0
+  c->sb(t5, 0, t7);                                 // sb t5, 0(t7)
+  c->pextlb(t6, r0, t6);                            // pextlb t6, r0, t6
+  c->sb(t5, 0, s0);                                 // sb t5, 0(s0)
+  c->pextlb(t6, r0, t6);                            // pextlb t6, r0, t6
+  c->lq(a3, 80, v0);                                // lq a3, 80(v0)
+  c->paddw(t6, t6, t3);                             // paddw t6, t6, t3
+  c->lbu(t7, 0, t6);                                // lbu t7, 0(t6)
+  c->dsrl32(t6, t6, 0);                             // dsrl32 t6, t6, 0
+  c->lw(a0, 8, at);                                 // lw a0, 8(at)
+  c->pextub(t2, r0, t2);                            // pextub t2, r0, t2
+  c->lbu(s0, 0, t6);                                // lbu s0, 0(t6)
+  c->pextlh(t0, a1, t2);                            // pextlh t0, a1, t2
+  c->mov128_vf_gpr(vf4, gp);                        // qmtc2.ni vf4, gp
+  c->pextuh(t2, a1, t2);                            // pextuh t2, a1, t2
+  c->mov128_vf_gpr(vf1, t0);                        // qmtc2.ni vf1, t0
+  c->pextlb(t1, r0, a3);                            // pextlb t1, r0, a3
+  c->mov128_vf_gpr(vf2, t2);                        // qmtc2.ni vf2, t2
+  c->pextlh(a2, a1, t1);                            // pextlh a2, a1, t1
+  c->mov128_vf_gpr(vf3, a2);                        // qmtc2.ni vf3, a2
+  c->pextuh(t9, r0, t9);                            // pextuh t9, r0, t9
+  c->sqc2(vf14, 144, v1);                           // sqc2 vf14, 144(v1)
+  c->daddiu(v1, v1, 128);                           // daddiu v1, v1, 128
+  c->addiu(s4, s4, 2);                              // addiu s4, s4, 2
+  c->sqc2(vf15, 64, v1);                            // sqc2 vf15, 64(v1)
+  bc = c->sgpr64(t5) == c->sgpr64(s5);              // beq t5, s5, L117
+  c->daddiu(t5, t5, 2);                             // daddiu t5, t5, 2
+  if (bc) {goto block_58;}                          // branch non-likely
+
+  // Unknown instr: vcallms 311
+  vcallms_311(c, vis);
+
+  c->sw(s3, 44, v1);                                // sw s3, 44(v1)
+  c->lwr(s3, 56, v0);                               // lwr s3, 56(v0)
+  c->daddu(t7, t7, t4);                             // daddu t7, t7, t4
+  c->lwl(s3, 69, v0);                               // lwl s3, 69(v0)
+  c->daddu(s0, s0, t4);                             // daddu s0, s0, t4
+  c->sw(a0, 28, v1);                                // sw a0, 28(v1)
+  c->pcpyud(t6, t6, r0);                            // pcpyud t6, t6, r0
+  c->sb(s4, 0, t7);                                 // sb s4, 0(t7)
+  c->pextlb(s3, r0, s3);                            // pextlb s3, r0, s3
+  c->sb(s4, 0, s0);                                 // sb s4, 0(s0)
+  c->dsllv(s3, s3, s2);                             // dsllv s3, s3, s2
+  c->lq(t8, 0, s6);                                 // lq t8, 0(s6)
+  c->paddh(s3, s3, s1);                             // paddh s3, s3, s1
+  c->lbu(t7, 0, t6);                                // lbu t7, 0(t6)
+  c->dsrl32(t6, t6, 0);                             // dsrl32 t6, t6, 0
+  c->lw(a0, 12, at);                                // lw a0, 12(at)
+  c->pextuh(t0, a1, t1);                            // pextuh t0, a1, t1
+  c->lbu(s0, 0, t6);                                // lbu s0, 0(t6)
+  c->pextub(a3, r0, a3);                            // pextub a3, r0, a3
+  c->mov128_vf_gpr(vf4, t9);                        // qmtc2.ni vf4, t9
+  c->pextlh(t2, a1, a3);                            // pextlh t2, a1, a3
+  c->mov128_vf_gpr(vf1, t0);                        // qmtc2.ni vf1, t0
+  c->pextuh(a3, a1, a3);                            // pextuh a3, a1, a3
+  c->mov128_vf_gpr(vf2, t2);                        // qmtc2.ni vf2, t2
+  c->pextlb(t9, r0, t8);                            // pextlb t9, r0, t8
+  c->mov128_vf_gpr(vf3, a3);                        // qmtc2.ni vf3, a3
+  c->pextlh(gp, r0, t9);                            // pextlh gp, r0, t9
+  c->sqc2(vf14, 48, v1);                            // sqc2 vf14, 48(v1)
+  c->daddiu(s6, s6, 16);                            // daddiu s6, s6, 16
+  bc = c->sgpr64(s4) != c->sgpr64(s5);              // bne s4, s5, L113
+  c->sqc2(vf15, 96, v1);                            // sqc2 vf15, 96(v1)
+  if (bc) {goto block_50;}                          // branch non-likely
+
+  //beq r0, r0, L117                                // beq r0, r0, L117
+  c->daddiu(v1, v1, 32);                            // daddiu v1, v1, 32
+  goto block_58;                                    // branch always
+
+
+  block_56:
+  //beq r0, r0, L117                                // beq r0, r0, L117
+  c->daddiu(v1, v1, 64);                            // daddiu v1, v1, 64
+  goto block_58;                                    // branch always
+
+
+  block_57:
+  //beq r0, r0, L117                                // beq r0, r0, L117
+  c->daddiu(v1, v1, 96);                            // daddiu v1, v1, 96
+  goto block_58;                                    // branch always
+
+
+  block_58:
+  c->sw(a0, 28, v1);                                // sw a0, 28(v1)
+  c->daddiu(s5, s5, 1);                             // daddiu s5, s5, 1
+  c->daddiu(v1, v1, 32);                            // daddiu v1, v1, 32
+  // nop                                            // sll r0, r0, 0
+  get_fake_spad_addr2(a3, cache.fake_scratchpad_data, 0, c);// lui a3, 28672
+  // nop                                            // sll r0, r0, 0
+  c->lw(a0, 7444, a3);                              // lw a0, 7444(a3)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a1, 7436, a3);                              // lw a1, 7436(a3)
+  // nop                                            // sll r0, r0, 0
+  c->lw(a3, 7440, a3);                              // lw a3, 7440(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sb(s5, 17, a1);                                // sb s5, 17(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(s0, 0, a0);                                // lbu s0, 0(a0)
+  c->addiu(s4, r0, 0);                              // addiu s4, r0, 0
+  c->lbu(s1, 7, a0);                                // lbu s1, 7(a0)
+  c->addiu(t8, r0, 0);                              // addiu t8, r0, 0
+  c->lbu(s2, 8, a0);                                // lbu s2, 8(a0)
+  c->sll(s0, s0, 2);                                // sll s0, s0, 2
+  c->daddu(s0, s0, a0);                             // daddu s0, s0, a0
+  c->sll(s1, s1, 2);                                // sll s1, s1, 2
+  bc = c->sgpr64(s1) == 0;                          // beq s1, r0, L119
+  c->daddu(s1, s1, s0);                             // daddu s1, s1, s0
+  if (bc) {goto block_61;}                          // branch non-likely
+
+
+  block_59:
+  c->lbu(s3, 0, s0);                                // lbu s3, 0(s0)
+  c->daddu(s4, s4, t4);                             // daddu s4, s4, t4
+  c->lbu(s6, 1, s0);                                // lbu s6, 1(s0)
+  c->daddu(t8, t8, t4);                             // daddu t8, t8, t4
+  c->lbu(t9, 0, s4);                                // lbu t9, 0(s4)
+  c->daddu(s3, s3, t3);                             // daddu s3, s3, t3
+  c->lbu(s4, 0, s3);                                // lbu s4, 0(s3)
+  c->daddu(s6, s6, t3);                             // daddu s6, s6, t3
+  c->sb(t9, 0, t8);                                 // sb t9, 0(t8)
+  c->daddiu(s0, s0, 4);                             // daddiu s0, s0, 4
+  bc = c->sgpr64(s0) != c->sgpr64(s1);              // bne s0, s1, L118
+  c->lbu(t8, 0, s6);                                // lbu t8, 0(s6)
+  if (bc) {goto block_59;}                          // branch non-likely
+
+  // nop                                            // sll r0, r0, 0
+  c->daddu(s4, s4, t4);                             // daddu s4, s4, t4
+  c->lbu(t9, 0, s4);                                // lbu t9, 0(s4)
+  c->daddu(t8, t8, t4);                             // daddu t8, t8, t4
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->sb(t9, 0, t8);                                 // sb t9, 0(t8)
+  // nop                                            // sll r0, r0, 0
+
+  block_61:
+  c->sll(s2, s2, 2);                                // sll s2, s2, 2
+  c->daddiu(t5, a3, 32);                            // daddiu t5, a3, 32
+  bc = c->sgpr64(s2) == 0;                          // beq s2, r0, L122
+  c->daddu(s2, s2, s1);                             // daddu s2, s2, s1
+  if (bc) {goto block_65;}                          // branch non-likely
+
+  c->lbu(s3, 0, s0);                                // lbu s3, 0(s0)
+  c->daddiu(t6, a3, 192);                           // daddiu t6, a3, 192
+  c->lbu(s6, 1, s0);                                // lbu s6, 1(s0)
+  c->daddiu(t7, a3, 448);                           // daddiu t7, a3, 448
+  // nop                                            // sll r0, r0, 0
+  c->daddu(s3, s3, t6);                             // daddu s3, s3, t6
+  c->lbu(s3, 0, s3);                                // lbu s3, 0(s3)
+  c->daddu(s6, s6, t3);                             // daddu s6, s6, t3
+  c->lbu(s6, 0, s6);                                // lbu s6, 0(s6)
+  c->daddiu(v1, v1, -32);                           // daddiu v1, v1, -32
+  // nop                                            // sll r0, r0, 0
+  c->daddu(s3, s3, t5);                             // daddu s3, s3, t5
+  c->lbu(s4, 0, s3);                                // lbu s4, 0(s3)
+  c->daddu(s6, s6, t4);                             // daddu s6, s6, t4
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(s0, s0, 4);                             // daddiu s0, s0, 4
+  c->sb(s5, 0, s6);                                 // sb s5, 0(s6)
+  c->daddiu(s5, s5, 1);                             // daddiu s5, s5, 1
+  bc = c->sgpr64(s0) == c->sgpr64(s2);              // beq s0, s2, L121
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_64;}                          // branch non-likely
+
+
+  block_63:
+  c->lbu(s3, 0, s0);                                // lbu s3, 0(s0)
+  c->sll(s4, s4, 5);                                // sll s4, s4, 5
+  c->lbu(s6, 1, s0);                                // lbu s6, 1(s0)
+  c->daddu(s4, s4, t7);                             // daddu s4, s4, t7
+  c->lq(t9, 0, s4);                                 // lq t9, 0(s4)
+  c->daddu(s3, s3, t6);                             // daddu s3, s3, t6
+  c->lbu(s3, 0, s3);                                // lbu s3, 0(s3)
+  c->daddu(s6, s6, t3);                             // daddu s6, s6, t3
+  c->lbu(s6, 0, s6);                                // lbu s6, 0(s6)
+  c->daddiu(v1, v1, 32);                            // daddiu v1, v1, 32
+  c->lq(gp, 16, s4);                                // lq gp, 16(s4)
+  c->daddu(s3, s3, t5);                             // daddu s3, s3, t5
+  c->lbu(s4, 0, s3);                                // lbu s4, 0(s3)
+  c->daddu(s6, s6, t4);                             // daddu s6, s6, t4
+  c->sq(t9, 0, v1);                                 // sq t9, 0(v1)
+  c->daddiu(s0, s0, 4);                             // daddiu s0, s0, 4
+  c->sb(s5, 0, s6);                                 // sb s5, 0(s6)
+  c->daddiu(s5, s5, 1);                             // daddiu s5, s5, 1
+  bc = c->sgpr64(s0) != c->sgpr64(s2);              // bne s0, s2, L120
+  c->sq(gp, 16, v1);                                // sq gp, 16(v1)
+  if (bc) {goto block_63;}                          // branch non-likely
+
+
+  block_64:
+  // nop                                            // sll r0, r0, 0
+  c->sll(s4, s4, 5);                                // sll s4, s4, 5
+  // nop                                            // sll r0, r0, 0
+  c->daddu(s4, s4, t7);                             // daddu s4, s4, t7
+  c->lq(t9, 0, s4);                                 // lq t9, 0(s4)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(v1, v1, 32);                            // daddiu v1, v1, 32
+  c->lq(gp, 16, s4);                                // lq gp, 16(s4)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->sq(t9, 0, v1);                                 // sq t9, 0(v1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->sq(gp, 16, v1);                                // sq gp, 16(v1)
+
+  block_65:
+  c->sh(s5, 20, a1);                                // sh s5, 20(a1)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lq(s0, 7536, at);                              // lq s0, 7536(at)
+  c->lq(s1, 7552, at);                              // lq s1, 7552(at)
+  c->lq(s2, 7568, at);                              // lq s2, 7568(at)
+  c->lq(s3, 7584, at);                              // lq s3, 7584(at)
+  c->lq(s4, 7600, at);                              // lq s4, 7600(at)
+  c->lq(s5, 7616, at);                              // lq s5, 7616(at)
+  c->lq(s6, 7632, at);                              // lq s6, 7632(at)
+  c->lq(t8, 7648, at);                              // lq t8, 7648(at)
+  c->lq(t9, 7664, at);                              // lq t9, 7664(at)
+  c->lq(gp, 7680, at);                              // lq gp, 7680(at)
+  c->lq(ra, 7728, at);                              // lq ra, 7728(at)
+  c->lq(sp, 7696, at);                              // lq sp, 7696(at)
+  //jr ra                                           // jr ra
+  c->lq(fp, 7712, at);                              // lq fp, 7712(at)
+  goto end_of_function;                             // return
+
+  //jr ra                                           // jr ra
+  c->daddu(sp, sp, r0);                             // daddu sp, sp, r0
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("mercneric-convert", execute, 128);
+}
+
+} // namespace mercneric_convert
+} // namespace Mips2C
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace high_speed_reject {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+
+void vcallms_438(ExecutionContext* c, u16* vis) {
+
+  // nop                        |  mulaz.xyzw ACC, vf09, vf01     158
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf01).vf.z());
+  // nop                        |  maddax.xyzw ACC, vf10, vf01    159
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf01].vf.x());
+  // nop                        |  maddy.xyzw vf01, vf11, vf01    160
+  u16 f1 = c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf01].vf, c->vf_src(vf11).vf, c->vf_src(vf01).vf.y());
+  // nop                        |  mulaz.xyzw ACC, vf09, vf02     161
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf02).vf.z());
+  // nop                        |  maddax.xyzw ACC, vf10, vf02    162
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf02].vf.x());
+  // nop                        |  maddy.xyzw vf02, vf11, vf02    163
+  u16 f2 = c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf02].vf, c->vf_src(vf11).vf, c->vf_src(vf02).vf.y());
+  // fmand vi01, vi09           |  mulaz.xyzw ACC, vf09, vf03     164
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf03).vf.z());   vis[1] = vis[9] & f1;
+  // nop                        |  maddax.xyzw ACC, vf10, vf03    165
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf03].vf.x());
+  // nop                        |  maddy.xyzw vf03, vf11, vf03    166
+  u16 f3 = c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf03].vf, c->vf_src(vf11).vf, c->vf_src(vf03).vf.y());
+  // fmand vi02, vi09           |  mulaz.xyzw ACC, vf09, vf04     167
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf04).vf.z());   vis[2] = vis[9] & f2;
+  // nop                        |  maddax.xyzw ACC, vf10, vf04    168
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf04].vf.x());
+  // nop                        |  maddy.xyzw vf04, vf11, vf04    169
+  c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf04].vf, c->vf_src(vf11).vf, c->vf_src(vf04).vf.y());
+  // fmand vi03, vi09           |  nop                            170
+  // ASSERT(false);
+  vis[3] = vis[9] & f3;
+  // nop                        |  nop                            171
+
+  // nop                        |  nop :e                         172
+
+  // fmand vi04, vi09           |  nop                            173
+  // ASSERT(false);
+  vis[4] = vis[9] & f4;
+
+}
+
+void vcallms_454(ExecutionContext* c, u16* vis) {
+  // nop                        |  mulaz.xyzw ACC, vf09, vf05     174
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf05).vf.z());
+  // nop                        |  maddax.xyzw ACC, vf10, vf05    175
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf05].vf.x());
+  // nop                        |  maddy.xyzw vf05, vf11, vf05    176
+  u16 f1 = c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf05].vf, c->vf_src(vf11).vf, c->vf_src(vf05).vf.y());
+  // nop                        |  mulaz.xyzw ACC, vf09, vf06     177
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf06).vf.z());
+  // nop                        |  maddax.xyzw ACC, vf10, vf06    178
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf06].vf.x());
+  // nop                        |  maddy.xyzw vf06, vf11, vf06    179
+  u16 f2 = c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf06].vf, c->vf_src(vf11).vf, c->vf_src(vf06).vf.y());
+  // fmand vi05, vi09           |  mulaz.xyzw ACC, vf09, vf07     180
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf07).vf.z());   vis[5] = vis[9] & f1;
+  // nop                        |  maddax.xyzw ACC, vf10, vf07    181
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf07].vf.x());
+  // nop                        |  maddy.xyzw vf07, vf11, vf07    182
+  u16 f3 = c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf07].vf, c->vf_src(vf11).vf, c->vf_src(vf07).vf.y());
+  // fmand vi06, vi09           |  mulaz.xyzw ACC, vf09, vf08     183
+  c->acc.vf.mula_xyzw(c->vf_src(vf09).vf, c->vf_src(vf08).vf.z());   vis[5] = vis[9] & f2;
+  // nop                        |  maddax.xyzw ACC, vf10, vf08    184
+  c->acc.vf.madda_xyzw(c->vfs[vf10].vf, c->vfs[vf08].vf.x());
+  // nop                        |  maddy.xyzw vf08, vf11, vf08    185
+  u16 f4 =c->acc.vf.madd_flag(Mask::xyzw, c->vfs[vf08].vf, c->vf_src(vf11).vf, c->vf_src(vf08).vf.y());
+  // fmand vi07, vi09           |  nop                            186
+  vis[7] = vis[9] & f3;
+  // nop                        |  nop                            187
+
+  // nop                        |  nop :e                         188
+
+  // fmand vi08, vi09           |  nop                            189
+  // ASSERT(false);
+  vis[8] = vis[9] & f4;
+
+}
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u16 vis[16];
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lw(a0, 7436, v1);                              // lw a0, 7436(v1)
+  c->daddiu(a1, a0, 448);                           // daddiu a1, a0, 448
+  c->lhu(a3, 20, a0);                               // lhu a3, 20(a0)
+  c->vmax_bc(DEST::xyzw, BC::w, vf9, vf0, vf0);     // vmaxw.xyzw vf9, vf0, vf0
+  c->lqc2(vf10, 7488, v1);                          // lqc2 vf10, 7488(v1)
+  c->lqc2(vf11, 7504, v1);                          // lqc2 vf11, 7504(v1)
+  c->lqc2(vf1, 0, a1);                              // lqc2 vf1, 0(a1)
+  c->addiu(a0, r0, 240);                            // addiu a0, r0, 240
+  c->lqc2(vf2, 32, a1);                             // lqc2 vf2, 32(a1)
+  vis[9] = c->gpr_src(a0).du16[0];                     // ctc2.i vi9, a0
+  c->lqc2(vf3, 64, a1);                             // lqc2 vf3, 64(a1)
+  c->lqc2(vf4, 96, a1);                             // lqc2 vf4, 96(a1)
+  c->daddiu(a0, r0, -1);                            // daddiu a0, r0, -1
+  // nop                                            // sll r0, r0, 0
+  // Unknown instr: vcallms 438
+  vcallms_438(c, vis);
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf5, 128, a1);                            // lqc2 vf5, 128(a1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf6, 160, a1);                            // lqc2 vf6, 160(a1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->lwu(t0, 8, a1);                                // lwu t0, 8(a1)
+  c->lqc2(vf7, 192, a1);                            // lqc2 vf7, 192(a1)
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  c->gprs[a2].du64[0] = vis[1];                        // cfc2.ni a2, vi1
+  c->lqc2(vf8, 224, a1);                            // lqc2 vf8, 224(a1)
+  c->srl(t0, t0, 31);                               // srl t0, t0, 31
+  c->or_(t0, a2, t0);                               // or t0, a2, t0
+  c->lwu(a2, 40, a1);                               // lwu a2, 40(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L82
+  c->and_(a0, a0, t0);                              // and a0, a0, t0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->daddiu(a1, a1, 128);                           // daddiu a1, a1, 128
+  c->daddiu(a3, a3, -1);                            // daddiu a3, a3, -1
+  bc = c->sgpr64(a3) == 0;                          // beq a3, r0, L81
+  c->gprs[t0].du64[0] = vis[2];                        // cfc2.ni t0, vi2
+  if (bc) {goto block_18;}                          // branch non-likely
+
+
+  block_2:
+  // Unknown instr: vcallms 454
+  vcallms_454(c, vis);
+  c->srl(a2, a2, 31);                               // srl a2, a2, 31
+  c->or_(a2, t0, a2);                               // or a2, t0, a2
+  c->lwu(t0, -56, a1);                              // lwu t0, -56(a1)
+  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L82
+  c->and_(a0, a0, a2);                              // and a0, a0, a2
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->lqc2(vf1, 128, a1);                            // lqc2 vf1, 128(a1)
+  c->daddiu(a2, a3, -1);                            // daddiu a2, a3, -1
+  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L81
+  c->gprs[a3].du64[0] = vis[3];                        // cfc2.ni a3, vi3
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  c->daddiu(a2, a2, -1);                            // daddiu a2, a2, -1
+  c->srl(t0, t0, 31);                               // srl t0, t0, 31
+  c->or_(t0, a3, t0);                               // or t0, a3, t0
+  c->lwu(a3, -24, a1);                              // lwu a3, -24(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L82
+  c->and_(a0, a0, t0);                              // and a0, a0, t0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L81
+  c->gprs[t0].du64[0] = vis[4];                        // cfc2.ni t0, vi4
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  c->lqc2(vf2, 160, a1);                            // lqc2 vf2, 160(a1)
+  c->srl(a3, a3, 31);                               // srl a3, a3, 31
+  c->or_(t0, t0, a3);                               // or t0, t0, a3
+  c->lwu(a3, 8, a1);                                // lwu a3, 8(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L82
+  c->and_(a0, a0, t0);                              // and a0, a0, t0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->lqc2(vf3, 192, a1);                            // lqc2 vf3, 192(a1)
+  c->daddiu(a2, a2, -1);                            // daddiu a2, a2, -1
+  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L81
+  c->gprs[t0].du64[0] = vis[5];                        // cfc2.ni t0, vi5
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  c->lqc2(vf4, 224, a1);                            // lqc2 vf4, 224(a1)
+  c->srl(a3, a3, 31);                               // srl a3, a3, 31
+  c->or_(t0, t0, a3);                               // or t0, t0, a3
+  c->lwu(a3, 40, a1);                               // lwu a3, 40(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L82
+  c->and_(a0, a0, t0);                              // and a0, a0, t0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->daddiu(a1, a1, 128);                           // daddiu a1, a1, 128
+  c->daddiu(a2, a2, -1);                            // daddiu a2, a2, -1
+  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L81
+  c->gprs[t0].du64[0] = vis[6];                        // cfc2.ni t0, vi6
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  // Unknown instr: vcallms 438
+  c->srl(a3, a3, 31);                               // srl a3, a3, 31
+  c->or_(t0, t0, a3);                               // or t0, t0, a3
+  c->lwu(a3, -56, a1);                              // lwu a3, -56(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L82
+  c->and_(a0, a0, t0);                              // and a0, a0, t0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->lqc2(vf5, 128, a1);                            // lqc2 vf5, 128(a1)
+  c->daddiu(a2, a2, -1);                            // daddiu a2, a2, -1
+  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L81
+  c->gprs[t0].du64[0] = vis[7];                        // cfc2.ni t0, vi7
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  c->daddiu(a2, a2, -1);                            // daddiu a2, a2, -1
+  c->srl(a3, a3, 31);                               // srl a3, a3, 31
+  c->or_(t0, t0, a3);                               // or t0, t0, a3
+  c->lwu(a3, -24, a1);                              // lwu a3, -24(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L82
+  c->and_(a0, a0, t0);                              // and a0, a0, t0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L81
+  c->gprs[t0].du64[0] = vis[8];                        // cfc2.ni t0, vi8
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  c->lqc2(vf6, 160, a1);                            // lqc2 vf6, 160(a1)
+  c->srl(a3, a3, 31);                               // srl a3, a3, 31
+  c->or_(a3, t0, a3);                               // or a3, t0, a3
+  c->lwu(t0, 8, a1);                                // lwu t0, 8(a1)
+  bc = c->sgpr64(a3) == 0;                          // beq a3, r0, L82
+  c->and_(a0, a0, a3);                              // and a0, a0, a3
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->lqc2(vf7, 192, a1);                            // lqc2 vf7, 192(a1)
+  c->daddiu(a3, a2, -1);                            // daddiu a3, a2, -1
+  bc = c->sgpr64(a3) == 0;                          // beq a3, r0, L81
+  c->gprs[a2].du64[0] = vis[1];                        // cfc2.ni a2, vi1
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  c->lqc2(vf8, 224, a1);                            // lqc2 vf8, 224(a1)
+  c->srl(t0, t0, 31);                               // srl t0, t0, 31
+  c->or_(t0, a2, t0);                               // or t0, a2, t0
+  c->lwu(a2, 40, a1);                               // lwu a2, 40(a1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L82
+  c->and_(a0, a0, t0);                              // and a0, a0, t0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->daddiu(a1, a1, 128);                           // daddiu a1, a1, 128
+  c->daddiu(a3, a3, -1);                            // daddiu a3, a3, -1
+  bc = c->sgpr64(a3) != 0;                          // bne a3, r0, L80
+  c->gprs[t0].du64[0] = vis[2];                        // cfc2.ni t0, vi2
+  if (bc) {goto block_2;}                           // branch non-likely
+
+
+  block_18:
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L82
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->sb(r0, 6853, v1);                              // sb r0, 6853(v1)
+
+  block_20:
+  //jr ra                                           // jr ra
+  // nop                                            // sll r0, r0, 0
+  goto end_of_function;                             // return
+
+  //jr ra                                           // jr ra
+  c->daddu(sp, sp, r0);                             // daddu sp, sp, r0
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("high-speed-reject", execute, 128);
+}
+
+} // namespace high_speed_reject
+} // namespace Mips2C
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_translucent {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -16);                           // daddiu sp, sp, -16
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->mov64(v1, a0);                                 // or v1, a0, r0
+  c->daddiu(a0, at, 12064);                         // daddiu a0, at, 12064
+  c->lbu(a1, 6842, at);                             // lbu a1, 6842(at)
+  c->daddiu(a2, at, 6960);                          // daddiu a2, at, 6960
+  c->mov64(a2, a2);                                 // or a2, a2, r0
+  c->movn(a0, a2, a1);                              // movn a0, a2, a1
+  c->lbu(a1, 6856, at);                             // lbu a1, 6856(at)
+  c->addiu(a2, r0, 128);                            // addiu a2, r0, 128
+  c->sltu(a2, a2, a1);                              // sltu a2, a2, a1
+  bc = c->sgpr64(a2) != 0;                          // bne a2, r0, L75
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_2;}                           // branch non-likely
+
+  c->addiu(a3, r0, 100);                            // addiu a3, r0, 100
+  c->lw(a2, 24, at);                                // lw a2, 24(at)
+  c->sw(a3, 112, a2);                               // sw a3, 112(a2)
+  c->addiu(a3, r0, 66);                             // addiu a3, r0, 66
+  c->sw(a3, 120, a2);                               // sw a3, 120(a2)
+  c->sw(a1, 116, a2);                               // sw a1, 116(a2)
+  //beq r0, r0, L76                                 // beq r0, r0, L76
+  // nop                                            // sll r0, r0, 0
+  goto block_3;                                     // branch always
+
+
+  block_2:
+  c->gprs[a1].du64[0] = 0;                          // or a1, r0, r0
+
+  block_3:
+  c->sw(r0, 48, at);                                // sw r0, 48(at)
+  c->sw(a0, 52, at);                                // sw a0, 52(at)
+  c->sw(v1, 44, at);                                // sw v1, 44(at)
+  c->lwu(t9, 7468, at);                             // lwu t9, 7468(at)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_prepare_dma_double::execute(c);
+  c->lwu(t9, 7472, at);                             // lwu t9, 7472(at)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_light_proc::execute(c);
+  c->lwu(t9, 7476, at);                             // lwu t9, 7476(at)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_envmap_proc::execute(c);
+  c->lw(v1, 24, at);                                // lw v1, 24(at)
+  c->lw(a0, 40, at);                                // lw a0, 40(at)
+  c->mov64(a3, v1);                                 // or a3, v1, r0
+  // nop                                            // sll r0, r0, 0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lui(a2, 4096);                                 // lui a2, 4096
+  c->lwu(a1, 60, at);                               // lwu a1, 60(at)
+  c->ori(a2, a2, 53248);                            // ori a2, a2, 53248
+  c->lw(t1, 0, a2);                                 // lw t1, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, at, 92);                            // daddiu t0, at, 92
+  c->andi(a3, a3, 16383);                           // andi a3, a3, 16383
+  c->andi(t1, t1, 256);                             // andi t1, t1, 256
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L78
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_7;}                           // branch non-likely
+
+  c->mov64(t1, a2);                                 // or t1, a2, r0
+  // nop                                            // sll r0, r0, 0
+
+  block_5:
+  c->lw(t2, 0, t0);                                 // lw t2, 0(t0)
+  // nop                                            // sll r0, r0, 0
+  c->lw(t3, 0, t1);                                 // lw t3, 0(t1)
+  // nop                                            // sll r0, r0, 0
+  c->andi(t3, t3, 256);                             // andi t3, t3, 256
+  c->daddiu(t2, t2, 1);                             // daddiu t2, t2, 1
+  bc = c->sgpr64(t3) != 0;                          // bne t3, r0, L77
+  c->sw(t2, 0, t0);                                 // sw t2, 0(t0)
+  if (bc) {goto block_5;}                           // branch non-likely
+
+  c->gprs[t0].du64[0] = 0;                          // or t0, r0, r0
+
+  block_7:
+  c->dsll(t0, a0, 4);                               // dsll t0, a0, 4
+  c->sw(a3, 128, a2);                               // sw a3, 128(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a1, 16, a2);                                // sw a1, 16(a2)
+  c->addiu(a3, r0, 256);                            // addiu a3, r0, 256
+  c->sw(a0, 32, a2);                                // sw a0, 32(a2)
+  c->daddu(a0, a1, t0);                             // daddu a0, a1, t0
+  c->sw(a3, 0, a2);                                 // sw a3, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 60, at);                                // sw a0, 60(at)
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->xori(v1, v1, 4608);                            // xori v1, v1, 4608
+  c->sw(v1, 24, at);                                // sw v1, 24(at)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 16);                            // daddiu sp, sp, 16
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  gLinkedFunctionTable.reg("generic-translucent", execute, 128);
+}
+
+} // namespace generic_translucent
+} // namespace Mips2C
+// add generic_translucent::link to the link callback table for the object file.
+// FWD DEC:
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_merc_query {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* vector_matrix; // vector-matrix*!
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -96);                           // daddiu sp, sp, -96
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->sq(s2, 16, sp);                                // sq s2, 16(sp)
+  c->sq(s3, 32, sp);                                // sq s3, 32(sp)
+  c->sq(s4, 48, sp);                                // sq s4, 48(sp)
+  c->sq(s5, 64, sp);                                // sq s5, 64(sp)
+  c->sq(gp, 80, sp);                                // sq gp, 80(sp)
+  c->mov64(s4, a0);                                 // or s4, a0, r0
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(gp, 6836, v1);                             // lwu gp, 6836(v1)
+  c->lhu(s3, 20, s4);                               // lhu s3, 20(s4)
+  c->lw(s2, 24, gp);                                // lw s2, 24(gp)
+  c->lw(s5, 20, gp);                                // lw s5, 20(gp)
+  c->addiu(v1, r0, 7136);                           // addiu v1, r0, 7136
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+  c->lwu(v1, 284, v1);                              // lwu v1, 284(v1)
+  bc = c->sgpr64(v1) != 0;                          // bne v1, r0, L70
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_2;}                           // branch non-likely
+
+  c->addiu(s5, r0, 0);                              // addiu s5, r0, 0
+  c->lw(s2, 12, gp);                                // lw s2, 12(gp)
+  c->mov64(v1, s2);                                 // or v1, s2, r0
+
+  block_2:
+  //beq r0, r0, L73                                 // beq r0, r0, L73
+  // nop                                            // sll r0, r0, 0
+  goto block_6;                                     // branch always
+
+
+  block_3:
+  c->lw(v1, 0, gp);                                 // lw v1, 0(gp)
+  c->slt(v1, s5, v1);                               // slt v1, s5, v1
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L72
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_5;}                           // branch non-likely
+
+  c->dsll(v1, s5, 4);                               // dsll v1, s5, 4
+  c->daddiu(v1, v1, 28);                            // daddiu v1, v1, 28
+  c->daddu(a1, v1, gp);                             // daddu a1, v1, gp
+  c->dsll(v1, s2, 5);                               // dsll v1, s2, 5
+  c->daddu(v1, v1, s4);                             // daddu v1, v1, s4
+  c->lwc1(f0, 448, v1);                             // lwc1 f0, 448(v1)
+  c->swc1(f0, 0, a1);                               // swc1 f0, 0(a1)
+  c->dsll(v1, s2, 5);                               // dsll v1, s2, 5
+  c->daddu(v1, v1, s4);                             // daddu v1, v1, s4
+  c->lwc1(f0, 452, v1);                             // lwc1 f0, 452(v1)
+  c->swc1(f0, 4, a1);                               // swc1 f0, 4(a1)
+  c->dsll(v1, s2, 5);                               // dsll v1, s2, 5
+  c->daddu(v1, v1, s4);                             // daddu v1, v1, s4
+  c->lwc1(f0, 456, v1);                             // lwc1 f0, 456(v1)
+  c->swc1(f0, 8, a1);                               // swc1 f0, 8(a1)
+  c->lui(v1, 16256);                                // lui v1, 16256
+  c->mtc1(f0, v1);                                  // mtc1 f0, v1
+  c->swc1(f0, 12, a1);                              // swc1 f0, 12(a1)
+  c->load_symbol2(t9, cache.vector_matrix);         // lw t9, vector-matrix*!(s7)
+  c->mov64(a0, a1);                                 // or a0, a1, r0
+  c->addiu(v1, r0, 7264);                           // addiu v1, r0, 7264
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->daddu(a2, v1, a2);                             // daddu a2, v1, a2
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->daddiu(s5, s5, 1);                             // daddiu s5, s5, 1
+  c->mov64(v1, s5);                                 // or v1, s5, r0
+
+  block_5:
+  c->lw(v1, 16, gp);                                // lw v1, 16(gp)
+  c->daddu(s2, s2, v1);                             // daddu s2, s2, v1
+
+  block_6:
+  c->slt(v1, s2, s3);                               // slt v1, s2, s3
+  bc = c->sgpr64(v1) != 0;                          // bne v1, r0, L71
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  c->dsubu(v1, s2, s3);                             // dsubu v1, s2, s3
+  c->sw(v1, 24, gp);                                // sw v1, 24(gp)
+  c->sw(s5, 20, gp);                                // sw s5, 20(gp)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->lq(gp, 80, sp);                                // lq gp, 80(sp)
+  c->lq(s5, 64, sp);                                // lq s5, 64(sp)
+  c->lq(s4, 48, sp);                                // lq s4, 48(sp)
+  c->lq(s3, 32, sp);                                // lq s3, 32(sp)
+  c->lq(s2, 16, sp);                                // lq s2, 16(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 96);                            // daddiu sp, sp, 96
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.vector_matrix = intern_from_c("vector-matrix*!").c();
+  gLinkedFunctionTable.reg("generic-merc-query", execute, 128);
+}
+
+} // namespace generic_merc_query
+} // namespace Mips2C
+// add generic_merc_query::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_merc_death {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* merc_death_spawn; // merc-death-spawn
+  void* vector_matrix; // vector-matrix*!
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -144);                          // daddiu sp, sp, -144
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->sq(s1, 48, sp);                                // sq s1, 48(sp)
+  c->sq(s2, 64, sp);                                // sq s2, 64(sp)
+  c->sq(s3, 80, sp);                                // sq s3, 80(sp)
+  c->sq(s4, 96, sp);                                // sq s4, 96(sp)
+  c->sq(s5, 112, sp);                               // sq s5, 112(sp)
+  c->sq(gp, 128, sp);                               // sq gp, 128(sp)
+  c->mov64(gp, a0);                                 // or gp, a0, r0
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lhu(s5, 6846, v1);                             // lhu s5, 6846(v1)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lhu(s3, 6844, v1);                             // lhu s3, 6844(v1)
+  c->lhu(s4, 20, gp);                               // lhu s4, 20(gp)
+  c->daddiu(s2, sp, 16);                            // daddiu s2, sp, 16
+  c->sq(r0, 0, s2);                                 // sq r0, 0(s2)
+  c->daddiu(s1, sp, 32);                            // daddiu s1, sp, 32
+  c->sq(r0, 0, s1);                                 // sq r0, 0(s1)
+  //beq r0, r0, L68                                 // beq r0, r0, L68
+  // nop                                            // sll r0, r0, 0
+  goto block_2;                                     // branch always
+
+
+  block_1:
+  c->dsll(v1, s5, 5);                               // dsll v1, s5, 5
+  c->daddu(v1, v1, gp);                             // daddu v1, v1, gp
+  c->lwc1(f0, 448, v1);                             // lwc1 f0, 448(v1)
+  c->swc1(f0, 0, s2);                               // swc1 f0, 0(s2)
+  c->dsll(v1, s5, 5);                               // dsll v1, s5, 5
+  c->daddu(v1, v1, gp);                             // daddu v1, v1, gp
+  c->lwc1(f0, 452, v1);                             // lwc1 f0, 452(v1)
+  c->swc1(f0, 4, s2);                               // swc1 f0, 4(s2)
+  c->dsll(v1, s5, 5);                               // dsll v1, s5, 5
+  c->daddu(v1, v1, gp);                             // daddu v1, v1, gp
+  c->lwc1(f0, 456, v1);                             // lwc1 f0, 456(v1)
+  c->swc1(f0, 8, s2);                               // swc1 f0, 8(s2)
+  c->lui(v1, 16256);                                // lui v1, 16256
+  c->mtc1(f0, v1);                                  // mtc1 f0, v1
+  c->swc1(f0, 12, s2);                              // swc1 f0, 12(s2)
+  c->dsll(v1, s5, 5);                               // dsll v1, s5, 5
+  c->daddu(v1, v1, gp);                             // daddu v1, v1, gp
+  c->lwc1(f0, 464, v1);                             // lwc1 f0, 464(v1)
+  c->swc1(f0, 0, s1);                               // swc1 f0, 0(s1)
+  c->dsll(v1, s5, 5);                               // dsll v1, s5, 5
+  c->daddu(v1, v1, gp);                             // daddu v1, v1, gp
+  c->lwc1(f0, 468, v1);                             // lwc1 f0, 468(v1)
+  c->swc1(f0, 4, s1);                               // swc1 f0, 4(s1)
+  c->dsll(v1, s5, 5);                               // dsll v1, s5, 5
+  c->daddu(v1, v1, gp);                             // daddu v1, v1, gp
+  c->lwc1(f0, 472, v1);                             // lwc1 f0, 472(v1)
+  c->swc1(f0, 8, s1);                               // swc1 f0, 8(s1)
+  c->mtc1(f0, r0);                                  // mtc1 f0, r0
+  c->swc1(f0, 12, s1);                              // swc1 f0, 12(s1)
+  c->load_symbol2(t9, cache.vector_matrix);         // lw t9, vector-matrix*!(s7)
+  c->mov64(a0, s2);                                 // or a0, s2, r0
+  c->mov64(a1, s2);                                 // or a1, s2, r0
+  c->addiu(v1, r0, 7264);                           // addiu v1, r0, 7264
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->daddu(a2, v1, a2);                             // daddu a2, v1, a2
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->load_symbol2(t9, cache.vector_matrix);         // lw t9, vector-matrix*!(s7)
+  c->mov64(a0, s1);                                 // or a0, s1, r0
+  c->mov64(a1, s1);                                 // or a1, s1, r0
+  c->addiu(v1, r0, 7264);                           // addiu v1, r0, 7264
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->daddu(a2, v1, a2);                             // daddu a2, v1, a2
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->load_symbol2(t9, cache.merc_death_spawn);      // lw t9, merc-death-spawn(s7)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(a0, 6848, v1);                             // lwu a0, 6848(v1)
+  c->mov64(a1, s2);                                 // or a1, s2, r0
+  c->mov64(a2, s1);                                 // or a2, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->daddu(s5, s5, s3);                             // daddu s5, s5, s3
+
+  block_2:
+  c->sltu(v1, s5, s4);                              // sltu v1, s5, s4
+  bc = c->sgpr64(v1) != 0;                          // bne v1, r0, L67
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  c->dsubu(a0, s5, s4);                             // dsubu a0, s5, s4
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->sh(a0, 6846, v1);                              // sh a0, 6846(v1)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->lq(gp, 128, sp);                               // lq gp, 128(sp)
+  c->lq(s5, 112, sp);                               // lq s5, 112(sp)
+  c->lq(s4, 96, sp);                                // lq s4, 96(sp)
+  c->lq(s3, 80, sp);                                // lq s3, 80(sp)
+  c->lq(s2, 64, sp);                                // lq s2, 64(sp)
+  c->lq(s1, 48, sp);                                // lq s1, 48(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 144);                           // daddiu sp, sp, 144
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.merc_death_spawn = intern_from_c("merc-death-spawn").c();
+  cache.vector_matrix = intern_from_c("vector-matrix*!").c();
+  gLinkedFunctionTable.reg("generic-merc-death", execute, 256);
+}
+
+} // namespace generic_merc_death
+} // namespace Mips2C
+// add generic_merc_death::link to the link callback table for the object file.
+// FWD DEC:
+
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_merc_execute_asm {
+struct Cache {
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* gsf_buffer; // *gsf-buffer*
+  void* generic_merc_death; // generic-merc-death
+  void* generic_merc_query; // generic-merc-query
+  void* generic_translucent; // generic-translucent
+  void* generic_warp_dest; // generic-warp-dest
+  void* generic_warp_envmap_dest; // generic-warp-envmap-dest
+  void* generic_warp_source; // generic-warp-source
+} cache;
+
+u64 execute(void* ctxt) {
+  u32 madr, sadr, qwc;
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -112);                          // daddiu sp, sp, -112
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->sq(s1, 16, sp);                                // sq s1, 16(sp)
+  c->sq(s2, 32, sp);                                // sq s2, 32(sp)
+  c->sq(s3, 48, sp);                                // sq s3, 48(sp)
+  c->sq(s4, 64, sp);                                // sq s4, 64(sp)
+  c->sq(s5, 80, sp);                                // sq s5, 80(sp)
+  c->sq(gp, 96, sp);                                // sq gp, 96(sp)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(v1, 7456, v1);                             // lwu v1, 7456(v1)
+  c->lwu(s2, 0, v1);                                // lwu s2, 0(v1)
+  c->addiu(v1, r0, 0);                              // addiu v1, r0, 0
+  c->addiu(gp, r0, 0);                              // addiu gp, r0, 0
+  c->addiu(s5, r0, 0);                              // addiu s5, r0, 0
+  c->load_symbol2(s4, cache.gsf_buffer);            // lw s4, *gsf-buffer*(s7)
+  c->lui(v1, 4096);                                 // lui v1, 4096
+  c->ori(s3, v1, 54272);                            // ori s3, v1, 54272
+  c->addiu(v1, r0, 624);                            // addiu v1, r0, 624
+  c->lui(a0, 4096);                                 // lui a0, 4096
+  c->ori(a0, a0, 54272);                            // ori a0, a0, 54272
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->ori(a1, a1, 88);                               // ori a1, a1, 88
+// dma
+//  c->lw(a2, 0, a0);                                 // lw a2, 0(a0)
+//  c->andi(a2, a2, 256);                             // andi a2, a2, 256
+//  bc = c->sgpr64(a2) == 0;                          // beq a2, r0, L21
+//  DANGER jump to delay slot, this MUST be fixed manually!
+//      c->lw(a2, 0, a1);                                 // lw a2, 0(a1)
+//  if (bc) {goto block_-1;}                          // branch non-likely
+//
+//
+//  block_1:
+//  c->lw(a2, 0, a1);                                 // lw a2, 0(a1)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(a3, 0, a0);                                 // lw a3, 0(a0)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(a3, a3, 256);                             // andi a3, a3, 256
+//  c->daddiu(a2, a2, 1);                             // daddiu a2, a2, 1
+//  bc = c->sgpr64(a3) != 0;                          // bne a3, r0, L20
+//  c->sw(a2, 0, a1);                                 // sw a2, 0(a1)
+//  if (bc) {goto block_1;}                           // branch non-likely
+
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  // c->sw(v1, 128, s3);                               // sw v1, 128(s3)
+  sadr = c->sgpr64(v1);
+
+  // c->sw(s2, 48, s3);                                // sw s2, 48(s3)
+  u32 tadr = c->sgpr64(s2);
+
+  // c->sw(r0, 32, s3);                                // sw r0, 32(s3)
+  // Unknown instr: sync.l
+  c->addiu(v1, r0, 324);                            // addiu v1, r0, 324
+  // c->sw(v1, 0, s3);                                 // sw v1, 0(s3)
+  spad_to_dma_blerc_chain(cache.fake_scratchpad_data, sadr, tadr);
+  // Unknown instr: sync.l
+  //beq r0, r0, L65                                 // beq r0, r0, L65
+  // nop                                            // sll r0, r0, 0
+  goto block_85;                                    // branch always
+
+
+  block_4:
+  bc = c->sgpr64(gp) != 0;                          // bne gp, r0, L23
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_6;}                           // branch non-likely
+
+  c->addiu(v1, r0, 624);                            // addiu v1, r0, 624
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+  //beq r0, r0, L24                                 // beq r0, r0, L24
+  // nop                                            // sll r0, r0, 0
+  goto block_7;                                     // branch always
+
+
+  block_6:
+  c->addiu(v1, r0, 3648);                           // addiu v1, r0, 3648
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+
+  block_7:
+  bc = c->sgpr64(gp) != 0;                          // bne gp, r0, L25
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_9;}                           // branch non-likely
+
+  c->addiu(a0, r0, 3648);                           // addiu a0, r0, 3648
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  //beq r0, r0, L26                                 // beq r0, r0, L26
+  // nop                                            // sll r0, r0, 0
+  goto block_10;                                    // branch always
+
+
+  block_9:
+  c->addiu(a0, r0, 624);                            // addiu a0, r0, 624
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+
+  block_10:
+  bc = c->sgpr64(gp) != 0;                          // bne gp, r0, L27
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_12;}                          // branch non-likely
+
+  c->addiu(a1, r0, 3568);                           // addiu a1, r0, 3568
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->daddu(a1, a1, a2);                             // daddu a1, a1, a2
+  //beq r0, r0, L28                                 // beq r0, r0, L28
+  // nop                                            // sll r0, r0, 0
+  goto block_13;                                    // branch always
+
+
+  block_12:
+  c->addiu(a1, r0, 6592);                           // addiu a1, r0, 6592
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->daddu(a1, a1, a2);                             // daddu a1, a1, a2
+
+  block_13:
+  bc = c->sgpr64(gp) != 0;                          // bne gp, r0, L29
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_15;}                          // branch non-likely
+
+  c->addiu(a1, r0, 6592);                           // addiu a1, r0, 6592
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->daddu(a1, a1, a2);                             // daddu a1, a1, a2
+  //beq r0, r0, L30                                 // beq r0, r0, L30
+  // nop                                            // sll r0, r0, 0
+  goto block_16;                                    // branch always
+
+
+  block_15:
+  c->addiu(a1, r0, 3568);                           // addiu a1, r0, 3568
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->daddu(a1, a1, a2);                             // daddu a1, a1, a2
+
+  block_16:
+  bc = c->sgpr64(gp) != 0;                          // bne gp, r0, L31
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_18;}                          // branch non-likely
+
+  c->daddu(s1, r0, s4);                             // daddu s1, r0, s4
+  //beq r0, r0, L32                                 // beq r0, r0, L32
+  // nop                                            // sll r0, r0, 0
+  goto block_19;                                    // branch always
+
+
+  block_18:
+  c->daddiu(s1, s4, 2752);                          // daddiu s1, s4, 2752
+
+  block_19:
+  bc = c->sgpr64(gp) != 0;                          // bne gp, r0, L33
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_21;}                          // branch non-likely
+
+  c->daddiu(a1, s4, 2752);                          // daddiu a1, s4, 2752
+  //beq r0, r0, L34                                 // beq r0, r0, L34
+  // nop                                            // sll r0, r0, 0
+  goto block_22;                                    // branch always
+
+
+  block_21:
+  c->daddu(a1, r0, s4);                             // daddu a1, r0, s4
+
+  block_22:
+  c->addiu(a2, r0, 7136);                           // addiu a2, r0, 7136
+  get_fake_spad_addr2(a3, cache.fake_scratchpad_data, 0, c);// lui a3, 28672
+  c->daddu(a2, a2, a3);                             // daddu a2, a2, a3
+  c->sw(gp, 280, a2);                               // sw gp, 280(a2)
+  c->sw(s5, 284, a2);                               // sw s5, 284(a2)
+  c->sw(v1, 292, a2);                               // sw v1, 292(a2)
+  c->sw(a0, 296, a2);                               // sw a0, 296(a2)
+  c->sw(s1, 300, a2);                               // sw s1, 300(a2)
+  c->sw(a1, 304, a2);                               // sw a1, 304(a2)
+  c->sw(s4, 312, a2);                               // sw s4, 312(a2)
+  c->mov64(a1, s4);                                 // or a1, s4, r0
+  c->lui(a1, 4096);                                 // lui a1, 4096
+  c->ori(a1, a1, 54272);                            // ori a1, a1, 54272
+  get_fake_spad_addr2(a2, cache.fake_scratchpad_data, 0, c);// lui a2, 28672
+  c->ori(a2, a2, 88);                               // ori a2, a2, 88
+//  c->lw(a3, 0, a1);                                 // lw a3, 0(a1)
+//  c->andi(a3, a3, 256);                             // andi a3, a3, 256
+//  bc = c->sgpr64(a3) == 0;                          // beq a3, r0, L36
+//  DANGER jump to delay slot, this MUST be fixed manually!
+      c->lw(a3, 0, a2);                                 // lw a3, 0(a2)
+//  if (bc) {goto block_-1;}                          // branch non-likely
+//
+//
+//  block_23:
+//  c->lw(a3, 0, a2);                                 // lw a3, 0(a2)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(t0, 0, a1);                                 // lw t0, 0(a1)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(t0, t0, 256);                             // andi t0, t0, 256
+//  c->daddiu(a3, a3, 1);                             // daddiu a3, a3, 1
+//  bc = c->sgpr64(t0) != 0;                          // bne t0, r0, L35
+//  c->sw(a3, 0, a2);                                 // sw a3, 0(a2)
+//  if (bc) {goto block_23;}                          // branch non-likely
+
+  c->gprs[a1].du64[0] = 0;                          // or a1, r0, r0
+  c->lwu(s2, 12, v1);                               // lwu s2, 12(v1)
+  bc = c->sgpr64(s2) == 0;                          // beq s2, r0, L37
+  c->mov64(a1, s7);                                 // or a1, s7, r0
+  if (bc) {goto block_27;}                          // branch non-likely
+
+  c->daddu(a0, r0, a0);                             // daddu a0, r0, a0
+  c->andi(a0, a0, 65535);                           // andi a0, a0, 65535
+  // c->sw(a0, 128, s3);                               // sw a0, 128(s3)
+  sadr = c->sgpr64(a0);
+  // c->sw(s2, 48, s3);                                // sw s2, 48(s3)
+  tadr = c->sgpr64(s2);
+  // c->sw(r0, 32, s3);                                // sw r0, 32(s3)
+  // Unknown instr: sync.l
+  c->addiu(a0, r0, 324);                            // addiu a0, r0, 324
+  // c->sw(a0, 0, s3);                                 // sw a0, 0(s3)
+  // hack - I don't really know why, but the andi above puts sadr into a 64 kb
+  // range instead of a 16 kB range. I believe the hardware will just mask it.
+  // or, maybe there's something else wrong? Not sure, but the transfer does seem to go
+  // to the right spot when I use this.
+  spad_to_dma_blerc_chain(cache.fake_scratchpad_data, sadr & 0x3fff, tadr);
+  // Unknown instr: sync.l
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+
+  block_27:
+  bc = c->sgpr64(s5) != 0;                          // bne s5, r0, L44
+  c->mov64(a0, s7);                                 // or a0, s7, r0
+  if (bc) {goto block_41;}                          // branch non-likely
+
+  c->addiu(a0, r0, 6672);                           // addiu a0, r0, 6672
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a1, a0, a1);                             // daddu a1, a0, a1
+  c->mov64(a2, v1);                                 // or a2, v1, r0
+  c->lwu(a0, 8, v1);                                // lwu a0, 8(v1)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(a3, a0, -4);                            // daddiu a3, a0, -4
+  c->mov64(a1, a1);                                 // or a1, a1, r0
+  bc = ((s64)c->sgpr64(a3)) < 0;                    // bltz a3, L39
+  c->mov64(a2, a2);                                 // or a2, a2, r0
+  if (bc) {goto block_30;}                          // branch non-likely
+
+
+  block_29:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t2, 0, a2);                                 // lq t2, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(a3, 16, a2);                                // lq a3, 16(a2)
+  c->daddiu(a0, a0, -4);                            // daddiu a0, a0, -4
+  c->lq(t0, 32, a2);                                // lq t0, 32(a2)
+  c->daddiu(a1, a1, 64);                            // daddiu a1, a1, 64
+  c->lq(t1, 48, a2);                                // lq t1, 48(a2)
+  c->daddiu(a2, a2, 64);                            // daddiu a2, a2, 64
+  c->sq(t2, -64, a1);                               // sq t2, -64(a1)
+  c->daddiu(t2, a0, -4);                            // daddiu t2, a0, -4
+  c->sq(a3, -48, a1);                               // sq a3, -48(a1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t0, -32, a1);                               // sq t0, -32(a1)
+  bc = ((s64)c->sgpr64(t2)) >= 0;                   // bgez t2, L38
+  c->sq(t1, -16, a1);                               // sq t1, -16(a1)
+  if (bc) {goto block_29;}                          // branch non-likely
+
+
+  block_30:
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L40
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_35;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L40
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_35;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L40
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_35;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L40
+  c->lq(a3, 0, a2);                                 // lq a3, 0(a2)
+  if (bc) {goto block_35;}                          // branch non-likely
+
+  c->daddiu(a2, a2, 16);                            // daddiu a2, a2, 16
+  c->daddiu(a1, a1, 16);                            // daddiu a1, a1, 16
+  c->daddiu(a0, a0, -1);                            // daddiu a0, a0, -1
+  c->sq(a3, -16, a1);                               // sq a3, -16(a1)
+
+  block_35:
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6840, a0);                             // lbu a0, 6840(a0)
+  bc = c->sgpr64(a0) != 0;                          // bne a0, r0, L41
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_37;}                          // branch non-likely
+
+  c->addiu(a0, r0, 8);                              // addiu a0, r0, 8
+  //beq r0, r0, L42                                 // beq r0, r0, L42
+  // nop                                            // sll r0, r0, 0
+  goto block_38;                                    // branch always
+
+
+  block_37:
+  c->addiu(a0, r0, 6);                              // addiu a0, r0, 6
+
+  block_38:
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->ori(a1, a1, 11984);                            // ori a1, a1, 11984
+  c->sh(a0, 0, a1);                                 // sh a0, 0(a1)
+  c->addiu(a0, r0, 12048);                          // addiu a0, r0, 12048
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->lwu(a1, 6832, a1);                             // lwu a1, 6832(a1)
+  c->sw(a1, 0, a0);                                 // sw a1, 0(a0)
+  c->sw(a1, 4, a0);                                 // sw a1, 4(a0)
+  c->sw(a1, 8, a0);                                 // sw a1, 8(a0)
+  c->sw(a1, 12, a0);                                // sw a1, 12(a0)
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->addiu(a0, a1, 7136);                           // addiu a0, a1, 7136
+  c->lbu(a2, 6841, a1);                             // lbu a2, 6841(a1)
+  c->addiu(a3, a1, 7200);                           // addiu a3, a1, 7200
+  c->addiu(a1, a1, 11808);                          // addiu a1, a1, 11808
+  c->movn(a0, a3, a2);                              // movn a0, a3, a2
+  c->lq(a2, 0, a0);                                 // lq a2, 0(a0)
+  c->lq(a3, 16, a0);                                // lq a3, 16(a0)
+  c->lq(t0, 32, a0);                                // lq t0, 32(a0)
+  c->lq(a0, 48, a0);                                // lq a0, 48(a0)
+  c->sq(a2, 0, a1);                                 // sq a2, 0(a1)
+  c->sq(a3, 16, a1);                                // sq a3, 16(a1)
+  c->sq(t0, 32, a1);                                // sq t0, 32(a1)
+  c->sq(a0, 48, a1);                                // sq a0, 48(a1)
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6843, a0);                             // lbu a0, 6843(a0)
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->sb(a0, 6853, a1);                              // sb a0, 6853(a1)
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lqc2(vf1, 6688, at);                           // lqc2 vf1, 6688(at)
+  c->lqc2(vf2, 6704, at);                           // lqc2 vf2, 6704(at)
+  c->lqc2(vf3, 6720, at);                           // lqc2 vf3, 6720(at)
+  c->lqc2(vf4, 6736, at);                           // lqc2 vf4, 6736(at)
+  c->lqc2(vf5, 6752, at);                           // lqc2 vf5, 6752(at)
+  c->lqc2(vf6, 6768, at);                           // lqc2 vf6, 6768(at)
+  c->lqc2(vf7, 6784, at);                           // lqc2 vf7, 6784(at)
+  c->sqc2(vf1, 12688, at);                          // sqc2 vf1, 12688(at)
+  c->sqc2(vf2, 12704, at);                          // sqc2 vf2, 12704(at)
+  c->sqc2(vf3, 12720, at);                          // sqc2 vf3, 12720(at)
+  c->sqc2(vf4, 12736, at);                          // sqc2 vf4, 12736(at)
+  c->sqc2(vf5, 12752, at);                          // sqc2 vf5, 12752(at)
+  c->sqc2(vf6, 12768, at);                          // sqc2 vf6, 12768(at)
+  c->sqc2(vf7, 12784, at);                          // sqc2 vf7, 12784(at)
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6856, a0);                             // lbu a0, 6856(a0)
+  c->addiu(a1, r0, 128);                            // addiu a1, r0, 128
+  c->sltu(a1, a1, a0);                              // sltu a1, a1, a0
+  bc = c->sgpr64(a1) != 0;                          // bne a1, r0, L43
+  c->mov64(a1, s7);                                 // or a1, s7, r0
+  if (bc) {goto block_40;}                          // branch non-likely
+
+  c->lui(a1, 15360);                                // lui a1, 15360
+  c->mtc1(f0, a1);                                  // mtc1 f0, a1
+  c->mtc1(f1, a0);                                  // mtc1 f1, a0
+  c->cvtsw(f1, f1);                                 // cvt.s.w f1, f1
+  c->muls(f0, f0, f1);                              // mul.s f0, f0, f1
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lwc1(f1, 12796, a0);                           // lwc1 f1, 12796(a0)
+  c->muls(f0, f0, f1);                              // mul.s f0, f0, f1
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->swc1(f0, 12796, a0);                           // swc1 f0, 12796(a0)
+  c->mfc1(a1, f0);                                  // mfc1 a1, f0
+
+  block_40:
+  c->lwu(a0, 8, v1);                                // lwu a0, 8(v1)
+  c->dsll(a0, a0, 4);                               // dsll a0, a0, 4
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+  c->mov64(a0, v1);                                 // or a0, v1, r0
+
+  block_41:
+  c->addiu(a0, r0, 7136);                           // addiu a0, r0, 7136
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  c->daddiu(v1, v1, 16);                            // daddiu v1, v1, 16
+  c->sw(v1, 308, a0);                               // sw v1, 308(a0)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7460, v1);                             // lwu t9, 7460(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  mercneric_convert::execute(c);
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->addiu(a0, r0, 1);                              // addiu a0, r0, 1
+  c->lbu(a1, 6840, v1);                             // lbu a1, 6840(v1)
+  c->daddiu(a2, s1, 448);                           // daddiu a2, s1, 448
+  c->lbu(a3, 6843, v1);                             // lbu a3, 6843(v1)
+  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L46
+  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
+  if (bc) {goto block_47;}                          // branch non-likely
+
+  bc = c->sgpr64(a3) == 0;                          // beq a3, r0, L46
+  c->vmax_bc(DEST::xyzw, BC::w, vf9, vf0, vf0);     // vmaxw.xyzw vf9, vf0, vf0
+  if (bc) {goto block_47;}                          // branch non-likely
+
+  c->sb(a0, 6853, v1);                              // sb a0, 6853(v1)
+  c->lqc2(vf10, 7488, v1);                          // lqc2 vf10, 7488(v1)
+  c->lqc2(vf11, 7504, v1);                          // lqc2 vf11, 7504(v1)
+  c->vmula_bc(DEST::xyzw, BC::z, vf9, vf1);         // vmulaz.xyzw acc, vf9, vf1
+  c->lw(a0, 8, a2);                                 // lw a0, 8(a2)
+  c->vmadda_bc(DEST::xyzw, BC::x, vf10, vf1);       // vmaddax.xyzw acc, vf10, vf1
+  bc = ((s64)c->sgpr64(a0)) < 0;                    // bltz a0, L45
+  c->lw(v1, 7480, v1);                              // lw v1, 7480(v1)
+  if (bc) {goto block_45;}                          // branch non-likely
+
+  c->vmadd_bc(DEST::xyzw, BC::y, vf1, vf11, vf1);   // vmaddy.xyzw vf1, vf11, vf1
+  c->mov128_gpr_vf(a0, vf1);                        // qmfc2.i a0, vf1
+  c->pcgtw(a0, r0, a0);                             // pcgtw a0, r0, a0
+  c->ppach(a0, r0, a0);                             // ppach a0, r0, a0
+  bc = c->sgpr64(a0) == 0;                          // beq a0, r0, L46
+  // DANGER jump to delay slot, this MUST be fixed manually!
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_47;}                          // branch non-likely
+
+
+  block_45:
+  // nop                                            // sll r0, r0, 0
+  call_addr = c->gprs[v1].du32[0];                  // function call:
+  // nop                                            // sll r0, r0, 0
+  c->jalr(call_addr);                               // jalr ra, v1
+  // high_speed_reject::execute(c);
+
+  block_47:
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(v1, 6836, v1);                             // lwu v1, 6836(v1)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L47
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_49;}                          // branch non-likely
+
+  c->load_symbol2(t9, cache.generic_merc_query);    // lw t9, generic-merc-query(s7)
+  c->mov64(a0, s1);                                 // or a0, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+
+  block_49:
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lhu(v1, 6844, v1);                             // lhu v1, 6844(v1)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L48
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_51;}                          // branch non-likely
+
+  c->load_symbol2(t9, cache.generic_merc_death);    // lw t9, generic-merc-death(s7)
+  c->mov64(a0, s1);                                 // or a0, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+
+  block_51:
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lw(v1, 7424, v1);                              // lw v1, 7424(v1)
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lwu(a0, 60, a0);                               // lwu a0, 60(a0)
+  c->dsubu(v1, v1, a0);                             // dsubu v1, v1, a0
+  c->slt(v1, r0, v1);                               // slt v1, r0, v1
+  bc = c->sgpr64(v1) != 0;                          // bne v1, r0, L49
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_53;}                          // branch non-likely
+
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->sb(r0, 6853, v1);                              // sb r0, 6853(v1)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->sb(r0, 6843, v1);                              // sb r0, 6843(v1)
+  c->gprs[v1].du64[0] = 0;                          // or v1, r0, r0
+
+  block_53:
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lbu(v1, 6853, v1);                             // lbu v1, 6853(v1)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L63
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_82;}                          // branch non-likely
+
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6854, a0);                             // lbu a0, 6854(a0)
+  bc = c->sgpr64(a0) != c->sgpr64(v1);              // bne a0, v1, L50
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_56;}                          // branch non-likely
+
+  c->load_symbol2(t9, cache.generic_warp_source);   // lw t9, generic-warp-source(s7)
+  c->mov64(a0, s1);                                 // or a0, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+  //beq r0, r0, L63                                 // beq r0, r0, L63
+  // nop                                            // sll r0, r0, 0
+  goto block_82;                                    // branch always
+
+
+  block_56:
+  c->addiu(v1, r0, 2);                              // addiu v1, r0, 2
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6854, a0);                             // lbu a0, 6854(a0)
+  bc = c->sgpr64(a0) != c->sgpr64(v1);              // bne a0, v1, L53
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_61;}                          // branch non-likely
+
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lbu(v1, 6955, v1);                             // lbu v1, 6955(v1)
+  c->andi(v1, v1, 1);                               // andi v1, v1, 1
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L51
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_59;}                          // branch non-likely
+
+  c->load_symbol2(t9, cache.generic_warp_envmap_dest);// lw t9, generic-warp-envmap-dest(s7)
+  c->mov64(a0, s1);                                 // or a0, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+  //beq r0, r0, L52                                 // beq r0, r0, L52
+  // nop                                            // sll r0, r0, 0
+  goto block_60;                                    // branch always
+
+
+  block_59:
+  c->load_symbol2(t9, cache.generic_warp_dest);     // lw t9, generic-warp-dest(s7)
+  c->mov64(a0, s1);                                 // or a0, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_warp_dest::execute(c);
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+
+  block_60:
+  //beq r0, r0, L63                                 // beq r0, r0, L63
+  // nop                                            // sll r0, r0, 0
+  goto block_82;                                    // branch always
+
+
+  block_61:
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lbu(v1, 6955, v1);                             // lbu v1, 6955(v1)
+  c->andi(v1, v1, 1);                               // andi v1, v1, 1
+  if (((s64)c->sgpr64(v1)) == ((s64)0)) {           // beql v1, r0, L54
+    c->mov64(v1, s7);                               // or v1, s7, r0
+    goto block_64;
+  }
+
+  c->daddiu(v1, s7, 4);                             // daddiu v1, s7, 4
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lbu(a0, 6852, a0);                             // lbu a0, 6852(a0)
+  c->movz(v1, s7, a0);                              // movz v1, s7, a0
+
+  block_64:
+  bc = c->sgpr64(s7) == c->sgpr64(v1);              // beq s7, v1, L55
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_66;}                          // branch non-likely
+
+  c->load_symbol2(t9, cache.generic_translucent);   // lw t9, generic-translucent(s7)
+  c->mov64(a0, s1);                                 // or a0, s1, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+  //beq r0, r0, L63                                 // beq r0, r0, L63
+  // nop                                            // sll r0, r0, 0
+  goto block_82;                                    // branch always
+
+
+  block_66:
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lbu(v1, 6955, v1);                             // lbu v1, 6955(v1)
+  c->andi(v1, v1, 1);                               // andi v1, v1, 1
+  if (((s64)c->sgpr64(v1)) == ((s64)0)) {           // beql v1, r0, L56
+    c->mov64(v1, s7);                               // or v1, s7, r0
+    goto block_69;
+  }
+
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lbu(v1, 6858, v1);                             // lbu v1, 6858(v1)
+  c->daddiu(a0, v1, -1);                            // daddiu a0, v1, -1
+  c->daddiu(v1, s7, 4);                             // daddiu v1, s7, 4
+  c->movz(v1, s7, a0);                              // movz v1, s7, a0
+
+  block_69:
+  bc = c->sgpr64(s7) == c->sgpr64(v1);              // beq s7, v1, L60
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_77;}                          // branch non-likely
+
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->mov64(v1, s1);                                 // or v1, s1, r0
+  c->daddiu(a0, at, 12064);                         // daddiu a0, at, 12064
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->lbu(a1, 6842, a1);                             // lbu a1, 6842(a1)
+  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L57
+  c->mov64(a1, s7);                                 // or a1, s7, r0
+  if (bc) {goto block_72;}                          // branch non-likely
+
+  c->addiu(a0, r0, 6960);                           // addiu a0, r0, 6960
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
+  c->mov64(a0, a0);                                 // or a0, a0, r0
+  c->mov64(a1, a0);                                 // or a1, a0, r0
+
+  block_72:
+  c->sw(r0, 48, at);                                // sw r0, 48(at)
+  c->sw(a0, 52, at);                                // sw a0, 52(at)
+  c->sw(v1, 44, at);                                // sw v1, 44(at)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7468, v1);                             // lwu t9, 7468(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_prepare_dma_double::execute(c);
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7472, v1);                             // lwu t9, 7472(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_light_proc::execute(c);
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7476, v1);                             // lwu t9, 7476(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_envmap_proc::execute(c);
+  c->lw(v1, 24, at);                                // lw v1, 24(at)
+  c->lw(a0, 40, at);                                // lw a0, 40(at)
+  c->mov64(a3, v1);                                 // or a3, v1, r0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lui(a2, 4096);                                 // lui a2, 4096
+  c->lwu(a1, 60, at);                               // lwu a1, 60(at)
+  c->ori(a2, a2, 53248);                            // ori a2, a2, 53248
+  // c->lw(t1, 0, a2);                                 // lw t1, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, at, 92);                            // daddiu t0, at, 92
+  c->andi(a3, a3, 16383);                           // andi a3, a3, 16383
+  c->andi(t1, t1, 256);                             // andi t1, t1, 256
+  // nop                                            // sll r0, r0, 0
+//  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L59
+//  // nop                                            // sll r0, r0, 0
+//  if (bc) {goto block_76;}                          // branch non-likely
+//
+//  c->mov64(t1, a2);                                 // or t1, a2, r0
+  // nop                                            // sll r0, r0, 0
+
+  block_74:
+
+//  c->lw(t2, 0, t0);                                 // lw t2, 0(t0)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(t3, 0, t1);                                 // lw t3, 0(t1)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(t3, t3, 256);                             // andi t3, t3, 256
+//  c->daddiu(t2, t2, 1);                             // daddiu t2, t2, 1
+//  bc = c->sgpr64(t3) != 0;                          // bne t3, r0, L58
+//  c->sw(t2, 0, t0);                                 // sw t2, 0(t0)
+//  if (bc) {goto block_74;}                          // branch non-likely
+
+  c->gprs[t0].du64[0] = 0;                          // or t0, r0, r0
+
+  block_76:
+  c->dsll(t0, a0, 4);                               // dsll t0, a0, 4
+  // c->sw(a3, 128, a2);                               // sw a3, 128(a2)
+  sadr = c->sgpr64(a3);
+  // nop                                            // sll r0, r0, 0
+  // c->sw(a1, 16, a2);                                // sw a1, 16(a2)
+  madr = c->sgpr64(a1);
+  c->addiu(a3, r0, 256);                            // addiu a3, r0, 256
+  // c->sw(a0, 32, a2);                                // sw a0, 32(a2)
+  qwc = c->sgpr64(a0);
+  c->daddu(a0, a1, t0);                             // daddu a0, a1, t0
+  // c->sw(a3, 0, a2);                                 // sw a3, 0(a2)
+  spad_from_dma_no_sadr_off(cache.fake_scratchpad_data, madr, sadr, qwc);
+
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 60, at);                                // sw a0, 60(at)
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->xori(v1, v1, 4608);                            // xori v1, v1, 4608
+  c->sw(v1, 24, at);                                // sw v1, 24(at)
+  //beq r0, r0, L63                                 // beq r0, r0, L63
+  // nop                                            // sll r0, r0, 0
+  goto block_82;                                    // branch always
+
+
+  block_77:
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->mov64(v1, s1);                                 // or v1, s1, r0
+  c->sw(r0, 48, at);                                // sw r0, 48(at)
+  c->sw(v1, 44, at);                                // sw v1, 44(at)
+  c->sh(r0, 56, at);                                // sh r0, 56(at)
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7464, v1);                             // lwu t9, 7464(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_prepare_dma_single::execute_real(c);
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(t9, 7472, v1);                             // lwu t9, 7472(v1)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  // c->jalr(call_addr);                               // jalr ra, t9
+  generic_light_proc::execute(c);
+  c->lw(v1, 24, at);                                // lw v1, 24(at)
+  c->lw(a0, 40, at);                                // lw a0, 40(at)
+  c->mov64(a3, v1);                                 // or a3, v1, r0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lui(a2, 4096);                                 // lui a2, 4096
+  c->lwu(a1, 60, at);                               // lwu a1, 60(at)
+  c->ori(a2, a2, 53248);                            // ori a2, a2, 53248
+  // c->lw(t1, 0, a2);                                 // lw t1, 0(a2)
+  // nop                                            // sll r0, r0, 0
+  c->daddiu(t0, at, 92);                            // daddiu t0, at, 92
+  c->andi(a3, a3, 16383);                           // andi a3, a3, 16383
+  c->andi(t1, t1, 256);                             // andi t1, t1, 256
+  // nop                                            // sll r0, r0, 0
+//  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L62
+//  // nop                                            // sll r0, r0, 0
+//  if (bc) {goto block_81;}                          // branch non-likely
+//
+//  c->mov64(t1, a2);                                 // or t1, a2, r0
+//  // nop                                            // sll r0, r0, 0
+//
+//  block_79:
+//  c->lw(t2, 0, t0);                                 // lw t2, 0(t0)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(t3, 0, t1);                                 // lw t3, 0(t1)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(t3, t3, 256);                             // andi t3, t3, 256
+//  c->daddiu(t2, t2, 1);                             // daddiu t2, t2, 1
+//  bc = c->sgpr64(t3) != 0;                          // bne t3, r0, L61
+//  c->sw(t2, 0, t0);                                 // sw t2, 0(t0)
+//  if (bc) {goto block_79;}                          // branch non-likely
+//
+//  c->gprs[t0].du64[0] = 0;                          // or t0, r0, r0
+
+  block_81:
+  c->dsll(t0, a0, 4);                               // dsll t0, a0, 4
+  // c->sw(a3, 128, a2);                               // sw a3, 128(a2)
+  sadr = c->sgpr64(a3);
+  // nop                                            // sll r0, r0, 0
+  // c->sw(a1, 16, a2);                                // sw a1, 16(a2)
+  madr = c->sgpr64(a1);
+  c->addiu(a3, r0, 256);                            // addiu a3, r0, 256
+  // c->sw(a0, 32, a2);                                // sw a0, 32(a2)
+  qwc = c->sgpr64(a0);
+  c->daddu(a0, a1, t0);                             // daddu a0, a1, t0
+  // c->sw(a3, 0, a2);                                 // sw a3, 0(a2)
+  spad_from_dma_no_sadr_off(cache.fake_scratchpad_data, madr, sadr, qwc);
+  // nop                                            // sll r0, r0, 0
+  c->sw(a0, 60, at);                                // sw a0, 60(at)
+  c->gprs[a0].du64[0] = 0;                          // or a0, r0, r0
+  c->xori(v1, v1, 4608);                            // xori v1, v1, 4608
+  c->sw(v1, 24, at);                                // sw v1, 24(at)
+
+  block_82:
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  c->dsubu(gp, v1, gp);                             // dsubu gp, v1, gp
+  c->daddiu(s5, s5, 1);                             // daddiu s5, s5, 1
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lhu(v1, 6946, v1);                             // lhu v1, 6946(v1)
+  bc = c->sgpr64(s5) != c->sgpr64(v1);              // bne s5, v1, L64
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_84;}                          // branch non-likely
+
+  c->addiu(s5, r0, 0);                              // addiu s5, r0, 0
+  c->mov64(v1, s5);                                 // or v1, s5, r0
+
+  block_84:
+  c->mov64(v1, s2);                                 // or v1, s2, r0
+
+  block_85:
+  bc = c->sgpr64(s2) != 0;                          // bne s2, r0, L22
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_4;}                           // branch non-likely
+
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(v1, 7456, v1);                             // lwu v1, 7456(v1)
+  c->sw(r0, 0, v1);                                 // sw r0, 0(v1)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->lq(gp, 96, sp);                                // lq gp, 96(sp)
+  c->lq(s5, 80, sp);                                // lq s5, 80(sp)
+  c->lq(s4, 64, sp);                                // lq s4, 64(sp)
+  c->lq(s3, 48, sp);                                // lq s3, 48(sp)
+  c->lq(s2, 32, sp);                                // lq s2, 32(sp)
+  c->lq(s1, 16, sp);                                // lq s1, 16(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 112);                           // daddiu sp, sp, 112
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.gsf_buffer = intern_from_c("*gsf-buffer*").c();
+  cache.generic_merc_death = intern_from_c("generic-merc-death").c();
+  cache.generic_merc_query = intern_from_c("generic-merc-query").c();
+  cache.generic_translucent = intern_from_c("generic-translucent").c();
+  cache.generic_warp_dest = intern_from_c("generic-warp-dest").c();
+  cache.generic_warp_envmap_dest = intern_from_c("generic-warp-envmap-dest").c();
+  cache.generic_warp_source = intern_from_c("generic-warp-source").c();
+  gLinkedFunctionTable.reg("generic-merc-execute-asm", execute, 256);
+}
+
+} // namespace generic_merc_execute_asm
+} // namespace Mips2C
+// add generic_merc_execute_asm::link to the link callback table for the object file.
+// FWD DEC:
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak2/kscheme.h"
+using ::jak2::intern_from_c;
+namespace Mips2C::jak2 {
+namespace generic_merc_do_chain {
+struct Cache {
+  void* display; // *display*
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* dma_bucket_insert_tag; // dma-bucket-insert-tag
+  void* generic_merc_execute_asm; // generic-merc-execute-asm
+  void* generic_work_init; // generic-work-init
+} cache;
+
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->daddiu(sp, sp, -80);                           // daddiu sp, sp, -80
+  c->sd(ra, 0, sp);                                 // sd ra, 0(sp)
+  c->sq(s3, 16, sp);                                // sq s3, 16(sp)
+  c->sq(s4, 32, sp);                                // sq s4, 32(sp)
+  c->sq(s5, 48, sp);                                // sq s5, 48(sp)
+  c->sq(gp, 64, sp);                                // sq gp, 64(sp)
+  c->mov64(s5, a0);                                 // or s5, a0, r0
+  c->mov64(gp, a1);                                 // or gp, a1, r0
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->sw(s5, 7456, v1);                              // sw s5, 7456(v1)
+  c->daddiu(a0, s5, 8);                             // daddiu a0, s5, 8
+  c->lwu(v1, 0, s5);                                // lwu v1, 0(s5)
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L18
+  c->mov64(v0, s7);                                 // or v0, s7, r0
+  if (bc) {goto block_5;}                           // branch non-likely
+
+  c->load_symbol2(v1, cache.display);               // lw v1, *display*(s7)
+  c->lw(v1, 0, v1);                                 // lw v1, 0(v1)
+  c->dsll(v1, v1, 2);                               // dsll v1, v1, 2
+  c->load_symbol2(a1, cache.display);               // lw a1, *display*(s7)
+  c->daddu(v1, v1, a1);                             // daddu v1, v1, a1
+  c->lwu(v1, 8, v1);                                // lwu v1, 8(v1)
+  c->lwu(s3, 36, v1);                               // lwu s3, 36(v1)
+  c->lwu(s4, 4, s3);                                // lwu s4, 4(s3)
+  c->load_symbol2(t9, cache.generic_work_init);     // lw t9, generic-work-init(s7)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->lwu(v1, 4, s3);                                // lwu v1, 4(s3)
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  // printf("watch *0x%lx\n", (uintptr_t)(g_ee_main_mem + c->sgpr64(a0) + 60));
+  c->sw(v1, 60, a0);                                // sw v1, 60(a0)
+  c->load_symbol2(t9, cache.generic_merc_execute_asm);// lw t9, generic-merc-execute-asm(s7)
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  get_fake_spad_addr2(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
+  c->lwu(v1, 60, v1);                               // lwu v1, 60(v1)
+  c->sw(v1, 4, s3);                                 // sw v1, 4(s3)
+  c->lui(v1, 4096);                                 // lui v1, 4096
+  c->ori(v1, v1, 53248);                            // ori v1, v1, 53248
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+//  c->ori(a0, a0, 92);                               // ori a0, a0, 92
+//  c->lw(a1, 0, v1);                                 // lw a1, 0(v1)
+//  c->andi(a1, a1, 256);                             // andi a1, a1, 256
+//  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L17
+//  DANGER jump to delay slot, this MUST be fixed manually!
+//      c->lw(a1, 0, a0);                                 // lw a1, 0(a0)
+//  if (bc) {goto block_-1;}                          // branch non-likely
+//
+//
+//  block_2:
+//  c->lw(a1, 0, a0);                                 // lw a1, 0(a0)
+//  // nop                                            // sll r0, r0, 0
+//  c->lw(a2, 0, v1);                                 // lw a2, 0(v1)
+//  // nop                                            // sll r0, r0, 0
+//  c->andi(a2, a2, 256);                             // andi a2, a2, 256
+//  c->daddiu(a1, a1, 1);                             // daddiu a1, a1, 1
+//  bc = c->sgpr64(a2) != 0;                          // bne a2, r0, L16
+//  c->sw(a1, 0, a0);                                 // sw a1, 0(a0)
+//  if (bc) {goto block_2;}                           // branch non-likely
+
+  c->gprs[v1].du64[0] = 0;                          // or v1, r0, r0
+  c->lwu(a3, 4, s3);                                // lwu a3, 4(s3)
+  c->lwu(v1, 4, s3);                                // lwu v1, 4(s3)
+  c->lui(a0, 8192);                                 // lui a0, 8192
+  c->sd(a0, 0, v1);                                 // sd a0, 0(v1)
+  c->sw(r0, 8, v1);                                 // sw r0, 8(v1)
+  c->sw(r0, 12, v1);                                // sw r0, 12(v1)
+  c->daddiu(v1, v1, 16);                            // daddiu v1, v1, 16
+  c->sw(v1, 4, s3);                                 // sw v1, 4(s3)
+  c->load_symbol2(t9, cache.dma_bucket_insert_tag); // lw t9, dma-bucket-insert-tag(s7)
+  c->load_symbol2(v1, cache.display);               // lw v1, *display*(s7)
+  c->lw(v1, 0, v1);                                 // lw v1, 0(v1)
+  c->dsll(v1, v1, 2);                               // dsll v1, v1, 2
+  c->load_symbol2(a0, cache.display);               // lw a0, *display*(s7)
+  c->daddu(v1, v1, a0);                             // daddu v1, v1, a0
+  c->lwu(v1, 8, v1);                                // lwu v1, 8(v1)
+  c->lwu(a0, 40, v1);                               // lwu a0, 40(v1)
+  c->lw(a1, 16, s5);                                // lw a1, 16(s5)
+  c->mov64(a2, s4);                                 // or a2, s4, r0
+  call_addr = c->gprs[t9].du32[0];                  // function call:
+  c->sll(v0, ra, 0);                                // sll v0, ra, 0
+  c->jalr(call_addr);                               // jalr ra, t9
+  c->mov64(v1, v0);                                 // or v1, v0, r0
+  c->lwu(v1, 4, gp);                                // lwu v1, 4(gp)
+  // Unknown instr: sync.l
+  // Unknown instr: cache dxwbin v1, 0
+  // Unknown instr: sync.l
+  // Unknown instr: cache dxwbin v1, 1
+  // Unknown instr: sync.l
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+
+  block_5:
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->lq(gp, 64, sp);                                // lq gp, 64(sp)
+  c->lq(s5, 48, sp);                                // lq s5, 48(sp)
+  c->lq(s4, 32, sp);                                // lq s4, 32(sp)
+  c->lq(s3, 16, sp);                                // lq s3, 16(sp)
+  //jr ra                                           // jr ra
+  c->daddiu(sp, sp, 80);                            // daddiu sp, sp, 80
+  goto end_of_function;                             // return
+
+  // nop                                            // sll r0, r0, 0
+  // nop                                            // sll r0, r0, 0
+  end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.display = intern_from_c("*display*").c();
+  cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
+  cache.dma_bucket_insert_tag = intern_from_c("dma-bucket-insert-tag").c();
+  cache.generic_merc_execute_asm = intern_from_c("generic-merc-execute-asm").c();
+  cache.generic_work_init = intern_from_c("generic-work-init").c();
+  gLinkedFunctionTable.reg("generic-merc-do-chain", execute, 128);
+}
+
+} // namespace generic_merc_do_chain
+} // namespace Mips2C
+// add generic_merc_do_chain::link to the link callback table for the object file.
+// FWD DEC:
diff --git a/game/mips2c/mips2c_private.h b/game/mips2c/mips2c_private.h
index 96a9698ba5..72619d5cf2 100644
--- a/game/mips2c/mips2c_private.h
+++ b/game/mips2c/mips2c_private.h
@@ -348,6 +348,7 @@ struct ExecutionContext {
     u64 args[8] = {gprs[a0].du64[0], gprs[a1].du64[0], gprs[a2].du64[0], gprs[a3].du64[0],
                    gprs[t0].du64[0], gprs[t1].du64[0], gprs[t2].du64[0], gprs[t3].du64[0]};
 #ifdef __linux__
+    ASSERT(addr);
     gprs[v0].du64[0] = _call_goal8_asm_linux(g_ee_main_mem + addr, args, 0, gprs[s6].du64[0],
                                              gprs[s7].du64[0], g_ee_main_mem);
 #elif _WIN32
@@ -703,6 +704,14 @@ struct ExecutionContext {
     }
   }
 
+  void psubh(int dest, int rs, int rt) {
+    auto s = gpr_src(rs);
+    auto t = gpr_src(rt);
+    for (int i = 0; i < 8; i++) {
+      gprs[dest].du16[i] = s.du16[i] - t.du16[i];
+    }
+  }
+
   void pminh(int dest, int rs, int rt) {
     auto s = gpr_src(rs);
     auto t = gpr_src(rt);
diff --git a/game/mips2c/mips2c_table.cpp b/game/mips2c/mips2c_table.cpp
index 1a8f43aae7..cb745c9d81 100644
--- a/game/mips2c/mips2c_table.cpp
+++ b/game/mips2c/mips2c_table.cpp
@@ -220,6 +220,24 @@ namespace method_53_squid { extern void link(); }
 namespace init_vortex_regs { extern void link(); }
 namespace draw_large_polygon_vortex { extern void link(); }
 namespace render_vortex_quad { extern void link(); }
+namespace foreground_generic_merc { extern void link(); }
+namespace generic_merc_init_asm { extern void link(); }
+namespace mercneric_convert { extern void link(); }
+namespace high_speed_reject { extern void link(); }
+namespace generic_translucent { extern void link(); }
+namespace generic_merc_query { extern void link(); }
+namespace generic_merc_death { extern void link(); }
+namespace generic_merc_execute_asm { extern void link(); }
+namespace generic_merc_do_chain { extern void link(); }
+namespace generic_light_proc { extern void link(); }
+namespace generic_envmap_proc { extern void link(); }
+namespace generic_prepare_dma_double { extern void link(); }
+namespace generic_prepare_dma_single { extern void link(); }
+namespace generic_warp_source_proc { extern void link(); }
+namespace generic_warp_dest_proc { extern void link(); }
+namespace generic_warp_dest { extern void link(); }
+namespace generic_warp_envmap_dest { extern void link(); }
+namespace generic_no_light_proc { extern void link(); }
 
 }
 // clang-format on
@@ -350,7 +368,9 @@ PerGameVersion<std::unordered_map<std::string, std::vector<void (*)()>>> gMips2C
        jak2::method_10_collide_cache_prim::link, jak2::method_17_collide_cache::link,
        jak2::method_9_collide_puss_work::link, jak2::method_10_collide_puss_work::link}},
      {"bones", {jak2::bones_mtx_calc::link}},
-     {"foreground", {jak2::foreground_check_longest_edge_asm::link, jak2::foreground_merc::link}},
+     {"foreground",
+      {jak2::foreground_check_longest_edge_asm::link, jak2::foreground_merc::link,
+       jak2::foreground_generic_merc::link}},
      {"lights",
       {jak2::add_light_sphere_to_light_group::link, jak2::light_hash_add_items::link,
        jak2::light_hash_count_items::link, jak2::light_hash_get_bucket_index::link}},
@@ -369,7 +389,18 @@ PerGameVersion<std::unordered_map<std::string, std::vector<void (*)()>>> gMips2C
      {"squid-setup", {jak2::method_53_squid::link}},
      {"vortex",
       {jak2::init_vortex_regs::link, jak2::draw_large_polygon_vortex::link,
-       jak2::render_vortex_quad::link}}}};
+       jak2::render_vortex_quad::link}},
+     {"generic-merc",
+      {jak2::generic_merc_init_asm::link, jak2::mercneric_convert::link,
+       jak2::high_speed_reject::link, jak2::generic_translucent::link,
+       jak2::generic_merc_query::link, jak2::generic_merc_death::link,
+       jak2::generic_merc_execute_asm::link, jak2::generic_merc_do_chain::link}},
+     {"generic-effect",
+      {jak2::generic_light_proc::link, jak2::generic_envmap_proc::link,
+       jak2::generic_prepare_dma_double::link, jak2::generic_prepare_dma_single::link,
+       jak2::generic_warp_source_proc::link, jak2::generic_warp_dest_proc::link,
+       jak2::generic_warp_dest::link, jak2::generic_warp_envmap_dest::link,
+       jak2::generic_no_light_proc::link}}}};
 
 void LinkedFunctionTable::reg(const std::string& name, u64 (*exec)(void*), u32 stack_size) {
   const auto& it = m_executes.insert({name, {exec, Ptr<u8>()}});
diff --git a/goal_src/jak1/engine/gfx/foreground/bones.gc b/goal_src/jak1/engine/gfx/foreground/bones.gc
index 38e27e5881..0006c7d5bb 100644
--- a/goal_src/jak1/engine/gfx/foreground/bones.gc
+++ b/goal_src/jak1/engine/gfx/foreground/bones.gc
@@ -1363,7 +1363,8 @@
                 ;; check if this effect uses "ripple"
                 (when (logtest? (-> geom effect effect-idx effect-bits) 4)
                   (when (-> arg0 ripple)
-                    (if *ripple-force-generic*
+                    ;; fall back to generic if there's a ripple query to respond to.
+                    (if (or *ripple-force-generic* (-> arg0 ripple query))
                       (set! pc-force-mercneric #t)
                       (set! pc-merc-vtx-update #t)
                       )
diff --git a/goal_src/jak2/engine/draw/drawable.gc b/goal_src/jak2/engine/draw/drawable.gc
index 02d5dff51d..18a4dc2d27 100644
--- a/goal_src/jak2/engine/draw/drawable.gc
+++ b/goal_src/jak2/engine/draw/drawable.gc
@@ -1387,7 +1387,7 @@
     (bones-init gp-0)
     (bones-mtx-calc-execute)
     ;; generic-merc/shadow have VU0/CPU parts that need bones, run them here.
-    ;;(generic-merc-execute-all gp-0)
+    (generic-merc-execute-all gp-0)
     ;;(shadow-execute-all gp-0)
     )
   (lightning-draw-all)
diff --git a/goal_src/jak2/engine/gfx/foreground/foreground.gc b/goal_src/jak2/engine/gfx/foreground/foreground.gc
index 5642f2c51a..1237f95ced 100644
--- a/goal_src/jak2/engine/gfx/foreground/foreground.gc
+++ b/goal_src/jak2/engine/gfx/foreground/foreground.gc
@@ -571,13 +571,87 @@
 (defun foreground-shadow ((arg0 draw-control) (arg1 (inline-array pris-mtx)) (arg2 pointer))
   arg2
   )
-;; todo foreground-generic-merc-death
-;; todo foreground-generic-merc-add-fragments
-;; todo foreground-generic-merc
-(defun foreground-generic-merc ((arg0 draw-control) (arg1 pointer) (arg2 int))
+
+(defun foreground-generic-merc-death ((arg0 draw-control) (arg1 generic-merc-ctrl))
+  "Modify a generic-merc-ctrl to set up merc-death effect."
+
+  ;; possibly disable drawing if requested
+  (when (and (>= (the-as int (- (-> arg0 death-timer-org) (-> arg0 death-timer)))
+                 (the-as int (-> arg0 death-draw-overlap))
+                 )
+             (!= (-> arg0 death-draw-overlap) 255)
+             )
+    (set! (-> arg1 header display-triangles) (the-as uint 0))
+    0
+    )
+
+  ;; update the vertices that we're querying.
+  (when (not (paused?))
+    (let ((v1-6 (+ (-> arg0 death-vertex-skip) (rand-vu-int-count (the-as int (-> arg0 death-vertex-skip))))))
+      (set! (-> arg1 header death-vertex-skip) v1-6)
+      (set! (-> arg1 header death-effect) (-> arg0 death-effect))
+      (set! (-> arg1 header death-start-vertex)
+            (/ (* v1-6 (- (-> arg0 death-timer-org) (-> arg0 death-timer))) (-> arg0 death-timer-org))
+            )
+      )
+    )
+  (none)
+  )
+
+(defun foreground-generic-merc-add-fragments ((arg0 merc-effect) (arg1 pointer) (arg2 mercneric-chain))
+  "Add fragments from a merc-effect to the generic chain."
+  (let ((v1-0 (-> arg0 frag-geo))
+        (a3-0 (the-as structure (-> arg0 frag-ctrl)))
+        (a0-1 (-> arg0 frag-count))
+        )
+
+    ;; loop over fragments, adding matrix refs.
+    (dotimes (t0-0 (the-as int a0-1))
+      (let ((t1-2 (+ (* (-> (the-as merc-fragment-control a3-0) mat-xfer-count) 2) 4))
+            (t2-0 (-> v1-0 header mm-quadword-size))
+            )
+        (set! (-> (the-as dma-packet arg1) dma)
+              (new 'static 'dma-tag :id (dma-tag-id ref) :addr (the-as int v1-0) :qwc t2-0)
+              )
+        (set! (-> (the-as dma-packet arg1) vif0) (new 'static 'vif-tag))
+        (set! (-> (the-as dma-packet arg1) vif1) (new 'static 'vif-tag))
+        (when (nonzero? t0-0)
+          (set! (-> (the-as (pointer int32) (-> arg2 next)) 0) (the-as int arg1))
+          (set! (-> arg2 next) (the-as uint (&+ arg1 12)))
+          )
+        (let ((a1-1 (the-as object (&+ arg1 16))))
+          (dotimes (t3-6 (the-as int (-> (the-as merc-fragment-control a3-0) mat-xfer-count)))
+            (let ((t5-4
+                    (-> (scratchpad-object foreground-work)
+                        regs
+                        mtxs
+                        (-> (the-as merc-fragment-control a3-0) mat-dest-data t3-6 matrix-number)
+                        )
+                    )
+                  )
+              (set! (-> (the-as dma-packet a1-1) dma)
+                    (new 'static 'dma-tag :qwc #x7 :id (dma-tag-id ref) :addr (the-as int t5-4))
+                    )
+              )
+            (set! (-> (the-as dma-packet a1-1) vif0) (new 'static 'vif-tag))
+            (set! (-> (the-as dma-packet a1-1) vif1) (new 'static 'vif-tag))
+            (set! a1-1 (&+ (the-as pointer a1-1) 16))
+            )
+          (set! (-> (the-as dma-packet a1-1) dma) (new 'static 'dma-tag :id (dma-tag-id end)))
+          (set! (-> (the-as dma-packet a1-1) vif0) (new 'static 'vif-tag))
+          (set! (-> (the-as dma-packet a1-1) vif1) (new 'static 'vif-tag))
+          (set! arg1 (&+ (the-as pointer a1-1) 16))
+          )
+        (set! a3-0 (&+ a3-0 t1-2))
+        (set! v1-0 (the-as merc-fragment (+ (the-as uint v1-0) (* t2-0 16))))
+        )
+      )
+    )
   arg1
   )
 
+(def-mips2c foreground-generic-merc (function draw-control pointer int pointer))
+
 (def-mips2c foreground-merc (function draw-control (inline-array pris-mtx) pointer int int object pointer))
 
 (define-extern foreground-emerc (function draw-control (inline-array pris-mtx) pointer object int int pointer))
@@ -605,6 +679,7 @@
         ;;(.sll v1-6 v1-5 7)
         (set! v1-6 (shl v1-5 7))
         )
+
       (let ((a0-1 (scratchpad-object foreground-work)))
         ;;(.addu t0-0 arg2 v1-6)
         (set! t0-0 (&+ arg2 v1-6))
@@ -681,7 +756,6 @@
         (dotimes (i 128) (set! (-> transferred-matrices i) 0))
 
         (let ((merc-ctrl (-> dc lod-set lod (-> dc cur-lod) geo)))
-
           ;; loop to: grab matrices and populate flags
           (dotimes (effect-idx (-> merc-ctrl header effect-count))
 
@@ -794,9 +868,11 @@
     ;; look for uses.
     (dotimes (i (-> mctrl header effect-count))
       ;;(format 0 "effect ~d, texture ~d~%" i (-> mctrl effect i texture-index))
-      (set! (-> use-flags (-> mctrl effect i texture-index)) 1)
-      (when (logtest? (-> (-> dc lod-set lod (-> dc cur-lod) geo) effect i effect-bits) (effect-bits ripple texscroll))
-        (set! has-ripple-or-texscroll #t)
+      (when (= 0 (-> *foreground* merc-bucket-info effect i merc-path))
+        (set! (-> use-flags (-> mctrl effect i texture-index)) 1)
+        (when (logtest? (-> (-> dc lod-set lod (-> dc cur-lod) geo) effect i effect-bits) (effect-bits ripple texscroll))
+          (set! has-ripple-or-texscroll #t)
+          )
         )
       )
 
@@ -1190,19 +1266,40 @@
                           )
                         )
 
-                      ;; massive hack use merc for everything..
+                      ;; reassign for PC. For the most part, we reassign everything to merc. The exceptions are:
+                      ;; - "warp" effect is on: this special effect isn't supported by PC merc
+                      ;; - "death" effect is on: this requires the renderer to return transformed vertices.
+                      ;; - "force-mercneric" is on: this is used rarely, and on stuff that doesn't seem to have
+                      ;; - ripple query?
                       (when (or (nonzero? (-> (scratchpad-object foreground-work) regs mercneric-used))
                                 (nonzero? (-> (scratchpad-object foreground-work) regs emerc-used))
                                 )
-                        (set! (-> (scratchpad-object foreground-work) regs mercneric-used) 0)
-                        (set! (-> (scratchpad-object foreground-work) regs emerc-used) 0)
-                        (set! (-> (scratchpad-object foreground-work) regs merc-used) 1)
-                        (dotimes (effect-idx (the-as int (-> geo header effect-count)))
-                          (set! (-> bucket-info effect effect-idx merc-path) 0)
-                          (when (logtest? (-> geo effect effect-idx effect-usage) 1)
-                            (set! (-> bucket-info effect effect-idx ignore-alpha) 1)
-                            )
 
+                        ;; technically we should use generic for ripple query, but the only user is dark eco,
+                        ;; which doesn't actually do anything with the result of the query.
+                        (when #t ;;(not (and (-> dc ripple) (-> dc ripple query)))
+                          (set! (-> (scratchpad-object foreground-work) regs mercneric-used) 0)
+                          (set! (-> (scratchpad-object foreground-work) regs emerc-used) 0)
+                          (set! (-> (scratchpad-object foreground-work) regs merc-used) 1)
+                          (dotimes (effect-idx (the-as int (-> geo header effect-count)))
+                            (cond
+                              ((or (logtest? (-> geo effect effect-idx effect-bits) (effect-bits cross-fade))
+                                   (logtest? (-> geo effect effect-idx effect-bits) (effect-bits force-mercneric))
+                                   (nonzero? (-> dc death-timer))
+                                   )
+                               ;; (format *stdcon* "[fg] ~S to generic~%" (-> dc process name))
+                               (set! (-> bucket-info effect effect-idx merc-path) 2)
+                               (set! (-> (scratchpad-object foreground-work) regs mercneric-used) 1)
+                               )
+                              (else
+                                (set! (-> bucket-info effect effect-idx merc-path) 0)
+                                )
+                              )
+
+                            (when (logtest? (-> geo effect effect-idx effect-usage) 1)
+                              (set! (-> bucket-info effect effect-idx ignore-alpha) 1)
+                              )
+                            )
                           )
                         )
 
diff --git a/goal_src/jak2/engine/gfx/generic/generic-effect.gc b/goal_src/jak2/engine/gfx/generic/generic-effect.gc
index 22bd186cb2..d16db592e3 100644
--- a/goal_src/jak2/engine/gfx/generic/generic-effect.gc
+++ b/goal_src/jak2/engine/gfx/generic/generic-effect.gc
@@ -7,9 +7,246 @@
 
 ;; DECOMP BEGINS
 
+;; definition for symbol *target-lock*, type object
+(define *target-lock* (the-as object 0))
+
+;; definition for symbol *generic-consts*, type generic-consts
+(define *generic-consts*
+  (new 'static 'generic-consts
+    :dma-header (new 'static 'dma-packet
+      :dma (new 'static 'dma-tag :id (dma-tag-id cnt))
+      :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl))
+      :vif1 (new 'static 'vif-tag :cmd (vif-cmd unpack-v4-32))
+      )
+    :vif-header (new 'static 'array uint32 4 #x1000404 #x1000404 #x1000404 #x6c000000)
+    :dma-ref-vtxs (new 'static 'dma-packet :dma (new 'static 'dma-tag :id (dma-tag-id ref)))
+    :dma-cnt-call (new 'static 'dma-packet :dma (new 'static 'dma-tag :id (dma-tag-id cnt)))
+    :matrix (new 'static 'matrix :vector (new 'static 'inline-array vector 4
+                                   (new 'static 'vector :x 1.0)
+                                   (new 'static 'vector :y 1.0)
+                                   (new 'static 'vector :z 1.0)
+                                   (new 'static 'vector :w 1.0)
+                                   )
+                         )
+    :base-strgif (new 'static 'generic-gif-tag
+      :fan-prim (new 'static 'gif-tag-prim
+        :pre #x1
+        :prim (new 'static 'gs-prim :prim (gs-prim-type tri-fan) :iip #x1 :tme #x1 :fge #x1 :abe #x1)
+        :nreg #x3
+        )
+      :str-prim (new 'static 'gif-tag-prim
+        :pre #x1
+        :prim (new 'static 'gs-prim :prim (gs-prim-type tri-strip) :iip #x1 :tme #x1 :fge #x1 :abe #x1)
+        :nreg #x3
+        )
+      :regs (new 'static 'gif-tag-regs-32 :regs0 (gif-reg-id st) :regs1 (gif-reg-id rgbaq) :regs2 (gif-reg-id xyzf2))
+      )
+    :alpha-opaque (new 'static 'gs-adcmd :cmds (gs-reg64 alpha-1))
+    :alpha-translucent (new 'static 'gs-adcmd :cmds (gs-reg64 alpha-1) :x #x44)
+    :ztest-normal (new 'static 'gs-adcmd :cmds (gs-reg64 test-1) :x #x5026b)
+    :ztest-opaque (new 'static 'gs-adcmd :cmds (gs-reg64 test-1) :x #x5000a)
+    :adcmd-offsets (new 'static 'array uint8 16 #x0 #x20 #x20 #x20 #x0 #x30 #x30 #x30 #x0 #x30 #x30 #x30 #x0 #x30 #x30 #x30)
+    :stcycle-tag #x1000103
+    :unpack-vtx-tag #x68000000
+    :unpack-clr-tag #x6e004000
+    :unpack-tex-tag #x65000000
+    :mscal-tag #x14000006
+    :reset-cycle-tag #x1000404
+    :dma-tag-cnt #x10000000
+    :envmap (new 'static 'generic-envmap-consts
+      :consts (new 'static 'vector :x 1.0 :z 0.5 :w 0.5)
+      :strgif (new 'static 'generic-gif-tag
+        :fan-prim (new 'static 'gif-tag-prim
+          :pre #x1
+          :prim (new 'static 'gs-prim :prim (gs-prim-type tri-fan) :iip #x1 :tme #x1 :abe #x1)
+          :nreg #x3
+          )
+        :str-prim (new 'static 'gif-tag-prim
+          :pre #x1
+          :prim (new 'static 'gs-prim :prim (gs-prim-type tri-strip) :iip #x1 :tme #x1 :abe #x1)
+          :nreg #x3
+          )
+        :regs (new 'static 'gif-tag-regs-32 :regs0 (gif-reg-id st) :regs1 (gif-reg-id rgbaq) :regs2 (gif-reg-id xyzf2))
+        )
+      :colors (new 'static 'vector4w :x -2139062144 :y -2139062144 :z -2139062144 :w -2139062144)
+      )
+    :light-consts (new 'static 'vector :x 255.0 :y 8388608.0)
+    )
+  )
+
+(define-extern *default-envmap-shader* adgif-shader)
+
+
+(defun generic-work-init ((arg0 generic-bucket-state))
+  (quad-copy!
+    (the-as pointer (-> (scratchpad-object generic-work) fx-buf work))
+    (the-as pointer *generic-consts*)
+    27
+    )
+  (set! (-> (scratchpad-object generic-work) saves gifbuf-adr) (-> arg0 gifbuf-adr))
+  (set! (-> (scratchpad-object generic-work) saves inbuf-adr) (-> arg0 inbuf-adr))
+  (set! (-> (scratchpad-object generic-work) saves cur-outbuf)
+        (the-as uint (-> (scratchpad-object generic-work) fx-buf))
+        )
+  (let* ((v1-6 *default-envmap-shader*)
+         (a0-9 (-> (scratchpad-object generic-work) fx-buf work consts envmap shader))
+         (a1-2 (-> v1-6 quad 0 quad))
+         (a2-1 (-> v1-6 quad 1 quad))
+         (a3-0 (-> v1-6 quad 2 quad))
+         (t0-0 (-> v1-6 quad 3 quad))
+         (v0-1 (-> v1-6 quad 4 quad))
+         )
+    (set! (-> a0-9 quad 0 quad) a1-2)
+    (set! (-> a0-9 quad 1 quad) a2-1)
+    (set! (-> a0-9 quad 2 quad) a3-0)
+    (set! (-> a0-9 quad 3 quad) t0-0)
+    (set! (-> a0-9 quad 4 quad) v0-1)
+    )
+  (none)
+  )
+
+(defun generic-upload-vu0 ()
+  (none)
+  )
+
+(defun generic-initialize-without-sync ((arg0 matrix) (arg1 vu-lights))
+  ;(upload-vu0-program generic-vu0-block (the-as pointer #x70000054))
+  (let ((a2-0 (-> (scratchpad-object generic-work) fx-buf work consts matrix))
+        (v1-1 (-> arg0 quad 0))
+        (a0-3 (-> arg0 quad 1))
+        (a1-2 (-> arg0 quad 2))
+        (a3-0 (-> arg0 trans quad))
+        )
+    (set! (-> a2-0 quad 0) v1-1)
+    (set! (-> a2-0 quad 1) a0-3)
+    (set! (-> a2-0 quad 2) a1-2)
+    (set! (-> a2-0 trans quad) a3-0)
+    )
+  (if arg1
+      (quad-copy! (the-as pointer (-> (scratchpad-object generic-work) fx-buf work lights)) (the-as pointer arg1) 7)
+      )
+  0
+  (none)
+  )
+
+(defun generic-initialize ((arg0 generic-bucket-state) (arg1 matrix) (arg2 vu-lights))
+  (generic-work-init arg0)
+  (generic-upload-vu0)
+  (let ((a2-1 (-> (scratchpad-object generic-work) fx-buf work consts matrix))
+        (v1-1 (-> arg1 quad 0))
+        (a0-2 (-> arg1 quad 1))
+        (a1-1 (-> arg1 quad 2))
+        (a3-0 (-> arg1 trans quad))
+        )
+    (set! (-> a2-1 quad 0) v1-1)
+    (set! (-> a2-1 quad 1) a0-2)
+    (set! (-> a2-1 quad 2) a1-1)
+    (set! (-> a2-1 trans quad) a3-0)
+    )
+  (if arg2
+      (quad-copy! (the-as pointer (-> (scratchpad-object generic-work) fx-buf work lights)) (the-as pointer arg2) 7)
+      )
+  0
+  (none)
+  )
+
+(defun generic-wrapup ((arg0 generic-bucket-state))
+  (set! (-> arg0 gifbuf-adr) (-> (scratchpad-object generic-work) saves gifbuf-adr))
+  (set! (-> arg0 inbuf-adr) (-> (scratchpad-object generic-work) saves inbuf-adr))
+  (none)
+  )
 
 (defun upload-vu0-program ((func vu-function) (wait-ptr pointer))
   "Upload and block until done.
    Generating the DMA is highly optimized."
   (none)
   )
+
+
+;; definition for function generic-dma-from-spr
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function generic-light-proc
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-light-proc function)
+
+;; definition for function generic-envmap-proc
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-envmap-proc function)
+
+;; definition for function generic-prepare-dma-double
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-prepare-dma-double function)
+
+;; definition for function generic-prepare-dma-single
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-prepare-dma-single function)
+
+;; definition for function generic-envmap-dproc
+;; ERROR: function has no type analysis. Cannot decompile.
+
+;; definition for function generic-interp-dproc
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function generic-no-light-proc
+;; ERROR: function has no type analysis. Cannot decompile.
+
+;; definition for function generic-no-light-dproc-only
+;; ERROR: function has no type analysis. Cannot decompile.
+
+;; definition for function generic-no-light-dproc
+;; ERROR: function has no type analysis. Cannot decompile.
+
+;; definition for function generic-no-light+envmap
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function generic-no-light
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function generic-envmap-only-proc
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function generic-light
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function generic-copy-vtx-dclr-dtex
+;; ERROR: function has no type analysis. Cannot decompile.
+
+;; definition for function generic-none
+;; ERROR: function has no type analysis. Cannot decompile.
+
+;; definition for function generic-none-dma-wait
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for symbol *warp-data*, type object
+(define *warp-data* (the-as object (malloc 'global 1024)))
+
+;; definition for function generic-warp-source-proc
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-warp-source-proc (function none))
+
+;; definition for function generic-warp-source
+;; ERROR: Unsupported inline assembly instruction kind - [lui at, 28672]
+(defun generic-warp-source ((arg0 gsf-buffer))
+  (set! (-> (scratchpad-object generic-work) saves gsf-buf) arg0)
+  (generic-warp-source-proc)
+  (none)
+  )
+
+;; definition for function generic-warp-dest-proc
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-warp-dest-proc function)
+
+;; definition for function generic-warp-dest
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-warp-dest function)
+
+;; definition for function generic-warp-envmap-dest
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-warp-envmap-dest function)
+
+;; definition for function generic-debug-light-proc
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition (debug) for function generic-post-debug
+;; ERROR: function has no type analysis. Cannot decompile.
diff --git a/goal_src/jak2/engine/gfx/generic/generic-merc.gc b/goal_src/jak2/engine/gfx/generic/generic-merc.gc
index fc60b15aad..9eaaf8ca4a 100644
--- a/goal_src/jak2/engine/gfx/generic/generic-merc.gc
+++ b/goal_src/jak2/engine/gfx/generic/generic-merc.gc
@@ -7,3 +7,129 @@
 
 ;; DECOMP BEGINS
 
+(define mercneric-vu0-block (new 'static 'vu-function #|:length #xbe :origin #x118 :qlength 95|#))
+
+(deftype invinitdata (structure)
+  ((count     uint8   :offset-assert   0)
+   (init-data uint8   :offset-assert   1)
+   (init-addr uint16  :offset-assert   2)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+(define *inv-init-table* (new 'static 'inline-array invinitdata 8
+                           (new 'static 'invinitdata :count #x48 :init-addr #x1)
+                           (new 'static 'invinitdata :count #x43 :init-data #xc :init-addr #x11)
+                           (new 'static 'invinitdata :count #x3d :init-data #x18 :init-addr #x21)
+                           (new 'static 'invinitdata :count #x38 :init-data #x22 :init-addr #xe0)
+                           (new 'static 'invinitdata :count #x38 :init-data #x24 :init-addr #xe1)
+                           (new 'static 'invinitdata :count #x33 :init-data #x30 :init-addr #xf1)
+                           (new 'static 'invinitdata :count #x2e :init-data #x3a :init-addr #x190)
+                           (new 'static 'invinitdata :count #x2d :init-data #x3c :init-addr #x191)
+                           )
+        )
+
+
+;; definition for function generic-merc-init-asm
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-merc-init-asm (function none))
+
+;; definition for function mercneric-matrix-asm
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function mercneric-shader-asm
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function mercneric-bittable-asm
+;; ERROR: function has no type analysis. Cannot decompile.
+
+;; definition for function mercneric-convert
+;; INFO: function output is handled by mips2c
+(def-mips2c mercneric-convert function)
+
+;; definition for function high-speed-reject
+;; INFO: function output is handled by mips2c
+(def-mips2c high-speed-reject function)
+
+;; definition for function generic-translucent
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-translucent (function gsf-buffer none))
+
+;; definition for function generic-merc-query
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-merc-query function)
+
+;; definition for function generic-merc-death
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-merc-death function)
+
+;; definition for function generic-merc-execute-asm
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-merc-execute-asm function)
+
+;; definition for function generic-merc-do-chain
+;; INFO: function output is handled by mips2c
+(def-mips2c generic-merc-do-chain (function mercneric-chain dma-buffer pointer))
+
+
+(defun generic-merc-execute-all ((arg0 dma-buffer))
+  "Run EE processing on all generic merc chains."
+  (let ((s4-0 (-> *foreground* foreground-grid))
+        (gp-0 (-> *display* frames (-> *display* on-screen) global-buf base))
+        )
+
+    (with-profiler 'generic-merc *profile-generic-merc-color*
+      ;; reset profiling
+      (reset! (-> *perf-stats* data (perf-stat-bucket mercneric)))
+      (set! (-> (scratchpad-object generic-work) saves to-vu0-waits) (the-as uint 0))
+      (set! (-> (scratchpad-object generic-work) saves to-spr-waits) (the-as uint 0))
+      (set! (-> (scratchpad-object generic-work) saves from-spr-waits) (the-as uint 0))
+      (flush-cache 0)
+
+      ;; init generic
+      (generic-initialize-without-sync (-> *math-camera* perspective) *default-lights*)
+      (generic-merc-init-asm)
+      (set! (-> (scratchpad-object generic-work) in-buf merc shadow write-limit) (the-as int (&+ (-> arg0 end) -262144)))
+
+      ;; loop over grid of chains (levels x textures) and do the chain.
+      (dotimes (s3-1 7)
+        (dotimes (s2-1 7)
+          (generic-merc-do-chain (-> s4-0 level-buckets s3-1 data s2-1 mercneric) arg0)
+          )
+        )
+
+      ;; do separate warp chain
+      (generic-merc-do-chain (-> s4-0 warp-chain) arg0)
+
+      ;; finish profiling
+      (read! (-> *perf-stats* data (perf-stat-bucket mercneric)))
+      (update-wait-stats
+        (-> *perf-stats* data 38)
+        (-> (scratchpad-object generic-work) saves to-vu0-waits)
+        (-> (scratchpad-object generic-work) saves to-spr-waits)
+        (-> (scratchpad-object generic-work) saves from-spr-waits)
+        )
+      )
+
+    ;; update dma memory usage stats.
+    (let ((v1-66 *dma-mem-usage*))
+      (when (nonzero? v1-66)
+        (set! (-> v1-66 length) (max 90 (-> v1-66 length)))
+        (set! (-> v1-66 data 89 name) "pris-generic")
+        (+! (-> v1-66 data 89 count) 1)
+        (+! (-> v1-66 data 89 used)
+            (&- (-> *display* frames (-> *display* on-screen) global-buf base) (the-as uint gp-0))
+            )
+        (set! (-> v1-66 data 89 total) (-> v1-66 data 89 used))
+        )
+      )
+    )
+  (none)
+  )
+
+
+
+
diff --git a/goal_src/jak2/engine/gfx/generic/generic-vu1.gc b/goal_src/jak2/engine/gfx/generic/generic-vu1.gc
index 736483c6ad..cd955d88cf 100644
--- a/goal_src/jak2/engine/gfx/generic/generic-vu1.gc
+++ b/goal_src/jak2/engine/gfx/generic/generic-vu1.gc
@@ -114,27 +114,28 @@
   (none)
   )
 
-; (defun generic-vu1-init-buf-special ((arg0 bucket-id) (arg1 gs-zbuf))
-;   (let ((s5-0 (-> *display* frames (-> *display* on-screen) bucket-group arg0)))
-;     (when (!= s5-0 (-> s5-0 last))
-;       (let* ((s4-0 (-> *display* frames (-> *display* on-screen) global-buf))
-;              (s3-1 (-> s4-0 base))
-;              )
-;         (fx-copy-buf s4-0)
-;         (generic-init-buf s4-0 arg1)
-;         (let ((v1-12 (-> s4-0 base)))
-;           (set! (-> (the-as (pointer uint64) v1-12)) (logior #x20000000 (shr (shl (-> s5-0 next) 33) 1)))
-;           (s.w! (+ v1-12 8) 0)
-;           (s.w! (+ v1-12 12) 0)
-;           (set! (-> s4-0 base) (&+ v1-12 16))
-;           )
-;         (set! (-> s5-0 next) (the-as uint s3-1))
-;         )
-;       )
-;     )
-;   0
-;   (none)
-;   )
+(defun generic-vu1-init-buf-special ((arg0 bucket-id) (arg1 gs-zbuf))
+  (let ((s5-0 (-> *display* frames (-> *display* on-screen) bucket-group arg0)))
+    (when (!= s5-0 (-> s5-0 last))
+      (let* ((s4-0 (-> *display* frames (-> *display* on-screen) global-buf))
+             (s3-1 (-> s4-0 base))
+             )
+        ;; this is like the normal one, but runs fx-copy-buf first, copying the framebuffer.
+        ;(fx-copy-buf s4-0)
+        (generic-init-buf s4-0 arg1)
+        (let ((v1-12 (the-as dma-packet (-> s4-0 base))))
+          (set! (-> v1-12 dma) (new 'static 'dma-tag :id (dma-tag-id next) :addr (-> s5-0 next)))
+          (set! (-> v1-12 vif0) (new 'static 'vif-tag))
+          (set! (-> v1-12 vif1) (new 'static 'vif-tag))
+          (set! (-> s4-0 base) (the-as pointer (&+ v1-12 16)))
+          )
+        (set! (-> s5-0 next) (the-as uint s3-1))
+        )
+      )
+    )
+  0
+  (none)
+  )
 
 ;; definition for function generic-vu1-init-buffers
 (defun generic-vu1-init-buffers ()
@@ -186,8 +187,7 @@
           )
         (generic-vu1-init-buf (bucket-id effects) gp-0)
         )
-      ;; no warp yet
-      ;(generic-vu1-init-buf-special (bucket-id gmerc-warp) s5-0)
+      (generic-vu1-init-buf-special (bucket-id gmerc-warp) s5-0)
       )
     )
   (none)
diff --git a/goal_src/jak2/engine/gfx/texture/texture-h.gc b/goal_src/jak2/engine/gfx/texture/texture-h.gc
index 8e0e0e75d2..e2709d9185 100644
--- a/goal_src/jak2/engine/gfx/texture/texture-h.gc
+++ b/goal_src/jak2/engine/gfx/texture/texture-h.gc
@@ -218,7 +218,8 @@
 ;; a pointer to an adgif-shader, stored in bits 8-32. This allows them to fit into
 ;; an adgif shader easily.
 (deftype shader-ptr (uint32)
-  ((shader uint32 :offset   8 :size  24)
+  ((first-8 uint8 :offset 0 :size 8) ;; added
+   (shader uint32 :offset   8 :size  24)
    )
   :method-count-assert 9
   :size-assert         #x4
diff --git a/goal_src/jak2/engine/gfx/warp.gc b/goal_src/jak2/engine/gfx/warp.gc
index 5e1f88dbfb..dce0921bd0 100644
--- a/goal_src/jak2/engine/gfx/warp.gc
+++ b/goal_src/jak2/engine/gfx/warp.gc
@@ -7,3 +7,19 @@
 
 ;; DECOMP BEGINS
 
+(define *warp-shader* (new 'static 'adgif-shader
+                        :reg-0 #x6
+                        :reg-1 #x14
+                        :reg-3 #x8
+                        :reg-4-u32 (gs-reg32 alpha-1)
+                        :tex0 (new 'static 'gs-tex0 :tbp0 #x4c0 :tbw #x8 :tw #x9 :th #x9 :tcc #x1)
+                        :tex1 (new 'static 'gs-tex1 :mmag #x1)
+                        :clamp (new 'static 'gs-clamp
+                          :wms (gs-tex-wrap-mode region-clamp)
+                          :wmt (gs-tex-wrap-mode region-clamp)
+                          :maxu #x1ff
+                          :maxv #x19f
+                          )
+                        :next (new 'static 'shader-ptr :first-8 #x34)
+                        )
+        )
\ No newline at end of file
diff --git a/goal_src/jak2/levels/underport/underb-master.gc b/goal_src/jak2/levels/underport/underb-master.gc
index f8ebe79e95..0a394527cc 100644
--- a/goal_src/jak2/levels/underport/underb-master.gc
+++ b/goal_src/jak2/levels/underport/underb-master.gc
@@ -188,8 +188,7 @@
         (not (-> *setting-control* user-current pilot-exit))
         )
        (('bubbler)
-        ;; TODO warp effect
-        (and ;; (handle->process (-> self warp-handle))
+        (and (handle->process (-> self warp-handle))
              (or (and (-> self next-state) (= (-> self next-state name) 'idle)) (not (under-warp-check self)))
              )
         )
@@ -230,19 +229,18 @@
           ((-> arg3 param 1)
            (set-under-fog-interp! 1.0)
            (when (not (handle->process (-> self warp-handle)))
-             ;; TODO warp effect
-             ;; (let ((s2-0 (camera-matrix))
-             ;;       (s3-0 (new 'stack-no-clear 'vector))
-             ;;       (gp-0 (new 'stack-no-clear 'vector))
-             ;;       (s5-0 (new 'stack-no-clear 'quaternion))
-             ;;       )
-             ;;   (set! (-> gp-0 quad) (-> (camera-pos) quad))
-             ;;   (vector-normalize-copy! s3-0 (-> s2-0 vector 2) 1.0)
-             ;;   (matrix->quaternion s5-0 s2-0)
-             ;;   (set! (-> self warp-handle)
-             ;;         (ppointer->handle (process-spawn under-warp gp-0 s5-0 (-> self level) :to *display-pool*))
-             ;;         )
-             ;;   )
+             (let ((s2-0 (camera-matrix))
+                   (s3-0 (new 'stack-no-clear 'vector))
+                   (gp-0 (new 'stack-no-clear 'vector))
+                   (s5-0 (new 'stack-no-clear 'quaternion))
+                   )
+               (set! (-> gp-0 quad) (-> (camera-pos) quad))
+               (vector-normalize-copy! s3-0 (-> s2-0 vector 2) 1.0)
+               (matrix->quaternion s5-0 s2-0)
+               (set! (-> self warp-handle)
+                     (ppointer->handle (process-spawn under-warp gp-0 s5-0 (-> self level) :to *display-pool*))
+                     )
+               )
              (set! v0-0 (sound-play "mech-under-amb"))
              (set! (-> self ambient-sound-id) (the-as sound-id v0-0))
              v0-0
diff --git a/test/decompiler/reference/jak2/engine/gfx/texture/texture-h_REF.gc b/test/decompiler/reference/jak2/engine/gfx/texture/texture-h_REF.gc
index d6a264e4fe..92a0afbe49 100644
--- a/test/decompiler/reference/jak2/engine/gfx/texture/texture-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/texture/texture-h_REF.gc
@@ -330,7 +330,8 @@
 
 ;; definition of type shader-ptr
 (deftype shader-ptr (uint32)
-  ((shader uint32 :offset   8 :size  24)
+  ((first-8 uint8  :offset   0 :size   8)
+   (shader  uint32 :offset   8 :size  24)
    )
   :method-count-assert 9
   :size-assert         #x4