diff --git a/decompiler/config/jak3/ntsc_v1/hacks.jsonc b/decompiler/config/jak3/ntsc_v1/hacks.jsonc
index 25223ccee9..3f7552a479 100644
--- a/decompiler/config/jak3/ntsc_v1/hacks.jsonc
+++ b/decompiler/config/jak3/ntsc_v1/hacks.jsonc
@@ -580,7 +580,8 @@
     "(method 9 prim-strip)",
     "live-func-curve",
     "birth-func-curve",
-    "sparticle-motion-blur-dirt"
+    "sparticle-motion-blur-dirt",
+    "foreground-draw-hud"
   ],
 
   "mips2c_jump_table_functions": {},
diff --git a/decompiler/config/jak3/ntsc_v1/label_types.jsonc b/decompiler/config/jak3/ntsc_v1/label_types.jsonc
index f2a568cb43..009f340e27 100644
--- a/decompiler/config/jak3/ntsc_v1/label_types.jsonc
+++ b/decompiler/config/jak3/ntsc_v1/label_types.jsonc
@@ -390,7 +390,7 @@
   "hud": [["L240", "vector"]],
   "hud-classes": [
     ["L205", "(inline-array hud-sprite)", 24],
-    ["L214", "(inline-array vector)", 4]
+    ["L214", "(inline-array vector)", 16]
   ],
   "level": [
     ["L1004", "uint64", true],
diff --git a/game/graphics/opengl_renderer/sprite/Sprite3.cpp b/game/graphics/opengl_renderer/sprite/Sprite3.cpp
index 7a1a846b6b..26dcd206eb 100644
--- a/game/graphics/opengl_renderer/sprite/Sprite3.cpp
+++ b/game/graphics/opengl_renderer/sprite/Sprite3.cpp
@@ -837,7 +837,7 @@ void Sprite3::do_block_common(SpriteMode mode,
       if ((flag & 0x10) || (flag & 0x20)) {
         // these flags mean we need to swap vertex order around - not yet implemented since it's too
         // hard to get right without this code running.
-        ASSERT_NOT_REACHED();
+        // ASSERT_NOT_REACHED();
       }
     }
 
diff --git a/game/mips2c/jak3_functions/debug.cpp b/game/mips2c/jak3_functions/debug.cpp
index b32a840809..7d1afca2ba 100644
--- a/game/mips2c/jak3_functions/debug.cpp
+++ b/game/mips2c/jak3_functions/debug.cpp
@@ -560,6 +560,8 @@ u64 execute(void* ctxt) {
   if (bc) {goto block_2;}                           // branch non-likely
 
   // Unknown instr: jr t9
+  draw_boundary_polygon::execute(ctxt);
+  goto end_of_function;
   // nop                                            // sll r0, r0, 0
 
 block_2:
@@ -572,6 +574,7 @@ block_2:
   c->sqc2(vf6, 176, a3);                            // sqc2 vf6, 176(a3)
   // nop                                            // sll r0, r0, 0
   // Unknown instr: jr t9
+  draw_boundary_polygon::execute(ctxt);
   // nop                                            // sll r0, r0, 0
   //jr ra                                           // jr ra
   c->daddu(sp, sp, r0);                             // daddu sp, sp, r0
diff --git a/game/mips2c/jak3_functions/foreground.cpp b/game/mips2c/jak3_functions/foreground.cpp
index 4177276409..8053ef7679 100644
--- a/game/mips2c/jak3_functions/foreground.cpp
+++ b/game/mips2c/jak3_functions/foreground.cpp
@@ -1352,3 +1352,313 @@ void link() {
 } // namespace Mips2C
 // add foreground_generic_merc::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/jak3/kscheme.h"
+using ::jak3::intern_from_c;
+namespace Mips2C::jak3 {
+namespace foreground_draw_hud {
+struct Cache {
+  void* bone_calculation_list; // *bone-calculation-list*
+  void* display; // *display*
+  void* fake_scratchpad_data; // *fake-scratchpad-data*
+  void* foreground; // *foreground*
+  void* foreground_generic_merc; // foreground-generic-merc
+} 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->sd(fp, 8, sp);                                 // sd fp, 8(sp)
+  c->mov64(fp, t9);                                 // or fp, t9, r0
+  get_fake_spad_addr2(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
+  c->lwu(a2, 4, a1);                                // lwu a2, 4(a1)
+  c->daddiu(v1, a2, 64);                            // daddiu v1, a2, 64
+  c->andi(a3, v1, 48);                              // andi a3, v1, 48
+  bc = c->sgpr64(a3) == 0;                          // beq a3, r0, L2
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_2;}                           // branch non-likely
+
+  c->daddiu(v1, v1, 64);                            // daddiu v1, v1, 64
+  c->dsubu(v1, v1, a3);                             // dsubu v1, v1, a3
+  
+block_2:
+  c->lwu(a3, 16, a0);                               // lwu a3, 16(a0)
+  c->lw(a3, 8, a3);                                 // lw a3, 8(a3)
+  c->daddiu(t1, a3, 3);                             // daddiu t1, a3, 3
+  c->dsll(a3, t1, 7);                               // dsll a3, t1, 7
+  get_fake_spad_addr2(t0, cache.fake_scratchpad_data, 0, c);// lui t0, 28672
+  c->daddu(t0, r0, t0);                             // daddu t0, r0, t0
+  c->lwu(t2, 12, a0);                               // lwu t2, 12(a0)
+  c->lwu(t2, 44, t2);                               // lwu t2, 44(t2)
+  c->sw(t2, 24, t0);                                // sw t2, 24(t0)
+  c->lwu(t2, 24, a0);                               // lwu t2, 24(a0)
+  c->daddiu(t2, t2, 12);                            // daddiu t2, t2, 12
+  c->sw(t2, 28, t0);                                // sw t2, 28(t0)
+  c->sw(t1, 32, t0);                                // sw t1, 32(t0)
+  c->mtc1(f0, r0);                                  // mtc1 f0, r0
+  c->swc1(f0, 0, t0);                               // swc1 f0, 0(t0)
+  c->sw(a1, 40, t0);                                // sw a1, 40(t0)
+  c->addiu(a1, r0, 336);                            // addiu a1, r0, 336
+  c->lbu(t1, 90, a0);                               // lbu t1, 90(a0)
+  get_fake_spad_addr2(t2, cache.fake_scratchpad_data, 0, c);// lui t2, 28672
+  c->daddu(t1, t1, t2);                             // daddu t1, t1, t2
+  c->lbu(t1, 64, t1);                               // lbu t1, 64(t1)
+  c->multu3(a1, a1, t1);                            // multu3 a1, a1, t1
+  c->daddiu(a1, a1, 80);                            // daddiu a1, a1, 80
+  get_fake_spad_addr2(t1, cache.fake_scratchpad_data, 0, c);// lui t1, 28672
+  c->daddu(a1, a1, t1);                             // daddu a1, a1, t1
+  c->sw(a1, 52, t0);                                // sw a1, 52(t0)
+  c->mov64(t1, v1);                                 // or t1, v1, r0
+  c->addiu(t2, r0, 2);                              // addiu t2, r0, 2
+  get_fake_spad_addr2(a1, cache.fake_scratchpad_data, 0, c);// lui a1, 28672
+  c->daddu(t5, r0, a1);                             // daddu t5, r0, a1
+  c->load_symbol2(a1, cache.bone_calculation_list); // lw a1, *bone-calculation-list*(s7)
+  c->mov64(t0, a2);                                 // or t0, a2, r0
+  c->lwu(t3, 24, t5);                               // lwu t3, 24(t5)
+  c->lwu(t4, 28, t5);                               // lwu t4, 28(t5)
+  c->lwu(t5, 32, t5);                               // lwu t5, 32(t5)
+  c->mov64(t6, t0);                                 // or t6, t0, r0
+  c->sh(t2, 0, t6);                                 // sh t2, 0(t6)
+  c->sh(t5, 2, t6);                                 // sh t5, 2(t6)
+  c->sw(t1, 4, t6);                                 // sw t1, 4(t6)
+  c->sw(t3, 8, t6);                                 // sw t3, 8(t6)
+  c->sw(t4, 12, t6);                                // sw t4, 12(t6)
+  c->sw(r0, 32, t6);                                // sw r0, 32(t6)
+  c->lwu(t1, 4, a1);                                // lwu t1, 4(a1)
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L3
+  c->mov64(t1, s7);                                 // or t1, s7, r0
+  if (bc) {goto block_4;}                           // branch non-likely
+
+  c->lwu(t1, 4, a1);                                // lwu t1, 4(a1)
+  c->sw(t0, 32, t1);                                // sw t0, 32(t1)
+  c->mov64(t1, t0);                                 // or t1, t0, r0
+  
+block_4:
+  c->lwu(t1, 0, a1);                                // lwu t1, 0(a1)
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L4
+  c->mov64(t1, s7);                                 // or t1, s7, r0
+  if (bc) {goto block_6;}                           // branch non-likely
+
+  c->sw(t0, 0, a1);                                 // sw t0, 0(a1)
+  c->mov64(t1, t0);                                 // or t1, t0, r0
+  
+block_6:
+  c->sw(t0, 4, a1);                                 // sw t0, 4(a1)
+  c->daddiu(a1, a2, 48);                            // daddiu a1, a2, 48
+  c->daddu(a1, v1, a3);                             // daddu a1, v1, a3
+  c->sw(v1, 36, at);                                // sw v1, 36(at)
+  c->load_symbol2(v1, cache.foreground);            // lw v1, *foreground*(s7)
+  c->daddiu(v1, v1, 3728);                          // daddiu v1, v1, 3728
+  c->addiu(a2, r0, 1);                              // addiu a2, r0, 1
+  c->lbu(a3, 6, a0);                                // lbu a3, 6(a0)
+  bc = c->sgpr64(a3) != c->sgpr64(a2);              // bne a3, a2, L14
+  c->mov64(a2, s7);                                 // or a2, s7, r0
+  if (bc) {goto block_25;}                          // branch non-likely
+
+  c->lwu(a2, 28, a0);                               // lwu a2, 28(a0)
+  c->addiu(a3, r0, 0);                              // addiu a3, r0, 0
+  //beq r0, r0, L13                                 // beq r0, r0, L13
+  // nop                                            // sll r0, r0, 0
+  goto block_22;                                    // branch always
+
+  
+block_8:
+  c->dsll(t0, a3, 5);                               // dsll t0, a3, 5
+  c->daddiu(t0, t0, 172);                           // daddiu t0, t0, 172
+  c->daddu(t0, t0, a2);                             // daddu t0, t0, a2
+  c->lbu(t0, 27, t0);                               // lbu t0, 27(t0)
+  c->andi(t0, t0, 1);                               // andi t0, t0, 1
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L9
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_17;}                          // branch non-likely
+
+  c->daddu(t1, r0, v1);                             // daddu t1, r0, v1
+  c->addiu(t0, r0, 3824);                           // addiu t0, r0, 3824
+  get_fake_spad_addr2(t2, cache.fake_scratchpad_data, 0, c);// lui t2, 28672
+  c->daddu(t2, t0, t2);                             // daddu t2, t0, t2
+  c->addiu(t0, r0, 7);                              // addiu t0, r0, 7
+  c->daddiu(t3, t0, -4);                            // daddiu t3, t0, -4
+  c->mov64(t1, t1);                                 // or t1, t1, r0
+  bc = ((s64)c->sgpr64(t3)) < 0;                    // bltz t3, L7
+  c->mov64(t2, t2);                                 // or t2, t2, r0
+  if (bc) {goto block_11;}                          // branch non-likely
+
+  
+block_10:
+  // nop                                            // sll r0, r0, 0
+  c->lq(t6, 0, t2);                                 // lq t6, 0(t2)
+  // nop                                            // sll r0, r0, 0
+  c->lq(t3, 16, t2);                                // lq t3, 16(t2)
+  c->daddiu(t0, t0, -4);                            // daddiu t0, t0, -4
+  c->lq(t4, 32, t2);                                // lq t4, 32(t2)
+  c->daddiu(t1, t1, 64);                            // daddiu t1, t1, 64
+  c->lq(t5, 48, t2);                                // lq t5, 48(t2)
+  c->daddiu(t2, t2, 64);                            // daddiu t2, t2, 64
+  c->sq(t6, -64, t1);                               // sq t6, -64(t1)
+  c->daddiu(t6, t0, -4);                            // daddiu t6, t0, -4
+  c->sq(t3, -48, t1);                               // sq t3, -48(t1)
+  // nop                                            // sll r0, r0, 0
+  c->sq(t4, -32, t1);                               // sq t4, -32(t1)
+  bc = ((s64)c->sgpr64(t6)) >= 0;                   // bgez t6, L6
+  c->sq(t5, -16, t1);                               // sq t5, -16(t1)
+  if (bc) {goto block_10;}                          // branch non-likely
+
+  
+block_11:
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L8
+  c->lq(t3, 0, t2);                                 // lq t3, 0(t2)
+  if (bc) {goto block_16;}                          // branch non-likely
+
+  c->daddiu(t2, t2, 16);                            // daddiu t2, t2, 16
+  c->daddiu(t1, t1, 16);                            // daddiu t1, t1, 16
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(t3, -16, t1);                               // sq t3, -16(t1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L8
+  c->lq(t3, 0, t2);                                 // lq t3, 0(t2)
+  if (bc) {goto block_16;}                          // branch non-likely
+
+  c->daddiu(t2, t2, 16);                            // daddiu t2, t2, 16
+  c->daddiu(t1, t1, 16);                            // daddiu t1, t1, 16
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(t3, -16, t1);                               // sq t3, -16(t1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L8
+  c->lq(t3, 0, t2);                                 // lq t3, 0(t2)
+  if (bc) {goto block_16;}                          // branch non-likely
+
+  c->daddiu(t2, t2, 16);                            // daddiu t2, t2, 16
+  c->daddiu(t1, t1, 16);                            // daddiu t1, t1, 16
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(t3, -16, t1);                               // sq t3, -16(t1)
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L8
+  c->lq(t3, 0, t2);                                 // lq t3, 0(t2)
+  if (bc) {goto block_16;}                          // branch non-likely
+
+  c->daddiu(t2, t2, 16);                            // daddiu t2, t2, 16
+  c->daddiu(t1, t1, 16);                            // daddiu t1, t1, 16
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  c->sq(t3, -16, t1);                               // sq t3, -16(t1)
+  
+block_16:
+  c->gprs[t0].du64[0] = 0;                          // or t0, r0, r0
+  // Unknown instr: ld t0, L217(fp)
+  c->dsll(t1, a3, 3);                               // dsll t1, a3, 3
+  c->daddu(t1, v1, t1);                             // daddu t1, v1, t1
+  c->sw(t0, 124, t1);                               // sw t0, 124(t1)
+  c->addiu(t0, r0, 2);                              // addiu t0, r0, 2
+  c->dsll(t1, a3, 3);                               // dsll t1, a3, 3
+  c->daddu(t1, v1, t1);                             // daddu t1, v1, t1
+  c->sb(t0, 128, t1);                               // sb t0, 128(t1)
+  //beq r0, r0, L10                                 // beq r0, r0, L10
+  // nop                                            // sll r0, r0, 0
+  goto block_18;                                    // branch always
+
+  
+block_17:
+  c->addiu(t0, r0, 2);                              // addiu t0, r0, 2
+  c->dsll(t1, a3, 3);                               // dsll t1, a3, 3
+  c->daddu(t1, v1, t1);                             // daddu t1, v1, t1
+  c->sb(t0, 128, t1);                               // sb t0, 128(t1)
+  
+block_18:
+  c->dsll(t0, a3, 3);                               // dsll t0, a3, 3
+  c->daddu(t0, v1, t0);                             // daddu t0, v1, t0
+  c->sb(r0, 130, t0);                               // sb r0, 130(t0)
+  c->dsll(t0, a3, 5);                               // dsll t0, a3, 5
+  c->daddu(t0, a2, t0);                             // daddu t0, a2, t0
+  c->lbu(t0, 189, t0);                              // lbu t0, 189(t0)
+  c->andi(t0, t0, 128);                             // andi t0, t0, 128
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L11
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_20;}                          // branch non-likely
+
+  c->addiu(t0, r0, 1);                              // addiu t0, r0, 1
+  //beq r0, r0, L12                                 // beq r0, r0, L12
+  // nop                                            // sll r0, r0, 0
+  goto block_21;                                    // branch always
+
+  
+block_20:
+  c->addiu(t0, r0, 0);                              // addiu t0, r0, 0
+  
+block_21:
+  c->dsll(t1, a3, 3);                               // dsll t1, a3, 3
+  c->daddu(t1, v1, t1);                             // daddu t1, v1, t1
+  c->sb(t0, 129, t1);                               // sb t0, 129(t1)
+  c->daddiu(a3, a3, 1);                             // daddiu a3, a3, 1
+  
+block_22:
+  c->lwu(t0, 68, a2);                               // lwu t0, 68(a2)
+  c->slt(t0, a3, t0);                               // slt t0, a3, t0
+  bc = c->sgpr64(t0) != 0;                          // bne t0, r0, L5
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_8;}                           // branch non-likely
+
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  c->load_symbol2(v1, cache.display);               // lw v1, *display*(s7)
+  c->ld(v1, 164, v1);                               // ld v1, 164(v1)
+  c->andi(v1, v1, 16384);                           // andi v1, v1, 16384
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L14
+  c->mov64(v1, s7);                                 // or v1, s7, r0
+  if (bc) {goto block_25;}                          // branch non-likely
+
+  c->load_symbol2(t9, cache.foreground_generic_merc);// lw t9, foreground-generic-merc(s7)
+  c->addiu(a2, r0, 1);                              // addiu a2, r0, 1
+  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(a1, v0);                                 // or a1, v0, r0
+  c->mov64(v1, a1);                                 // or v1, a1, r0
+  
+block_25:
+  c->andi(v1, a1, 48);                              // andi v1, a1, 48
+  c->mov128_gpr_gpr(a0, r0);                        // por a0, r0, r0
+  bc = c->sgpr64(v1) == 0;                          // beq v1, r0, L15
+  c->lui(a0, 8192);                                 // lui a0, 8192
+  if (bc) {goto block_27;}                          // branch non-likely
+
+  c->sq(a0, 0, a1);                                 // sq a0, 0(a1)
+  c->mov64(a0, a1);                                 // or a0, a1, r0
+  c->dsubu(v1, a1, v1);                             // dsubu v1, a1, v1
+  c->daddiu(a1, v1, 64);                            // daddiu a1, v1, 64
+  c->sw(a1, 4, a0);                                 // sw a1, 4(a0)
+  
+block_27:
+  c->lui(v1, 4095);                                 // lui v1, 4095
+  c->ori(v1, v1, 65535);                            // ori v1, v1, 65535
+  c->and_(v1, a1, v1);                              // and v1, a1, v1
+  get_fake_spad_addr2(a0, cache.fake_scratchpad_data, 0, c);// lui a0, 28672
+  c->lwu(a0, 40, a0);                               // lwu a0, 40(a0)
+  c->sw(v1, 4, a0);                                 // sw v1, 4(a0)
+  c->gprs[v0].du64[0] = 0;                          // or v0, r0, r0
+  c->ld(ra, 0, sp);                                 // ld ra, 0(sp)
+  c->ld(fp, 8, sp);                                 // ld fp, 8(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
+  // nop                                            // sll r0, r0, 0
+end_of_function:
+  return c->gprs[v0].du64[0];
+}
+
+void link() {
+  cache.bone_calculation_list = intern_from_c(-1, 0, "*bone-calculation-list*").c();
+  cache.display = intern_from_c(-1, 0, "*display*").c();
+  cache.fake_scratchpad_data = intern_from_c(-1, 0, "*fake-scratchpad-data*").c();
+  cache.foreground = intern_from_c(-1, 0, "*foreground*").c();
+  cache.foreground_generic_merc = intern_from_c(-1, 0, "foreground-generic-merc").c();
+  gLinkedFunctionTable.reg("foreground-draw-hud", execute, 256);
+}
+
+} // namespace foreground_draw_hud
+} // namespace Mips2C
+// add foreground_draw_hud::link to the link callback table for the object file.
+// FWD DEC:
diff --git a/game/mips2c/jak3_functions/sky.cpp b/game/mips2c/jak3_functions/sky.cpp
index b32f32d3bb..e807d114b2 100644
--- a/game/mips2c/jak3_functions/sky.cpp
+++ b/game/mips2c/jak3_functions/sky.cpp
@@ -23,32 +23,588 @@ void link() {
 }  // namespace set_sky_vf27
 }  // namespace Mips2C::jak3
 
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak3/kscheme.h"
+using ::jak3::intern_from_c;
 namespace Mips2C::jak3 {
-namespace set_sky_vf23_value {
+namespace clip_polygon_against_positive_hyperplane {
 u64 execute(void* ctxt) {
   auto* c = (ExecutionContext*)ctxt;
-  // sky_regs_vfs.vfs[27]
-  u64 value = c->sgpr64(a0);
-  memcpy(&sky_regs_vfs.vfs[23].f[0], &value, 8);
-  return 0;
+  bool bc = false;
+  u32 call_addr = 0;
+  bool cop1_bc = false;
+  // nop                                            // sll r0, r0, 0
+  c->mov64(t1, t0);                                 // or t1, t0, r0
+  c->addiu(t0, r0, 0);                              // addiu t0, r0, 0
+  c->lwc1(f1, 0, t2);                               // lwc1 f1, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lwc1(f0, 12, a2);                              // lwc1 f0, 12(a2)
+  c->mov64(t3, a3);                                 // or t3, a3, r0
+  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  cop1_bc = c->fprs[f0] < c->fprs[f1];              // c.lt.s f0, f1
+  c->lqc2(vf2, -32, a2);                            // lqc2 vf2, -32(a2)
+  bc = !cop1_bc;                                    // bc1f L119
+  c->lqc2(vf3, -16, a2);                            // lqc2 vf3, -16(a2)
+  if (bc) {goto block_9;}                           // branch non-likely
+
+  
+block_1:
+  c->lwc1(f3, 0, t2);                               // lwc1 f3, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lwc1(f2, 12, a2);                              // lwc1 f2, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lqc2(vf4, 0, a2);                              // lqc2 vf4, 0(a2)
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  cop1_bc = c->fprs[f2] < c->fprs[f3];              // c.lt.s f2, f3
+  c->lqc2(vf5, -32, a2);                            // lqc2 vf5, -32(a2)
+  bc = !cop1_bc;                                    // bc1f L117
+  c->lqc2(vf6, -16, a2);                            // lqc2 vf6, -16(a2)
+  if (bc) {goto block_6;}                           // branch non-likely
+
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L123
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_17;}                          // branch non-likely
+
+  
+block_3:
+  c->lwc1(f1, 0, t2);                               // lwc1 f1, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lwc1(f0, 12, a2);                              // lwc1 f0, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  cop1_bc = c->fprs[f0] < c->fprs[f1];              // c.lt.s f0, f1
+  c->lqc2(vf2, -32, a2);                            // lqc2 vf2, -32(a2)
+  bc = !cop1_bc;                                    // bc1f L118
+  c->lqc2(vf3, -16, a2);                            // lqc2 vf3, -16(a2)
+  if (bc) {goto block_8;}                           // branch non-likely
+
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L115
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  //beq r0, r0, L123                                // beq r0, r0, L123
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_6:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf4, vf1);               // vsub.xyzw vf7, vf4, vf1
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf5, vf2);               // vsub.xyzw vf8, vf5, vf2
+  c->subs(f5, f7, f8);                              // sub.s f5, f7, f8
+  c->vsub(DEST::xyzw, vf9, vf6, vf3);               // vsub.xyzw vf9, vf6, vf3
+  c->divs(f6, f7, f5);                              // div.s f6, f7, f5
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  c->vmula_bc(DEST::xyzw, BC::w, vf1, vf0);         // vmulaw.xyzw acc, vf1, vf0
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf2, vf0);         // vmulaw.xyzw acc, vf2, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf3, vf0);         // vmulaw.xyzw acc, vf3, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L120
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_11;}                          // branch non-likely
+
+  //beq r0, r0, L123                                // beq r0, r0, L123
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_8:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf1, vf4);               // vsub.xyzw vf7, vf1, vf4
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf2, vf5);               // vsub.xyzw vf8, vf2, vf5
+  c->subs(f5, f8, f7);                              // sub.s f5, f8, f7
+  c->vsub(DEST::xyzw, vf9, vf3, vf6);               // vsub.xyzw vf9, vf3, vf6
+  c->divs(f6, f8, f5);                              // div.s f6, f8, f5
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  c->vmula_bc(DEST::xyzw, BC::w, vf4, vf0);         // vmulaw.xyzw acc, vf4, vf0
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf5, vf0);         // vmulaw.xyzw acc, vf5, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf6, vf0);         // vmulaw.xyzw acc, vf6, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L123
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_17;}                          // branch non-likely
+
+  
+block_9:
+  c->lwc1(f3, 0, t2);                               // lwc1 f3, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lwc1(f2, 12, a2);                              // lwc1 f2, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lqc2(vf4, 0, a2);                              // lqc2 vf4, 0(a2)
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  cop1_bc = c->fprs[f2] < c->fprs[f3];              // c.lt.s f2, f3
+  c->lqc2(vf5, -32, a2);                            // lqc2 vf5, -32(a2)
+  bc = cop1_bc;                                     // bc1t L121
+  c->lqc2(vf6, -16, a2);                            // lqc2 vf6, -16(a2)
+  if (bc) {goto block_14;}                          // branch non-likely
+
+  c->sqc2(vf1, 0, a3);                              // sqc2 vf1, 0(a3)
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->sqc2(vf2, -32, a3);                            // sqc2 vf2, -32(a3)
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L123
+  c->sqc2(vf3, -16, a3);                            // sqc2 vf3, -16(a3)
+  if (bc) {goto block_17;}                          // branch non-likely
+
+  
+block_11:
+  c->lwc1(f1, 0, t2);                               // lwc1 f1, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lwc1(f0, 12, a2);                              // lwc1 f0, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  cop1_bc = c->fprs[f0] < c->fprs[f1];              // c.lt.s f0, f1
+  c->lqc2(vf2, -32, a2);                            // lqc2 vf2, -32(a2)
+  bc = cop1_bc;                                     // bc1t L122
+  c->lqc2(vf3, -16, a2);                            // lqc2 vf3, -16(a2)
+  if (bc) {goto block_16;}                          // branch non-likely
+
+  c->sqc2(vf4, 0, a3);                              // sqc2 vf4, 0(a3)
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->sqc2(vf5, -32, a3);                            // sqc2 vf5, -32(a3)
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L119
+  c->sqc2(vf6, -16, a3);                            // sqc2 vf6, -16(a3)
+  if (bc) {goto block_9;}                           // branch non-likely
+
+  //beq r0, r0, L123                                // beq r0, r0, L123
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_14:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf1, vf4);               // vsub.xyzw vf7, vf1, vf4
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf2, vf5);               // vsub.xyzw vf8, vf2, vf5
+  c->subs(f5, f8, f7);                              // sub.s f5, f8, f7
+  c->vsub(DEST::xyzw, vf9, vf3, vf6);               // vsub.xyzw vf9, vf3, vf6
+  c->divs(f6, f8, f5);                              // div.s f6, f8, f5
+  c->daddiu(a3, a3, 96);                            // daddiu a3, a3, 96
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->sqc2(vf1, -96, a3);                            // sqc2 vf1, -96(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf4, vf0);         // vmulaw.xyzw acc, vf4, vf0
+  c->sqc2(vf2, -80, a3);                            // sqc2 vf2, -80(a3)
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  c->sqc2(vf3, -64, a3);                            // sqc2 vf3, -64(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf5, vf0);         // vmulaw.xyzw acc, vf5, vf0
+  c->daddiu(t0, t0, 2);                             // daddiu t0, t0, 2
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmula_bc(DEST::xyzw, BC::w, vf6, vf0);         // vmulaw.xyzw acc, vf6, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L116
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  //beq r0, r0, L123                                // beq r0, r0, L123
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_16:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf4, vf1);               // vsub.xyzw vf7, vf4, vf1
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf5, vf2);               // vsub.xyzw vf8, vf5, vf2
+  c->subs(f5, f7, f8);                              // sub.s f5, f7, f8
+  c->vsub(DEST::xyzw, vf9, vf6, vf3);               // vsub.xyzw vf9, vf6, vf3
+  c->divs(f6, f7, f5);                              // div.s f6, f7, f5
+  c->daddiu(a3, a3, 96);                            // daddiu a3, a3, 96
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->sqc2(vf4, -96, a3);                            // sqc2 vf4, -96(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf1, vf0);         // vmulaw.xyzw acc, vf1, vf0
+  c->sqc2(vf5, -80, a3);                            // sqc2 vf5, -80(a3)
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  c->sqc2(vf6, -64, a3);                            // sqc2 vf6, -64(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf2, vf0);         // vmulaw.xyzw acc, vf2, vf0
+  c->daddiu(t0, t0, 2);                             // daddiu t0, t0, 2
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmula_bc(DEST::xyzw, BC::w, vf3, vf0);         // vmulaw.xyzw acc, vf3, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L115
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  
+block_17:
+  c->lqc2(vf1, 0, t3);                              // lqc2 vf1, 0(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf2, 16, t3);                             // lqc2 vf2, 16(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf3, 32, t3);                             // lqc2 vf3, 32(t3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf1, 0, a3);                              // sqc2 vf1, 0(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf2, 16, a3);                             // sqc2 vf2, 16(a3)
+  // nop                                            // sll r0, r0, 0
+  //jr ra                                           // jr ra
+  c->sqc2(vf3, 32, a3);                             // sqc2 vf3, 32(a3)
+  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() {
-  gLinkedFunctionTable.reg("set-sky-vf23-value", execute, 64);
+  gLinkedFunctionTable.reg("clip-polygon-against-positive-hyperplane", execute, 128);
 }
 
-}  // namespace set_sky_vf23_value
-}  // namespace Mips2C::jak3
+} // namespace clip_polygon_against_positive_hyperplane
+} // namespace Mips2C
 
+//--------------------------MIPS2C---------------------
+// clang-format off
+#include "game/mips2c/mips2c_private.h"
+#include "game/kernel/jak3/kscheme.h"
+using ::jak3::intern_from_c;
 namespace Mips2C::jak3 {
-namespace clip_polygon_against_positive_hyperplane {
-u64 execute(void*) {
-  ASSERT_NOT_REACHED();
-}
-}  // namespace clip_polygon_against_positive_hyperplane
 namespace clip_polygon_against_negative_hyperplane {
-u64 execute(void*) {
-  ASSERT_NOT_REACHED();
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  bool cop1_bc = false;
+  // nop                                            // sll r0, r0, 0
+  c->mov64(t1, t0);                                 // or t1, t0, r0
+  c->addiu(t0, r0, 0);                              // addiu t0, r0, 0
+  c->lwc1(f0, 12, a2);                              // lwc1 f0, 12(a2)
+  c->mov64(t3, a3);                                 // or t3, a3, r0
+  c->lwc1(f1, 0, t2);                               // lwc1 f1, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
+  c->negs(f0, f0);                                  // neg.s f0, f0
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf2, 16, a2);                             // lqc2 vf2, 16(a2)
+  cop1_bc = c->fprs[f1] < c->fprs[f0];              // c.lt.s f1, f0
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  bc = !cop1_bc;                                    // bc1f L109
+  c->lqc2(vf3, -16, a2);                            // lqc2 vf3, -16(a2)
+  if (bc) {goto block_9;}                           // branch non-likely
+
+  
+block_1:
+  c->lwc1(f2, 12, a2);                              // lwc1 f2, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lwc1(f3, 0, t2);                               // lwc1 f3, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lqc2(vf4, 0, a2);                              // lqc2 vf4, 0(a2)
+  c->negs(f2, f2);                                  // neg.s f2, f2
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf5, 16, a2);                             // lqc2 vf5, 16(a2)
+  cop1_bc = c->fprs[f3] < c->fprs[f2];              // c.lt.s f3, f2
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  bc = !cop1_bc;                                    // bc1f L107
+  c->lqc2(vf6, -16, a2);                            // lqc2 vf6, -16(a2)
+  if (bc) {goto block_6;}                           // branch non-likely
+
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L113
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_17;}                          // branch non-likely
+
+  
+block_3:
+  c->lwc1(f0, 12, a2);                              // lwc1 f0, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lwc1(f1, 0, t2);                               // lwc1 f1, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
+  c->negs(f0, f0);                                  // neg.s f0, f0
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf2, 16, a2);                             // lqc2 vf2, 16(a2)
+  cop1_bc = c->fprs[f1] < c->fprs[f0];              // c.lt.s f1, f0
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  bc = !cop1_bc;                                    // bc1f L108
+  c->lqc2(vf3, -16, a2);                            // lqc2 vf3, -16(a2)
+  if (bc) {goto block_8;}                           // branch non-likely
+
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L105
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  //beq r0, r0, L113                                // beq r0, r0, L113
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_6:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf4, vf1);               // vsub.xyzw vf7, vf4, vf1
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf5, vf2);               // vsub.xyzw vf8, vf5, vf2
+  c->subs(f5, f7, f8);                              // sub.s f5, f7, f8
+  c->vsub(DEST::xyzw, vf9, vf6, vf3);               // vsub.xyzw vf9, vf6, vf3
+  c->divs(f6, f7, f5);                              // div.s f6, f7, f5
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  c->vmula_bc(DEST::xyzw, BC::w, vf1, vf0);         // vmulaw.xyzw acc, vf1, vf0
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf2, vf0);         // vmulaw.xyzw acc, vf2, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf3, vf0);         // vmulaw.xyzw acc, vf3, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L110
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_11;}                          // branch non-likely
+
+  //beq r0, r0, L113                                // beq r0, r0, L113
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_8:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf1, vf4);               // vsub.xyzw vf7, vf1, vf4
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf2, vf5);               // vsub.xyzw vf8, vf2, vf5
+  c->subs(f5, f8, f7);                              // sub.s f5, f8, f7
+  c->vsub(DEST::xyzw, vf9, vf3, vf6);               // vsub.xyzw vf9, vf3, vf6
+  c->divs(f6, f8, f5);                              // div.s f6, f8, f5
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  c->vmula_bc(DEST::xyzw, BC::w, vf4, vf0);         // vmulaw.xyzw acc, vf4, vf0
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf5, vf0);         // vmulaw.xyzw acc, vf5, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  // nop                                            // sll r0, r0, 0
+  c->vmula_bc(DEST::xyzw, BC::w, vf6, vf0);         // vmulaw.xyzw acc, vf6, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L113
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_17;}                          // branch non-likely
+
+  
+block_9:
+  c->lwc1(f2, 12, a2);                              // lwc1 f2, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lwc1(f3, 0, t2);                               // lwc1 f3, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lqc2(vf4, 0, a2);                              // lqc2 vf4, 0(a2)
+  c->negs(f2, f2);                                  // neg.s f2, f2
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf5, 16, a2);                             // lqc2 vf5, 16(a2)
+  cop1_bc = c->fprs[f3] < c->fprs[f2];              // c.lt.s f3, f2
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  bc = cop1_bc;                                     // bc1t L111
+  c->lqc2(vf6, -16, a2);                            // lqc2 vf6, -16(a2)
+  if (bc) {goto block_14;}                          // branch non-likely
+
+  c->sqc2(vf1, 0, a3);                              // sqc2 vf1, 0(a3)
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->sqc2(vf2, -32, a3);                            // sqc2 vf2, -32(a3)
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  bc = c->sgpr64(t1) == 0;                          // beq t1, r0, L113
+  c->sqc2(vf3, -16, a3);                            // sqc2 vf3, -16(a3)
+  if (bc) {goto block_17;}                          // branch non-likely
+
+  
+block_11:
+  c->lwc1(f0, 12, a2);                              // lwc1 f0, 12(a2)
+  c->daddiu(t1, t1, -1);                            // daddiu t1, t1, -1
+  c->lwc1(f1, 0, t2);                               // lwc1 f1, 0(t2)
+  c->daddiu(t2, t2, 48);                            // daddiu t2, t2, 48
+  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
+  c->negs(f0, f0);                                  // neg.s f0, f0
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf2, 16, a2);                             // lqc2 vf2, 16(a2)
+  cop1_bc = c->fprs[f1] < c->fprs[f0];              // c.lt.s f1, f0
+  c->daddiu(a2, a2, 48);                            // daddiu a2, a2, 48
+  bc = cop1_bc;                                     // bc1t L112
+  c->lqc2(vf3, -16, a2);                            // lqc2 vf3, -16(a2)
+  if (bc) {goto block_16;}                          // branch non-likely
+
+  c->sqc2(vf4, 0, a3);                              // sqc2 vf4, 0(a3)
+  c->daddiu(a3, a3, 48);                            // daddiu a3, a3, 48
+  c->sqc2(vf5, -32, a3);                            // sqc2 vf5, -32(a3)
+  c->daddiu(t0, t0, 1);                             // daddiu t0, t0, 1
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L109
+  c->sqc2(vf6, -16, a3);                            // sqc2 vf6, -16(a3)
+  if (bc) {goto block_9;}                           // branch non-likely
+
+  //beq r0, r0, L113                                // beq r0, r0, L113
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_14:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf1, vf4);               // vsub.xyzw vf7, vf1, vf4
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf2, vf5);               // vsub.xyzw vf8, vf2, vf5
+  c->subs(f5, f8, f7);                              // sub.s f5, f8, f7
+  c->vsub(DEST::xyzw, vf9, vf3, vf6);               // vsub.xyzw vf9, vf3, vf6
+  c->divs(f6, f8, f5);                              // div.s f6, f8, f5
+  c->daddiu(a3, a3, 96);                            // daddiu a3, a3, 96
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->sqc2(vf1, -96, a3);                            // sqc2 vf1, -96(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf4, vf0);         // vmulaw.xyzw acc, vf4, vf0
+  c->sqc2(vf2, -80, a3);                            // sqc2 vf2, -80(a3)
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  c->sqc2(vf3, -64, a3);                            // sqc2 vf3, -64(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf5, vf0);         // vmulaw.xyzw acc, vf5, vf0
+  c->daddiu(t0, t0, 2);                             // daddiu t0, t0, 2
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmula_bc(DEST::xyzw, BC::w, vf6, vf0);         // vmulaw.xyzw acc, vf6, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L106
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  //beq r0, r0, L113                                // beq r0, r0, L113
+  // nop                                            // sll r0, r0, 0
+  goto block_17;                                    // branch always
+
+  
+block_16:
+  c->subs(f7, f0, f1);                              // sub.s f7, f0, f1
+  c->vsub(DEST::xyzw, vf7, vf4, vf1);               // vsub.xyzw vf7, vf4, vf1
+  c->subs(f8, f2, f3);                              // sub.s f8, f2, f3
+  c->vsub(DEST::xyzw, vf8, vf5, vf2);               // vsub.xyzw vf8, vf5, vf2
+  c->subs(f5, f7, f8);                              // sub.s f5, f7, f8
+  c->vsub(DEST::xyzw, vf9, vf6, vf3);               // vsub.xyzw vf9, vf6, vf3
+  c->divs(f6, f7, f5);                              // div.s f6, f7, f5
+  c->daddiu(a3, a3, 96);                            // daddiu a3, a3, 96
+  c->mfc1(v1, f6);                                  // mfc1 v1, f6
+  c->mov128_vf_gpr(vf10, v1);                       // qmtc2.i vf10, v1
+  c->sqc2(vf4, -96, a3);                            // sqc2 vf4, -96(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf1, vf0);         // vmulaw.xyzw acc, vf1, vf0
+  c->sqc2(vf5, -80, a3);                            // sqc2 vf5, -80(a3)
+  c->vmadd_bc(DEST::xyzw, BC::x, vf7, vf7, vf10);   // vmaddx.xyzw vf7, vf7, vf10
+  c->sqc2(vf6, -64, a3);                            // sqc2 vf6, -64(a3)
+  c->vmula_bc(DEST::xyzw, BC::w, vf2, vf0);         // vmulaw.xyzw acc, vf2, vf0
+  c->daddiu(t0, t0, 2);                             // daddiu t0, t0, 2
+  c->vmadd_bc(DEST::xyzw, BC::x, vf8, vf8, vf10);   // vmaddx.xyzw vf8, vf8, vf10
+  c->daddiu(t6, s7, 4);                             // daddiu t6, s7, 4
+  c->vmula_bc(DEST::xyzw, BC::w, vf3, vf0);         // vmulaw.xyzw acc, vf3, vf0
+  // nop                                            // sll r0, r0, 0
+  c->vmadd_bc(DEST::xyzw, BC::x, vf9, vf9, vf10);   // vmaddx.xyzw vf9, vf9, vf10
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf7, -48, a3);                            // sqc2 vf7, -48(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf8, -32, a3);                            // sqc2 vf8, -32(a3)
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t1) != 0;                          // bne t1, r0, L105
+  c->sqc2(vf9, -16, a3);                            // sqc2 vf9, -16(a3)
+  if (bc) {goto block_1;}                           // branch non-likely
+
+  
+block_17:
+  c->lqc2(vf1, 0, t3);                              // lqc2 vf1, 0(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf2, 16, t3);                             // lqc2 vf2, 16(t3)
+  // nop                                            // sll r0, r0, 0
+  c->lqc2(vf3, 32, t3);                             // lqc2 vf3, 32(t3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf1, 0, a3);                              // sqc2 vf1, 0(a3)
+  // nop                                            // sll r0, r0, 0
+  c->sqc2(vf2, 16, a3);                             // sqc2 vf2, 16(a3)
+  // nop                                            // sll r0, r0, 0
+  //jr ra                                           // jr ra
+  c->sqc2(vf3, 32, a3);                             // sqc2 vf3, 32(a3)
+  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];
 }
-}  // namespace clip_polygon_against_negative_hyperplane
-}  // namespace Mips2C::jak3
\ No newline at end of file
+
+void link() {
+  gLinkedFunctionTable.reg("clip-polygon-against-negative-hyperplane", execute, 128);
+}
+
+} // namespace clip_polygon_against_negative_hyperplane
+} // namespace Mips2C
\ No newline at end of file
diff --git a/game/mips2c/mips2c_table.cpp b/game/mips2c/mips2c_table.cpp
index 9db3a79448..609213f45d 100644
--- a/game/mips2c/mips2c_table.cpp
+++ b/game/mips2c/mips2c_table.cpp
@@ -346,6 +346,7 @@ namespace nav_dma_send_to_spr_no_flush { extern void link(); }
 namespace blerc_execute { extern void link(); }
 namespace setup_blerc_chains_for_one_fragment { extern void link(); }
 namespace sparticle_motion_blur_dirt { extern void link(); }
+namespace foreground_draw_hud { extern void link(); }
 
 }
 // clang-format on
@@ -540,7 +541,7 @@ PerGameVersion<std::unordered_map<std::string, std::vector<void (*)()>>> gMips2C
         {"joint", {jak3::cspace_parented_transformq_joint::link}},
         {"foreground",
          {jak3::foreground_check_longest_edge_asm::link, jak3::foreground_generic_merc::link,
-          jak3::foreground_merc::link}},
+          jak3::foreground_merc::link, jak3::foreground_draw_hud::link}},
         {"particle-curves", {jak3::live_func_curve::link, jak3::birth_func_curve::link}},
         {"collide-hash",
          {jak3::method_11_collide_hash::link, jak3::method_12_collide_hash::link,
diff --git a/goal_src/jak3/engine/game/game-info.gc b/goal_src/jak3/engine/game/game-info.gc
index 631831f98c..b4ff04b720 100644
--- a/goal_src/jak3/engine/game/game-info.gc
+++ b/goal_src/jak3/engine/game/game-info.gc
@@ -487,8 +487,7 @@
           "title-start"
           )
          ((and *debug-segment* (= mode 'boot))
-          "halfpipe"
-          ;; "wascity-start"
+          "wascity-start"
           )
          (else
            "title-start"
diff --git a/goal_src/jak3/engine/gfx/foreground/foreground.gc b/goal_src/jak3/engine/gfx/foreground/foreground.gc
index f113277e71..31ddc33c3d 100644
--- a/goal_src/jak3/engine/gfx/foreground/foreground.gc
+++ b/goal_src/jak3/engine/gfx/foreground/foreground.gc
@@ -821,7 +821,7 @@
                                     :shadow-dir (new 'static 'vector :x -0.4226 :y -0.9063 :w 409600.0)
                                     :bot-plane (new 'static 'plane :y 1.0 :w 37683.2)
                                     :top-plane (new 'static 'plane :y 1.0 :w 4096.0)
-                                    :fade-vec (new 'static 'vector :x 409600.0)
+                                    :fade-dist 409600.0
                                     )
         )
 
@@ -855,7 +855,7 @@
     (let ((t1-5 (-> a3-3 flags)))
       (-> arg0 cur-lod)
       (when (not (logtest? t1-5 (shadow-flags disable-fade)))
-        (if (< (-> a3-3 fade-vec x) t0-0)
+        (if (< (-> a3-3 fade-dist) t0-0)
             (set! t1-5 (logior t1-5 (shadow-flags disable-draw)))
             )
         )
@@ -2358,6 +2358,8 @@
         )
   )
 
+(def-mips2c foreground-draw-hud (function draw-control dma-buffer float none))
+
 (kmemopen global "foreground-engine")
 
 (define *foreground* (new 'global 'foreground-globals))
diff --git a/goal_src/jak3/engine/gfx/sky/sky-tng.gc b/goal_src/jak3/engine/gfx/sky/sky-tng.gc
index dcc7eb0aef..4c10895d47 100644
--- a/goal_src/jak3/engine/gfx/sky/sky-tng.gc
+++ b/goal_src/jak3/engine/gfx/sky/sky-tng.gc
@@ -7,6 +7,25 @@
 
 ;; DECOMP BEGINS
 
+(defun close-sky-buffer ((arg0 dma-buffer))
+  "Terminate dma from large polygon renderer. This should be called after the last
+   call to render-sky-tri/quad."
+  (nop!)
+  (let ((v1-0 #x8000)
+        (v0-0 (-> arg0 base))
+        )
+    (set! (-> (the-as (pointer uint128) v0-0)) (the uint128 0))
+    (nop!)
+    (set! (-> (the-as (pointer int32) v0-0)) v1-0)
+    (let ((v0-1 (&+ v0-0 16)))
+      ;; to save like 1 instruction they put this in the delay slot of the jr-ra
+      ;;(.jr ra-0)
+      (set! (-> arg0 base) v0-1)
+      )
+    )
+  (none)
+  )
+
 (defmethod update-time-and-speed ((this sky-work) (arg0 float) (arg1 float))
   (if (and (level-get-target-inside *level*) (= (-> (level-get-target-inside *level*) info taskname) 'nest))
       (set! arg1 (* 10.0 arg1))
diff --git a/goal_src/jak3/engine/level/level.gc b/goal_src/jak3/engine/level/level.gc
index 3926660194..663f0e57bd 100644
--- a/goal_src/jak3/engine/level/level.gc
+++ b/goal_src/jak3/engine/level/level.gc
@@ -2779,7 +2779,7 @@
   (none)
   )
 
-(defconstant *default-boot-level* 'halfpipe)
+(defconstant *default-boot-level* 'wasall)
 
 (defmacro play-desert ()
   `(start 'play (get-continue-by-name *game-info* "desert-start"))
diff --git a/goal_src/jak3/engine/level/region.gc b/goal_src/jak3/engine/level/region.gc
index eaabe34ef0..b658e2a088 100644
--- a/goal_src/jak3/engine/level/region.gc
+++ b/goal_src/jak3/engine/level/region.gc
@@ -253,14 +253,14 @@
       )
     (add-debug-sphere #t (bucket-id debug) s5-0 (-> this bsphere w) (new 'static 'rgba :r #xff :a #x30))
     )
-  ;; (add-debug-bound
-  ;;   (bucket-id debug)
-  ;;   (-> this data points)
-  ;;   (the-as int (-> this data num-points))
-  ;;   (new 'static 'rgba :r #x80 :g #x80 :a #x40)
-  ;;   (new 'static 'rgba :r #x80 :a #x40)
-  ;;   0
-  ;;   )
+  (add-debug-bound
+    (bucket-id debug)
+    (-> this data points)
+    (the-as int (-> this data num-points))
+    (new 'static 'rgba :r #x80 :g #x80 :a #x40)
+    (new 'static 'rgba :r #x80 :a #x40)
+    0
+    )
   0
   (none)
   )
diff --git a/goal_src/jak3/engine/ui/hud-classes.gc b/goal_src/jak3/engine/ui/hud-classes.gc
index af430ad166..890117bcae 100644
--- a/goal_src/jak3/engine/ui/hud-classes.gc
+++ b/goal_src/jak3/engine/ui/hud-classes.gc
@@ -71,7 +71,7 @@
 
 (defmethod update-values! ((this hud-map))
   (cond
-    ((and (nonzero? *minimap*) (update! *minimap*))
+    ((update! *minimap*)
      (logior! (-> this flags) (hud-flags show))
      (let ((t9-1 (method-of-type hud update-values!)))
        (t9-1 this)
@@ -110,7 +110,7 @@
   (set! (-> this sprites 1 flags) (hud-sprite-flags hsf2))
   (set! (-> this sprites 1 pos z) #xffff00)
   (set! (-> this values 0 current) 0)
-  (if (nonzero? *minimap*) (update! *minimap*))
+  (update! *minimap*)
   0
   (none)
   )
@@ -192,11 +192,23 @@
   (let ((s5-0 (-> this values 4 current)))
     (dotimes (s4-0 s5-0)
       (let ((v1-38
-              (-> (new 'static 'inline-array vector 4
+              (-> (new 'static 'inline-array vector 16
                     (new 'static 'vector :x 23.0 :y 5.0 :w 1.0)
                     (new 'static 'vector :x 36.0 :y 2.0 :w 1.0)
                     (new 'static 'vector :x 49.0 :y 5.0 :w 1.0)
                     (new 'static 'vector :x 60.0 :y 12.0 :w 1.0)
+                    (new 'static 'vector :x 67.0 :y 23.0 :w 1.0)
+                    (new 'static 'vector :x 70.0 :y 36.0 :w 1.0)
+                    (new 'static 'vector :x 67.0 :y 49.0 :w 1.0)
+                    (new 'static 'vector :x 60.0 :y 60.0 :w 1.0)
+                    (new 'static 'vector :x 49.0 :y 67.0 :w 1.0)
+                    (new 'static 'vector :x 36.0 :y 70.0 :w 1.0)
+                    (new 'static 'vector :x 23.0 :y 67.0 :w 1.0)
+                    (new 'static 'vector :x 12.0 :y 60.0 :w 1.0)
+                    (new 'static 'vector :x 5.0 :y 49.0 :w 1.0)
+                    (new 'static 'vector :x 2.0 :y 36.0 :w 1.0)
+                    (new 'static 'vector :x 5.0 :y 23.0 :w 1.0)
+                    (new 'static 'vector :x 12.0 :y 12.0 :w 1.0)
                     )
                   (logand (+ (- 20 (/ s5-0 2)) s4-0) 15)
                   )
diff --git a/goal_src/jak3/game.gp b/goal_src/jak3/game.gp
index e2a7a40af7..5f3275beed 100644
--- a/goal_src/jak3/game.gp
+++ b/goal_src/jak3/game.gp
@@ -288,8 +288,8 @@
 ; (cgo-file "museum3b.gd" common-dep)
 ; (cgo-file "museum4.gd" common-dep)
 ; (cgo-file "museum4b.gd" common-dep)
-; ;; test
-; (cgo-file "halfpipe.gd" common-dep)
+;; test
+(cgo-file "halfpipe.gd" common-dep)
 ; ;; borrow
 ; (cgo-file "lashelin.gd" common-dep)
 ; (cgo-file "lbbring1.gd" common-dep)
diff --git a/scripts/batch/gk3-display.bat b/scripts/batch/gk3-display.bat
new file mode 100644
index 0000000000..9369da3c75
--- /dev/null
+++ b/scripts/batch/gk3-display.bat
@@ -0,0 +1,4 @@
+@echo off
+cd ..\..
+out\build\Release\bin\gk -v --game jak3 -- -boot -fakeiso -debug
+pause
diff --git a/test/decompiler/reference/jak3/engine/gfx/foreground/foreground_REF.gc b/test/decompiler/reference/jak3/engine/gfx/foreground/foreground_REF.gc
index 194d997658..dd53829b14 100644
--- a/test/decompiler/reference/jak3/engine/gfx/foreground/foreground_REF.gc
+++ b/test/decompiler/reference/jak3/engine/gfx/foreground/foreground_REF.gc
@@ -1513,181 +1513,8 @@
   )
 
 ;; definition for function foreground-draw-hud
-;; INFO: Used lq/sq
-;; WARN: Return type mismatch int vs none.
-;; ERROR: Unsupported inline assembly instruction kind - [lui at, 28672]
-(defun foreground-draw-hud ((arg0 draw-control) (arg1 dma-buffer) (arg2 float))
-  (local-vars
-    (at-0 foreground-work)
-    (a0-2 (pointer uint128))
-    (t2-8 object)
-    (t3-3 uint)
-    (t3-4 uint)
-    (t3-5 uint)
-    (t3-6 uint)
-    )
-  (.lui at-0 28672)
-  (let* ((a2-1 (-> arg1 base))
-         (v1-0 (the-as object (&+ a2-1 64)))
-         )
-    (let ((a3-0 (logand (the-as int v1-0) 48)))
-      (b! (zero? a3-0) cfg-2 :delay (nop!))
-      (set! v1-0 (&- (&+ (the-as pointer v1-0) 64) (the-as uint a3-0)))
-      )
-    (label cfg-2)
-    (let* ((t1-0 (+ (-> arg0 mgeo length) 3))
-           (a3-3 (* t1-0 128))
-           )
-      (let ((t0-1 (-> (the-as foreground-work #x70000000) regs)))
-        (set! (-> t0-1 joint-ptr) (the-as (inline-array joint) (-> arg0 jgeo data 0)))
-        (set! (-> t0-1 bone-ptr) (-> arg0 skeleton bones))
-        (set! (-> t0-1 num-bones) (the-as uint t1-0))
-        (set! (-> t0-1 dist) 0.0)
-        (set! (-> t0-1 dma-buf) arg1)
-        (set! (-> t0-1 level-buckets)
-              (-> (the-as foreground-work #x70000000)
-                  grid
-                  level-buckets
-                  (-> (the-as foreground-work #x70000000) draw-index-map (-> arg0 level-index))
-                  )
-              )
-        )
-      (let ((t1-5 v1-0)
-            (t2-5 2)
-            (t5-0 (-> (the-as foreground-work #x70000000) regs))
-            (a1-6 *bone-calculation-list*)
-            (t0-2 a2-1)
-            )
-        (let ((t3-0 (-> t5-0 joint-ptr))
-              (t4-0 (-> t5-0 bone-ptr))
-              (t5-1 (-> t5-0 num-bones))
-              (t6-0 (the-as bone-calculation t0-2))
-              )
-          (set! (-> t6-0 flags) (the-as bone-calc-flags t2-5))
-          (set! (-> t6-0 num-bones) t5-1)
-          (set! (-> t6-0 matrix-area) (the-as (inline-array pris-mtx) t1-5))
-          (set! (-> t6-0 joints) t3-0)
-          (set! (-> t6-0 bones) t4-0)
-          (set! (-> t6-0 next) (the-as bone-calculation 0))
-          )
-        (if (nonzero? (-> a1-6 next))
-            (set! (-> a1-6 next next) (the-as bone-calculation t0-2))
-            )
-        (if (zero? (-> a1-6 first))
-            (set! (-> a1-6 first) (the-as bone-calculation t0-2))
-            )
-        (set! (-> a1-6 next) (the-as bone-calculation t0-2))
-        )
-      (&+ a2-1 48)
-      (let ((a1-8 (the-as object (+ (the-as uint v1-0) a3-3))))
-        (set! (-> at-0 regs mtxs) (the-as (inline-array pris-mtx) v1-0))
-        (let ((v1-3 (-> *foreground* merc-bucket-info)))
-          (when (= (-> arg0 data-format) (draw-control-data-format merc))
-            (let ((a2-4 (-> arg0 lod-set lod 0 geo))
-                  (a3-5 0)
-                  )
-              (b! #t cfg-22 :delay (nop!))
-              (label cfg-8)
-              (b! (not (logtest? (-> a2-4 effect a3-5 effect-usage) 1)) cfg-17 :delay (nop!))
-              (let* ((t1-13 (-> v1-3 light))
-                     (t2-7 (-> (the-as foreground-work #x70000000) lights))
-                     (t0-9 7)
-                     (t1-14 (the-as object t1-13))
-                     )
-                (b! (< (+ t0-9 -4) 0) cfg-11 :delay (set! t2-8 t2-7))
-                (nop!)
-                (let ((t6-1 (-> (the-as (pointer uint128) t2-8) 0)))
-                  (nop!)
-                  (let ((t3-2 (-> (the-as (pointer uint128) t2-8) 1)))
-                    (+! t0-9 -4)
-                    (let ((t4-1 (-> (the-as (pointer uint128) t2-8) 2)))
-                      (set! t1-14 (-> (the-as vu-lights t1-14) color 1))
-                      (let ((t5-2 (-> (the-as (pointer uint128) t2-8) 3)))
-                        (set! t2-8 (&-> (the-as (pointer uint128) t2-8) 4))
-                        (set! (-> (the-as (pointer uint128) t1-14) -4) t6-1)
-                        (let ((t6-2 (+ t0-9 -4)))
-                          (set! (-> (the-as (pointer uint128) t1-14) -3) t3-2)
-                          (nop!)
-                          (set! (-> (the-as (pointer uint128) t1-14) -2) t4-1)
-                          (b! (>= t6-2 0) cfg-10 :delay (set! (-> (the-as (pointer uint128) t1-14) -1) t5-2))
-                          )
-                        )
-                      )
-                    )
-                  )
-                (label cfg-11)
-                (b! (zero? t0-9) cfg-16 :delay (set! t3-3 (the-as uint (-> (the-as (pointer uint128) t2-8) 0))))
-                (let ((t2-9 (&-> (the-as (pointer uint128) t2-8) 1))
-                      (t1-15 (the-as object (&-> (the-as (pointer uint128) t1-14) 1)))
-                      (t0-10 (+ t0-9 -1))
-                      )
-                  (s.q! (+ (the-as vu-lights t1-15) -16) t3-3)
-                  (b! (zero? t0-10) cfg-16 :delay (set! t3-4 (the-as uint (-> t2-9 0))))
-                  (let ((t2-10 (&-> t2-9 1))
-                        (t1-16 (&-> (the-as (pointer uint128) t1-15) 1))
-                        (t0-11 (+ t0-10 -1))
-                        )
-                    (set! (-> t1-16 -1) (the-as uint128 t3-4))
-                    (b! (zero? t0-11) cfg-16 :delay (set! t3-5 (the-as uint (-> t2-10 0))))
-                    (let ((t2-11 (&-> t2-10 1))
-                          (t1-17 (&-> t1-16 1))
-                          (t0-12 (+ t0-11 -1))
-                          )
-                      (set! (-> t1-17 -1) (the-as uint128 t3-5))
-                      (b! (zero? t0-12) cfg-16 :delay (set! t3-6 (the-as uint (-> t2-11 0))))
-                      (&-> t2-11 1)
-                      (let ((t1-18 (&-> t1-17 1)))
-                        (+ t0-12 -1)
-                        (set! (-> t1-18 -1) (the-as uint128 t3-6))
-                        )
-                      )
-                    )
-                  )
-                )
-              (label cfg-16)
-              0
-              (set! (-> v1-3 effect a3-5 color-fade) (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80))
-              (set! (-> v1-3 effect a3-5 merc-path) (the-as uint 2))
-              (b! #t cfg-18 :delay (nop!))
-              (label cfg-17)
-              (set! (-> v1-3 effect a3-5 merc-path) (the-as uint 2))
-              (label cfg-18)
-              (set! (-> v1-3 effect a3-5 disable-draw) (the-as uint 0))
-              (set! (-> v1-3 effect a3-5 ignore-alpha)
-                    (the-as uint (if (logtest? (-> a2-4 effect a3-5 effect-bits) (effect-bits ignore-alpha))
-                                     1
-                                     0
-                                     )
-                            )
-                    )
-              (+! a3-5 1)
-              (label cfg-22)
-              (b! (< a3-5 (the-as int (-> a2-4 header effect-count))) cfg-8)
-              )
-            (if (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask generic))
-                (set! a1-8 (foreground-generic-merc arg0 (the-as pointer a1-8) 1))
-                )
-            )
-          )
-        (let ((v1-11 (logand (the-as int a1-8) 48)))
-          0
-          (b! (zero? v1-11) cfg-27 :delay (set! a0-2 (the-as (pointer uint128) #x20000000)))
-          (s.q! a1-8 a0-2)
-          (let ((a0-3 a1-8))
-            (set! a1-8 (+ (- (the-as int a1-8) (the-as uint v1-11)) 64))
-            (s.w! (+ a0-3 4) (the-as int a1-8))
-            )
-          )
-        (label cfg-27)
-        (set! (-> (the-as foreground-work #x70000000) regs dma-buf base)
-              (the-as pointer (logand a1-8 (the-as uint #xfffffff)))
-              )
-        )
-      )
-    )
-  0
-  (none)
-  )
+;; INFO: function output is handled by mips2c
+(def-mips2c foreground-draw-hud (function draw-control dma-buffer float none))
 
 ;; failed to figure out what this is:
 (kmemopen global "foreground-engine")
diff --git a/test/decompiler/reference/jak3/engine/ui/hud-classes_REF.gc b/test/decompiler/reference/jak3/engine/ui/hud-classes_REF.gc
index e2f59bce6a..a5889ea55c 100644
--- a/test/decompiler/reference/jak3/engine/ui/hud-classes_REF.gc
+++ b/test/decompiler/reference/jak3/engine/ui/hud-classes_REF.gc
@@ -196,11 +196,23 @@
   (let ((s5-0 (-> this values 4 current)))
     (dotimes (s4-0 s5-0)
       (let ((v1-38
-              (-> (new 'static 'inline-array vector 4
+              (-> (new 'static 'inline-array vector 16
                     (new 'static 'vector :x 23.0 :y 5.0 :w 1.0)
                     (new 'static 'vector :x 36.0 :y 2.0 :w 1.0)
                     (new 'static 'vector :x 49.0 :y 5.0 :w 1.0)
                     (new 'static 'vector :x 60.0 :y 12.0 :w 1.0)
+                    (new 'static 'vector :x 67.0 :y 23.0 :w 1.0)
+                    (new 'static 'vector :x 70.0 :y 36.0 :w 1.0)
+                    (new 'static 'vector :x 67.0 :y 49.0 :w 1.0)
+                    (new 'static 'vector :x 60.0 :y 60.0 :w 1.0)
+                    (new 'static 'vector :x 49.0 :y 67.0 :w 1.0)
+                    (new 'static 'vector :x 36.0 :y 70.0 :w 1.0)
+                    (new 'static 'vector :x 23.0 :y 67.0 :w 1.0)
+                    (new 'static 'vector :x 12.0 :y 60.0 :w 1.0)
+                    (new 'static 'vector :x 5.0 :y 49.0 :w 1.0)
+                    (new 'static 'vector :x 2.0 :y 36.0 :w 1.0)
+                    (new 'static 'vector :x 5.0 :y 23.0 :w 1.0)
+                    (new 'static 'vector :x 12.0 :y 12.0 :w 1.0)
                     )
                   (logand (+ (- 20 (/ s5-0 2)) s4-0) 15)
                   )
@@ -1503,7 +1515,3 @@
   0
   (none)
   )
-
-
-
-