diff --git a/common/type_system/TypeSpec.h b/common/type_system/TypeSpec.h
index dd93101a97..e604940a6b 100644
--- a/common/type_system/TypeSpec.h
+++ b/common/type_system/TypeSpec.h
@@ -94,7 +94,7 @@ class TypeSpec {
   void modify_tag(const std::string& tag_name, const std::string& tag_value);
   void add_or_modify_tag(const std::string& tag_name, const std::string& tag_value);
 
-  const std::string base_type() const { return m_type; }
+  const std::string& base_type() const { return m_type; }
 
   bool has_single_arg() const {
     if (m_arguments) {
diff --git a/decompiler/CMakeLists.txt b/decompiler/CMakeLists.txt
index 0374470012..2a6a6d2c42 100644
--- a/decompiler/CMakeLists.txt
+++ b/decompiler/CMakeLists.txt
@@ -79,6 +79,7 @@ add_library(
         util/goal_data_reader.cpp
         util/sparticle_decompile.cpp
         util/TP_Type.cpp
+        util/type_utils.cpp
 
         VuDisasm/VuDisassembler.cpp
         VuDisasm/VuInstruction.cpp
diff --git a/decompiler/IR2/AtomicOpForm.cpp b/decompiler/IR2/AtomicOpForm.cpp
index 32aac3afc7..c4e1e6f364 100644
--- a/decompiler/IR2/AtomicOpForm.cpp
+++ b/decompiler/IR2/AtomicOpForm.cpp
@@ -727,6 +727,14 @@ Form* LoadVarOp::get_load_src(FormPool& pool, const Env& env) const {
         return pool.alloc_single_element_form<DerefElement>(nullptr, cast_dest, false,
                                                             std::vector<DerefToken>());
       }
+
+      // if we fail here, report a LoadSourceElement with the register and offset to be consumed
+      // by the expression pass, which can detect more complicated cases (see
+      // LoadSourceElement::update_from_stack, which needs expressions)
+      auto source =
+          pool.alloc_single_element_form<SimpleExpressionElement>(nullptr, m_src, m_my_idx);
+      return pool.alloc_single_element_form<LoadSourceElement>(nullptr, source, m_size, m_kind, ro,
+                                                               input_type);
     }
   }
 
@@ -738,7 +746,8 @@ Form* LoadVarOp::get_load_src(FormPool& pool, const Env& env) const {
   }
 
   auto source = pool.alloc_single_element_form<SimpleExpressionElement>(nullptr, m_src, m_my_idx);
-  return pool.alloc_single_element_form<LoadSourceElement>(nullptr, source, m_size, m_kind);
+  return pool.alloc_single_element_form<LoadSourceElement>(
+      nullptr, source, m_size, m_kind, std::optional<IR2_RegOffset>{}, TP_Type());
 }
 
 FormElement* LoadVarOp::get_as_form(FormPool& pool, const Env& env) const {
diff --git a/decompiler/IR2/AtomicOpTypeAnalysis.cpp b/decompiler/IR2/AtomicOpTypeAnalysis.cpp
index 6acf67430a..bffbd8ac3b 100644
--- a/decompiler/IR2/AtomicOpTypeAnalysis.cpp
+++ b/decompiler/IR2/AtomicOpTypeAnalysis.cpp
@@ -8,7 +8,7 @@
 #include "decompiler/ObjectFile/LinkedObjectFile.h"
 #include "decompiler/util/DecompilerTypeSystem.h"
 #include "decompiler/util/TP_Type.h"
-#include "decompiler/util/goal_constants.h"
+#include "decompiler/util/type_utils.h"
 
 #include "third-party/fmt/core.h"
 
@@ -464,8 +464,18 @@ TP_Type SimpleExpression::get_type_int2(const TypeState& input,
       }
 
       if (arg1_type.is_integer_constant() && is_int_or_uint(dts, arg0_type)) {
+        TypeSpec sum_type = arg0_type.typespec();
+        FieldReverseLookupInput rd_in;
+        rd_in.offset = arg1_type.get_integer_constant();
+        rd_in.stride = 0;
+        rd_in.base_type = arg0_type.typespec();
+        auto out = env.dts->ts.reverse_field_lookup(rd_in);
+        if (out.success) {
+          sum_type = coerce_to_reg_type(out.result_type);
+        }
+
         return TP_Type::make_from_integer_constant_plus_var(arg1_type.get_integer_constant(),
-                                                            arg0_type.typespec());
+                                                            arg0_type.typespec(), sum_type);
       }
 
       break;
@@ -663,8 +673,8 @@ TP_Type SimpleExpression::get_type_int2(const TypeState& input,
 
   if (tc(dts, TypeSpec("structure"), arg1_type) && !m_args[0].is_int() &&
       is_int_or_uint(dts, arg0_type)) {
-    if (arg1_type.typespec() == TypeSpec("symbol") &&
-        arg0_type.is_integer_constant(DECOMP_SYM_INFO_OFFSET + POINTER_SIZE)) {
+    if (allowable_base_type_for_symbol_to_string(arg1_type.typespec()) &&
+        arg0_type.is_integer_constant(SYMBOL_TO_STRING_MEM_OFFSET_DECOMP[env.version])) {
       // symbol -> GOAL String
       // NOTE - the offset doesn't fit in a s16, so it's loaded into a register first.
       // so we expect the arg to be a variable, and the type propagation will figure out the
@@ -674,7 +684,22 @@ TP_Type SimpleExpression::get_type_int2(const TypeState& input,
       // byte access of offset array field trick.
       // arg1 holds a structure.
       // arg0 is an integer in a register.
-      return TP_Type::make_object_plus_product(arg1_type.typespec(), 1, true);
+      // return TP_Type::make_object_plus_product(arg1_type.typespec(), 1, true);
+      if (arg0_type.is_integer_constant()) {
+        TypeSpec sum_type = arg1_type.typespec();
+        FieldReverseLookupInput rd_in;
+        rd_in.offset = arg0_type.get_integer_constant();
+        rd_in.stride = 0;
+        rd_in.base_type = arg1_type.typespec();
+        auto out = env.dts->ts.reverse_field_lookup(rd_in);
+        if (out.success) {
+          sum_type = coerce_to_reg_type(out.result_type);
+        }
+        return TP_Type::make_from_integer_constant_plus_var(arg0_type.get_integer_constant(),
+                                                            arg1_type.typespec(), sum_type);
+      } else {
+        return TP_Type::make_object_plus_product(arg1_type.typespec(), 1, true);
+      }
     }
   }
 
@@ -1145,6 +1170,40 @@ TP_Type LoadVarOp::get_src_type(const TypeState& input,
       }
     }
 
+    if (input_type.kind == TP_Type::Kind::INTEGER_CONSTANT_PLUS_VAR &&
+        input_type.get_integer_constant() == 0) {
+      FieldReverseLookupInput rd_in;
+      DerefKind dk;
+      dk.is_store = false;
+      dk.reg_kind = get_reg_kind(ro.reg);
+      dk.sign_extend = m_kind == LoadVarOp::Kind::SIGNED;
+      dk.size = m_size;
+      rd_in.deref = dk;
+      rd_in.base_type = input_type.get_objects_typespec();
+      rd_in.offset = ro.offset;
+      auto rd = dts.ts.reverse_field_lookup(rd_in);
+      if (rd.success) {
+        return TP_Type::make_from_ts(coerce_to_reg_type(rd.result_type));
+      }
+    }
+
+    if (input_type.kind == TP_Type::Kind::INTEGER_CONSTANT_PLUS_VAR && ro.offset == 0) {
+      FieldReverseLookupInput rd_in;
+      DerefKind dk;
+      dk.is_store = false;
+      dk.reg_kind = get_reg_kind(ro.reg);
+      dk.sign_extend = kind() == LoadVarOp::Kind::SIGNED;
+      dk.size = size();
+      rd_in.deref = dk;
+      rd_in.base_type = input_type.get_objects_typespec();
+      rd_in.stride = 0;
+      rd_in.offset = input_type.get_integer_constant();
+      auto rd = dts.ts.reverse_field_lookup(rd_in);
+      if (rd.success) {
+        return TP_Type::make_from_ts(coerce_to_reg_type(rd.result_type));
+      }
+    }
+
     // rd failed, try as pair.
     if (env.allow_sloppy_pair_typing()) {
       // we are strict here - only permit pair-type loads from object or pair.
diff --git a/decompiler/IR2/Form.cpp b/decompiler/IR2/Form.cpp
index f1857207f7..640068b597 100644
--- a/decompiler/IR2/Form.cpp
+++ b/decompiler/IR2/Form.cpp
@@ -197,8 +197,16 @@ void StoreElement::get_modified_regs(RegSet& regs) const {
 // LoadSourceElement
 /////////////////////////////
 
-LoadSourceElement::LoadSourceElement(Form* addr, int size, LoadVarOp::Kind kind)
-    : m_addr(addr), m_size(size), m_kind(kind) {
+LoadSourceElement::LoadSourceElement(Form* addr,
+                                     int size,
+                                     LoadVarOp::Kind kind,
+                                     const std::optional<IR2_RegOffset>& load_source_ro,
+                                     const TP_Type& ro_reg_type)
+    : m_addr(addr),
+      m_size(size),
+      m_kind(kind),
+      m_load_source_ro(load_source_ro),
+      m_ro_reg_type(ro_reg_type) {
   m_addr->parent_element = this;
 }
 
diff --git a/decompiler/IR2/Form.h b/decompiler/IR2/Form.h
index 5a3f41d3c0..3b75601e48 100644
--- a/decompiler/IR2/Form.h
+++ b/decompiler/IR2/Form.h
@@ -265,11 +265,14 @@ class StoreElement : public FormElement {
 
 /*!
  * Representing a value loaded from memory.  Not the destination.
- * Unclear if this should have some common base with store?
  */
 class LoadSourceElement : public FormElement {
  public:
-  LoadSourceElement(Form* addr, int size, LoadVarOp::Kind kind);
+  LoadSourceElement(Form* addr,
+                    int size,
+                    LoadVarOp::Kind kind,
+                    const std::optional<IR2_RegOffset>& load_source_ro,
+                    const TP_Type& ro_reg_type);
   goos::Object to_form_internal(const Env& env) const override;
   void apply(const std::function<void(FormElement*)>& f) override;
   void apply_form(const std::function<void(Form*)>& f) override;
@@ -289,6 +292,8 @@ class LoadSourceElement : public FormElement {
   Form* m_addr = nullptr;
   int m_size = -1;
   LoadVarOp::Kind m_kind;
+  std::optional<IR2_RegOffset> m_load_source_ro;
+  TP_Type m_ro_reg_type;
 };
 
 /*!
diff --git a/decompiler/IR2/FormExpressionAnalysis.cpp b/decompiler/IR2/FormExpressionAnalysis.cpp
index 3199b17e65..3f1d7999ea 100644
--- a/decompiler/IR2/FormExpressionAnalysis.cpp
+++ b/decompiler/IR2/FormExpressionAnalysis.cpp
@@ -13,7 +13,7 @@
 #include "decompiler/ObjectFile/LinkedObjectFile.h"
 #include "decompiler/util/DecompilerTypeSystem.h"
 #include "decompiler/util/data_decompile.h"
-#include "decompiler/util/goal_constants.h"
+#include "decompiler/util/type_utils.h"
 
 /*
  * TODO
@@ -688,6 +688,21 @@ void LoadSourceElement::update_from_stack(const Env& env,
                                           bool allow_side_effects) {
   mark_popped();
   m_addr->update_children_from_stack(env, pool, stack, allow_side_effects);
+
+  // most of the time, the AtomicOpForm logic is able to figure the load, but sometimes
+  // it's impossible before expressions:
+
+  //  ori a2, r0, 33708
+  //  lw a3, *level*(s7)
+  //  daddu a2, a2, a3
+  //  lq a2, 0(a2)
+
+  /*
+  if (m_load_source_ro && m_load_source_ro->offset == 0) {
+    // maybe a case like above, try to improve
+  }
+  */
+
   result->push_back(this);
 }
 
@@ -1025,19 +1040,9 @@ void SimpleExpressionElement::update_from_stack_add_i(const Env& env,
 
     // try to find symbol to string stuff
     auto arg0_int = get_goal_integer_constant(args.at(0), env);
-    u64 symbol_to_string_offset = -1;
-    switch (env.version) {
-      case GameVersion::Jak1:
-        symbol_to_string_offset = DECOMP_SYM_INFO_OFFSET + 4;
-        break;
-      case GameVersion::Jak2:
-        symbol_to_string_offset = jak2::SYM_TO_STRING_OFFSET;
-        break;
-      default:
-        ASSERT(false);
-    }
-    if (arg0_int && (*arg0_int == symbol_to_string_offset) &&
-        arg1_type.typespec() == TypeSpec("symbol")) {
+
+    if (arg0_int && (*arg0_int == SYMBOL_TO_STRING_MEM_OFFSET_DECOMP[env.version]) &&
+        allowable_base_type_for_symbol_to_string(arg1_type.typespec())) {
       result->push_back(pool.alloc_element<GetSymbolStringPointer>(args.at(1)));
       return;
     }
@@ -1250,10 +1255,29 @@ void SimpleExpressionElement::update_from_stack_add_i(const Env& env,
           throw std::runtime_error("Failed to match product_with_constant inline array access 2.");
         }
       }
+    } else if (arg0_type.kind == TP_Type::Kind::INTEGER_CONSTANT) {
+      // try to see if this is valid, from the type system.
+      FieldReverseLookupInput input;
+      input.offset = arg0_type.get_integer_constant();
+      input.stride = 0;
+      input.base_type = arg1_type.typespec();
+      auto out = env.dts->ts.reverse_field_lookup(input);
+      if (out.success && !out.has_variable_token()) {
+        // it is. now we have to modify things
+        // first, look for the index
+        std::vector<DerefToken> tokens;
+        for (auto& tok : out.tokens) {
+          tokens.push_back(to_token(tok));
+        }
+
+        result->push_back(pool.alloc_element<DerefElement>(args.at(1), out.addr_of, tokens));
+        return;
+      }
     }
   }
 
-  if (env.dts->ts.tc(TypeSpec("structure"), arg0_type.typespec()) && m_expr.get_arg(1).is_int()) {
+  if (env.dts->ts.tc(TypeSpec("structure"), arg0_type.typespec()) && m_expr.get_arg(1).is_int() &&
+      arg0_type.kind != TP_Type::Kind::INTEGER_CONSTANT_PLUS_VAR) {
     auto type_info = env.dts->ts.lookup_type(arg0_type.typespec());
     if (type_info->get_size_in_memory() == m_expr.get_arg(1).get_int()) {
       auto new_form = pool.alloc_element<GenericElement>(
@@ -1276,7 +1300,7 @@ void SimpleExpressionElement::update_from_stack_add_i(const Env& env,
     }
   }
 
-  if (arg0_ptr) {
+  if (arg0_ptr && arg0_type.kind != TP_Type::Kind::INTEGER_CONSTANT_PLUS_VAR) {
     auto new_form = pool.alloc_element<GenericElement>(
         GenericOperator::make_fixed(FixedOperatorKind::ADDITION_PTR), args.at(0), args.at(1));
     result->push_back(new_form);
diff --git a/decompiler/IR2/bitfields.cpp b/decompiler/IR2/bitfields.cpp
index 3ca51408f1..ec70119504 100644
--- a/decompiler/IR2/bitfields.cpp
+++ b/decompiler/IR2/bitfields.cpp
@@ -859,9 +859,13 @@ Form* cast_to_bitfield(const BitFieldType* type_info,
   // check if it's just a constant:
   auto in_as_atom = form_as_atom(in);
   if (in_as_atom && in_as_atom->is_int()) {
+    s64 val = in_as_atom->get_int();
+    if (type_info->get_name() == "gif-tag-regs" && (u64)val == 0xeeeeeeeeeeeeeeee) {
+      return pool.form<ConstantTokenElement>("GIF_REGS_ALL_AD");
+    }
+
     // will always be 64-bits
-    auto fields =
-        try_decompile_bitfield_from_int(typespec, env.dts->ts, in_as_atom->get_int(), false, {});
+    auto fields = try_decompile_bitfield_from_int(typespec, env.dts->ts, val, false, {});
     if (!fields) {
       return pool.form<CastElement>(typespec, in);
     }
diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc
index 2417646167..44a53d0508 100644
--- a/decompiler/config/jak2/all-types.gc
+++ b/decompiler/config/jak2/all-types.gc
@@ -102,6 +102,8 @@
 (define-extern sql-query (function string sql-result))
 
 (define-extern loading-level kheap)
+(define-extern dma-sync (function pointer int int int))
+
 
 
 (defenum kmalloc-flags
@@ -118,9 +120,6 @@
 (define-extern *kernel-boot-message* symbol)
 (define-extern *kernel-boot-art-group* string)
 
-;; added - part of the kernel
-(define-extern dma-sync (function pointer int int int))
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; gcommon                        ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1052,7 +1051,7 @@
   )
 
 (deftype vector4w (structure)
-  ((data  uint32  4 :offset-assert 0 :score -1)
+  ((data  int32  4 :offset-assert 0 :score -1)
    (x     int32     :offset        0)
    (y     int32     :offset        4)
    (z     int32     :offset        8)
@@ -2671,335 +2670,420 @@
 ;; vu1-user-h                     ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(defenum texture-enable-mask
+  :type uint64
+  :bitfield #t
+  (tfrag  0)
+  (pris   1)
+  (shrub  2)
+  (alpha  3)
+  (water  4)
+  (warp   5)
+  (sprite 6)
+  (map    7)
+  (sky    8)
+  (tex9   9)
+  (tex10 10)
+  (tex11 11)
+  (tex12 12)
+  (tex13 13)
+  (tex14 14)
+  (tex15 15)
+  (tex16 16)
+  )
+
+(defenum texture-enable-mask-u32
+  :type uint32
+  :bitfield #t
+  :copy-entries texture-enable-mask
+  )
+
+;;  <what renderer>-<what level>-<what tpage>
 (defenum bucket-id
   :type int32
   :bitfield #f
-  (bucket-0 0)
-  (bucket-1 1)
-  (bucket-2 2)
-  (bucket-3 3)
-  (bucket-4 4)
-  (bucket-5 5)
-  (bucket-6 6)
-  (bucket-7 7)     ;; level 0 tex
-  (bucket-8 8)
-  (bucket-9 9)
-  (bucket-10 10)
-  (bucket-11 11)
-  (bucket-12 12)
-  (bucket-13 13)
-  (bucket-14 14)
-  (bucket-15 15)
-  (bucket-16 16)
-  (bucket-17 17)
-  (bucket-18 18)
-  (bucket-19 19)
-  (bucket-20 20)
-  (bucket-21 21)
-  (bucket-22 22)
-  (bucket-23 23)
-  (bucket-24 24)
-  (bucket-25 25)
-  (bucket-26 26)
-  (bucket-27 27)
-  (bucket-28 28)
-  (bucket-29 29)
-  (bucket-30 30)
-  (bucket-31 31)
-  (bucket-32 32)
-  (bucket-33 33)
-  (bucket-34 34)
-  (bucket-35 35)
-  (bucket-36 36)
-  (bucket-37 37)
-  (bucket-38 38)
-  (bucket-39 39)
-  (bucket-40 40)
-  (bucket-41 41)
-  (bucket-42 42)
-  (bucket-43 43)
-  (bucket-44 44)
-  (bucket-45 45)
-  (bucket-46 46)
-  (bucket-47 47)
-  (bucket-48 48)
-  (bucket-49 49)
-  (bucket-50 50)
-  (bucket-51 51)
-  (bucket-52 52)
-  (bucket-53 53)
-  (bucket-54 54)
-  (bucket-55 55)
-  (bucket-56 56)
-  (bucket-57 57)
-  (bucket-58 58)
-  (bucket-59 59)
-  (bucket-60 60)
-  (bucket-61 61)
-  (bucket-62 62)
-  (bucket-63 63)
-  (bucket-64 64)
-  (bucket-65 65)
-  (bucket-66 66)
-  (bucket-67 67)
-  (bucket-68 68)
-  (bucket-69 69)
-  (bucket-70 70)
-  (bucket-71 71)
-  (bucket-72 72)
-  (bucket-73 73)
-  (bucket-74 74)
-  (bucket-75 75)
-  (bucket-76 76)
-  (bucket-77 77)
-  (bucket-78 78)
-  (bucket-79 79)
-  (bucket-80 80)
-  (bucket-81 81)
-  (bucket-82 82)
-  (bucket-83 83)
-  (bucket-84 84)
-  (bucket-85 85)
-  (bucket-86 86)
-  (bucket-87 87)
-  (bucket-88 88)
-  (bucket-89 89)
-  (bucket-90 90)
-  (bucket-91 91)
-  (bucket-92 92)
-  (bucket-93 93)
-  (bucket-94 94)
-  (bucket-95 95)
-  (bucket-96 96)
-  (bucket-97 97)
-  (bucket-98 98)
-  (bucket-99 99)
-  (bucket-100 100)
-  (bucket-101 101)
-  (bucket-102 102)
-  (bucket-103 103)
-  (bucket-104 104)
-  (bucket-105 105)
-  (bucket-106 106)
-  (bucket-107 107)
-  (bucket-108 108)
-  (bucket-109 109)
-  (bucket-110 110)
-  (bucket-111 111)
-  (bucket-112 112)
-  (bucket-113 113)
-  (bucket-114 114)
-  (bucket-115 115)
-  (bucket-116 116)
-  (bucket-117 117)
-  (bucket-118 118)
-  (bucket-119 119)
-  (bucket-120 120)
-  (bucket-121 121)
-  (bucket-122 122)
-  (bucket-123 123)
-  (bucket-124 124)
-  (bucket-125 125)
-  (bucket-126 126)
-  (bucket-127 127)
-  (bucket-128 128)
-  (bucket-129 129)
-  (bucket-130 130)
-  (bucket-131 131)
-  (bucket-132 132)
-  (bucket-133 133)
-  (bucket-134 134)
-  (bucket-135 135)
-  (bucket-136 136)
-  (bucket-137 137)
-  (bucket-138 138)
-  (bucket-139 139)
-  (bucket-140 140)
-  (bucket-141 141)
-  (bucket-142 142)
-  (bucket-143 143)
-  (bucket-144 144)
-  (bucket-145 145)
-  (bucket-146 146)
-  (bucket-147 147)
-  (bucket-148 148)
-  (bucket-149 149)
-  (bucket-150 150)
-  (bucket-151 151)
-  (bucket-152 152)
-  (bucket-153 153)
-  (bucket-154 154)
-  (bucket-155 155)
-  (bucket-156 156)
-  (bucket-157 157)
-  (bucket-158 158)
-  (bucket-159 159)
-  (bucket-160 160)
-  (bucket-161 161)
-  (bucket-162 162)
-  (bucket-163 163)
-  (bucket-164 164)
-  (bucket-165 165)
-  (bucket-166 166)
-  (bucket-167 167)
-  (bucket-168 168)
-  (bucket-169 169)
-  (bucket-170 170)
-  (bucket-171 171)
-  (bucket-172 172)
-  (bucket-173 173)
-  (bucket-174 174)
-  (bucket-175 175)
-  (bucket-176 176)
-  (bucket-177 177)
-  (bucket-178 178)
-  (bucket-179 179)
-  (bucket-180 180)
-  (bucket-181 181)
-  (bucket-182 182)
-  (bucket-183 183)
-  (bucket-184 184)
-  (bucket-185 185)
-  (bucket-186 186)
-  (bucket-187 187)
-  (bucket-188 188)
-  (bucket-189 189)
-  (bucket-190 190)
-  (bucket-191 191)
-  (bucket-192 192)
-  (bucket-193 193)
-  (bucket-194 194)
-  (bucket-195 195)
-  (bucket-196 196)
-  (bucket-197 197)
-  (bucket-198 198)
-  (bucket-199 199)
-  (bucket-200 200)
-  (bucket-201 201)
-  (bucket-202 202)
-  (bucket-203 203)
-  (bucket-204 204)
-  (bucket-205 205)
-  (bucket-206 206)
-  (bucket-207 207)
-  (bucket-208 208)
-  (bucket-209 209)
-  (bucket-210 210)
-  (bucket-211 211)
-  (bucket-212 212)
-  (bucket-213 213)
-  (bucket-214 214)
-  (bucket-215 215)
-  (bucket-216 216)
-  (bucket-217 217)
-  (bucket-218 218)
-  (bucket-219 219)
-  (bucket-220 220)
-  (bucket-221 221)
-  (bucket-222 222)
-  (bucket-223 223)
-  (bucket-224 224)
-  (bucket-225 225)
-  (bucket-226 226)
-  (bucket-227 227)
-  (bucket-228 228)
-  (bucket-229 229)
-  (bucket-230 230)
-  (bucket-231 231)
-  (bucket-232 232)
-  (bucket-233 233)
-  (bucket-234 234)
-  (bucket-235 235)
-  (bucket-236 236)
-  (bucket-237 237)
-  (bucket-238 238)
-  (bucket-239 239)
-  (bucket-240 240)
-  (bucket-241 241)
-  (bucket-242 242)
-  (bucket-243 243)
-  (bucket-244 244)
-  (bucket-245 245)
-  (bucket-246 246)
-  (bucket-247 247)
-  (bucket-248 248)
-  (bucket-249 249)
-  (bucket-250 250)
-  (bucket-251 251)
-  (bucket-252 252)
-  (bucket-253 253)
-  (bucket-254 254)
-  (bucket-255 255)
-  (bucket-256 256)
-  (bucket-257 257)
-  (bucket-258 258)
-  (bucket-259 259)
-  (bucket-260 260)
-  (bucket-261 261)
-  (bucket-262 262)
-  (bucket-263 263)
-  (bucket-264 264)
-  (bucket-265 265)
-  (bucket-266 266)
-  (bucket-267 267)
-  (bucket-268 268)
-  (bucket-269 269)
-  (bucket-270 270)
-  (bucket-271 271)
-  (bucket-272 272)
-  (bucket-273 273)
-  (bucket-274 274)
-  (bucket-275 275)
-  (bucket-276 276)
-  (bucket-277 277)
-  (bucket-278 278)
-  (bucket-279 279)
-  (bucket-280 280)
-  (bucket-281 281)
-  (bucket-282 282)
-  (bucket-283 283)
-  (bucket-284 284)
-  (bucket-285 285)
-  (bucket-286 286)
-  (bucket-287 287)
-  (bucket-288 288)
-  (bucket-289 289)
-  (bucket-290 290)
-  (bucket-291 291)
-  (bucket-292 292)
-  (bucket-293 293)
-  (bucket-294 294)
-  (bucket-295 295)
-  (bucket-296 296)
-  (bucket-297 297)
-  (bucket-298 298)
-  (bucket-299 299)
-  (bucket-300 300)
-  (bucket-301 301)
-  (bucket-302 302)
-  (bucket-303 303)
-  (bucket-304 304)
-  (bucket-305 305)
-  (bucket-306 306)
-  (bucket-307 307)
-  (bucket-308 308)
-  (bucket-309 309)
-  (bucket-310 310)
-  (bucket-311 311)
-  (bucket-312 312)
-  (bucket-313 313)
-  (bucket-314 314)
-  (bucket-315 315)
-  (bucket-316 316)
-  (bucket-317 317)
-  (bucket-318 318)
-  (bucket-319 319)
-  (bucket-320 320)
-  (bucket-321 321)
-  (bucket-322 322)
-  (bucket-323 323)
-  (bucket-324 324)
-  (debug-no-zbuf 325)
+
+  ;;;;;;;;;;
+
+  (bucket-0      0)
+  (bucket-1      1)
+  (bucket-2      2)
+  (bucket-3      3)   ;; blit displays
+  (tex-lcom-sky-pre  4)   ;; tex
+  (bucket-5      5)   ;; sky
+  (bucket-6      6)   ;; ocean
+
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; All levels with tfrag tpage
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  (tex-l0-tfrag      7)   ;; level 0 tex
+  (bucket-8          8)   ;; tfrag
+  (bucket-9          9)   ;; tie
+  (bucket-10        10)   ;; tie
+  (bucket-11        11)   ;; tfrag
+  (bucket-12        12)   ;; tie
+  (bucket-13        13)   ;; tie
+  (merc-l0-tfrag    14)   ;; merc
+  (emerc-l0-tfrag   15)   ;; emerc
+  (bucket-16        16)   ;; mercneric
+  (bucket-17        17)   ;; tie
+
+  (tex-l1-tfrag     18)   ;; tex
+  (bucket-19        19)   ;; tfrag
+  (bucket-20        20)   ;; tie
+  (bucket-21        21)   ;; tie
+  (bucket-22        22)   ;; tfrag
+  (bucket-23        23)   ;; tie
+  (bucket-24        24)   ;; tie
+  (merc-l1-tfrag    25)   ;; merc
+  (emerc-l1-tfrag   26)   ;; emerc
+  (bucket-27        27)   ;; mercneric
+  (bucket-28        28)   ;; tie
+
+  (tex-l2-tfrag     29)   ;; tex
+  (bucket-30        30)   ;; tfrag
+  (bucket-31        31)   ;; tie
+  (bucket-32        32)   ;; tie
+  (bucket-33        33)   ;; tfrag
+  (bucket-34        34)   ;; tie
+  (bucket-35        35)   ;; tie
+  (merc-l2-tfrag    36)   ;; merc
+  (emerc-l2-tfrag   37)   ;; emerc
+  (bucket-38        38)   ;; mercneric
+  (bucket-39        39)   ;; tie
+
+  (tex-l3-tfrag     40)   ;; tex
+  (bucket-41        41)   ;; tfrag
+  (bucket-42        42)   ;; tie
+  (bucket-43        43)   ;; tie
+  (bucket-44        44)   ;; tfrag
+  (bucket-45        45)   ;; tie
+  (bucket-46        46)   ;; tie
+  (merc-l3-tfrag    47)   ;; merc
+  (emerc-l3-tfrag   48)   ;; emerc
+  (bucket-49        49)   ;; mercneric
+  (bucket-50        50)   ;; tie
+
+  (tex-l4-tfrag     51)   ;; tex
+  (bucket-52        52)   ;; tfrag
+  (bucket-53        53)   ;; tie
+  (bucket-54        54)   ;; tie
+  (bucket-55        55)   ;; tfrag
+  (bucket-56        56)   ;; tie
+  (bucket-57        57)   ;; tie
+  (merc-l4-tfrag    58)   ;; merc
+  (emerc-l4-tfrag   59)   ;; emerc
+  (bucket-60        60)   ;; mercneric
+  (bucket-61        61)   ;; tie
+
+  (tex-l5-tfrag     62)   ;; tex
+  (bucket-63        63)   ;; tfrag
+  (bucket-64        64)   ;; tie
+  (bucket-65        65)   ;; tie
+  (bucket-66        66)   ;; tfrag
+  (bucket-67        67)   ;; tie
+  (bucket-68        68)   ;; tie
+  (merc-l5-tfrag    69)   ;; merc
+  (emerc-l5-tfrag   70)   ;; emerc
+  (bucket-71        71)   ;; mercneric
+  (bucket-72        72)   ;; tie
+
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; All levels with shrub tpage
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  (tex-l0-shrub      73)   ;; tex
+  (bucket-74         74)   ;; shrub
+  (bucket-75         75)   ;; shrub
+  (bucket-76         76)   ;; shrub
+  (bucket-77         77)   ;; shrub
+  (bucket-78         78)   ;; shrub
+  (merc-l0-shrub     79)   ;; merc
+  (emerc-l0-shrub    80)   ;; emerc
+  (bucket-81         81)   ;; mercneric
+
+  (tex-l1-shrub      82)   ;; tex
+  (bucket-83         83)   ;; shrub
+  (bucket-84         84)   ;; shrub
+  (bucket-85         85)   ;; shrub
+  (bucket-86         86)   ;; shrub
+  (bucket-87         87)   ;; shrub
+  (merc-l1-shrub     88)   ;; merc
+  (emerc-l1-shrub    89)   ;; emerc
+  (bucket-90         90)   ;; mercneric
+
+  (tex-l2-shrub      91)   ;; tex
+  (bucket-92         92)   ;; shrub
+  (bucket-93         93)   ;; shrub
+  (bucket-94         94)   ;; shrub
+  (bucket-95         95)   ;; shrub
+  (bucket-96         96)   ;; shrub
+  (merc-l2-shrub     97)   ;; merc
+  (emerc-l2-shrub    98)   ;; emerc
+  (bucket-99         99)   ;; mercneric
+
+  (tex-l3-shrub     100)  ;; tex
+  (bucket-101       101)  ;; shrub
+  (bucket-102       102)  ;; shrub
+  (bucket-103       103)  ;; shrub
+  (bucket-104       104)  ;; shrub
+  (bucket-105       105)  ;; shrub
+  (merc-l3-shrub    106)  ;; merc
+  (emerc-l3-shrub   107)  ;; emerc
+  (bucket-108       108)  ;; mercneric
+
+  (tex-l4-shrub     109)  ;; tex
+  (bucket-110       110)  ;; shrub
+  (bucket-111       111)  ;; shrub
+  (bucket-112       112)  ;; shrub
+  (bucket-113       113)  ;; shrub
+  (bucket-114       114)  ;; shrub
+  (merc-l4-shrub    115)  ;; merc
+  (emerc-l4-shrub   116)  ;; emerc
+  (bucket-117       117)  ;; mercneric
+
+  (tex-l5-shrub     118)  ;; tex
+  (bucket-119       119)  ;; shrub
+  (bucket-120       120)  ;; shrub
+  (bucket-121       121)  ;; shrub
+  (bucket-122       122)  ;; shrub
+  (bucket-123       123)  ;; shrub
+  (merc-l5-shrub    124)  ;; merc
+  (emerc-l5-shrub   125)  ;; emerc
+  (bucket-126       126)  ;; mercneric
+
+  (tex-l0-alpha     127)  ;; tex
+  (bucket-128       128)  ;; tfrag
+  (bucket-129       129)  ;; tie
+  (bucket-130       130)  ;; tie
+  (merc-l0-alpha    131)  ;; merc
+  (emerc-l0-alpha   132)  ;; emerc
+  (bucket-133       133)  ;; mercneric
+  (bucket-134       134)  ;; tfrag
+  (bucket-135       135)  ;; tie
+  (bucket-136       136)  ;; tie
+
+  (tex-l1-alpha     137)  ;; tex
+  (bucket-138       138)  ;; tfrag
+  (bucket-139       139)  ;; tie
+  (bucket-140       140)  ;; tie
+  (merc-l1-alpha    141)  ;; merc
+  (emerc-l1-alpha   142)  ;; emerc
+  (bucket-143       143)  ;; mercneric
+  (bucket-144       144)  ;; tfrag
+  (bucket-145       145)  ;; tie
+  (bucket-146       146)  ;; tie
+
+  (tex-l2-alpha     147)  ;; tex
+  (bucket-148       148)  ;; tfrag
+  (bucket-149       149)  ;; tie
+  (bucket-150       150)  ;; tie
+  (merc-l2-alpha    151)  ;; merc
+  (emerc-l2-alpha   152)  ;; emerc
+  (bucket-153       153)  ;; mercneric
+  (bucket-154       154)  ;; tfrag
+  (bucket-155       155)  ;; tie
+  (bucket-156       156)  ;; tie
+
+  (tex-l3-alpha     157)  ;; tex
+  (bucket-158       158)  ;; tfrag
+  (bucket-159       159)  ;; tie
+  (bucket-160       160)  ;; tie
+  (merc-l3-alpha    161)  ;; merc
+  (emerc-l3-alpha   162)  ;; emerc
+  (bucket-163       163)  ;; mercneric
+  (bucket-164       164)  ;; tfrag
+  (bucket-165       165)  ;; tie
+  (bucket-166       166)  ;; tie
+
+  (tex-l4-alpha     167)  ;; tex
+  (bucket-168       168)  ;; tfrag
+  (bucket-169       169)  ;; tie
+  (bucket-170       170)  ;; tie
+  (merc-l4-alpha    171)  ;; merc
+  (emerc-l4-alpha   172)  ;; emerc
+  (bucket-173       173)  ;; mercneric
+  (bucket-174       174)  ;; tfrag
+  (bucket-175       175)  ;; tie
+  (bucket-176       176)  ;; tie
+
+  (tex-l5-alpha     177)  ;; tex
+  (bucket-178       178)  ;; tfrag
+  (bucket-179       179)  ;; tie
+  (bucket-180       180)  ;; tie
+  (merc-l5-alpha    181)  ;; merc
+  (emerc-l5-alpha   182)  ;; emerc
+  (bucket-183       183)  ;; mercneric
+  (bucket-184       184)  ;; tfrag
+  (bucket-185       185)  ;; tie
+  (bucket-186       186)  ;; tie
+
+  (tex-lcom-tfrag   187)  ;; tex
+  (merc-lcom-tfrag  188)  ;; merc
+  (emerc-lcom-tfrag 189)  ;; emerc
+  (bucket-190       190)  ;; mercneric
+
+  (tex-lcom-shrub   191)  ;; tex
+  (merc-lcom-shrub  192)  ;; merc
+  (emerc-lcom-shrub 193)  ;; emerc
+  (bucket-194       194)  ;; mercneric
+
+  (bucket-195       195)  ;; shadow
+
+  (tex-l0-pris      196)  ;; tex
+  (merc-l0-pris     197)  ;; merc
+  (emerc-l0-pris    198)  ;; emerc
+  (bucket-199       199)  ;; mercneric
+
+  (tex-l1-pris      200)  ;; tex
+  (merc-l1-pris     201)  ;; merc
+  (emerc-l1-pris    202)  ;; emerc
+  (bucket-203       203)  ;; mercneric
+
+  (tex-l2-pris      204)  ;; tex
+  (merc-l2-pris     205)  ;; merc
+  (emerc-l2-pris    206)  ;; emerc
+  (bucket-207       207)  ;; mercneric
+
+  (tex-l3-pris      208)  ;; tex
+  (merc-l3-pris     209)  ;; merc
+  (emerc-l3-pris    210)  ;; emerc
+  (bucket-211       211)  ;; mercneric
+
+  (tex-l4-pris      212)  ;; tex
+  (merc-l4-pris     213)  ;; merc
+  (emerc-l4-pris    214)  ;; emerc
+  (bucket-215       215)  ;; mercneric
+
+  (tex-l5-pris      216)  ;; tex
+  (merc-l5-pris     217)  ;; merc
+  (emerc-l5-pris    218)  ;; emerc
+  (bucket-219       219)  ;; mercneric
+
+  (tex-lcom-pris    220)  ;; tex
+  (merc-lcom-pris   221)  ;; merc
+  (emerc-lcom-pris  222)  ;; emerc
+  (bucket-223       223)  ;; mercneric
+
+  (tex-l0-pris2     224)  ;; tex
+  (merc-l0-pris2    225)  ;; merc
+  (emerc-l0-pris2   226)  ;; emerc
+  (bucket-227       227)  ;; mercneric
+
+  (tex-l1-pris2     228)  ;; tex
+  (merc-l1-pris2    229)  ;; merc
+  (emerc-l1-pris2   230)  ;; emerc
+  (bucket-231       231)  ;; mercneric
+
+  (tex-l2-pris2     232)  ;; tex
+  (merc-l2-pris2    233)  ;; merc
+  (emerc-l2-pris2   234)  ;; emerc
+  (bucket-235       235)  ;; mercneric
+
+  (tex-l3-pris2     236)  ;; tex
+  (merc-l3-pris2    237)  ;; merc
+  (emerc-l3-pris2   238)  ;; emerc
+  (bucket-239       239)  ;; mercneric
+
+  (tex-l4-pris2     240)  ;; tex
+  (merc-l4-pris2    241)  ;; merc
+  (emerc-l4-pris2   242)  ;; emerc
+  (bucket-243       243)  ;; mercneric
+
+  (tex-l5-pris2     244)  ;; tex
+  (merc-l5-pris2    245)  ;; merc
+  (emerc-l5-pris2   246)  ;; emerc
+  (bucket-247       247)  ;; mercneric
+
+  (tex-lcom-pris2   248)  ;; tex
+  (merc-lcom-pris2  249)  ;; merc
+  (emerc-lcom-pris2 250)  ;; emerc
+  (bucket-251       251)  ;; mercneric
+
+  (tex-l0-water     252)  ;; tex
+  (merc-l0-water    253)  ;; merc
+  (bucket-254       254)  ;; mercneric
+  (bucket-255       255)  ;; tfrag
+  (bucket-256       256)
+  (bucket-257       257)
+  (bucket-258       258)
+  (bucket-259       259)  ;; tfrag
+  (bucket-260       260)
+
+  (tex-l1-water     261)  ;; tex
+  (merc-l1-water    262)  ;; merc
+  (bucket-263       263)  ;; mercneric
+  (bucket-264       264)  ;; tfrag
+  (bucket-265       265)
+  (bucket-266       266)
+  (bucket-267       267)
+  (bucket-268       268)  ;; tfrag
+  (bucket-269       269)
+
+  (tex-l2-water     270)  ;; tex
+  (merc-l2-water    271)  ;; merc
+  (bucket-272       272)  ;; mercneric
+  (bucket-273       273)  ;; tfrag
+  (bucket-274       274)
+  (bucket-275       275)
+  (bucket-276       276)
+  (bucket-277       277)  ;; tfrag
+  (bucket-278       278)
+
+  (tex-l3-water     279)  ;; tex
+  (merc-l3-water    280)  ;; merc
+  (bucket-281       281)  ;; mercneric
+  (bucket-282       282)  ;; tfrag
+  (bucket-283       283)
+  (bucket-284       284)
+  (bucket-285       285)
+  (bucket-286       286)  ;; tfrag
+  (bucket-287       287)
+
+  (tex-l4-water     288)  ;; tex
+  (merc-l4-water    289)  ;; merc
+  (bucket-290       290)  ;; mercneric
+  (bucket-291       291)  ;; tfrag
+  (bucket-292       292)
+  (bucket-293       293)
+  (bucket-294       294)
+  (bucket-295       295)  ;; tfrag
+  (bucket-296       296)
+
+  (tex-l5-water     297)  ;; tex
+  (merc-l5-water    298)  ;; merc
+  (bucket-299       299)  ;; mercneric
+  (bucket-300       300)  ;; tfrag
+  (bucket-301       301)
+  (bucket-302       302)
+  (bucket-303       303)
+  (bucket-304       304)  ;; tfrag
+  (bucket-305       305)
+
+  (tex-lcom-water   306)  ;; tex
+  (merc-lcom-water  307)  ;; merc
+  (bucket-308       308)  ;; mercneric
+
+  (tex-lcom-sky-post 309)
+
+  (bucket-310       310)  ;; ocean
+  (bucket-311       311)  ;; depth-cue
+
+  (tex-all-sprite   312)
+  (bucket-313       313)  ;; particles
+  (bucket-314       314)  ;; shadow
+  (bucket-315       315)  ;; effects
+  (tex-all-warp     316)  ;; tex
+  (bucket-317       317)  ;; mercneric
+  (bucket-318       318)  ;; debug, no zbuf
+  (tex-all-map      319)  ;; tex
+  (bucket-320       320)  ;; hud
+  (bucket-321       321)  ;; hud letterbox, no zbuf
+  (bucket-322       322)  ;; hud
+  (bucket-323       323)  ;; hud
+  (bucket-324   324)  ;; debug
+  (debug-no-zbuf 325)  ;; debug
   (debug-unknown-326 326)
   )
 
@@ -3058,6 +3142,12 @@
   (sky    9)
   )
 
+(defenum tpage-category-u32
+  :type uint32
+  :copy-entries tpage-category
+  )
+
+
 (deftype dma-foreground-sink (basic)
   ((bucket                   bucket-id      :offset-assert 4)
    (foreground-texture-page  tpage-category :offset-assert 8)
@@ -4732,8 +4822,8 @@
    (common-page-mask         int32                           :offset-assert 180)
    (update-sprites-flag      symbol                          :offset-assert 184)
    (update-flag              symbol                          :offset-assert 188)
-   (texture-enable-user      uint64                          :offset-assert 192)
-   (texture-enable-user-menu uint64                          :offset-assert 200)
+   (texture-enable-user      texture-enable-mask             :offset-assert 192)
+   (texture-enable-user-menu texture-enable-mask             :offset-assert 200)
    (ids                      uint32                  128     :offset-assert 208) ;; guessed by decompiler
    )
   :method-count-assert 26
@@ -4742,21 +4832,21 @@
   (:methods
     (new (symbol type) _type_ 0)
     (initialize! (_type_) _type_ 9)
-    (texture-pool-method-10 () none 10) ;; (print-usage (_type_) _type_ 10)
-    (texture-pool-method-11 () none 11) ;; (setup-font-texture! (_type_) none 11)
-    (allocate-defaults! (_type_) none 12)
+    (print-usage (_type_) _type_ 10)
+    (setup-font-texture (_type_) none 11)
+    (allocate-defaults (_type_) none 12)
     (login-level-textures (_type_ level int (pointer texture-id)) none 13)
-    (texture-pool-method-14 () none 14) ;; (add-tex-to-dma! (_type_ level int) none 14)
+    (add-level-tpage-dma (_type_ level tpage-category bucket-id) none 14)
     (allocate-vram-words! (_type_ int) int 15)
-    (allocate-segment! (_type_ texture-pool-segment int) texture-pool-segment 16)
-    (texture-pool-method-17 () none 17) ;; (unused-17 () none 17)
-    (texture-pool-method-18 (_type_ int) int 18) ;; (unused-18 () none 18)
-    (update-warp-and-hud (_type_) none 19) ;; (unused-19 () none 19)
-    (update-sprites (_type_) none 20) ;; (unload! (_type_ texture-page) int 20)
-    (flag-update-and-sprite (_type_) none 21) ;; (upload-one-common! (_type_ level) symbol 21)
-    (relocate-sprite-dests! (_type_) none 22) ;; (lookup-boot-common-id (_type_ int) int 22)
-    (relocate-hud-dests! (_type_) none 23)
-    (relocate-warp-dests! (_type_) none 24)
+    (allocate-segment (_type_ texture-pool-segment int) texture-pool-segment 16)
+    (unload-page (_type_ texture-page) none 17)
+    (get-common-page-slot-by-id (_type_ int) int 18)
+    (update-warp-and-hud (_type_) none 19)
+    (update-sprites (_type_) none 20)
+    (mark-hud-warp-sprite-dirty (_type_) none 21)
+    (lay-out-sprite-tex (_type_) none 22)
+    (lay-out-hud-tex (_type_) none 23)
+    (lay-out-warp-tex (_type_) none 24)
     (clear-ids (_type_) none 25)
     )
   )
@@ -4822,9 +4912,17 @@
   :flag-assert         #x90000000c
   )
 
+(defenum tex-upload-mode
+  (none     -3)
+  (seg0-1   -2)
+  (seg0-1-2 -1)
+  (seg0      0)
+  (seg2      2)
+  )
+
 (deftype texture-page (basic)
   ((info      file-info                      :offset-assert 4)
-   (name      basic                          :offset-assert 8)
+   (name      string                         :offset-assert 8)
    (id        uint32                         :offset-assert 12)
    (length    int32                          :offset-assert 16)
    (mip0-size uint32                         :offset-assert 20)
@@ -4838,11 +4936,12 @@
   :size-assert         #x80
   :flag-assert         #xe00000080
   (:methods
-    (remove-from-heap (_type_ kheap) _type_ 9)
+    (relocate (_type_ kheap (pointer uint8)) texture-page :replace 7)
+    (remove-data-from-heap (_type_ kheap) _type_ 9)
     (get-leftover-block-count (_type_ int int) int 10)
-    (relocate-dests! (_type_ int int) none 11) ;; (unused-11 () none 11)
-    (texture-page-method-12 () none 12) ;;
-    (upload-now! (_type_ int) none 13) ;; (add-to-dma-buffer (_type_ dma-buffer int) int 13)
+    (relocate-dests! (_type_ int int) none 11)
+    (add-to-dma-buffer (_type_ dma-buffer tex-upload-mode) int 12)
+    (upload-now! (_type_ tex-upload-mode) none 13)
     )
   )
 
@@ -4891,8 +4990,8 @@
 (defenum link-test-flags
   :type uint32
   :bitfield #t
-  ; (needs-log-in 8)
-  ; (bit-9 9)
+  (needs-log-in 8)
+  (bit-9 9)
   )
 
 
@@ -4901,7 +5000,7 @@
    (prims      gs-reg64        10 :offset 0 :score -100)
    (reg-0      uint8              :offset 8)
    (reg-1      uint8              :offset 24)
-   (reg-2      uint8              :offset 40)
+   (reg-2      uint8              :offset 40 :score -1)
    (reg-3      uint8              :offset 56)
    (reg-4-u32  gs-reg32           :offset 72)
    (reg-4      uint8              :offset 72)
@@ -4943,8 +5042,8 @@
 (deftype texture-page-translate-item (structure)
   ((bucket             bucket-id  :offset-assert 0)
    (level-index        uint32     :offset-assert 4)
-   (level-texture-page uint32     :offset-assert 8)
-   (texture-user       uint32     :offset-assert 12)
+   (level-texture-page tpage-category-u32     :offset-assert 8)
+   (texture-user       texture-enable-mask-u32     :offset-assert 12)
    )
   :method-count-assert 9
   :size-assert         #x10
@@ -4957,7 +5056,7 @@
    )
   (:methods
     (relocate (_type_ kheap (pointer uint8)) none :replace 7)
-    (unlink-textures-in-heap! (_type_ kheap) int 9)
+    (unlink-shaders-in-heap (_type_ kheap) int 9)
     )
   :flag-assert #xa00000014
   )
@@ -5841,7 +5940,7 @@
    (load-time float :offset-assert 156)
    (load-login-time float :offset-assert 160)
    (draw-level-count int32 :offset-assert 164)
-   (draw-level basic 7 :offset-assert 168)
+   (draw-level level 7 :offset-assert 168)
    (draw-index-map uint8 7 :offset-assert 196)
    (load-order uint64 :offset-assert 208)
    ;; ?
@@ -6233,7 +6332,7 @@
 
 (define-extern *font-default-matrix* matrix)
 (define-extern *font-work* font-work)
-(define-extern font-set-tex0 (function (pointer gs-tex0) texture uint uint uint none))
+(define-extern font-set-tex0 (function (pointer gs-tex0) texture int int int none))
 (define-extern set-font-color (function int int int int int none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -7479,37 +7578,35 @@
 (define-extern texture-page-font-allocate (function texture-pool texture-page kheap int texture-page))
 (define-extern texture-page-common-boot-allocate (function texture-pool texture-page kheap int texture-page))
 (define-extern upload-vram-data (function dma-buffer int pointer int int none))
-(define-extern upload-vram-pages  (function texture-pool texture-pool-segment texture-page int bucket-id int))
-(define-extern update-vram-pages (function texture-pool texture-pool-segment texture-page int int))
-(define-extern upload-vram-pages-pris (function texture-pool texture-pool-segment texture-page bucket-id int int))
+(define-extern upload-vram-pages  (function texture-pool texture-pool-segment texture-page tex-upload-mode bucket-id int))
+(define-extern update-vram-pages (function texture-pool texture-pool-segment texture-page tex-upload-mode int))
+(define-extern upload-vram-pages-pris (function texture-pool texture-pool-segment texture-page bucket-id (pointer int32) int))
 (define-extern texture-page-level-allocate (function texture-pool texture-page kheap int texture-page))
-;; (define-extern texture-page-size-check function) ;; (function texture-pool level symbol int)
-;; (define-extern set-skull-gem-masks function)
+(define-extern texture-page-size-check (function texture-pool level symbol int))
+(define-extern set-skull-gem-masks (function none))
 (define-extern upload-textures (function texture-pool none))
 (define-extern *txt-dma-list* dma-buffer)
-;; (define-extern texture-relocate function) ;; (function dma-buffer texture int gs-psm int dma-buffer)
+(define-extern texture-relocate (function dma-buffer texture int gs-psm int dma-buffer))
 (define-extern relocate-later (function symbol))
-;; (define-extern texture-page-login function) ;; (function texture-id (function texture-pool texture-page kheap int texture-page) kheap texture-page-dir-entry)
+(define-extern texture-page-login  (function texture-id (function texture-pool texture-page kheap int texture-page) kheap texture-page-dir-entry))
 (define-extern lookup-texture-by-id (function texture-id texture))
 (define-extern lookup-texture-by-id-fast (function texture-id texture))
-;; (define-extern lookup-texture-by-name function)
-(define-extern lookup-texture-id-by-name (function string symbol texture-id))
-;; (define-extern lookup-level-texture-by-name function)
+(define-extern lookup-texture-by-name (function string string (pointer texture-page) texture))
+(define-extern lookup-texture-id-by-name (function string string texture-id))
+(define-extern lookup-level-texture-by-name (function string level (pointer texture-page) texture))
 (define-extern *shader-list* pair)
 (define-extern *edit-shader* texture-id)
-;; (define-extern link-texture-by-id function) ;; (function texture-id adgif-shader texture-page-dir-entry)
+(define-extern link-texture-by-id (function texture-id adgif-shader texture-page-dir-entry))
 (define-extern adgif-shader<-texture! (function adgif-shader texture adgif-shader))
 (define-extern adgif-shader-update! (function adgif-shader texture none))
-;; (define-extern adgif-shader<-texture-with-update! function) ;; (function adgif-shader texture adgif-shader)
-;; (define-extern hack-texture function)
+(define-extern adgif-shader<-texture-with-update! (function adgif-shader texture adgif-shader))
+(define-extern hack-texture (function texture float))
 (define-extern adgif-shader-login (function adgif-shader texture))
 (define-extern adgif-shader-login-no-remap (function adgif-shader texture))
-;; (define-extern adgif-shader-login-fast function) ;; (function adgif-shader texture)
-;; (define-extern adgif-shader-login-no-remap-fast function) ;; (function adgif-shader texture)
+(define-extern adgif-shader-login-fast (function adgif-shader texture))
+(define-extern adgif-shader-login-no-remap-fast (function adgif-shader texture))
 (define-extern adgif-shader<-texture-simple! (function adgif-shader texture adgif-shader))
-(define-extern set-dirty-mask!
-  "First arg is the level name off the [[*level*]]'s `default-level`"
-  (function string int int int none))
+(define-extern set-dirty-mask! (function level int int int none))
 (define-extern texture-page-dir-inspect (function texture-page-dir symbol none))
 (define-extern *texture-pool* texture-pool)
 
@@ -20963,7 +21060,7 @@
      ;; (new (symbol type collide-shape int float) _type_ 0)
     (nav-control-method-9 () none 9) ;; (debug-draw (_type_) none 9)
     (point-in-bounds?
-      "Is the given point ([[vector]]) outside of the [[nav-mesh]]'s `bounds` [[sphere]] radius" 
+      "Is the given point ([[vector]]) outside of the [[nav-mesh]]'s `bounds` [[sphere]] radius"
       (_type_ vector) symbol 10)
     (nav-control-method-11 "TODO" (_type_ vector) vector 11) ;; (dummy-11 (_type_ vector) vector 11)
     (nav-control-method-12 () none 12) ;; (TODO-RENAME-12 (_type_ nav-gap-info) symbol 12)
@@ -21411,7 +21508,7 @@
 
 ;; (define-extern raw-ray-sphere-intersect function) ;; (function float float)
 (define-extern ray-sphere-intersect (function vector vector vector float float))
-(define-extern ray-circle-intersect (function vector vector vector float float)) ;; 
+(define-extern ray-circle-intersect (function vector vector vector float float)) ;;
 (define-extern ray-cylinder-intersect (function vector vector vector vector float float vector float))
 ;; (define-extern ray-plane-intersect function) ;; (function vector vector vector vector vector vector vector float)
 ;; (define-extern ray-triangle-intersect function) ;; (function vector vector float matrix vector vector float)
@@ -21539,7 +21636,7 @@
 ;; (define-extern *test-shrub* object) ;; int
 (define-extern bsp-camera-asm (function bsp-header vector none)) ;;
 (define-extern print-collide-stats (function none))
-;; (define-extern level-remap-texture function) ;; (function texture-id texture-id)
+(define-extern level-remap-texture (function texture-id texture-id))
 (define-extern build-masks (function bsp-header none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -22594,7 +22691,7 @@
 ;; (define-extern blend-clut-texture-anim-layer-func function)
 ;; (define-extern move-rg-to-ba-texture-anim-layer-func function)
 ;; (define-extern fill-rgb-texture-anim-layer-func function)
-;; (define-extern update-texture-anim function)
+(define-extern update-texture-anim (function bucket-id none))
 ;; (define-extern no-alpha-texture-anim-layer-func function)
 ;; (define-extern copy-alpha-texture-anim-layer-func function)
 ;; (define-extern copy-clut-alpha-texture-anim-layer-func function)
@@ -25677,7 +25774,7 @@
   :flag-assert         #x90000000c
   )
 
-(define-extern *camera-layout-blink* symbol) ;; 
+(define-extern *camera-layout-blink* symbol) ;;
 (define-extern *CAM_LAYOUT-bank* cam-layout-bank) ;; cam-layout-bank
 (define-extern *camera-layout-message-ypos* int) ;; int
 (define-extern *volume-point-current* int) ;; int
@@ -25686,33 +25783,33 @@
 (define-extern *volume-normal* vector-array) ;; vector-array
 (define-extern *volume-descriptor-current* int) ;; int
 (define-extern *volume-descriptor* vol-control) ;; vol-control
-(define-extern cam-layout-print (function int int string pointer)) ;; 
-(define-extern cam-layout-intersect-dist (function vector vector vector float)) ;; 
-(define-extern cam-layout-entity-volume-info-create (function entity-camera symbol symbol :behavior cam-layout)) ;; 
-(define-extern cam-layout-entity-volume-info (function symbol :behavior cam-layout)) ;; 
-(define-extern v-slrp! (function vector vector vector float vector)) ;; 
-(define-extern interp-test (function (function vector vector vector float vector float none) interp-test-info none)) ;; 
-(define-extern interp-test-deg (function (function vector vector vector vector float none) interp-test-info none)) ;; 
-(define-extern cam-layout-entity-info (function entity-actor none)) ;; 
-(define-extern clmf-button-test "Displays the message `button test`" (function symbol)) ;; 
-(define-extern clmf-bna "Displays the message `button not available`" (function symbol)) ;; 
-(define-extern clmf-implement "Displays the message `button not implemented yet`" (function symbol)) ;; 
-(define-extern clmf-input (function vector vector int vector)) ;; 
-(define-extern clmf-pos-rot (function symbol symbol symbol :behavior cam-layout)) ;; 
-(define-extern clmf-next-volume (function int symbol :behavior cam-layout)) ;; 
-(define-extern clmf-next-vol-dpad (function symbol)) ;; 
-(define-extern clmf-to-edit-cam (function symbol)) ;; 
+(define-extern cam-layout-print (function int int string pointer)) ;;
+(define-extern cam-layout-intersect-dist (function vector vector vector float)) ;;
+(define-extern cam-layout-entity-volume-info-create (function entity-camera symbol symbol :behavior cam-layout)) ;;
+(define-extern cam-layout-entity-volume-info (function symbol :behavior cam-layout)) ;;
+(define-extern v-slrp! (function vector vector vector float vector)) ;;
+(define-extern interp-test (function (function vector vector vector float vector float none) interp-test-info none)) ;;
+(define-extern interp-test-deg (function (function vector vector vector vector float none) interp-test-info none)) ;;
+(define-extern cam-layout-entity-info (function entity-actor none)) ;;
+(define-extern clmf-button-test "Displays the message `button test`" (function symbol)) ;;
+(define-extern clmf-bna "Displays the message `button not available`" (function symbol)) ;;
+(define-extern clmf-implement "Displays the message `button not implemented yet`" (function symbol)) ;;
+(define-extern clmf-input (function vector vector int vector)) ;;
+(define-extern clmf-pos-rot (function symbol symbol symbol :behavior cam-layout)) ;;
+(define-extern clmf-next-volume (function int symbol :behavior cam-layout)) ;;
+(define-extern clmf-next-vol-dpad (function symbol)) ;;
+(define-extern clmf-to-edit-cam (function symbol)) ;;
 (define-extern *last-cur-entity* int) ;; int
-(define-extern clmf-next-entity (function int symbol :behavior cam-layout)) ;; 
-(define-extern clmf-to-spline-attr (function symbol)) ;; 
-(define-extern clmf-to-intro-attr (function symbol)) ;; 
-(define-extern clmf-to-index-attr (function symbol)) ;; 
+(define-extern clmf-next-entity (function int symbol :behavior cam-layout)) ;;
+(define-extern clmf-to-spline-attr (function symbol)) ;;
+(define-extern clmf-to-intro-attr (function symbol)) ;;
+(define-extern clmf-to-index-attr (function symbol)) ;;
 (define-extern clmf-to-focalpull-attr (function symbol)) ;; (function symbol)
-(define-extern clmf-to-edit (function symbol :behavior cam-layout)) ;; 
+(define-extern clmf-to-edit (function symbol :behavior cam-layout)) ;;
 (define-extern clmf-to-select (function symbol)) ;; (function symbol)
-(define-extern clmf-look-through (function symbol :behavior cam-layout)) ;; 
-(define-extern fov->maya (function float float)) ;; 
-(define-extern cam-layout-save-cam-rot (function symbol string entity-actor none)) ;; 
+(define-extern clmf-look-through (function symbol :behavior cam-layout)) ;;
+(define-extern fov->maya (function float float)) ;;
+(define-extern cam-layout-save-cam-rot (function symbol string entity-actor none)) ;;
 (define-extern cam-layout-save-cam-trans (function symbol string entity-actor none)) ;; (function symbol string entity-actor string)
 (define-extern cam-layout-save-pivot (function symbol string entity-actor none)) ;; (function symbol string entity-actor string)
 (define-extern cam-layout-save-align (function symbol string entity-actor none)) ;; (function symbol string entity-actor string)
@@ -25735,19 +25832,19 @@
 (define-extern cam-layout-save-stringMaxHeight (function symbol string entity-actor none)) ;; (function symbol string entity-actor string)
 (define-extern cam-layout-save-stringCliffHeight (function symbol string entity-actor none)) ;; (function symbol string entity-actor string)
 (define-extern cam-layout-save-maxAngle (function symbol string entity-actor none)) ;; (function symbol string entity-actor string)
-(define-extern clmf-save-single (function entity-camera symbol symbol file-stream :behavior cam-layout)) ;; 
+(define-extern clmf-save-single (function entity-camera symbol symbol file-stream :behavior cam-layout)) ;;
 (define-extern clmf-save-one (function symbol symbol :behavior cam-layout)) ;; (function symbol symbol :behavior cam-layout)
 (define-extern clmf-save-all (function symbol symbol :behavior cam-layout)) ;; (function symbol symbol :behavior cam-layout)
 (define-extern clmf-cam-flag-toggle (function int int symbol :behavior cam-layout)) ;; (function int int symbol :behavior cam-layout)
-(define-extern clmf-cam-flag (function string uint uint symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-float-adjust (function symbol (pointer float) symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-meters (function meters symbol symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-fov (function degrees symbol symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-deg (function degrees symbol symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-intro-time (function float symbol symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-interp-time (function float symbol symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-float (function float symbol symbol :behavior cam-layout)) ;; 
-(define-extern clmf-cam-string (function string symbol symbol :behavior cam-layout)) ;; 
+(define-extern clmf-cam-flag (function string uint uint symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-float-adjust (function symbol (pointer float) symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-meters (function meters symbol symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-fov (function degrees symbol symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-deg (function degrees symbol symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-intro-time (function float symbol symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-interp-time (function float symbol symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-float (function float symbol symbol :behavior cam-layout)) ;;
+(define-extern clmf-cam-string (function string symbol symbol :behavior cam-layout)) ;;
 (define-extern *clm-focalpull-attr* clm) ;; clm
 (define-extern *clm-index-attr* clm) ;; clm
 (define-extern *clm-intro-attr* clm) ;; clm
@@ -25759,11 +25856,11 @@
 (define-extern *clm-save-one* clm) ;; clm
 (define-extern *clm-select* clm) ;; clm
 (define-extern *clm* clm) ;; clm
-(define-extern cam-layout-do-action (function clm-item-action symbol :behavior cam-layout)) ;; 
-(define-extern cam-layout-function-call (function symbol string int basic symbol :behavior cam-layout)) ;; 
-(define-extern cam-layout-do-menu (function clm symbol :behavior cam-layout)) ;; 
-(define-extern cam-layout-active (state cam-layout)) ;; 
-(define-extern cam-layout-init (function object :behavior cam-layout)) ;; 
+(define-extern cam-layout-do-action (function clm-item-action symbol :behavior cam-layout)) ;;
+(define-extern cam-layout-function-call (function symbol string int basic symbol :behavior cam-layout)) ;;
+(define-extern cam-layout-do-menu (function clm symbol :behavior cam-layout)) ;;
+(define-extern cam-layout-active (state cam-layout)) ;;
+(define-extern cam-layout-init (function object :behavior cam-layout)) ;;
 (define-extern cam-layout-stop (function symbol))
 (define-extern cam-layout-start (function symbol))
 (define-extern cam-layout-restart (function symbol))
@@ -27718,42 +27815,42 @@
   (current-selection 3))
 ;; ---debug-h:debug-menu-dest
 
-(define-extern debug-menu-item-var-update-display-str (function debug-menu-item-var debug-menu-item-var)) ;; 
+(define-extern debug-menu-item-var-update-display-str (function debug-menu-item-var debug-menu-item-var)) ;;
 (define-extern debug-menu-item-var-make-int (function debug-menu-item-var (function int debug-menu-msg int int int) int symbol int int symbol debug-menu-item-var))
 (define-extern debug-menu-item-var-make-float (function debug-menu-item-var (function int debug-menu-msg float float float) float symbol float float int debug-menu-item-var))
-(define-extern debug-menu-context-grab-joypad (function debug-menu-context basic (function basic none) symbol)) ;; 
-(define-extern debug-menu-context-release-joypad (function debug-menu-context symbol)) ;; 
-(define-extern debug-menu-item-get-max-width (function debug-menu-item debug-menu int)) ;; 
-(define-extern debug-menu-context-default-selection (function debug-menu-context symbol debug-menu-context)) ;; 
-(define-extern debug-menu-rebuild (function debug-menu debug-menu)) ;; 
+(define-extern debug-menu-context-grab-joypad (function debug-menu-context basic (function basic none) symbol)) ;;
+(define-extern debug-menu-context-release-joypad (function debug-menu-context symbol)) ;;
+(define-extern debug-menu-item-get-max-width (function debug-menu-item debug-menu int)) ;;
+(define-extern debug-menu-context-default-selection (function debug-menu-context symbol debug-menu-context)) ;;
+(define-extern debug-menu-rebuild (function debug-menu debug-menu)) ;;
 (define-extern debug-menu-context-set-root-menu (function debug-menu-context debug-menu debug-menu-context))
 (define-extern debug-menu-append-item (function debug-menu debug-menu-node debug-menu-node))
 (define-extern debug-menu-remove-all-items (function debug-menu debug-menu))
-(define-extern debug-menu-func-decode (function object function)) ;; 
+(define-extern debug-menu-func-decode (function object function)) ;;
 (define-extern debug-menu-make-from-template (function debug-menu-context pair debug-menu-node))
 (define-extern debug-menu-find-from-template (function debug-menu-context pair debug-menu))
-(define-extern debug-menu-item-submenu-render (function debug-menu-item-submenu int int int symbol debug-menu-item-submenu)) ;; 
-(define-extern debug-menu-item-function-render (function debug-menu-item-function int int int symbol debug-menu-item-function)) ;; 
-(define-extern debug-menu-item-flag-render (function debug-menu-item-flag int int int symbol debug-menu-item-flag)) ;; 
-(define-extern debug-menu-item-var-render (function debug-menu-item-var int int int symbol debug-menu-item-var)) ;; 
-(define-extern debug-menu-item-render (function debug-menu-item int int int symbol debug-menu-item)) ;; 
-(define-extern debug-menu-render (function debug-menu int int debug-menu-node int debug-menu)) ;; 
-(define-extern debug-menu-context-render (function debug-menu-context debug-menu-context)) ;; 
-(define-extern debug-menu-context-select-next-or-prev-item (function debug-menu-context int debug-menu-context)) ;; 
-(define-extern debug-menu-context-select-new-item (function debug-menu-context int debug-menu-context)) ;; 
-(define-extern debug-menu-context-open-submenu (function debug-menu-context debug-menu basic)) ;; 
-(define-extern debug-menu-context-close-submenu (function debug-menu-context debug-menu-context)) ;; 
-(define-extern debug-menu-item-submenu-msg (function debug-menu-item-submenu debug-menu-msg debug-menu-item-submenu)) ;; 
-(define-extern debug-menu-item-function-msg (function debug-menu-item-function debug-menu-msg debug-menu-item-function)) ;; 
-(define-extern debug-menu-item-flag-msg (function debug-menu-item-flag debug-menu-msg debug-menu-item-flag)) ;; 
-(define-extern debug-menu-item-var-joypad-handler (function debug-menu-item-var debug-menu-msg debug-menu-item-var)) ;; 
-(define-extern debug-menu-item-var-msg (function debug-menu-item-var debug-menu-msg debug-menu-item-var)) ;; 
-(define-extern debug-menu-item-send-msg (function debug-menu-item debug-menu-msg debug-menu-item)) ;; 
-(define-extern debug-menu-send-msg (function debug-menu debug-menu-msg symbol debug-menu)) ;; 
+(define-extern debug-menu-item-submenu-render (function debug-menu-item-submenu int int int symbol debug-menu-item-submenu)) ;;
+(define-extern debug-menu-item-function-render (function debug-menu-item-function int int int symbol debug-menu-item-function)) ;;
+(define-extern debug-menu-item-flag-render (function debug-menu-item-flag int int int symbol debug-menu-item-flag)) ;;
+(define-extern debug-menu-item-var-render (function debug-menu-item-var int int int symbol debug-menu-item-var)) ;;
+(define-extern debug-menu-item-render (function debug-menu-item int int int symbol debug-menu-item)) ;;
+(define-extern debug-menu-render (function debug-menu int int debug-menu-node int debug-menu)) ;;
+(define-extern debug-menu-context-render (function debug-menu-context debug-menu-context)) ;;
+(define-extern debug-menu-context-select-next-or-prev-item (function debug-menu-context int debug-menu-context)) ;;
+(define-extern debug-menu-context-select-new-item (function debug-menu-context int debug-menu-context)) ;;
+(define-extern debug-menu-context-open-submenu (function debug-menu-context debug-menu basic)) ;;
+(define-extern debug-menu-context-close-submenu (function debug-menu-context debug-menu-context)) ;;
+(define-extern debug-menu-item-submenu-msg (function debug-menu-item-submenu debug-menu-msg debug-menu-item-submenu)) ;;
+(define-extern debug-menu-item-function-msg (function debug-menu-item-function debug-menu-msg debug-menu-item-function)) ;;
+(define-extern debug-menu-item-flag-msg (function debug-menu-item-flag debug-menu-msg debug-menu-item-flag)) ;;
+(define-extern debug-menu-item-var-joypad-handler (function debug-menu-item-var debug-menu-msg debug-menu-item-var)) ;;
+(define-extern debug-menu-item-var-msg (function debug-menu-item-var debug-menu-msg debug-menu-item-var)) ;;
+(define-extern debug-menu-item-send-msg (function debug-menu-item debug-menu-msg debug-menu-item)) ;;
+(define-extern debug-menu-send-msg (function debug-menu debug-menu-msg symbol debug-menu)) ;;
 (define-extern debug-menu-context-send-msg (function debug-menu-context debug-menu-msg debug-menu-dest debug-menu-context))
-(define-extern debug-menu-context-activate-selection (function debug-menu-context debug-menu-context)) ;; 
-(define-extern debug-menus-default-joypad-func (function debug-menu-context debug-menu-context)) ;; 
-(define-extern debug-menus-active (function debug-menu-context debug-menu-context)) ;; 
+(define-extern debug-menu-context-activate-selection (function debug-menu-context debug-menu-context)) ;;
+(define-extern debug-menus-default-joypad-func (function debug-menu-context debug-menu-context)) ;;
+(define-extern debug-menus-active (function debug-menu-context debug-menu-context)) ;;
 (define-extern debug-menus-handler (function debug-menu-context debug-menu-context))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -28106,17 +28203,17 @@
 (define-extern nav-dma-send-to-spr-no-flush (function object object object none))
 (define-extern nav-dma-send-from-spr-no-flush (function none))
 ;; TODO - local vars and docstrings "Increments and returns the provided [[int]], if the value exceeds `2`, wrap back to `0`"
-(define-extern inc-mod3 (function int int)) ;; 
+(define-extern inc-mod3 (function int int)) ;;
 (define-extern nav-state-patch-pointers (function none))
-(define-extern vu-point-triangle-intersection? (function vector vector vector vector symbol)) ;; 
+(define-extern vu-point-triangle-intersection? (function vector vector vector vector symbol)) ;;
 (define-extern poly-in-height-range? (function nav-poly float float symbol))
-(define-extern init-ray-local (function nav-ray nav-poly vector vector none)) ;; 
-(define-extern init-ray-dir-local (function nav-ray nav-poly vector vector float none)) ;; 
-(define-extern nav-ray-test (function nav-mesh nav-poly vector vector meters)) ;; 
+(define-extern init-ray-local (function nav-ray nav-poly vector vector none)) ;;
+(define-extern init-ray-dir-local (function nav-ray nav-poly vector vector float none)) ;;
+(define-extern nav-ray-test (function nav-mesh nav-poly vector vector meters)) ;;
 (define-extern point-poly-distance-min (function nav-poly none))
 (define-extern nav-mesh-route-table-bit-index (function nav-mesh uint int int))
-(define-extern ray-ccw-line-segment-intersection? (function vector vector vector vector symbol)) ;; 
-(define-extern ray-line-segment-intersection? (function vector vector vector vector symbol)) ;; 
+(define-extern ray-ccw-line-segment-intersection? (function vector vector vector vector symbol)) ;;
+(define-extern ray-line-segment-intersection? (function vector vector vector vector symbol)) ;;
 (define-extern plane-height-at-xz-point (function plane vector float))
 (define-extern nav-normal-from-3-points (function vector vector vector vector none))
 (define-extern get-nav-mesh (function actor-id nav-mesh))
@@ -28171,10 +28268,10 @@
   "Adds the given [[sphere]] to the [[nav-control]]'s `sphere-array` so long as
    `max-spheres` is less than [[nav-control]]'s `sphere-count`"
   (function nav-control sphere int none))
-(define-extern add-collide-shape-spheres (function nav-control collide-shape sphere none)) ;; 
-(define-extern circle-tangent-directions (function vector vector vector vector vector)) ;; 
+(define-extern add-collide-shape-spheres (function nav-control collide-shape sphere none)) ;;
+(define-extern circle-tangent-directions (function vector vector vector vector vector)) ;;
 (define-extern circle-ray-intersection? (function vector vector float vector symbol))
-(define-extern find-closest-circle-ray-intersection (function vector vector float int (inline-array vector) int int)) ;; 
+(define-extern find-closest-circle-ray-intersection (function vector vector float int (inline-array vector) int int)) ;;
 ;; (define-extern compute-dir-parm function) ;; (function vector vector vector float)
 ;; (define-extern vector-rotate-y-sincos! function)
 ;; (define-extern test-xz-point-on-line-segment? function) ;; (function vector vector vector float symbol)
@@ -29523,7 +29620,7 @@
   :flag-assert         #x1e00000018
   (:methods
     (get-color
-      "Returns the [[rgba]] that corresponds to the type of [[editable]] TODO - document the colors" 
+      "Returns the [[rgba]] that corresponds to the type of [[editable]] TODO - document the colors"
       (_type_ int) rgba 9)
     (editable-method-10 (_type_) none 10)
     (editable-method-11 (_type_ vector) symbol 11)
@@ -30158,7 +30255,7 @@
 (define-extern debug-menu-make-instance-menu (function debug-menu-context debug-menu-item-submenu))
 (define-extern dm-task-menu-pick-func (function game-task debug-menu-msg symbol))
 (define-extern debug-menu-make-continue-sub-menu (function debug-menu-context symbol pair))
-(define-extern debug-menu-make-task-sub-menu "TODO - need to know more about game-info" (function debug-menu-context debug-menu-node))
+(define-extern debug-menu-make-task-sub-menu "TODO - need to know more about game-info" (function symbol pair))
 (define-extern debug-menu-make-task-menu (function debug-menu-context debug-menu-item-submenu))
 (define-extern dm-play-task-with-continue (function game-task string none))
 (define-extern dm-play-task (function game-task none))
@@ -50343,3 +50440,12 @@
 |#
 
 ;; (define-extern hiphog-activate function)
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; texture-upload                 ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-extern *default-envmap-shader* adgif-shader)
+(define-extern *generic-envmap-texture* texture)
diff --git a/decompiler/config/jak2/hacks.jsonc b/decompiler/config/jak2/hacks.jsonc
index 5f92ae4789..a6dff9f14e 100644
--- a/decompiler/config/jak2/hacks.jsonc
+++ b/decompiler/config/jak2/hacks.jsonc
@@ -158,7 +158,10 @@
     "(anon-function 24 grenadier)",
     // no longer bug or asm, not done yet
     "particle-adgif-callback",
-    "editable-menu-context-make-menus" // label guesser can't handle pairs
+    "editable-menu-context-make-menus", // label guesser can't handle pairs
+
+    // texture
+    "adgif-shader<-texture!"
   ],
 
   // these functions use pairs and the decompiler
@@ -247,6 +250,7 @@
     "(method 11 perf-stat)": [0],
     "(method 22 gui-control)": [117, 121, 127, 128, 129, 139],
     "bsp-camera-asm": [1, 2, 3, 4, 6, 7],
+    "(method 9 texture-page-dir)": [5, 6],
     "level-remap-texture": [2, 3, 4, 5, 6],
     "(method 27 nav-mesh)": [0, 1, 2, 4, 5],
     "(method 31 nav-mesh)": [0, 1, 2, 7, 8, 9, 11, 12, 13, 15],
@@ -274,6 +278,7 @@
     "draw-string-asm",
     "draw-string",
     "get-string-length",
+    "adgif-shader<-texture-with-update!",
     "init-boundary-regs"
   ],
 
diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc
index 305168baf2..45d6435a16 100644
--- a/decompiler/config/jak2/type_casts.jsonc
+++ b/decompiler/config/jak2/type_casts.jsonc
@@ -340,13 +340,32 @@
     [[32, 44], "a3", "gs-gif-tag"],
     [[47, 62], "a2", "dma-packet"]
   ],
-  "texture-page-default-allocate": [[51, "a3", "texture-page"]],
-  "texture-page-font-allocate": [[33, "a3", "texture-page"]],
+  "texture-page-default-allocate": [[51, "a3", "texture"]],
+  "texture-page-font-allocate": [[33, "a3", "texture"]],
   "(method 24 texture-pool)": [
     [67, "a1", "shader-ptr"],
-    [[70, 91], "a1", "adgif-shader"],
+    [[70, 93], "a1", "adgif-shader"],
     [92, "a1", "adgif-shader"]
   ],
+  "upload-vram-data": [
+    [[10, 17], "a0", "dma-packet"],
+    [[19, 26], "a0", "gs-gif-tag"],
+    [35, "a0", "(pointer gs-bitbltbuf)"],
+    [37, "a0", "(pointer gs-reg64)"],
+    [38, "a0", "(pointer gs-trxpos)"],
+    [40, "a0", "(pointer gs-reg64)"],
+    [46, "a0", "(pointer gs-trxreg)"],
+    [48, "a0", "(pointer gs-reg64)"],
+    [49, "a0", "(pointer gs-trxdir)"],
+    [51, "a0", "(pointer gs-reg64)"]
+  ],
+  "upload-vram-pages": [
+    [[140, 147], "a0", "dma-packet"],
+    [[149, 156], "a0", "gs-gif-tag"],
+    [160, "a0", "(pointer int64)"],
+    [162, "a0", "(pointer gs-reg64)"],
+    [[166, 172], "v1", "dma-packet"]
+  ],
   "(method 3 generic-tie-interp-point)": [[19, "gp", "(pointer uint128)"]],
   "(method 19 res-lump)": [
     [46, "t2", "(pointer uint64)"],
@@ -2002,6 +2021,80 @@
     [23, "a1", "texture-masks"],
     [24, "a1", "texture-mask"]
   ],
+  "upload-vram-pages-pris": [
+    [[134, 141], "a0", "dma-packet"],
+    [[143, 150], "a0", "gs-gif-tag"],
+    [154, "a0", "(pointer int64)"],
+    [156, "a0", "(pointer gs-reg64)"],
+    [[160, 166], "v1", "dma-packet"]
+  ],
+  "(method 14 texture-pool)": [
+    [22, "a3", "(pointer int32)"]
+  ],
+  "(method 13 texture-page)": [
+    [[16, 23], "a0", "dma-packet"],
+    [[25, 32], "a0", "gs-gif-tag"],
+    [36, "a0", "(pointer int64)"],
+    [38, "a0", "(pointer gs-reg64)"],
+    [[42, 45], "a0", "dma-packet"],
+    [45, "a0", "(pointer int64)"]
+  ],
+  "texture-relocate": [
+    [[17, 21], "t4", "dma-packet"],
+    [[27, 30], "t4", "gs-gif-tag"],
+    [60, "t4", "(pointer gs-bitbltbuf)"],
+    [62, "t4", "(pointer gs-reg64)"],
+    [63, "t4", "(pointer gs-trxpos)"],
+    [65, "t4", "(pointer gs-reg64)"],
+    [71, "t4", "(pointer gs-trxreg)"],
+    [73, "t4", "(pointer gs-reg64)"],
+    [75, "t4", "(pointer gs-trxdir)"],
+    [77, "t4", "(pointer gs-reg64)"],
+    [[98, 102], "a2", "dma-packet"],
+    [[108, 111], "a2", "gs-gif-tag"],
+    [132, "a2", "(pointer gs-bitbltbuf)"],
+    [134, "a2", "(pointer gs-reg64)"],
+    [135, "a2", "(pointer gs-trxpos)"],
+    [137, "a2", "(pointer gs-reg64)"],
+    [139, "a2", "(pointer gs-trxreg)"],
+    [141, "a2", "(pointer gs-reg64)"],
+    [143, "a2", "(pointer gs-trxdir)"],
+    [145, "a2", "(pointer gs-reg64)"],
+    [[157, 161], "a2", "dma-packet"],
+    [[167, 170], "a2", "gs-gif-tag"],
+    [191, "a2", "(pointer gs-bitbltbuf)"],
+    [193, "a2", "(pointer gs-reg64)"],
+    [194, "a2", "(pointer gs-trxpos)"],
+    [196, "a2", "(pointer gs-reg64)"],
+    [198, "a2", "(pointer gs-trxreg)"],
+    [200, "a2", "(pointer gs-reg64)"],
+    [202, "a2", "(pointer gs-trxdir)"],
+    [204, "a2", "(pointer gs-reg64)"]
+  ],
+  "(method 11 texture-pool)": [
+    [[189, 196], "a0", "dma-packet"],
+    [217, "a0", "dma-packet"],
+    [218, "a0", "(pointer int64)"],
+    [211, "a0", "(pointer gs-reg64)"],
+    [209, "a0", "(pointer int64)"],
+    [[198, 205], "a0", "gs-gif-tag"]
+  ],
+  "texture-page-login": [
+    [[34, 45], "s2", "texture-page"]
+  ],
+  "(method 9 texture-page-dir)": [[[27, 32], "t3", "adgif-shader"],
+    [[20, 30], "t2", "(pointer shader-ptr)"]],
+  "texture-page-dir-inspect": [[[137, 138], "v1", "adgif-shader"]],
+  "level-remap-texture": [
+    [15, "t0", "(pointer uint32)"],
+    [21, "t0", "(pointer uint32)"],
+    [19, "t0", "(pointer uint64)"],
+    [12, "v1", "int"],
+    [12, "a3", "int"]
+  ],
+  "debug-menu-func-decode": [
+    [18, "a0", "symbol"]
+  ],
   // placeholder
   "placeholder-do-not-add-below": []
 }
diff --git a/decompiler/config/jak2/var_names.jsonc b/decompiler/config/jak2/var_names.jsonc
index 1000e626ce..ef914afa01 100644
--- a/decompiler/config/jak2/var_names.jsonc
+++ b/decompiler/config/jak2/var_names.jsonc
@@ -738,5 +738,230 @@
   },
   "add-nav-sphere": {
     "args": ["nav", "sphere", "max-spheres"]
+  },
+
+  "texture-bpp": {
+    "args": ["tex-fmt"]
+  },
+  "texture-qwc": {
+    "args": ["width", "height", "tex-fmt"]
+  },
+  "physical-address": {
+    "args": ["ptr"]
+  },
+  "dma-buffer-add-ref-texture": {
+    "args": ["dma-buf", "tex-data-ptr", "width", "height", "tex-fmt"],
+    "vars": {
+      "s5-0":"padr",
+      "v1-0":"qwc-remaining",
+      "a0-4":"qwc-transfer",
+      "a1-3":"eop"
+    }
+  },
+  "gs-find-block": {
+    "args" : ["bx", "by", "fmt"]
+  },
+  "(method 18 texture-pool)": {
+    "args":["obj", "tpage-id"]
+  },
+  "(method 10 texture-page)": {
+    "args":["obj", "num-segments", "upload-offset"],
+    "vars": {"v1-0":"offset", "a2-1":"i"}
+  },
+  "(method 16 texture-pool)": {
+    "args":["obj", "seg", "num-words"]
+  },
+  "(method 9 texture-page)": {
+    "args":["obj", "heap"]
+  },
+  "texture-page-default-allocate" : {
+    "args":["pool", "tpage", "heap", "tpage-id"],
+    "vars": {
+      "s3-0":"seg",
+      "a1-2":"vram-loc",
+      "v1-12":"tex-idx",
+      "a0-7":"tex",
+      "a1-6":"mask-idx",
+      "a2-2":"mask-word"
+    }
+  },
+  "texture-page-common-allocate": {
+    "args":["pool", "tpage", "heap", "tpage-id"],
+    "vars": {
+      "s5-0":"vram-loc",
+      "s4-0":"seg"
+    }
+  },
+  "texture-page-font-allocate": {
+    "args":["pool", "tpage", "heap", "tpage-id"],
+    "vars": {
+      "v1-4":"tex-idx",
+      "a0-5":"tex",
+      "a1-5":"mask-idx",
+      "a2-2":"mask-word"
+    }
+  },
+  "(method 22 texture-pool)": {
+    "vars": {
+      "s5-0":"vram-loc",
+      "gp-0":"level-idx",
+      "v1-3":"lev",
+      "s4-0":"tpage",
+      "s3-0":"seg"
+    }
+  },
+  "(method 23 texture-pool)": {
+    "vars": {
+      "s5-0":"vram-loc",
+      "gp-0":"level-idx",
+      "v1-3":"lev",
+      "s4-0":"tpage",
+      "s3-0":"seg"
+    }
+  },
+  "(method 24 texture-pool)": {
+    "vars": {
+      "gp-0":"vram-loc",
+      "s5-0":"level-idx",
+      "v1-3":"lev",
+      "s4-0":"tpage",
+      "s3-0":"old-dest-base",
+      "s2-0":"new-dest-base",
+      "v1-15":"new-tbp",
+      "a0-11":"texture-idx",
+      "a1-12":"adgif-iter"
+    }
+  },
+  "texture-page-common-boot-allocate": {
+    "args":["pool", "tpage", "heap", "tpage-id"],
+    "vars": {
+      "s2-0":"common-page-slot-id"
+    }
+  },
+  "upload-vram-data": {
+    "args": ["buf", "dest", "data", "height", "width"],
+    "vars": {
+      "a3-2":"height-this-time"
+    }
+  },
+  "upload-vram-pages": {
+    "args":["pool", "dest-seg", "tpage", "mode", "bucket"],
+    "vars": {
+      "gp-0":"num-chunks",
+      "s3-0":"dma-buf",
+      "sv-16":"data-ptr",
+      "sv-20":"vram-ptr",
+      "sv-24":"tpage-num-chunks",
+      "sv-32":"chunks-pending",
+      "sv-40":"first-chunk",
+      "sv-48":"tpage-id"
+    }
+  },
+  "update-vram-pages": {
+    "args":["pool", "dest-seg", "tpage", "mode", "bucket"],
+    "vars": {
+      "t1-0":"vram-ptr",
+      "t2-0":"tpage-num-chunks",
+      "v1-2":"chunks-pending",
+      "t0-1":"tpage-id",
+      "a1-4":"adjusted-num-chunks",
+      "a2-3":"chunk-idx",
+      "a3-8":"chunk-ptr"
+    }
+  },
+  "upload-vram-pages-pris": {
+    "args": ["pool", "dest-seg", "tpage", "bucket"],
+    "vars": {
+      "gp-0":"total-chunks-uploaded",
+      "s3-0":"dma-buf",
+      "sv-16":"data-ptr",
+      "sv-20":"vram-ptr",
+      "sv-24":"tpage-num-chunks",
+      "sv-32":"chunks-pending",
+      "sv-40":"first-chunk",
+      "sv-48":"tpage-id",
+      "s0-0":"chunk-idx",
+      "v1-17":"chunk-dest",
+      "a1-1":"mask-work",
+      "sv-52":"should-upload"
+    }
+  },
+  "texture-page-level-allocate": {
+    "args":["pool", "tpage", "heap", "tpage-id"],
+    "vars": {"s2-0": "common-page-slot-id"}
+  },
+  "texture-page-size-check": {
+    "args":["pool", "lev", "silent"]
+  },
+  "(method 13 texture-pool)": {
+    "args":["pool", "lev", "num-tpage-ids", "tpage-ids"],
+    "vars": {
+      "s2-0":"lev-tex-ids",
+      "a0-3":"tpage-id",
+      "s1-0":"loaded-tpage-idx",
+      "v1-9":"logged-in-tpage-id"
+    }
+  },
+  "(method 14 texture-pool)": {
+    "args":["pool", "lev", "cat", "bucket"],
+    "vars": {
+      "a2-1": "tpage"
+    }
+  },
+  "upload-textures": {
+    "vars": {
+      "v1-6":"lev-idx",
+      "a0-7":"lev",
+      "s5-0":"num-tpage",
+      "v1-11":"tpage-info",
+      "a1-9":"src-level"
+    }
+  },
+  "texture-relocate": {
+    "args": ["dma-buff", "tex", "dest-loc", "dest-fmt", "clut-dst"]
+  },
+  "(method 11 texture-page)": {
+    "args":["obj", "new-dest", "segs"],
+    "vars": {
+      "v1-0":"new-tbp",
+      "a3-4":"old-tbp",
+      "t0-1":"tex-idx",
+      "t1-6":"tex",
+      "t2-0":"num-mips",
+      "t3-4":"mip-idx"
+    }
+  },
+  "(method 7 texture-page)": {
+    "args":["obj", "loading-heap", "name"],
+    "vars": {
+      "v1-2":"loading-level",
+      "a3-0":"tpage-id",
+      "s4-0":"dir-entry"
+    }
+  },
+  "texture-page-login": {
+    "args":["tex-id", "alloc-func", "heap"],
+    "vars": {
+      "s5-0":"dir-entry",
+      "s4-0":"old-alloc-func",
+      "s3-0":"name",
+      "s2-0":"loaded-tpage"
+    }
+  },
+  "(method 9 texture-page-dir)": {
+    "args": ["obj", "heap"],
+    "vars": {
+      "v1-0": "mem-start",
+      "a1-1": "mem-end",
+      "a2-0": "entry-idx",
+      "t1-0": "entry",
+      "t0-0": "tex-page",
+      "a3-4": "link-arr",
+      "t0-3": "tex-count",
+      "t1-3": "tex-idx",
+      "t2-2": "link-slot",
+      "t3-2": ["shader", "adgif-shader"],
+      "t4-1": "dist-past-end"
+    }
   }
 }
diff --git a/decompiler/types2/ForwardProp.cpp b/decompiler/types2/ForwardProp.cpp
index 136aaf196e..885ea0420c 100644
--- a/decompiler/types2/ForwardProp.cpp
+++ b/decompiler/types2/ForwardProp.cpp
@@ -4,7 +4,7 @@
 #include "decompiler/IR2/bitfields.h"
 #include "decompiler/ObjectFile/LinkedObjectFile.h"
 #include "decompiler/types2/types2.h"
-#include "decompiler/util/goal_constants.h"
+#include "decompiler/util/type_utils.h"
 
 /*!
  * This file contains implementations of forward type propagation.
@@ -1100,8 +1100,19 @@ void types2_for_add(types2::Type& type_out,
 
   // propagate integer math: a + C1
   if (arg1_type.is_integer_constant() && is_int_or_uint(dts, arg0_type)) {
+    TypeSpec sum_type = arg0_type.typespec();
+
+    FieldReverseLookupInput rd_in;
+    rd_in.offset = arg1_type.get_integer_constant();
+    rd_in.stride = 0;
+    rd_in.base_type = arg0_type.typespec();
+    auto out = env.dts->ts.reverse_field_lookup(rd_in);
+    if (out.success) {
+      sum_type = coerce_to_reg_type(out.result_type);
+    }
+
     type_out.type = TP_Type::make_from_integer_constant_plus_var(arg1_type.get_integer_constant(),
-                                                                 arg0_type.typespec());
+                                                                 arg0_type.typespec(), sum_type);
     return;
   }
 
@@ -1296,8 +1307,8 @@ void types2_for_add(types2::Type& type_out,
 
   if (tc(dts, TypeSpec("structure"), arg1_type) && !expr.get_arg(0).is_int() &&
       is_int_or_uint(dts, arg0_type)) {
-    if (arg1_type.typespec() == TypeSpec("symbol") &&
-        arg0_type.is_integer_constant(DECOMP_SYM_INFO_OFFSET + POINTER_SIZE)) {
+    if (allowable_base_type_for_symbol_to_string(arg1_type.typespec()) &&
+        arg0_type.is_integer_constant(SYMBOL_TO_STRING_MEM_OFFSET_DECOMP[env.version])) {
       // symbol -> GOAL String
       // NOTE - the offset doesn't fit in a s16, so it's loaded into a register first.
       // so we expect the arg to be a variable, and the type propagation will figure out the
@@ -1308,8 +1319,25 @@ void types2_for_add(types2::Type& type_out,
       // byte access of offset array field trick.
       // arg1 holds a structure.
       // arg0 is an integer in a register.
-      type_out.type = TP_Type::make_object_plus_product(arg1_type.typespec(), 1, true);
-      return;
+
+      // TODO port to old type pass too
+      if (arg0_type.is_integer_constant()) {
+        TypeSpec sum_type = arg1_type.typespec();
+        FieldReverseLookupInput rd_in;
+        rd_in.offset = arg0_type.get_integer_constant();
+        rd_in.stride = 0;
+        rd_in.base_type = arg1_type.typespec();
+        auto out = env.dts->ts.reverse_field_lookup(rd_in);
+        if (out.success) {
+          sum_type = coerce_to_reg_type(out.result_type);
+        }
+        type_out.type = TP_Type::make_from_integer_constant_plus_var(
+            arg0_type.get_integer_constant(), arg1_type.typespec(), sum_type);
+        return;
+      } else {
+        type_out.type = TP_Type::make_object_plus_product(arg1_type.typespec(), 1, true);
+        return;
+      }
     }
   }
 
@@ -1938,6 +1966,29 @@ bool load_var_op_determine_type(types2::Type& type_out,
       }
     }
 
+    if (input_type.kind == TP_Type::Kind::INTEGER_CONSTANT_PLUS_VAR &&
+        input_type.get_integer_constant() == 0) {
+      FieldReverseLookupInput rd_in;
+      DerefKind dk;
+      dk.is_store = false;
+      dk.reg_kind = get_reg_kind(ro.reg);
+      dk.sign_extend = op.kind() == LoadVarOp::Kind::SIGNED;
+      dk.size = op.size();
+      rd_in.deref = dk;
+      rd_in.base_type = input_type.get_objects_typespec();
+      rd_in.offset = ro.offset;
+      auto rd = dts.ts.reverse_field_multi_lookup(rd_in);
+      if (rd.success) {
+        if (rd.results.size() == 1) {
+          type_out.type = TP_Type::make_from_ts(coerce_to_reg_type(rd.results.front().result_type));
+          return true;
+        } else {
+          types2_from_ambiguous_deref(output_instr, type_out, rd.results, extras.tags_locked);
+          return true;
+        }
+      }
+    }
+
     if (input_type.kind == TP_Type::Kind::TYPESPEC && ro.offset == -4 &&
         op.kind() == LoadVarOp::Kind::UNSIGNED && op.size() == 4 && ro.reg.get_kind() == Reg::GPR) {
       // get type of basic likely, but misrecognized as an object.
@@ -2069,9 +2120,32 @@ bool load_var_op_determine_type(types2::Type& type_out,
       }
     }
 
+    if (input_type.kind == TP_Type::Kind::INTEGER_CONSTANT_PLUS_VAR && ro.offset == 0) {
+      FieldReverseLookupInput rd_in;
+      DerefKind dk;
+      dk.is_store = false;
+      dk.reg_kind = get_reg_kind(ro.reg);
+      dk.sign_extend = op.kind() == LoadVarOp::Kind::SIGNED;
+      dk.size = op.size();
+      rd_in.deref = dk;
+      rd_in.base_type = input_type.get_objects_typespec();
+      rd_in.stride = 0;
+      rd_in.offset = input_type.get_integer_constant();
+      auto rd = dts.ts.reverse_field_multi_lookup(rd_in);
+      if (rd.success) {
+        if (rd.results.size() == 1) {
+          type_out.type = TP_Type::make_from_ts(coerce_to_reg_type(rd.results.front().result_type));
+          return true;
+        } else {
+          types2_from_ambiguous_deref(output_instr, type_out, rd.results, extras.tags_locked);
+          return true;
+        }
+      }
+    }
+
     throw std::runtime_error(fmt::format("Could not figure out load: {}", op.to_string(env)));
   } else {
-    throw std::runtime_error(fmt::format("Could not figure out load: {}", op.to_string(env)));
+    throw std::runtime_error(fmt::format("Could not figure out load (2): {}", op.to_string(env)));
   }
 }
 
diff --git a/decompiler/types2/types2.cpp b/decompiler/types2/types2.cpp
index 04d321b7f0..8ab979aa4a 100644
--- a/decompiler/types2/types2.cpp
+++ b/decompiler/types2/types2.cpp
@@ -4,7 +4,7 @@
 
 #include "decompiler/ObjectFile/LinkedObjectFile.h"
 #include "decompiler/types2/types2.h"
-#include "decompiler/util/goal_constants.h"
+#include "decompiler/util/type_utils.h"
 
 namespace decompiler::types2 {
 
diff --git a/decompiler/util/DecompilerTypeSystem.cpp b/decompiler/util/DecompilerTypeSystem.cpp
index b6538cc30e..86e0cb2eaf 100644
--- a/decompiler/util/DecompilerTypeSystem.cpp
+++ b/decompiler/util/DecompilerTypeSystem.cpp
@@ -287,10 +287,10 @@ TP_Type DecompilerTypeSystem::tp_lca(const TP_Type& existing,
         }
       case TP_Type::Kind::INTEGER_CONSTANT_PLUS_VAR:
         if (existing.get_integer_constant() == add.get_integer_constant()) {
+          auto new_t = coerce_to_reg_type(ts.lowest_common_ancestor(existing.get_objects_typespec(),
+                                                                    add.get_objects_typespec()));
           auto new_child = TP_Type::make_from_integer_constant_plus_var(
-              existing.get_integer_constant(),
-              coerce_to_reg_type(ts.lowest_common_ancestor(existing.get_objects_typespec(),
-                                                           add.get_objects_typespec())));
+              existing.get_integer_constant(), new_t, new_t);
           *changed = (new_child != existing);
           return new_child;
         } else {
diff --git a/decompiler/util/TP_Type.cpp b/decompiler/util/TP_Type.cpp
index d505bf4f49..108411fc76 100644
--- a/decompiler/util/TP_Type.cpp
+++ b/decompiler/util/TP_Type.cpp
@@ -124,7 +124,8 @@ bool TP_Type::operator==(const TP_Type& other) const {
     case Kind::FORMAT_STRING:
       return m_int == other.m_int;
     case Kind::INTEGER_CONSTANT_PLUS_VAR:
-      return m_int == other.m_int && m_ts == other.m_ts;
+      return m_int == other.m_int && m_ts == other.m_ts &&
+             m_method_from_type == other.m_method_from_type;
     case Kind::DYNAMIC_METHOD_ACCESS:
       return true;
     case Kind::INTEGER_CONSTANT_PLUS_VAR_MULT:
@@ -185,9 +186,10 @@ TypeSpec TP_Type::typespec() const {
       return TypeSpec("string");
     case Kind::INTEGER_CONSTANT:
       return TypeSpec("int");
-    case Kind::INTEGER_CONSTANT_PLUS_VAR:
     case Kind::INTEGER_CONSTANT_PLUS_VAR_MULT:
       return m_ts;
+    case Kind::INTEGER_CONSTANT_PLUS_VAR:
+      return m_method_from_type;
     case Kind::DYNAMIC_METHOD_ACCESS:
       return TypeSpec("object");
     case Kind::FORMAT_STRING:
diff --git a/decompiler/util/TP_Type.h b/decompiler/util/TP_Type.h
index ff2600f08c..56a105a711 100644
--- a/decompiler/util/TP_Type.h
+++ b/decompiler/util/TP_Type.h
@@ -189,11 +189,14 @@ class TP_Type {
     return result;
   }
 
-  static TP_Type make_from_integer_constant_plus_var(int64_t value, const TypeSpec& var_type) {
+  static TP_Type make_from_integer_constant_plus_var(int64_t value,
+                                                     const TypeSpec& var_type,
+                                                     const TypeSpec& sum_type) {
     TP_Type result;
     result.kind = Kind::INTEGER_CONSTANT_PLUS_VAR;
     result.m_int = value;
     result.m_ts = var_type;
+    result.m_method_from_type = sum_type;
     return result;
   }
 
@@ -393,7 +396,7 @@ class TP_Type {
 
  private:
   TypeSpec m_ts;
-  TypeSpec m_method_from_type;
+  TypeSpec m_method_from_type;  // hack, also stores sum type.
   int m_method_id = -1;
   std::string m_str;
   int64_t m_int = 0;
diff --git a/decompiler/util/goal_constants.h b/decompiler/util/goal_constants.h
deleted file mode 100644
index eb3737e1ee..0000000000
--- a/decompiler/util/goal_constants.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include "common/common_types.h"
-#include "common/versions.h"
-
-// Separate constants for the decompiler, so we can make changes to the game without breaking
-// decompilation.
-
-constexpr s32 DECOMP_SYM_INFO_OFFSET = 8167 * 8 - 4;
-
-constexpr PerGameVersion<int> OFFSET_OF_NEXT_STATE_STORE = {72, 64};
\ No newline at end of file
diff --git a/decompiler/util/type_utils.cpp b/decompiler/util/type_utils.cpp
new file mode 100644
index 0000000000..522d924aa2
--- /dev/null
+++ b/decompiler/util/type_utils.cpp
@@ -0,0 +1,8 @@
+#include "type_utils.h"
+
+namespace decompiler {
+bool allowable_base_type_for_symbol_to_string(const TypeSpec& ts) {
+  auto& bt = ts.base_type();
+  return bt == "symbol" || bt == "basic" || bt == "structure";
+}
+}  // namespace decompiler
\ No newline at end of file
diff --git a/decompiler/util/type_utils.h b/decompiler/util/type_utils.h
new file mode 100644
index 0000000000..b4587eda1c
--- /dev/null
+++ b/decompiler/util/type_utils.h
@@ -0,0 +1,19 @@
+#pragma once
+#include "common/goal_constants.h"
+#include "common/type_system/TypeSpec.h"
+#include "common/versions.h"
+
+namespace decompiler {
+
+/*!
+ * Is ts something we can use symbol->string on?
+ * Ideally, this would just check for symbol, but it's convenient for this to work on
+ * structure/basic, as we sometimes get symbols out of res-lump lookups or similar.
+ */
+bool allowable_base_type_for_symbol_to_string(const TypeSpec& ts);
+
+constexpr PerGameVersion<int> SYMBOL_TO_STRING_MEM_OFFSET_DECOMP = {8167 * 8,
+                                                                    jak2::SYM_TO_STRING_OFFSET};
+
+constexpr PerGameVersion<int> OFFSET_OF_NEXT_STATE_STORE = {72, 64};
+}  // namespace decompiler
\ No newline at end of file
diff --git a/game/CMakeLists.txt b/game/CMakeLists.txt
index ce2ce08d4a..2036d07565 100644
--- a/game/CMakeLists.txt
+++ b/game/CMakeLists.txt
@@ -85,6 +85,7 @@ set(RUNTIME_SOURCE
         mips2c/jak2_functions/collide_func.cpp
         mips2c/jak2_functions/font.cpp
         mips2c/jak2_functions/joint.cpp
+        mips2c/jak2_functions/texture.cpp
         overlord/dma.cpp
         overlord/fake_iso.cpp
         overlord/iso.cpp
diff --git a/game/graphics/opengl_renderer/OpenGLRenderer.cpp b/game/graphics/opengl_renderer/OpenGLRenderer.cpp
index 72f1ac54a0..3774ccb5ed 100644
--- a/game/graphics/opengl_renderer/OpenGLRenderer.cpp
+++ b/game/graphics/opengl_renderer/OpenGLRenderer.cpp
@@ -764,6 +764,7 @@ void OpenGLRenderer::dispatch_buckets_jak2(DmaFollower dma,
     vif_interrupt_callback(bucket_id);
     m_category_times[(int)m_bucket_categories[bucket_id]] += bucket_prof.get_elapsed_time();
   }
+  vif_interrupt_callback(m_bucket_renderers.size());
 
   // TODO ending data.
 }
diff --git a/game/kernel/common/kmachine.cpp b/game/kernel/common/kmachine.cpp
index 13fb121c05..984741fdf2 100644
--- a/game/kernel/common/kmachine.cpp
+++ b/game/kernel/common/kmachine.cpp
@@ -519,4 +519,15 @@ u64 pc_get_mips2c(u32 name) {
  */
 void send_gfx_dma_chain(u32 /*bank*/, u32 chain) {
   Gfx::send_chain(g_ee_main_mem, chain);
+}
+
+/*!
+ * Called from game thread to upload a texture outside of the main DMA chain.
+ */
+void pc_texture_upload_now(u32 page, u32 mode) {
+  Gfx::texture_upload_now(Ptr<u8>(page).c(), mode, s7.offset);
+}
+
+void pc_texture_relocate(u32 dst, u32 src, u32 format) {
+  Gfx::texture_relocate(dst, src, format);
 }
\ No newline at end of file
diff --git a/game/kernel/common/kmachine.h b/game/kernel/common/kmachine.h
index c8b4e5b971..cdcf117a0e 100644
--- a/game/kernel/common/kmachine.h
+++ b/game/kernel/common/kmachine.h
@@ -80,4 +80,6 @@ void set_gfx_hack(u64 which, u32 symptr);
 u32 offset_of_s7();
 void vif_interrupt_callback(int bucket_id);
 u64 pc_get_mips2c(u32 name);
-void send_gfx_dma_chain(u32 /*bank*/, u32 chain);
\ No newline at end of file
+void send_gfx_dma_chain(u32 /*bank*/, u32 chain);
+void pc_texture_upload_now(u32 page, u32 mode);
+void pc_texture_relocate(u32 dst, u32 src, u32 format);
\ No newline at end of file
diff --git a/game/kernel/jak1/kmachine.cpp b/game/kernel/jak1/kmachine.cpp
index b9428a5413..9fa45b87b2 100644
--- a/game/kernel/jak1/kmachine.cpp
+++ b/game/kernel/jak1/kmachine.cpp
@@ -387,17 +387,6 @@ int ShutdownMachine() {
 
 // todo, these could probably be moved to common
 
-/*!
- * Called from game thread to upload a texture outside of the main DMA chain.
- */
-void pc_texture_upload_now(u32 page, u32 mode) {
-  Gfx::texture_upload_now(Ptr<u8>(page).c(), mode, s7.offset);
-}
-
-void pc_texture_relocate(u32 dst, u32 src, u32 format) {
-  Gfx::texture_relocate(dst, src, format);
-}
-
 /*!
  * Called from the game thread at each frame to tell the PC rendering code which levels to start
  * loading. The loader internally handles locking.
diff --git a/game/kernel/jak2/kmachine.cpp b/game/kernel/jak2/kmachine.cpp
index 98c5a4ea5c..aa3754efa2 100644
--- a/game/kernel/jak2/kmachine.cpp
+++ b/game/kernel/jak2/kmachine.cpp
@@ -463,8 +463,8 @@ void InitMachine_PCPort() {
   make_function_symbol_from_c("__read-ee-timer", (void*)read_ee_timer);
   make_function_symbol_from_c("__mem-move", (void*)c_memmove);
   make_function_symbol_from_c("__send-gfx-dma-chain", (void*)send_gfx_dma_chain);
-  // make_function_symbol_from_c("__pc-texture-upload-now", (void*)pc_texture_upload_now);
-  // make_function_symbol_from_c("__pc-texture-relocate", (void*)pc_texture_relocate);
+  make_function_symbol_from_c("__pc-texture-upload-now", (void*)pc_texture_upload_now);
+  make_function_symbol_from_c("__pc-texture-relocate", (void*)pc_texture_relocate);
   make_function_symbol_from_c("__pc-get-mips2c", (void*)pc_get_mips2c);
   // make_function_symbol_from_c("__pc-set-levels", (void*)pc_set_levels);
 
diff --git a/game/kernel/jak2/kprint.cpp b/game/kernel/jak2/kprint.cpp
index 1758fe065f..456566467d 100644
--- a/game/kernel/jak2/kprint.cpp
+++ b/game/kernel/jak2/kprint.cpp
@@ -246,6 +246,16 @@ s32 format_impl_jak2(uint64_t* args) {
           output_ptr = strend(output_ptr);
         } break;
 
+        case 'O':
+        case 'o': {
+          *output_ptr = '~';
+          output_ptr++;
+          kitoa(output_ptr, arg_regs[arg_reg_idx++], 10, 0, ' ', 0);
+          output_ptr = strend(output_ptr);
+          *output_ptr = 'u';
+          output_ptr++;
+        } break;
+
         case 'A':  // print a boxed object
         case 'a':  // pad,padchar (like ) ~8,'0A
         {
diff --git a/game/mips2c/jak2_functions/font.cpp b/game/mips2c/jak2_functions/font.cpp
index 0a835c3ebe..44c61d87ee 100644
--- a/game/mips2c/jak2_functions/font.cpp
+++ b/game/mips2c/jak2_functions/font.cpp
@@ -54,7 +54,6 @@ u64 execute(void* ctxt) {
   c->daddu(a2, a2, a3);                             // daddu a2, a2, a3
   c->load_symbol2(a3, cache.font_work);              // lw a3, *font-work*(s7)
   c->daddu(a2, a2, a3);                             // daddu a2, a2, a3
-  printf("a2 = 0x%lx, a3 = 0x%lx\n", c->sgpr64(a2), c->sgpr64(a3));
   c->lwu(a2, 2160, a2);                             // lwu a2, 2160(a2)
   // Unknown instr: ld a3, L164(fp)
   c->gprs[a3].du64[0] = 0xffffffff'00ffffff;
diff --git a/game/mips2c/jak2_functions/texture.cpp b/game/mips2c/jak2_functions/texture.cpp
new file mode 100644
index 0000000000..2d46af7838
--- /dev/null
+++ b/game/mips2c/jak2_functions/texture.cpp
@@ -0,0 +1,188 @@
+//--------------------------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 adgif_shader_texture_with_update {
+u64 execute(void* ctxt) {
+  auto* c = (ExecutionContext*)ctxt;
+  bool bc = false;
+  u32 call_addr = 0;
+  c->ld(a2, 16, a0);                                // ld a2, 16(a0)
+  c->addiu(v1, r0, 256);                            // addiu v1, r0, 256
+  c->andi(a2, a2, 513);                             // andi a2, a2, 513
+  c->mtc1(f0, v1);                                  // mtc1 f0, v1
+  c->cvtsw(f0, f0);                                 // cvt.s.w f0, f0
+  c->lbu(v1, 4, a1);                                // lbu v1, 4(a1)
+  c->lwc1(f1, 44, a1);                              // lwc1 f1, 44(a1)
+  c->daddiu(v1, v1, -1);                            // daddiu v1, v1, -1
+  c->divs(f0, f0, f1);                              // div.s f0, f0, f1
+  c->dsll(v1, v1, 2);                               // dsll v1, v1, 2
+  c->or_(a2, a2, v1);                               // or a2, a2, v1
+  c->lbu(v1, 7, a1);                                // lbu v1, 7(a1)
+  c->dsll(v1, v1, 19);                              // dsll v1, v1, 19
+  c->lbu(a3, 5, a1);                                // lbu a3, 5(a1)
+  c->or_(a2, a2, v1);                               // or a2, a2, v1
+  c->dsll(a3, a3, 5);                               // dsll a3, a3, 5
+  c->or_(a2, a2, a3);                               // or a2, a2, a3
+  c->ld(t1, 0, a0);                                 // ld t1, 0(a0)
+  c->dsll(t1, t1, 27);                              // dsll t1, t1, 27
+  c->lbu(v1, 6, a1);                                // lbu v1, 6(a1)
+  c->dsra32(t1, t1, 30);                            // dsra32 t1, t1, 30
+  c->dsll(v1, v1, 20);                              // dsll v1, v1, 20
+  c->dsll32(t1, t1, 3);                             // dsll32 t1, t1, 3
+  c->lhu(a3, 10, a1);                               // lhu a3, 10(a1)
+  c->or_(t1, t1, v1);                               // or t1, t1, v1
+  c->lbu(v1, 26, a1);                               // lbu v1, 26(a1)
+  c->or_(t1, t1, a3);                               // or t1, t1, a3
+  c->dsll(v1, v1, 14);                              // dsll v1, v1, 14
+  c->or_(t1, t1, v1);                               // or t1, t1, v1
+  c->lhu(v1, 0, a1);                                // lhu v1, 0(a1)
+  c->plzcw(v1, v1);                                 // plzcw v1, v1
+  c->addiu(t0, r0, 30);                             // addiu t0, r0, 30
+  c->subu(v1, t0, v1);                              // subu v1, t0, v1
+  c->lhu(a3, 2, a1);                                // lhu a3, 2(a1)
+  c->dsll(v1, v1, 26);                              // dsll v1, v1, 26
+  c->plzcw(a3, a3);                                 // plzcw a3, a3
+  c->or_(t1, t1, v1);                               // or t1, t1, v1
+  c->subu(a3, t0, a3);                              // subu a3, t0, a3
+  c->dsll(a3, a3, 30);                              // dsll a3, a3, 30
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  c->or_(t1, t1, a3);                               // or t1, t1, a3
+  c->dsll32(v1, v1, 2);                             // dsll32 v1, v1, 2
+  c->or_(t1, t1, v1);                               // or t1, t1, v1
+  c->lhu(v1, 24, a1);                               // lhu v1, 24(a1)
+  c->dsll32(v1, v1, 5);                             // dsll32 v1, v1, 5
+  c->lhu(a3, 8, a1);                                // lhu a3, 8(a1)
+  c->dsll32(a3, a3, 19);                            // dsll32 a3, a3, 19
+  c->or_(t1, t1, v1);                               // or t1, t1, v1
+  c->or_(t1, t1, a3);                               // or t1, t1, a3
+  c->addiu(v1, r0, 1);                              // addiu v1, r0, 1
+  c->dsll32(v1, v1, 29);                            // dsll32 v1, v1, 29
+  c->cvtws(f0, f0);                                 // cvt.w.s f0, f0
+  c->or_(t1, t1, v1);                               // or t1, t1, v1
+  c->mfc1(v1, f0);                                  // mfc1 v1, f0
+  c->sd(t1, 0, a0);                                 // sd t1, 0(a0)
+  c->plzcw(a3, v1);                                 // plzcw a3, v1
+  c->subu(a3, t0, a3);                              // subu a3, t0, a3
+  c->lbu(t0, 7, a1);                                // lbu t0, 7(a1)
+  c->daddiu(t0, t0, -1);                            // daddiu t0, t0, -1
+  // nop                                            // sll r0, r0, 0
+  bc = c->sgpr64(t0) == 0;                          // beq t0, r0, L43
+  // nop                                            // sll r0, r0, 0
+  if (bc) {goto block_5;}                           // branch non-likely
+
+  c->daddiu(t0, a3, -4);                            // daddiu t0, a3, -4
+  c->dsll(a3, a3, 4);                               // dsll a3, a3, 4
+  bc = ((s64)c->sgpr64(t0)) < 0;                    // bltz t0, L41
+  c->daddiu(a3, a3, -175);                          // daddiu a3, a3, -175
+  if (bc) {goto block_3;}                           // branch non-likely
+
+  //beq r0, r0, L42                                 // beq r0, r0, L42
+  c->dsrav(t0, v1, t0);                             // dsrav t0, v1, t0
+  goto block_4;                                     // branch always
+
+
+  block_3:
+  c->dsubu(t0, r0, t0);                             // dsubu t0, r0, t0
+  c->dsllv(t0, v1, t0);                             // dsllv t0, v1, t0
+
+  block_4:
+  c->andi(t0, t0, 15);                              // andi t0, t0, 15
+  // nop                                            // sll r0, r0, 0
+  //beq r0, r0, L46                                 // beq r0, r0, L46
+  c->daddu(a3, a3, t0);                             // daddu a3, a3, t0
+  goto block_9;                                     // branch always
+
+
+  block_5:
+  c->daddiu(t0, a3, -5);                            // daddiu t0, a3, -5
+  c->dsll(a3, a3, 5);                               // dsll a3, a3, 5
+  bc = ((s64)c->sgpr64(t0)) < 0;                    // bltz t0, L44
+  c->daddiu(a3, a3, -350);                          // daddiu a3, a3, -350
+  if (bc) {goto block_7;}                           // branch non-likely
+
+  //beq r0, r0, L45                                 // beq r0, r0, L45
+  c->dsrav(t0, v1, t0);                             // dsrav t0, v1, t0
+  goto block_8;                                     // branch always
+
+
+  block_7:
+  c->dsubu(t0, r0, t0);                             // dsubu t0, r0, t0
+  c->dsllv(t0, v1, t0);                             // dsllv t0, v1, t0
+
+  block_8:
+  c->andi(t0, t0, 31);                              // andi t0, t0, 31
+  // nop                                            // sll r0, r0, 0
+  c->daddu(a3, a3, t0);                             // daddu a3, a3, t0
+  // nop                                            // sll r0, r0, 0
+
+  block_9:
+  c->andi(a3, a3, 4095);                            // andi a3, a3, 4095
+  c->lhu(t1, 12, a1);                               // lhu t1, 12(a1)
+  c->dsll32(a3, a3, 0);                             // dsll32 a3, a3, 0
+  c->lbu(v1, 27, a1);                               // lbu v1, 27(a1)
+  c->or_(a2, a2, a3);                               // or a2, a2, a3
+  c->dsll(v1, v1, 14);                              // dsll v1, v1, 14
+  c->sd(a2, 16, a0);                                // sd a2, 16(a0)
+  c->or_(a2, t1, v1);                               // or a2, t1, v1
+  c->lhu(v1, 14, a1);                               // lhu v1, 14(a1)
+  // nop                                            // sll r0, r0, 0
+  c->lbu(a3, 28, a1);                               // lbu a3, 28(a1)
+  c->dsll(v1, v1, 20);                              // dsll v1, v1, 20
+  c->or_(a2, a2, v1);                               // or a2, a2, v1
+  c->dsll32(a3, a3, 2);                             // dsll32 a3, a3, 2
+  c->or_(a2, a2, a3);                               // or a2, a2, a3
+  c->lhu(v1, 16, a1);                               // lhu v1, 16(a1)
+  c->lbu(a3, 29, a1);                               // lbu a3, 29(a1)
+  c->dsll32(v1, v1, 8);                             // dsll32 v1, v1, 8
+  c->or_(a2, a2, v1);                               // or a2, a2, v1
+  c->dsll32(a3, a3, 22);                            // dsll32 a3, a3, 22
+  c->or_(a2, a2, a3);                               // or a2, a2, a3
+  c->lbu(t0, 4, a1);                                // lbu t0, 4(a1)
+  c->daddiu(t0, t0, -5);                            // daddiu t0, t0, -5
+  c->sd(a2, 32, a0);                                // sd a2, 32(a0)
+  bc = ((s64)c->sgpr64(t0)) < 0;                    // bltz t0, L47
+  c->lbu(a3, 30, a1);                               // lbu a3, 30(a1)
+  if (bc) {goto block_11;}                          // branch non-likely
+
+  c->lhu(a2, 18, a1);                               // lhu a2, 18(a1)
+  c->dsll(a3, a3, 14);                              // dsll a3, a3, 14
+  c->or_(a2, a2, a3);                               // or a2, a2, a3
+  c->lhu(v1, 20, a1);                               // lhu v1, 20(a1)
+  c->dsll(v1, v1, 20);                              // dsll v1, v1, 20
+  c->lbu(a3, 31, a1);                               // lbu a3, 31(a1)
+  c->or_(a2, a2, v1);                               // or a2, a2, v1
+  c->dsll32(a3, a3, 2);                             // dsll32 a3, a3, 2
+  c->or_(a2, a2, a3);                               // or a2, a2, a3
+  c->lhu(v1, 22, a1);                               // lhu v1, 22(a1)
+  c->dsll32(v1, v1, 8);                             // dsll32 v1, v1, 8
+  c->lbu(a3, 32, a1);                               // lbu a3, 32(a1)
+  c->or_(a2, a2, v1);                               // or a2, a2, v1
+  c->dsll32(a3, a3, 22);                            // dsll32 a3, a3, 22
+  c->or_(a2, a2, a3);                               // or a2, a2, a3
+  c->addiu(v1, r0, 54);                             // addiu v1, r0, 54
+  c->sd(a2, 64, a0);                                // sd a2, 64(a0)
+  // nop                                            // sll r0, r0, 0
+  c->sw(v1, 72, a0);                                // sw v1, 72(a0)
+  // nop                                            // sll r0, r0, 0
+
+  block_11:
+  c->mov64(v0, a0);                                 // or v0, a0, r0
+  //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("adgif-shader<-texture-with-update!", execute, 128);
+}
+
+} // namespace adgif_shader<_texture_with_update
+} // namespace Mips2C
diff --git a/game/mips2c/mips2c_table.cpp b/game/mips2c/mips2c_table.cpp
index 8bfad6f216..8befad053c 100644
--- a/game/mips2c/mips2c_table.cpp
+++ b/game/mips2c/mips2c_table.cpp
@@ -122,6 +122,7 @@ namespace cspace_parented_transformq_joint { extern void link(); }
 namespace draw_string_asm { extern void link(); }
 namespace draw_string { extern void link(); }
 namespace get_string_length { extern void link(); }
+namespace adgif_shader_texture_with_update { extern void link(); }
 }
 // clang-format on
 
@@ -201,7 +202,8 @@ PerGameVersion<std::unordered_map<std::string, std::vector<void (*)()>>> gMips2C
       {jak2::collide_do_primitives::link, jak2::moving_sphere_triangle_intersect::link}},
      {"joint", {jak2::calc_animation_from_spr::link, jak2::cspace_parented_transformq_joint::link}},
      {"font",
-      {jak2::draw_string::link, jak2::get_string_length::link, jak2::draw_string_asm::link}}},
+      {jak2::draw_string::link, jak2::get_string_length::link, jak2::draw_string_asm::link}},
+     {"texture", {jak2::adgif_shader_texture_with_update::link}}},
 };
 
 void LinkedFunctionTable::reg(const std::string& name, u64 (*exec)(void*), u32 stack_size) {
diff --git a/goal_src/jak1/examples/debug-jak2.gc b/goal_src/jak1/examples/debug-jak2.gc
new file mode 100644
index 0000000000..9219e1fe9d
--- /dev/null
+++ b/goal_src/jak1/examples/debug-jak2.gc
@@ -0,0 +1,114 @@
+(defun hack-update-camera ((location vector) (inv-rot matrix))
+  "Debugging function to set the camera's position and orientation"
+  ;; update to compute the perspective matrix.
+  (update-math-camera
+   *math-camera*
+   'ntsc
+   'aspect4x3
+   (-> *math-camera* fov)
+   )
+
+  ;; copy the input rotation
+  (matrix-copy! (-> *math-camera* inv-camera-rot) inv-rot)
+  ;; inverse of rotation matrix matrix is its transpose
+  (matrix-transpose! (-> *math-camera* camera-rot) (-> *math-camera* inv-camera-rot))
+
+  ;; fake some value here
+  (set! (-> *math-camera* fov-correction-factor) 1.0)
+
+  ;; do the math
+  (set! (-> *math-camera* trans quad) (-> location quad))
+    (let ((cam-temp (-> *math-camera* camera-temp))
+        (cam-rot (-> *math-camera* camera-rot))
+        (inv-cam-rot (-> *math-camera* inv-camera-rot))
+        (cam-trans (-> *math-camera* trans))
+        )
+   (let ((rotated-trans (new-stack-vector0)))
+    (set! (-> rotated-trans x) (- (-> cam-trans x)))
+    (set! (-> rotated-trans y) (- (-> cam-trans y)))
+    (set! (-> rotated-trans z) (- (-> cam-trans z)))
+    (set! (-> rotated-trans w) 1.0)
+    (vector-matrix*! rotated-trans rotated-trans cam-rot)
+    (set! (-> cam-rot vector 3 quad) (-> rotated-trans quad))
+    )
+   (matrix*! cam-temp cam-rot (-> *math-camera* perspective))
+   (set! (-> inv-cam-rot vector 3 quad) (-> cam-trans quad))
+
+   ;; fixes it!
+   ;(set! (-> *math-camera* camera-temp data 15) -6.)
+   )
+
+  (none)
+  )
+
+(defun test-function ((iter int))
+  "This function draws the debug stuff. You can edit this, then reload this file to play with it."
+
+  ;; val will increase from 0 to 1, then reset back to 0.
+  (let* ((frame (the float (mod (* 4 iter) 1600)))
+         (val (/ frame 1600.0)))
+    (format *stdcon* "~0kval ~f~%" val)
+
+    ;; orbit the camera around in a circle with radius 5 m.
+    (let* ((rad (meters 5.0))
+           (x (* rad (sin (* (degrees 360.0) val))))
+           (z (* rad (cos (* (degrees 360.0) val))))
+           (cam-pos (new 'stack 'vector))
+           (cam-inv-rot (new 'stack 'matrix))
+           )
+      ;; this matrix will look directly at the origin...
+      (set! (-> cam-pos x) x)
+      (set! (-> cam-pos z) z)
+      (set! (-> cam-pos y) (meters 1.))
+      (forward-down->inv-matrix cam-inv-rot cam-pos (new 'static 'vector :y 1.0))
+
+      ;; if the camera is here.
+      (set! (-> cam-pos x) (- 0. x))
+      (set! (-> cam-pos z) (- 0. z))
+      (set! (-> cam-pos y) (meters -3.))
+      (hack-update-camera cam-pos cam-inv-rot)
+
+
+      ;; create some test points
+      (let ((p0 (new 'static 'vector :x (meters .8) :y (meters .2) :z (meters 2.0)))
+            (p1 (new 'static 'vector :x (meters .3) :y (meters .3) :z (meters 2.5)))
+            (p2 (new 'static 'vector :x (meters .5) :y (meters .7) :z (meters 1.5)))
+            (b0 (new 'static 'vector :x (meters .5) :y (meters .5) :z (meters .5)))
+            (b1 (new 'static 'vector :x (meters -.5) :y (meters -.5) :z (meters -.5)))
+
+            )
+
+        (add-debug-cross #t (bucket-id debug-no-zbuf) (new 'static 'vector) (meters 2.0))
+        (add-debug-box #t (bucket-id debug-no-zbuf) p0 p2 (new 'static 'rgba :b #x80 :r #x80 :g #x80 :a #x80))
+        (add-debug-flat-triangle #t (bucket-id debug-no-zbuf) p0 p1 p2 (new 'static 'rgba :r #x80 :a #x80))
+        (add-debug-text-3d #t (bucket-id debug-no-zbuf) "triangle!" p0 (the font-color 1) (the vector2h #f))
+        (add-debug-sphere #t (bucket-id debug-no-zbuf) p0 (meters 0.5) (new 'static 'rgba :r #x80 :a #x80))
+
+        (add-debug-line-sphere #t (bucket-id debug-no-zbuf)
+                               (new 'static 'vector :x (meters 0.8))
+                               (new 'static 'vector :y (meters -4.0))
+                                (meters 1.0) (new 'static 'rgba :r #x40 :g #x80 :a #x80))
+        )
+      )
+    )
+  (none)
+  )
+
+
+(defun launch-test-process ()
+  "Call this to launch a process that draws the debug demo"
+  (let ((proc (get-process *nk-dead-pool* process 1024)))
+    (activate proc *active-pool* "test" *kernel-dram-stack*)
+    (run-next-time-in-process proc (lambda ()
+                                     (let ((iter 0))
+                                       (while #t
+                                         (test-function iter)
+                                         (suspend)
+                                         (+! iter 1)
+                                         )
+                                       )
+                                     )
+                              )
+    proc)
+
+  )
\ No newline at end of file
diff --git a/goal_src/jak2/dgos/game.gd b/goal_src/jak2/dgos/game.gd
index ef1aa733b3..106af5dee3 100644
--- a/goal_src/jak2/dgos/game.gd
+++ b/goal_src/jak2/dgos/game.gd
@@ -253,7 +253,7 @@
   ("collide-shape.o" "collide-shape")
   ("collide-shape-rider.o" "collide-shape-rider")
   ("collide.o" "collide")
-  ("collide-planes.o" "collide-planes")
+  ;; ("collide-planes.o" "collide-planes")
   ("spatial-hash.o" "spatial-hash")
   ("actor-hash.o" "actor-hash")
   ("merc-death.o" "merc-death")
diff --git a/goal_src/jak2/engine/camera/cam-debug.gc b/goal_src/jak2/engine/camera/cam-debug.gc
index 009c244944..c8dc78a431 100644
--- a/goal_src/jak2/engine/camera/cam-debug.gc
+++ b/goal_src/jak2/engine/camera/cam-debug.gc
@@ -64,8 +64,6 @@
   :flag-assert         #x9000001d0
   )
 
-
-;; WARN: Return type mismatch object vs string.
 (defun cam-slave-options->string ((arg0 cam-slave-options) (arg1 object))
   (if (= (logand arg0 (cam-slave-options SAME_SIDE)) (cam-slave-options SAME_SIDE))
       (format arg1 "SAME_SIDE ")
@@ -144,7 +142,6 @@
   (the-as string arg1)
   )
 
-;; WARN: Return type mismatch object vs string.
 (defun cam-index-options->string ((arg0 cam-index-options) (arg1 object))
   (if (= (logand arg0 (cam-index-options SPHERICAL)) (cam-index-options SPHERICAL))
       (format arg1 "RADIAL ")
@@ -253,22 +250,21 @@
   )
 
 (defun camera-line2d ((arg0 vector4w) (arg1 vector4w))
-  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 x) (* (+ (-> arg0 x) 1792) 16))
+  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 x) (the-as int (* (+ (-> arg0 x) 1792) 16)))
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 y)
-        (* (- 2256 (-> (the-as cam-dbg-scratch arg0) linevec4w 0 y)) 16)
+        (the-as int (* (- 2256 (the-as int (-> (the-as cam-dbg-scratch arg0) linevec4w 0 y))) 16))
         )
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 z) #x7fffff)
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1 x)
-        (* (+ (-> (the-as cam-dbg-scratch arg1) linevec4w 0 x) 1792) 16)
+        (the-as int (* (+ (-> (the-as cam-dbg-scratch arg1) linevec4w 0 x) 1792) 16))
         )
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1 y)
-        (* (- 2256 (-> (the-as cam-dbg-scratch arg1) linevec4w 0 y)) 16)
+        (the-as int (* (- 2256 (the-as int (-> (the-as cam-dbg-scratch arg1) linevec4w 0 y))) 16))
         )
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1 z) #x7fffff)
   (cam-line-dma)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun camera-plot-float-func ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 (function float float)) (arg5 vector4w))
   (let ((f30-0 (- arg1 arg0))
         (f24-0 (- arg3 arg2))
@@ -288,11 +284,11 @@
               )
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) 20)
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x)
-              (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x)
+              (the-as int (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x))
               )
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
         (camera-line2d
-          (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
           (the-as vector4w (+ 64 #x70000000))
           )
         )
@@ -303,11 +299,11 @@
               )
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y)
-              (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y)
+              (the-as int (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y))
               )
         (camera-line2d
-          (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-          (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+          (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
           )
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) 20)
@@ -315,32 +311,32 @@
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) 20)
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) (+ (the int (* f28-0 f24-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (let ((v1-64 (-> arg5 quad)))
         (set! (-> (the-as cam-dbg-scratch #x70000000) color quad) v1-64)
@@ -357,8 +353,8 @@
                 (+ (the int (* f28-0 (- (arg4 (+ arg0 (* f30-0 (/ (the float s3-1) (* f26-0 f30-0))))) arg2))) 20)
                 )
           (camera-line2d
-            (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-            (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+            (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+            (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
             )
           (+! s3-1 1)
           )
@@ -369,7 +365,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun camera-line-setup ((arg0 vector4w))
   (let ((v1-0 (-> arg0 quad)))
     (set! (-> (the-as cam-dbg-scratch #x70000000) color quad) v1-0)
@@ -379,20 +374,18 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
-;; WARN: Function camera-line-draw has a return type of none, but the expression builder found a return statement.
 (defun camera-line-draw ((arg0 vector) (arg1 vector))
-  (set! (-> (the-as (pointer uint128) (+ 80 (the-as int (the-as cam-dbg-scratch #x70000000))))) (-> arg0 quad))
-  (set! (-> (the-as (pointer uint128) (+ 96 (the-as int (the-as cam-dbg-scratch #x70000000))))) (-> arg1 quad))
+  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 0 quad) (-> arg0 quad))
+  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 1 quad) (-> arg1 quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 0 w) (the-as int 1.0))
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 1 w) (the-as int 1.0))
   (transform-float-point
-    (the-as vector (+ 80 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) linevec))
     (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) linevec4w))
     )
   (transform-float-point
-    (the-as vector (+ 96 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector4w (+ 16 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) linevec 1))
+    (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1)
     )
   (cond
     ((< (the-as uint #xe00000) (the-as uint (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 z)))
@@ -407,7 +400,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun camera-line ((arg0 vector) (arg1 vector) (arg2 vector4w))
   (camera-line-setup arg2)
   (camera-line-draw arg0 arg1)
@@ -416,23 +408,22 @@
   )
 
 (defun camera-line-rel ((arg0 vector) (arg1 vector) (arg2 vector4w))
-  (vector+! (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg0 arg1)
-  (camera-line arg0 (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg2)
+  (vector+! (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg0 arg1)
+  (camera-line arg0 (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg2)
   (none)
   )
 
 (defun camera-line-rel-len ((arg0 vector) (arg1 vector) (arg2 float) (arg3 vector4w))
-  (vector-normalize-copy! (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg1 arg2)
+  (vector-normalize-copy! (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg1 arg2)
   (vector+!
-    (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) rel-vec)
+    (-> (the-as cam-dbg-scratch #x70000000) rel-vec)
     arg0
     )
-  (camera-line arg0 (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg3)
+  (camera-line arg0 (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg3)
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun camera-sphere ((arg0 vector) (arg1 float) (arg2 vector4w))
   (camera-line-setup arg2)
   (dotimes (s4-0 10)
@@ -468,12 +459,12 @@
               (+ (-> arg0 z) (* (sin (* 6553.6 (the float s3-0))) f28-1))
               )
         (camera-line-draw
-          (the-as vector (+ 128 (the-as int (the-as cam-dbg-scratch #x70000000))))
-          (the-as vector (+ 144 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-start)
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-end)
           )
         (camera-line-draw
-          (the-as vector (+ 128 (the-as int (the-as cam-dbg-scratch #x70000000))))
-          (the-as vector (+ 160 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-start)
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-down)
           )
         )
       )
@@ -483,123 +474,110 @@
   )
 
 (defun camera-cross ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector4w) (arg4 meters))
-  (vector-normalize-copy! (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg0 arg4)
+  (vector-normalize-copy! (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec)) arg0 arg4)
   (vector+!
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (vector-!
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (camera-line
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg3
     )
   (vector-cross!
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     arg1
     )
-  (vector-normalize! (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg4)
+  (vector-normalize! (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec)) arg4)
   (vector+!
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (vector-!
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (camera-line
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg3
     )
   (vector-cross!
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     arg0
     )
-  (vector-normalize! (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg4)
+  (vector-normalize! (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec)) arg4)
   (vector+!
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (vector-!
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (camera-line
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg3
     )
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun camera-bounding-box-draw ((arg0 bounding-box) (arg1 basic) (arg2 rgba))
   (camera-line-setup (new 'static 'vector4w :x #x7f :y #x7f :z #x7f :w #x80))
-  (set! (-> (the-as (pointer uint128) (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 min quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 0 quad) (-> arg0 min quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 0 x) (-> arg0 max x))
-  (set! (-> (the-as (pointer uint128) (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 min quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1 quad) (-> arg0 min quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1 y) (-> arg0 max y))
-  (set! (-> (the-as (pointer uint128) (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 min quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2 quad) (-> arg0 min quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2 z) (-> arg0 max z))
-  (set! (-> (the-as (pointer uint128) (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 max quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3 quad) (-> arg0 max quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3 x) (-> arg0 min x))
-  (set! (-> (the-as (pointer uint128) (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 max quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4 quad) (-> arg0 max quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4 y) (-> arg0 min y))
-  (set! (-> (the-as (pointer uint128) (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 max quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5 quad) (-> arg0 max quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5 z) (-> arg0 min z))
-  (camera-line-draw (-> arg0 min) (the-as vector (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 min) (the-as vector (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 min) (the-as vector (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 max) (the-as vector (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 max) (the-as vector (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 max) (the-as vector (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000)))))
+  (camera-line-draw (-> arg0 min) (the-as vector (-> (the-as cam-dbg-scratch #x70000000) bboxvec)))
+  (camera-line-draw (-> arg0 min) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1))
+  (camera-line-draw (-> arg0 min) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2))
+  (camera-line-draw (-> arg0 max) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3))
+  (camera-line-draw (-> arg0 max) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4))
+  (camera-line-draw (-> arg0 max) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5))
   (camera-line-draw
-    (the-as vector (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) bboxvec))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4)
     )
   (camera-line-draw
-    (the-as vector (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2)
     )
   (camera-line-draw
-    (the-as vector (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3)
     )
   (camera-line-draw
-    (the-as vector (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1)
     )
   (camera-line-draw
-    (the-as vector (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5)
     )
   (camera-line-draw
-    (the-as vector (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5)
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) bboxvec))
     )
   0
   (none)
@@ -615,7 +593,6 @@
   :flag-assert         #x900000044
   )
 
-
 (define *cam-debug-los-tri-current* 0)
 
 (define *cam-debug-los-tri* (the-as (inline-array cam-debug-tri) (malloc 'debug #x8fc0)))
@@ -624,7 +601,6 @@
 
 (define *cam-debug-coll-tri* (the-as (inline-array cam-debug-tri) (malloc 'debug #x8fc0)))
 
-;; WARN: Return type mismatch int vs none.
 (defun cam-debug-reset-coll-tri ()
   (set! *cam-debug-los-tri-current* 0)
   (set! *cam-debug-coll-tri-current* 0)
@@ -632,7 +608,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun cam-debug-add-los-tri ((arg0 (inline-array collide-cache-tri)) (arg1 vector) (arg2 vector))
   (cond
     ((>= *cam-debug-los-tri-current* 460)
@@ -655,7 +630,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun cam-debug-add-coll-tri ((arg0 cam-debug-tri) (arg1 vector) (arg2 cam-debug-tri))
   (cond
     ((>= *cam-debug-coll-tri-current* 460)
@@ -744,7 +718,7 @@
          (vf4 :class vf)
          )
     (init-vf0-vector)
-    (let ((v1-1 (the-as object (+ 336 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-1 (the-as (object vector) (-> (the-as cam-dbg-scratch #x70000000) fov-vv))))
       (let ((t2-1 arg2)
             (t3-0 arg1)
             (f0-0 arg3)
@@ -760,7 +734,7 @@
       (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111)
       (.svf (the-as (pointer uint128) (&-> (the-as (pointer vector) v1-1) 0)) vf4)
       )
-    (let ((v1-3 (the-as object (+ 352 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-3 (the-as object (-> (the-as cam-dbg-scratch #x70000000) fov-vv 1))))
       (let ((t2-4 arg2)
             (t3-1 arg0)
             (f0-1 arg3)
@@ -776,7 +750,7 @@
       (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111)
       (.svf (the-as (pointer uint128) (&-> (the-as (pointer vector) v1-3) 0)) vf4)
       )
-    (let ((v1-5 (the-as object (+ 368 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-5 (the-as object (-> (the-as cam-dbg-scratch #x70000000) fov-vv 2))))
       (let ((a3-3 arg2)
             (f0-2 arg4)
             )
@@ -791,7 +765,7 @@
       (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111)
       (.svf (the-as (pointer uint128) (&-> (the-as (pointer vector) v1-5) 0)) vf4)
       )
-    (let ((v1-7 (the-as object (+ 384 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-7 (the-as object (-> (the-as cam-dbg-scratch #x70000000) fov-vv 3))))
       (let ((a0-3 arg2)
             (f0-3 arg4)
             )
@@ -808,119 +782,114 @@
       )
     (camera-line-setup arg5)
     (camera-line-draw
-      (the-as vector (+ 336 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 352 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (the-as vector (-> (the-as cam-dbg-scratch #x70000000) fov-vv))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 1)
       )
     (camera-line-draw
-      (the-as vector (+ 352 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 368 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 1)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 2)
       )
     (camera-line-draw
-      (the-as vector (+ 368 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 384 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 2)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 3)
       )
     (none)
     )
   )
 
-;; WARN: Return type mismatch none vs symbol.
 (defun camera-fov-frame ((arg0 matrix) (arg1 vector) (arg2 float) (arg3 float) (arg4 float) (arg5 vector4w))
+  (vector-float*! (-> (the-as cam-dbg-scratch #x70000000) fov-vert) (-> arg0 vector 1) (* arg3 (tan arg2)))
   (vector-float*!
-    (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (-> arg0 vector 1)
-    (* arg3 (tan arg2))
-    )
-  (vector-float*!
-    (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
     (the-as vector (-> arg0 vector))
     (* arg4 (tan arg2))
     )
   (vector+!
-    (the-as vector (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-src)
     (-> arg0 vector 2)
     (vector+!
-      (the-as vector (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-src)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-src) 1.0)
   (vector+!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector-!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (camera-fov-draw
-    (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-    (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
     arg1
     4096.0
     20480.0
     arg5
     )
-  (set! (-> (the-as (pointer uint128) (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> (the-as vector4w (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) quad)
+  (set! (-> (the-as cam-dbg-scratch #x70000000) fov-src quad)
+        (-> (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) fov-dest)) quad)
         )
   (vector-!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector+!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (camera-fov-draw
-    (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-    (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
     arg1
     4096.0
     20480.0
     arg5
     )
-  (set! (-> (the-as (pointer uint128) (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> (the-as vector4w (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) quad)
+  (set! (-> (the-as cam-dbg-scratch #x70000000) fov-src quad)
+        (-> (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) fov-dest)) quad)
         )
   (vector-!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector-!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (camera-fov-draw
-    (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-    (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
     arg1
     4096.0
     20480.0
     arg5
     )
-  (set! (-> (the-as (pointer uint128) (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> (the-as vector4w (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) quad)
+  (set! (-> (the-as cam-dbg-scratch #x70000000) fov-src quad)
+        (-> (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) fov-dest)) quad)
         )
   (vector+!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector+!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (the-as symbol (camera-fov-draw
-                   (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-                   (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+                   (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+                   (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
                    arg1
                    4096.0
                    20480.0
@@ -929,7 +898,6 @@
           )
   )
 
-;; WARN: Return type mismatch int vs none.
 (defmethod debug-point-info tracking-spline ((obj tracking-spline) (arg0 int))
   (if (= arg0 (-> obj used-point))
       (format 0 "u")
@@ -958,7 +926,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defmethod debug-all-points tracking-spline ((obj tracking-spline))
   (let ((s5-0 (-> obj used-point)))
     (while (!= s5-0 -134250495)
@@ -971,7 +938,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defmethod debug-draw-spline tracking-spline ((obj tracking-spline))
   (let ((s5-0 (-> obj used-point)))
     (let ((s4-0 (-> obj point (-> obj used-point) next)))
@@ -1127,7 +1093,6 @@
     )
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun camera-slave-debug ((arg0 camera-slave))
   (rlet ((acc :class vf)
          (vf0 :class vf)
@@ -1474,7 +1439,6 @@
     )
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun master-draw-coordinates ((arg0 vector))
   (let ((s5-0 (new-stack-vector0))
         (gp-0 (new-stack-vector0))
@@ -1562,7 +1526,6 @@
   :flag-assert         #x9000000a8
   )
 
-
 (deftype cam-collision-record-array (inline-array-class)
   ((data cam-collision-record :dynamic :offset-assert  16)
    )
@@ -1582,7 +1545,6 @@
 
 (define *cam-collision-record* (new 'debug 'cam-collision-record-array 600))
 
-;; WARN: Return type mismatch int vs none.
 (defun cam-collision-record-save ((arg0 vector) (arg1 vector) (arg2 int) (arg3 symbol) (arg4 camera-slave))
   (with-pp
     (when *record-cam-collide-history*
@@ -1621,7 +1583,6 @@
     )
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun cam-collision-record-step ((arg0 int))
   (set! *cam-collision-record-show* (+ *cam-collision-record-show* arg0))
   (while (>= *cam-collision-record-show* 600)
@@ -1634,11 +1595,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
-;; WARN: Function may read a register that is not set: t0
-;; WARN: Function may read a register that is not set: t1
-;; WARN: Function may read a register that is not set: t2
-;; WARN: Function may read a register that is not set: t3
 (defun cam-collision-record-draw ()
   (cond
     ((cpad-pressed? 0 down)
@@ -1797,7 +1753,6 @@
   (none)
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun camera-master-debug ((arg0 camera-master))
   (rlet ((acc :class vf)
          (vf0 :class vf)
@@ -1933,7 +1888,6 @@
   arg0
   )
 
-;; WARN: Return type mismatch int vs none.
 (defun-debug cam-restore ()
   (let ((a0-0 (new-stack-vector0))
         (a1-0 (new-stack-matrix0))
diff --git a/goal_src/jak2/engine/debug/debug.gc b/goal_src/jak2/engine/debug/debug.gc
index b219d5990f..b550c2082d 100644
--- a/goal_src/jak2/engine/debug/debug.gc
+++ b/goal_src/jak2/engine/debug/debug.gc
@@ -184,7 +184,14 @@
   #f
   )
 
-(define-extern debug-line-clip? (function vector vector vector vector symbol))
+;;(define-extern debug-line-clip? (function vector vector vector vector symbol))
+
+;; TODO: doesn't actually do any clipping.
+(defun debug-line-clip? ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector))
+  (vector-copy! arg0 arg2)
+  (vector-copy! arg1 arg3)
+  #t
+  )
 
 (defun-debug internal-draw-debug-line ((bucket bucket-id) (start vector) (end vector) (start-color rgba) (mode symbol) (end-color rgba))
   "Draw a debug line from p0 to p1. Mode can be:
diff --git a/goal_src/jak2/engine/debug/default-menu.gc b/goal_src/jak2/engine/debug/default-menu.gc
index 99c7c117a5..3229614f16 100644
--- a/goal_src/jak2/engine/debug/default-menu.gc
+++ b/goal_src/jak2/engine/debug/default-menu.gc
@@ -861,11 +861,12 @@
 
 (defun dm-texture-user-set-pick-func ((arg0 int) (arg1 debug-menu-msg))
   (if (= arg1 (debug-menu-msg press))
-      (set! (-> *texture-pool* texture-enable-user-menu) (the-as uint arg0))
+      (set! (-> *texture-pool* texture-enable-user-menu) (the-as texture-enable-mask arg0))
       )
   (= (-> *texture-pool* texture-enable-user-menu) arg0)
   )
 
+
 (defun dm-strip-lines-toggle-pick-func ((arg0 int) (arg1 debug-menu-msg))
   (if (= arg1 (debug-menu-msg press))
       (set! *display-strip-lines* (logxor *display-strip-lines* (the-as uint (/ arg0 8))))
@@ -2662,7 +2663,7 @@
   )
 
 ;; WARN: Return type mismatch pair vs debug-menu-node.
-(defun debug-menu-make-task-sub-menu ((arg0 debug-menu-context))
+(defun debug-menu-make-task-sub-menu ((arg0 symbol))
   (local-vars
     (sv-16 (function symbol type object object pair))
     (sv-32 symbol)
@@ -2712,7 +2713,7 @@
           )
         )
       )
-    (the-as debug-menu-node (cons 'menu (cons (-> (the-as (pointer uint32) (+ #xff37 (the-as int arg0)))) gp-0)))
+    (cons 'menu (cons (symbol->string arg0) gp-0))
     )
   )
 
@@ -2751,7 +2752,7 @@
               (s0-0 debug-menu-make-from-template)
               )
           (set! sv-16 arg0)
-          (let ((a1-2 (debug-menu-make-task-sub-menu (the-as debug-menu-context a0-3))))
+          (let ((a1-2 (debug-menu-make-task-sub-menu (the-as symbol a0-3))))
             (s2-0 s1-0 (s0-0 sv-16 (the-as pair a1-2)))
             )
           )
diff --git a/goal_src/jak2/engine/debug/editable-player.gc b/goal_src/jak2/engine/debug/editable-player.gc
index 21a76c72ff..64cb1c7907 100644
--- a/goal_src/jak2/engine/debug/editable-player.gc
+++ b/goal_src/jak2/engine/debug/editable-player.gc
@@ -11,9 +11,13 @@
 
 (define-extern insert-box (function editable-array vector none))
 (define-extern editable-menu-context-make-menus (function debug-menu-context none))
+(define-extern editable-player-init (function symbol none :behavior editable-player))
 
 ;; DECOMP BEGINS
 
+(format 0 "SKIP: editable-player setup~%")
+(format #t "SKIP: editable-player setup~%")
+#|
 ;; this file is debug only
 (declare-file (debug))
 (when *debug-segment*
@@ -2586,5 +2590,4 @@
 
 )
 
-
-
+|#
\ No newline at end of file
diff --git a/goal_src/jak2/engine/debug/editable.gc b/goal_src/jak2/engine/debug/editable.gc
index f6a1a31dfb..ab8f45087b 100644
--- a/goal_src/jak2/engine/debug/editable.gc
+++ b/goal_src/jak2/engine/debug/editable.gc
@@ -1732,6 +1732,10 @@
   arg0
   )
 
+(format 0 "SKIP: editable setup~%")
+(format #t "SKIP: editable setup~%")
+
+#|
 (when (zero? *editable-sample-region*)
   (let ((v1-4 (new 'debug 'editable-region)))
     (set! (-> v1-4 locked) #t)
@@ -1755,6 +1759,7 @@
     (set! *editable-entity-region* v0-84)
     )
   )
+  |#
 
 )
 
diff --git a/goal_src/jak2/engine/game/main.gc b/goal_src/jak2/engine/game/main.gc
index 246f650544..fe976761e6 100644
--- a/goal_src/jak2/engine/game/main.gc
+++ b/goal_src/jak2/engine/game/main.gc
@@ -11,6 +11,10 @@
   (or (= *master-mode* 'pause) (= *master-mode* 'progress) (= *master-mode* 'menu) (= *master-mode* 'freeze))
   )
 
+(defun movie? ()
+  (logtest? (-> *kernel-context* prevent-from-run) (process-mask movie))
+  )
+
 
 ;; Rough loop outline:
 ;; (while *run*
@@ -60,9 +64,9 @@
                 (draw-bars! *profile-array* s3-0 a2-0)
                 )
             )
-      ;     (if (and (!= *master-mode* 'menu) *stats-profile-bars*)
-      ;         (draw-text! *profile-array*)
-      ;         )
+          (if (and (!= *master-mode* 'menu) *stats-profile-bars*)
+              (draw-text! *profile-array*)
+              )
           )
       ;   (when *display-deci-count*
       ;     (let ((s2-0 draw-string-xy))
@@ -75,87 +79,87 @@
       )
 
     ;; draw console buffer
-    ; (let ((buf (if *debug-segment*
-    ;                  (-> arg0 frames (-> arg0 on-screen) debug-buf)
-    ;                  (-> arg0 frames (-> arg0 on-screen) global-buf)
-    ;                  )
-    ;              )
-    ;        )
-    ;   (with-dma-buffer-add-bucket ((s3-0 buf) (bucket-id debug-no-zbuf))
-    ;   (if (and (= *master-mode* 'pause)
-    ;            (and (!= *cheat-mode* 'camera) (or (zero? *screen-shot-work*) (= (-> *screen-shot-work* count) -1)))
-    ;            )
-    ;       (draw-string-xy
-    ;         (lookup-text! *common-text* (game-text-id pause) #f)
-    ;         s3-1
-    ;         256
-    ;         (if (< (-> *display* base-clock frame-counter) (-> *game-info* letterbox-time))
-    ;             352
-    ;             320
-    ;             )
-    ;         (font-color precursor-#ec3b00)
-    ;         (font-flags shadow kerning middle large)
-    ;         )
-    ;       )
-    ;   (let ((s2-2 (the int (-> *font-context* origin y))))
-    ;     (cond
-    ;       ((or (movie?) (< (-> *display* base-clock frame-counter) (-> *game-info* letterbox-time)))
-    ;        (+! s2-2 56)
-    ;        )
-    ;       (*display-profile*
-    ;         (+! s2-2 48)
-    ;         )
-    ;       )
-    ;     (when (or (zero? *screen-shot-work*) (= (-> *screen-shot-work* count) -1))
-    ;       (let* ((v1-82
-    ;                (draw-string-xy
-    ;                  *stdcon0*
-    ;                  s3-1
-    ;                  (the int (-> *font-context* origin x))
-    ;                  s2-2
-    ;                  (font-color default-#cddbcd)
-    ;                  (font-flags shadow)
-    ;                  )
-    ;                )
-    ;              (a3-6 (+ s2-2 (the int (* 2.0 (the-as float (gpr->fpr (sar (the-as int v1-82) 32)))))))
-    ;              )
-    ;         (draw-string-xy
-    ;           *stdcon1*
-    ;           s3-1
-    ;           (the int (-> *font-context* origin x))
-    ;           a3-6
-    ;           (font-color default-#cddbcd)
-    ;           (font-flags shadow)
-    ;           )
-    ;         )
-    ;       )
-    ;     )
-    ;   (if *display-iop-info*
-    ;       (show-iop-info s3-1)
-    ;       )
-    ;   (if *display-memcard-info*
-    ;       (show-mc-info s3-1)
-    ;       )
-    ;     )
-    ;   )
-    ; (let ((v1-101 *dma-mem-usage*))
-    ;   (when (nonzero? v1-101)
-    ;     (set! (-> v1-101 length) (max 88 (-> v1-101 length)))
-    ;     (set! (-> v1-101 data 87 name) "debug")
-    ;     (+! (-> v1-101 data 87 count) 1)
-    ;     (+! (-> v1-101 data 87 used) (&-
-    ;                                    (-> (if *debug-segment*
-    ;                                            (-> arg0 frames (-> arg0 on-screen) debug-buf)
-    ;                                            (-> arg0 frames (-> arg0 on-screen) global-buf)
-    ;                                            )
-    ;                                        base
-    ;                                        )
-    ;                                    (the-as uint s5-0)
-    ;                                    )
-    ;         )
-    ;     (set! (-> v1-101 data 87 total) (-> v1-101 data 87 used))
-    ;     )
-    ;   )
+    (let ((buf (if *debug-segment*
+                     (-> arg0 frames (-> arg0 on-screen) debug-buf)
+                     (-> arg0 frames (-> arg0 on-screen) global-buf)
+                     )
+                 )
+           )
+      (with-dma-buffer-add-bucket ((s3-0 buf) (bucket-id debug-no-zbuf))
+      (if (and (= *master-mode* 'pause)
+               (and (!= *cheat-mode* 'camera) (or (zero? *screen-shot-work*) (= (-> *screen-shot-work* count) -1)))
+               )
+          (draw-string-xy
+            "pause or something like that" ;;(lookup-text! *common-text* (game-text-id pause) #f)
+            buf
+            256
+            (if (< (-> *display* base-clock frame-counter) (-> *game-info* letterbox-time))
+                352
+                320
+                )
+            (font-color precursor-#ec3b00)
+            (font-flags shadow kerning middle large)
+            )
+          )
+      (let ((s2-2 (the int (-> *font-context* origin y))))
+        (cond
+          ((or (movie?) (< (-> *display* base-clock frame-counter) (-> *game-info* letterbox-time)))
+           (+! s2-2 56)
+           )
+          (*display-profile*
+            (+! s2-2 48)
+            )
+          )
+        (when (or (zero? *screen-shot-work*) (= (-> *screen-shot-work* count) -1))
+          (let* ((v1-82
+                   (draw-string-xy
+                     *stdcon0*
+                     buf
+                     (the int (-> *font-context* origin x))
+                     s2-2
+                     (font-color default-#cddbcd)
+                     (font-flags shadow)
+                     )
+                   )
+                 (a3-6 (+ s2-2 (the int (* 2.0 (the-as float (-> v1-82 b))))))
+                 )
+            (draw-string-xy
+              *stdcon1*
+              buf
+              (the int (-> *font-context* origin x))
+              a3-6
+              (font-color default-#cddbcd)
+              (font-flags shadow)
+              )
+            )
+          )
+        )
+      (if *display-iop-info*
+          (show-iop-info buf)
+          )
+      (if *display-memcard-info*
+          (show-mc-info buf)
+          )
+        )
+      )
+    (let ((v1-101 *dma-mem-usage*))
+      (when (nonzero? v1-101)
+        (set! (-> v1-101 length) (max 88 (-> v1-101 length)))
+        (set! (-> v1-101 data 87 name) "debug")
+        (+! (-> v1-101 data 87 count) 1)
+        (+! (-> v1-101 data 87 used) (&-
+                                       (-> (if *debug-segment*
+                                               (-> arg0 frames (-> arg0 on-screen) debug-buf)
+                                               (-> arg0 frames (-> arg0 on-screen) global-buf)
+                                               )
+                                           base
+                                           )
+                                       (the-as uint s5-0)
+                                       )
+            )
+        (set! (-> v1-101 data 87 total) (-> v1-101 data 87 used))
+        )
+      )
     )
   (set! *stdcon* (clear *stdcon0*))
   0
@@ -190,17 +194,17 @@
     ;   )
 
     ;; execute the debug hook before doing the big updates
-    ; (with-profiler 'debug *profile-debug-color*
-    ;   (let* ((s5-5 *debug-hook*)
-    ;          (t9-12 (car s5-5)))
-    ;     (while (not (null? s5-5))
-    ;       ((the-as (function none) t9-12))
-    ;       (set! s5-5 (cdr s5-5))
-    ;       (set! t9-12 (car s5-5))
-    ;       )
-    ;     )
-    ;   (main-cheats)
-    ;   )
+    (with-profiler 'debug *profile-debug-color*
+      (let* ((s5-5 *debug-hook*)
+             (t9-12 (car s5-5)))
+        (while (not (null? s5-5))
+          ((the-as (function none) t9-12))
+          (set! s5-5 (cdr s5-5))
+          (set! t9-12 (car s5-5))
+          )
+        )
+      ; (main-cheats)
+      )
 
     ;; using the position of the in-game camera, update visiblity and matrices for rendering.
     ; (with-profiler 'camera *profile-camera-color*
diff --git a/goal_src/jak2/engine/gfx/font-h.gc b/goal_src/jak2/engine/gfx/font-h.gc
index 151b076b3e..ca553f6e23 100644
--- a/goal_src/jak2/engine/gfx/font-h.gc
+++ b/goal_src/jak2/engine/gfx/font-h.gc
@@ -382,7 +382,7 @@
         (new 'static 'vector :z 1.0)
         )
       )
-    :color-shadow (new 'static 'vector4w :data (new 'static 'array uint32 4 #x0 #x0 #x0 #x80))
+    :color-shadow (new 'static 'vector4w :data (new 'static 'array int32 4 #x0 #x0 #x0 #x80))
     :color-table (new 'static 'inline-array char-color 40
       (new 'static 'char-color :color (new 'static 'array rgba 4
                                         (new 'static 'rgba :r #x70 :g #x78 :b #x70 :a #x80)
@@ -668,17 +668,17 @@
     )
   )
 
-(defun font-set-tex0 ((arg0 (pointer gs-tex0)) (arg1 texture) (arg2 uint) (arg3 uint) (arg4 uint))
+(defun font-set-tex0 ((arg0 (pointer gs-tex0)) (arg1 texture) (arg2 int) (arg3 int) (arg4 int))
   "Write the TEX0 parameters for a font"
   (set! (-> arg0 0) (new 'static 'gs-tex0
                       :tcc #x1
                       :cld #x1
-                      :cbp arg4
+                      :cbp (the-as uint arg4)
                       :th (+ (log2 (+ (-> arg1 h) -1)) 1)
                       :tw (log2 (-> arg1 w))
                       :tbw (-> arg1 width 0)
-                      :tbp0 (/ (the-as int arg2) 64)
-                      :psm arg3
+                      :tbp0 (/ arg2 64)
+                      :psm (the-as uint arg3)
                       )
         )
   (none)
diff --git a/goal_src/jak2/engine/gfx/foreground/eye-h.gc b/goal_src/jak2/engine/gfx/foreground/eye-h.gc
index 1ca6065afb..baa86d7f4d 100644
--- a/goal_src/jak2/engine/gfx/foreground/eye-h.gc
+++ b/goal_src/jak2/engine/gfx/foreground/eye-h.gc
@@ -97,3 +97,4 @@
 
 
 
+(define-extern get-eye-block (function int int int))
diff --git a/goal_src/jak2/engine/gfx/foreground/eye.gc b/goal_src/jak2/engine/gfx/foreground/eye.gc
index 0faad092e8..335218d37c 100644
--- a/goal_src/jak2/engine/gfx/foreground/eye.gc
+++ b/goal_src/jak2/engine/gfx/foreground/eye.gc
@@ -7,3 +7,10 @@
 
 ;; DECOMP BEGINS
 
+(defun get-eye-block ((arg0 int) (arg1 int))
+  (let ((v1-0 arg0)
+        (a0-4 (-> ct32-24-block-table (* arg1 4)))
+        )
+    (the-as int (+ (-> *eyes-texture-base* vram-block) (* v1-0 32) a0-4))
+    )
+  )
diff --git a/goal_src/jak2/engine/gfx/hw/display.gc b/goal_src/jak2/engine/gfx/hw/display.gc
index f1581fe4e1..d44fc2bb7a 100644
--- a/goal_src/jak2/engine/gfx/hw/display.gc
+++ b/goal_src/jak2/engine/gfx/hw/display.gc
@@ -285,6 +285,7 @@
 (defun vif1-handler-debug ((mark-in int))
   "Handle the VIF1 interrupt.
   The mark register of VIF will be set to the bucket that is now starting."
+
   ; B0:
   ; L42:
   ;     daddiu sp, sp, -32
@@ -316,8 +317,10 @@
          ;     lwu a1, 0(a1)
          ;     sync.l
          (current-time (timer-count TIMER1_BANK))
+         (delta-time (the uint 0))
          )
 
+
     (cond
       ;     sltu t0, a0, a2  t0 = (mark < last-index)
       ;     beq t0, r0, L46
@@ -373,15 +376,21 @@
         ; B6:
         ; L46:
         ;     dsubu a1, a1, a3
-        (let ((delta-time (- current-time base-time)))
+        ;(let ((delta-time (- current-time base-time)))
+          (set! delta-time (- current-time base-time))
+
           ;     dsll a2, a2, 4
           ;     daddu a2, v1, a2
           ;     sh a1, 50(a2)
           (set! (-> prof data last-index end-time) (the int delta-time))
+          ; (format 0 "mark: ~D last ~D elapsed ~D~%" mark last-index
+          ;         (- (-> prof data last-index end-time)
+          ;            (-> prof data last-index start-time)))
+
           ;     sh a1, 50(v1)
           (set! (-> prof data 0 end-time) (the int delta-time))
           ;     or a2, a1, r0
-          )
+          ;)
         ) ;; end else
       ) ;; end cond
     ; B7:
@@ -393,7 +402,7 @@
     ;     dsll a2, a0, 4
     ;     daddu v1, v1, a2
     ;     sh a1, 48(v1)
-    (set! (-> prof data mark start-time) (the int current-time))
+    (set! (-> prof data mark start-time) (the int delta-time))
     ;     lw v1, *profile-work*(s7)
     ;     sw a0, 64(v1)
     (set! (-> *profile-work* last-index) mark)
@@ -522,25 +531,7 @@
            (t3-2 (the-as object (-> v1-2 base)))
            )
       (set! (-> (the-as gs-gif-tag t3-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-      (set! (-> (the-as gs-gif-tag t3-2) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag t3-2) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-2 base) (&+ (the-as pointer t3-2) 16))
       )
     (let* ((v1-3 arg0)
@@ -584,25 +575,7 @@
            (t5-2 (the-as object (-> v1-2 base)))
            )
       (set! (-> (the-as gs-gif-tag t5-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-      (set! (-> (the-as gs-gif-tag t5-2) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag t5-2) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-2 base) (&+ (the-as pointer t5-2) 16))
       )
     (let* ((v1-3 arg0)
@@ -647,26 +620,7 @@
          (a2-3 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a2-3) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-    (set! (-> (the-as gs-gif-tag a2-3) regs)
-          (new 'static 'gif-tag-regs
-            :regs0 (gif-reg-id a+d)
-            :regs1 (gif-reg-id a+d)
-            :regs2 (gif-reg-id a+d)
-            :regs3 (gif-reg-id a+d)
-            :regs4 (gif-reg-id a+d)
-            :regs5 (gif-reg-id a+d)
-            :regs6 (gif-reg-id a+d)
-            :regs7 (gif-reg-id a+d)
-            :regs8 (gif-reg-id a+d)
-            :regs9 (gif-reg-id a+d)
-            :regs10 (gif-reg-id a+d)
-            :regs11 (gif-reg-id a+d)
-            :regs12 (gif-reg-id a+d)
-            :regs13 (gif-reg-id a+d)
-            :regs14 (gif-reg-id a+d)
-            :regs15 (gif-reg-id a+d)
-            )
-          )
+    (set! (-> (the-as gs-gif-tag a2-3) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a2-3) 16))
     )
   (let* ((v1-2 arg1)
diff --git a/goal_src/jak2/engine/gfx/hw/gs.gc b/goal_src/jak2/engine/gfx/hw/gs.gc
index 665e1ab6f5..659731ca7e 100644
--- a/goal_src/jak2/engine/gfx/hw/gs.gc
+++ b/goal_src/jak2/engine/gfx/hw/gs.gc
@@ -102,6 +102,26 @@
   (sprite 6)
   )
 
+(defconstant GIF_REGS_ALL_AD
+  (new 'static 'gif-tag-regs
+       :regs0 (gif-reg-id a+d)
+       :regs1 (gif-reg-id a+d)
+       :regs2 (gif-reg-id a+d)
+       :regs3 (gif-reg-id a+d)
+       :regs4 (gif-reg-id a+d)
+       :regs5 (gif-reg-id a+d)
+       :regs6 (gif-reg-id a+d)
+       :regs7 (gif-reg-id a+d)
+       :regs8 (gif-reg-id a+d)
+       :regs9 (gif-reg-id a+d)
+       :regs10 (gif-reg-id a+d)
+       :regs11 (gif-reg-id a+d)
+       :regs12 (gif-reg-id a+d)
+       :regs13 (gif-reg-id a+d)
+       :regs14 (gif-reg-id a+d)
+       :regs15 (gif-reg-id a+d)
+       )
+  )
 
 ;; DECOMP BEGINS
 
diff --git a/goal_src/jak2/engine/gfx/math-camera.gc b/goal_src/jak2/engine/gfx/math-camera.gc
index c6d925e1cf..a593244f68 100644
--- a/goal_src/jak2/engine/gfx/math-camera.gc
+++ b/goal_src/jak2/engine/gfx/math-camera.gc
@@ -466,10 +466,12 @@
    (.lvf vf28 (&-> arg1 quad))
 
    ;; matrix multiply, result in vf28
+   ;(print-vf vf28)
    (.mul.x.vf acc vf24 vf28)
    (.add.mul.y.vf acc vf25 vf28 acc)
    (.add.mul.z.vf acc vf26 vf28 acc)
    (.add.mul.w.vf vf28 vf27 vf0 acc)
+   ;(print-vf vf28)
 
 
    (.add.w.vf vf23 vf0 vf0) ;; set w = 1.0
diff --git a/goal_src/jak2/engine/gfx/merc/emerc.gc b/goal_src/jak2/engine/gfx/merc/emerc.gc
index 9f22a5ff09..84c875c163 100644
--- a/goal_src/jak2/engine/gfx/merc/emerc.gc
+++ b/goal_src/jak2/engine/gfx/merc/emerc.gc
@@ -73,26 +73,7 @@
                (a0-6 (the-as object (-> v1-13 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-6) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-          (set! (-> (the-as gs-gif-tag a0-6) regs)
-                (new 'static 'gif-tag-regs
-                  :regs0 (gif-reg-id a+d)
-                  :regs1 (gif-reg-id a+d)
-                  :regs2 (gif-reg-id a+d)
-                  :regs3 (gif-reg-id a+d)
-                  :regs4 (gif-reg-id a+d)
-                  :regs5 (gif-reg-id a+d)
-                  :regs6 (gif-reg-id a+d)
-                  :regs7 (gif-reg-id a+d)
-                  :regs8 (gif-reg-id a+d)
-                  :regs9 (gif-reg-id a+d)
-                  :regs10 (gif-reg-id a+d)
-                  :regs11 (gif-reg-id a+d)
-                  :regs12 (gif-reg-id a+d)
-                  :regs13 (gif-reg-id a+d)
-                  :regs14 (gif-reg-id a+d)
-                  :regs15 (gif-reg-id a+d)
-                  )
-                )
+          (set! (-> (the-as gs-gif-tag a0-6) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-13 base) (&+ (the-as pointer a0-6) 16))
           )
         (let* ((v1-14 dma-buf)
@@ -118,137 +99,173 @@
 
 (defun emerc-vu1-init-buffers ()
   (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask emerc))
-    (emerc-vu1-init-buffer (bucket-id bucket-15) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-26) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-37) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-48) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-59) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-70) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
     (emerc-vu1-init-buffer
-      (bucket-id bucket-189)
+      (bucket-id emerc-l0-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-198)
+      (bucket-id emerc-l1-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-202)
+      (bucket-id emerc-l2-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-206)
+      (bucket-id emerc-l3-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-210)
+      (bucket-id emerc-l4-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-214)
+      (bucket-id emerc-l5-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-218)
+      (bucket-id emerc-lcom-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-222)
-      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
-      0
-      )
-    (emerc-vu1-init-buffer (bucket-id bucket-80) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-89) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-98) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer
-      (bucket-id bucket-107)
+      (bucket-id emerc-l0-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-116)
+      (bucket-id emerc-l1-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-125)
+      (bucket-id emerc-l2-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-193)
+      (bucket-id emerc-l3-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-132)
+      (bucket-id emerc-l4-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-142)
+      (bucket-id emerc-l5-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-152)
+      (bucket-id emerc-lcom-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-162)
+      (bucket-id emerc-l0-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-172)
+      (bucket-id emerc-l1-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-182)
+      (bucket-id emerc-l2-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-226)
+      (bucket-id emerc-l3-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-230)
+      (bucket-id emerc-l4-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-234)
+      (bucket-id emerc-l5-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-238)
+      (bucket-id emerc-lcom-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-242)
+      (bucket-id emerc-l0-alpha)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-246)
+      (bucket-id emerc-l1-alpha)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-250)
+      (bucket-id emerc-l2-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l3-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l4-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l5-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l0-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l1-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l2-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l3-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l4-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l5-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-lcom-pris2)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
diff --git a/goal_src/jak2/engine/gfx/merc/merc.gc b/goal_src/jak2/engine/gfx/merc/merc.gc
index bc8ddc65a2..601c4900f4 100644
--- a/goal_src/jak2/engine/gfx/merc/merc.gc
+++ b/goal_src/jak2/engine/gfx/merc/merc.gc
@@ -109,10 +109,10 @@
                )
            (cond
              ((< v1-6 3)
-              ;; (adgif-shader-login s3-0)
-              ;; (let ((v1-8 (get-eye-block s1-0 0)))
-              ;;   (set! (-> s3-0 tex0 tbp0) v1-8)
-              ;;   )
+              (adgif-shader-login s3-0)
+              (let ((v1-8 (get-eye-block s1-0 0)))
+                (set! (-> s3-0 tex0 tbp0) v1-8)
+                )
               (set! (-> s3-0 tex0 tw) 5)
               (set! (-> s3-0 tex0 th) 5)
               (set! (-> s3-0 tex0 tcc) 1)
@@ -124,7 +124,7 @@
                     )
               )
              (else
-               ;; (adgif-shader-login s3-0)
+               (adgif-shader-login s3-0)
                (let ((v1-34 (+ (-> *eyes-texture-base* vram-block) (* s1-0 32))))
                  (set! (-> s3-0 tex0 tbp0) v1-34)
                  )
@@ -147,10 +147,10 @@
                )
            (cond
              ((< v1-61 3)
-              ;; (adgif-shader-login s3-0)
-              ;; (let ((v1-63 (get-eye-block s1-1 1)))
-              ;;   (set! (-> s3-0 tex0 tbp0) v1-63)
-              ;;   )
+              (adgif-shader-login s3-0)
+              (let ((v1-63 (get-eye-block s1-1 1)))
+                (set! (-> s3-0 tex0 tbp0) v1-63)
+                )
               (set! (-> s3-0 tex0 tw) 5)
               (set! (-> s3-0 tex0 th) 5)
               (set! (-> s3-0 tex0 tcc) 1)
@@ -162,7 +162,7 @@
                     )
               )
              (else
-               ;; (adgif-shader-login s3-0)
+               (adgif-shader-login s3-0)
                (let ((v1-89 (+ (-> *eyes-texture-base* vram-block) (* (+ s1-1 1) 32))))
                  (set! (-> s3-0 tex0 tbp0) v1-89)
                  )
@@ -180,11 +180,11 @@
            )
          )
         (else
-          ;; (let ((a0-69 (adgif-shader-login s3-0)))
-          ;;   (if a0-69
-          ;;       (texture-usage-update a0-69)
-          ;;       )
-          ;;   )
+          (let ((a0-69 (adgif-shader-login s3-0)))
+            (if a0-69
+                (texture-usage-update a0-69)
+                )
+            )
           )
         )
       (&+! s3-0 80)
@@ -212,11 +212,11 @@
   (let ((tex (-> obj extra-info)))
     (when (nonzero? tex)
       (when (nonzero? (-> tex shader-offset))
-        ;; (let ((a0-6 (adgif-shader-login (the-as adgif-shader (+ (the-as uint tex) (* (-> tex shader-offset) 16))))))
-        ;;   (if a0-6
-        ;;       (texture-usage-update a0-6)
-        ;;       )
-        ;;   )
+        (let ((a0-6 (adgif-shader-login (the-as adgif-shader (+ (the-as uint tex) (* (-> tex shader-offset) 16))))))
+          (if a0-6
+              (texture-usage-update a0-6)
+              )
+          )
         )
       )
     )
@@ -314,11 +314,11 @@
   (when (and (-> obj header eye-ctrl) (nonzero? (-> obj header eye-ctrl)))
     (let ((s5-1 (-> obj header eye-ctrl)))
       (dotimes (s4-0 (-> s5-1 shader-count))
-        ;; (let ((a0-5 (adgif-shader-login (-> s5-1 shader s4-0))))
-        ;;   (if a0-5
-        ;;       (texture-usage-update a0-5)
-        ;;       )
-        ;;   )
+        (let ((a0-5 (adgif-shader-login (-> s5-1 shader s4-0))))
+          (if a0-5
+              (texture-usage-update a0-5)
+              )
+          )
         )
       )
     )
@@ -554,25 +554,7 @@
                (a0-6 (the-as object (-> v1-13 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-6) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-          (set! (-> (the-as gs-gif-tag a0-6) regs) (new 'static 'gif-tag-regs
-                                                     :regs0 (gif-reg-id a+d)
-                                                     :regs1 (gif-reg-id a+d)
-                                                     :regs2 (gif-reg-id a+d)
-                                                     :regs3 (gif-reg-id a+d)
-                                                     :regs4 (gif-reg-id a+d)
-                                                     :regs5 (gif-reg-id a+d)
-                                                     :regs6 (gif-reg-id a+d)
-                                                     :regs7 (gif-reg-id a+d)
-                                                     :regs8 (gif-reg-id a+d)
-                                                     :regs9 (gif-reg-id a+d)
-                                                     :regs10 (gif-reg-id a+d)
-                                                     :regs11 (gif-reg-id a+d)
-                                                     :regs12 (gif-reg-id a+d)
-                                                     :regs13 (gif-reg-id a+d)
-                                                     :regs14 (gif-reg-id a+d)
-                                                     :regs15 (gif-reg-id a+d)
-                                                     )
-                )
+          (set! (-> (the-as gs-gif-tag a0-6) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-13 base) (&+ (the-as pointer a0-6) 16))
           )
         (let* ((v1-14 dma-buf)
@@ -611,47 +593,47 @@
 (defun merc-vu1-init-buffers ()
   "Init merc DMA buffers."
   (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask merc))
-    (merc-vu1-init-buffer (bucket-id bucket-14) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-25) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-36) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-47) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-58) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-69) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-188) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-197) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-201) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-205) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-209) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-213) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-217) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-221) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-79) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-88) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-97) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-106) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-115) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-124) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-192) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-131) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-141) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-151) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-161) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-171) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-181) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-225) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-229) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-233) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-237) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-241) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-245) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-249) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-253) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-262) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-271) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-280) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-289) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-298) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-307) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l0-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l1-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l2-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l3-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l4-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l5-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-water) 1 #f)
     )
   0
   (none)
diff --git a/goal_src/jak2/engine/gfx/mood/mood-funcs2.gc b/goal_src/jak2/engine/gfx/mood/mood-funcs2.gc
index 406fb634ce..c1681c37d5 100644
--- a/goal_src/jak2/engine/gfx/mood/mood-funcs2.gc
+++ b/goal_src/jak2/engine/gfx/mood/mood-funcs2.gc
@@ -206,7 +206,7 @@
           (vector-lerp!
             (the-as vector (-> arg0 times))
             (the-as vector (-> arg0 times))
-            (the-as vector (+ #x83ac (the-as int *level*)))
+            (the-as vector (-> *level* default-level mood-context times))
             f0-5
             )
           )
@@ -706,7 +706,7 @@
           (set! (-> s5-0 clock-moon) (the-as uint (the int (rand-vu-float-range 64.0 192.0))))
           )
         (if (and (-> s5-0 door) (zero? (logand (-> s5-0 door extra perm status) (entity-perm-status subtask-complete))))
-            (set! (-> arg0 times 0 quad) (-> (the-as (pointer uint128) (+ #x83ac (the-as int *level*)))))
+            (set! (-> arg0 times 0 quad) (-> *level* default-level mood-context times 0 quad))
             )
         )
       (let ((a0-121 (new 'stack-no-clear 'sphere))
@@ -717,7 +717,7 @@
           (vector-lerp!
             (the-as vector (-> arg0 times))
             (the-as vector (-> arg0 times))
-            (the-as vector (+ #x83ac (the-as int *level*)))
+            (the-as vector (-> *level* default-level mood-context times))
             f0-76
             )
           )
diff --git a/goal_src/jak2/engine/gfx/mood/mood.gc b/goal_src/jak2/engine/gfx/mood/mood.gc
index 29a5155f8e..9af282d912 100644
--- a/goal_src/jak2/engine/gfx/mood/mood.gc
+++ b/goal_src/jak2/engine/gfx/mood/mood.gc
@@ -261,7 +261,7 @@
           )
         )
       (let ((v1-5 (-> arg0 times))
-            (a0-2 (the-as (inline-array vector) (+ #x83ac (the-as int *level*))))
+            (a0-2 (-> *level* default-level mood-context times))
             )
         (dotimes (a1-6 5)
           (set! (-> v1-5 0 quad) (-> a0-2 0 quad))
@@ -290,9 +290,9 @@
           (set! a2-3 (-> (the-as mood-context a2-3) current-fog fog-dists))
           )
         )
-      (set! (-> arg0 times 0 quad) (-> (the-as (pointer uint128) (+ #x83ac (the-as int *level*)))))
+      (set! (-> arg0 times 0 quad) (-> *level* default-level mood-context times 0 quad))
       (when arg1
-        (set! (-> arg0 times 1 quad) (-> (the-as (pointer uint128) (+ #x83bc (the-as int *level*)))))
+        (set! (-> arg0 times 1 quad) (-> *level* default-level mood-context times 1 quad))
         (set! (-> arg0 times 1 w) 1.0)
         )
       )
diff --git a/goal_src/jak2/engine/gfx/sprite/sprite.gc b/goal_src/jak2/engine/gfx/sprite/sprite.gc
index 99dea985c5..eb843965f5 100644
--- a/goal_src/jak2/engine/gfx/sprite/sprite.gc
+++ b/goal_src/jak2/engine/gfx/sprite/sprite.gc
@@ -595,7 +595,7 @@
          (set! (-> pkt1 dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
          (set! (-> pkt1 vif0) (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)))
          (set! (-> pkt1 vif1) (new 'static 'vif-tag :num #x5 ;; matrix + qword
-                                                    :cmd (vif-cmd unpack-v4-32) 
+                                                    :cmd (vif-cmd unpack-v4-32)
                                                     :imm (shr (shl count 54) 54)))
          (set! (-> a1-1 base) (&+ (the-as pointer pkt1) 16))
          )
@@ -628,7 +628,7 @@
          (set! (-> pkt2 vif0) (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)))
          (set! (-> pkt2 vif1)
                (new 'static 'vif-tag :num #x50 ;; matrix + qword + 75 qword table
-                                     :cmd (vif-cmd unpack-v4-32) 
+                                     :cmd (vif-cmd unpack-v4-32)
                                      :imm (shr (shl count 54) 54))
                )
          (set! (-> a1-10 base) (&+ (the-as pointer pkt2) 16))
@@ -705,7 +705,7 @@
     (sprite-setup-header (the-as sprite-header (-> dma-buff base)) num-sprites)
     (&+! (-> dma-buff base) (* qwc-pkt1 16))
     )
-  
+
   ;; second packet is vector data (3 qw / sprite)
   (let* ((qwc-pkt2 (* 3 num-sprites))
          (v1-4 dma-buff)
@@ -738,7 +738,7 @@
     (set! (-> pkt3 vif1) (new 'static 'vif-tag :imm #x8091 :cmd (vif-cmd unpack-v4-32) :num qwc-pkt3))
     (set! (-> v1-6 base) (&+ (the-as pointer pkt3) 16))
     )
-  
+
   ;; fourth packet runs the renderer!
   (let ((pkt4 (the-as dma-packet (-> dma-buff base))))
     (set! (-> pkt4 dma) (new 'static 'dma-tag :id (dma-tag-id cnt)))
@@ -794,7 +794,7 @@
     (sprite-setup-header (the-as sprite-header (-> dma-buff base)) num-sprites)
     (&+! (-> dma-buff base) (* qwc-pkt1 16))
     )
-  
+
   ;; second packet is vector data (3 qw / sprite)
   (let* ((qwc-pkt2 (* 3 num-sprites))
          (v1-4 dma-buff)
@@ -811,7 +811,7 @@
     (set! (-> pkt2 vif1) (new 'static 'vif-tag :imm #x8001 :cmd (vif-cmd unpack-v4-32) :num qwc-pkt2))
     (set! (-> v1-4 base) (&+ (the-as pointer pkt2) 16))
     )
-  
+
   ;; third packet is adgif data (5 qw/sprite)
   (let* ((qwc-pkt3 (* 5 num-sprites))
          (v1-6 dma-buff)
@@ -827,7 +827,7 @@
     (set! (-> pkt3 vif1) (new 'static 'vif-tag :imm #x8091 :cmd (vif-cmd unpack-v4-32) :num qwc-pkt3))
     (set! (-> v1-6 base) (&+ (the-as pointer pkt3) 16))
     )
-  
+
   ;; fourth packet runs the renderer!
   (let ((pkt4 (the-as dma-packet (-> dma-buff base))))
     (set! (-> pkt4 dma) (new 'static 'dma-tag :id (dma-tag-id cnt)))
@@ -849,7 +849,7 @@
                               )
           (remaining-sprites (-> sprites num-valid group-idx))
           )
-      
+
       ;; loop over chunks
       (while (< 48 remaining-sprites)
         (sprite-add-3d-chunk sprites current-sprite-idx 48 dma-buff)
@@ -890,26 +890,7 @@
              (giftag (the-as gs-gif-tag (-> v1-18 base)))
              )
         (set! (-> giftag tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> giftag regs)
-              (new 'static 'gif-tag-regs
-                :regs0 (gif-reg-id a+d)
-                :regs1 (gif-reg-id a+d)
-                :regs2 (gif-reg-id a+d)
-                :regs3 (gif-reg-id a+d)
-                :regs4 (gif-reg-id a+d)
-                :regs5 (gif-reg-id a+d)
-                :regs6 (gif-reg-id a+d)
-                :regs7 (gif-reg-id a+d)
-                :regs8 (gif-reg-id a+d)
-                :regs9 (gif-reg-id a+d)
-                :regs10 (gif-reg-id a+d)
-                :regs11 (gif-reg-id a+d)
-                :regs12 (gif-reg-id a+d)
-                :regs13 (gif-reg-id a+d)
-                :regs14 (gif-reg-id a+d)
-                :regs15 (gif-reg-id a+d)
-                )
-              )
+        (set! (-> giftag regs) GIF_REGS_ALL_AD)
         (set! (-> v1-18 base) (the-as pointer (&+ giftag 16)))
         )
       (let* ((v1-19 dma-buff)
@@ -932,7 +913,7 @@
         (set! (-> (the-as (pointer gs-reg64) a0-10) 3) (gs-reg64 clamp-1))
         (set! (-> v1-19 base) (&+ a0-10 32))
         )
-      
+
       ;; load the VU1 code
       (dma-buffer-add-vu-function dma-buff sprite-vu1-block 1)
 
@@ -948,7 +929,7 @@
         (set! (-> pkt2 vif1) (new 'static 'vif-tag :cmd (vif-cmd flushe) :msk #x1)) ;; wait for mpg
         (set! (-> v1-20 base) (&+ (the-as pointer pkt2) 16))
         )
-      
+
       ;; set up double buffer upload and draw
       (let* ((v1-21 dma-buff)
              (pkt3 (the-as dma-packet (-> v1-21 base)))
@@ -962,7 +943,7 @@
       ;;;;;;;;;;;;;;;;
       ;; group 0 draw
       ;;;;;;;;;;;;;;;;
-      
+
       ;; add matrix data (not needed for init)
       (sprite-add-matrix-data dma-buff (the-as uint 0))
 
@@ -970,7 +951,7 @@
       (sprite-add-3d-all *sprite-array-3d* dma-buff 0)
       ;; add 2d's (group 0)
       (sprite-add-2d-all *sprite-array-2d* dma-buff 0)
-      
+
       ;; draw group 0
       (let* ((v1-22 dma-buff)
              (pkt4 (the-as dma-packet (-> v1-22 base)))
@@ -1032,7 +1013,7 @@
           )
         )
       )
-    
+
     ;; update memory usage
     (let ((mem-use *dma-mem-usage*))
       (when (nonzero? mem-use)
diff --git a/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc b/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc
index dbf4dc8314..685ad33d4a 100644
--- a/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc
+++ b/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc
@@ -198,3 +198,6 @@
              )
         )
 
+
+(define-extern update-texture-anim (function bucket-id none))
+(define-extern *skull-gem-texture-anim-array* texture-anim-array)
diff --git a/goal_src/jak2/engine/gfx/texture/texture-finish.gc b/goal_src/jak2/engine/gfx/texture/texture-finish.gc
index da3fe35f38..d0f6e28fd9 100644
--- a/goal_src/jak2/engine/gfx/texture/texture-finish.gc
+++ b/goal_src/jak2/engine/gfx/texture/texture-finish.gc
@@ -7,3 +7,37 @@
 
 ;; DECOMP BEGINS
 
+
+;; failed to figure out what this is:
+(setup-font-texture *texture-pool*)
+
+(format 0 "SKIP: texture-finish anim stuff~%")
+(format #t "SKIP: texture-finish anim stuff~%")
+
+; ;; failed to figure out what this is:
+; (let ((v1-2 (lookup-texture-by-id (new 'static 'texture-id :index #x4 :page #x70c))))
+;   (when v1-2
+;     (set! (-> v1-2 w) 32)
+;     (set! (-> v1-2 h) 32)
+;     (set! (-> v1-2 dest 0) (-> *skull-gem-texture-base* vram-block))
+;     )
+;   )
+
+; ;; failed to figure out what this is:
+; ((method-of-object *sky-texture-anim-array* texture-anim-array-method-9))
+
+; ;; failed to figure out what this is:
+; ((method-of-object *darkjak-texture-anim-array* texture-anim-array-method-9))
+
+; ;; failed to figure out what this is:
+; ((method-of-object *skull-gem-texture-anim-array* texture-anim-array-method-9))
+
+; ;; failed to figure out what this is:
+; ((method-of-object *bomb-texture-anim-array* texture-anim-array-method-9))
+
+;; failed to figure out what this is:
+(kmemclose)
+
+
+
+
diff --git a/goal_src/jak2/engine/gfx/texture/texture-h.gc b/goal_src/jak2/engine/gfx/texture/texture-h.gc
index ad93c8a5c8..af08d7151d 100644
--- a/goal_src/jak2/engine/gfx/texture/texture-h.gc
+++ b/goal_src/jak2/engine/gfx/texture/texture-h.gc
@@ -8,27 +8,27 @@
 ;; TODO document and method names with texture.gc
 
 (declare-type texture-page basic)
-
-;; NOTE - for settings
 (declare-type texture-pool basic)
-(define-extern *texture-pool* texture-pool)
-
-;; NOTE - for cam-update
 (declare-type fog-texture-work structure)
-(define-extern *fog-texture-work* fog-texture-work)
-
-;; NOTE - for sparticle
 (declare-type adgif-shader structure)
 (declare-type texture basic)
 (declare-type texture-id uint32)
 (define-extern adgif-shader<-texture-simple! (function adgif-shader texture adgif-shader))
 (define-extern lookup-texture-by-id-fast (function texture-id texture))
-
-;; NOTE - for default-menu
 (define-extern *edit-shader* texture-id)
 (define-extern adgif-shader-update! (function adgif-shader texture none))
 (declare-type texture-page-dir basic)
 (define-extern texture-page-dir-inspect (function texture-page-dir symbol none))
+(define-extern *texture-pool* texture-pool)
+(define-extern *fog-texture-work* fog-texture-work)
+
+(defenum tex-upload-mode
+  (none     -3)
+  (seg0-1   -2)
+  (seg0-1-2 -1)
+  (seg0      0)
+  (seg2      2)
+  )
 
 ;; DECOMP BEGINS
 
@@ -62,10 +62,10 @@
    (segment-common           texture-pool-segment                                        :inline   :offset         28)
    (common-page              texture-page                                                32        :offset-assert  52)
    (common-page-mask         int32                                                                 :offset-assert 180)
-   (update-sprites-flag      symbol                                                                 :offset-assert 184)
-   (update-flag              symbol                                                                 :offset-assert 188)
-   (texture-enable-user      uint64                                                                :offset-assert 192)
-   (texture-enable-user-menu uint64                                                                :offset-assert 200)
+   (update-sprites-flag      symbol                                                                :offset-assert 184)
+   (update-flag              symbol                                                                :offset-assert 188)
+   (texture-enable-user      texture-enable-mask                                                   :offset-assert 192)
+   (texture-enable-user-menu texture-enable-mask                                                   :offset-assert 200)
    (ids                      uint32                                                      128       :offset-assert 208)
    )
   :method-count-assert 26
@@ -74,21 +74,21 @@
   (:methods
     (new (symbol type) _type_ 0)
     (initialize! (_type_) _type_ 9)
-    (texture-pool-method-10 () none 10) ;; (print-usage (_type_) _type_ 10)
-    (texture-pool-method-11 () none 11) ;; (setup-font-texture! (_type_) none 11)
-    (allocate-defaults! (_type_) none 12)
+    (print-usage (_type_) _type_ 10)
+    (setup-font-texture (_type_) none 11)
+    (allocate-defaults (_type_) none 12)
     (login-level-textures (_type_ level int (pointer texture-id)) none 13)
-    (texture-pool-method-14 () none 14) ;; (add-tex-to-dma! (_type_ level int) none 14)
+    (add-level-tpage-dma (_type_ level tpage-category bucket-id) none 14)
     (allocate-vram-words! (_type_ int) int 15)
-    (allocate-segment! (_type_ texture-pool-segment int) texture-pool-segment 16)
-    (texture-pool-method-17 () none 17) ;; (unused-17 () none 17)
-    (texture-pool-method-18 (_type_ int) int 18) ;; (unused-18 () none 18)
-    (update-warp-and-hud (_type_) none 19) ;; (unused-19 () none 19)
-    (update-sprites (_type_) none 20) ;; (unload! (_type_ texture-page) int 20)
-    (flag-update-and-sprite (_type_) none 21) ;; (upload-one-common! (_type_ level) symbol 21)
-    (relocate-sprite-dests! (_type_) none 22) ;; (lookup-boot-common-id (_type_ int) int 22)
-    (relocate-hud-dests! (_type_) none 23)
-    (relocate-warp-dests! (_type_) none 24)
+    (allocate-segment (_type_ texture-pool-segment int) texture-pool-segment 16)
+    (unload-page (_type_ texture-page) none 17)
+    (get-common-page-slot-by-id (_type_ int) int 18)
+    (update-warp-and-hud (_type_) none 19)
+    (update-sprites (_type_) none 20)
+    (mark-hud-warp-sprite-dirty (_type_) none 21)
+    (lay-out-sprite-tex (_type_) none 22)
+    (lay-out-hud-tex (_type_) none 23)
+    (lay-out-warp-tex (_type_) none 24)
     (clear-ids (_type_) none 25)
     )
   )
@@ -167,7 +167,7 @@
 
 (deftype texture-page (basic)
   ((info      file-info                      :offset-assert   4)
-   (name      basic                          :offset-assert   8)
+   (name      string                         :offset-assert   8)
    (id        uint32                         :offset-assert  12)
    (length    int32                          :offset-assert  16)
    (mip0-size uint32                         :offset-assert  20)
@@ -181,11 +181,12 @@
   :size-assert         #x80
   :flag-assert         #xe00000080
   (:methods
-    (remove-from-heap (_type_ kheap) _type_ 9)
+    (relocate (_type_ kheap (pointer uint8)) texture-page :replace 7)
+    (remove-data-from-heap (_type_ kheap) _type_ 9)
     (get-leftover-block-count (_type_ int int) int 10)
-    (relocate-dests! (_type_ int int) none 11) ;; (unused-11 () none 11)
-    (texture-page-method-12 () none 12) ;;
-    (upload-now! (_type_ int) none 13) ;; (add-to-dma-buffer (_type_ dma-buffer int) int 13)
+    (relocate-dests! (_type_ int int) none 11)
+    (add-to-dma-buffer (_type_ dma-buffer tex-upload-mode) int 12)
+    (upload-now! (_type_ tex-upload-mode) none 13)
     )
   )
 
@@ -227,7 +228,7 @@
   :flag-assert         #xa00000014
   (:methods
     (relocate (_type_ kheap (pointer uint8)) none :replace 7)
-    (unlink-textures-in-heap! (_type_ kheap) int 9)
+    (unlink-shaders-in-heap (_type_ kheap) int 9)
     )
   )
 
@@ -252,8 +253,8 @@
 (defenum link-test-flags
   :type uint32
   :bitfield #t
-  ; (needs-log-in 8)
-  ; (bit-9 9)
+  (needs-log-in 8)
+  (bit-9 9)
   )
 
 (deftype adgif-shader (structure)
@@ -361,365 +362,394 @@
         )
 
 (deftype texture-page-translate-item (structure)
-  ((bucket             bucket-id  :offset-assert   0)
-   (level-index        uint32     :offset-assert   4)
-   (level-texture-page uint32     :offset-assert   8)
-   (texture-user       uint32     :offset-assert  12)
+  ((bucket             bucket-id                :offset-assert   0)
+   (level-index        uint32                   :offset-assert   4)
+   (level-texture-page tpage-category-u32       :offset-assert   8)
+   (texture-user       texture-enable-mask-u32  :offset-assert  12)
    )
   :method-count-assert 9
   :size-assert         #x10
   :flag-assert         #x900000010
   )
 
-
+;; the order of all texture uploads in a frame.
+;; this is used by the texture system to figure out if anything can be reused
+;; or if it needs to be uploaded at a certain time.
 (define *texture-page-translate*
         (new 'static 'boxed-array :type texture-page-translate-item
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-4)
+                  :bucket (bucket-id tex-lcom-sky-pre)
                   :level-index #x6
-                  :level-texture-page #x9
-                  :texture-user #x100
-                  )
-             (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-7) :texture-user #x1)
-             (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-18) :level-index #x1 :texture-user #x1)
-             (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-29) :level-index #x2 :texture-user #x1)
-             (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-40) :level-index #x3 :texture-user #x1)
-             (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-51) :level-index #x4 :texture-user #x1)
-             (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-62) :level-index #x5 :texture-user #x1)
-             (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-73)
-                  :level-texture-page #x2
-                  :texture-user #x4
+                  :level-texture-page (tpage-category-u32 sky)
+                  :texture-user (texture-enable-mask-u32 sky)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-82)
+                  :bucket (bucket-id tex-l0-tfrag)
+                  :texture-user (texture-enable-mask-u32 tfrag)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-l1-tfrag)
                   :level-index #x1
-                  :level-texture-page #x2
-                  :texture-user #x4
+                  :texture-user (texture-enable-mask-u32 tfrag)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-91)
+                  :bucket (bucket-id tex-l2-tfrag)
                   :level-index #x2
-                  :level-texture-page #x2
-                  :texture-user #x4
+                  :texture-user (texture-enable-mask-u32 tfrag)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-100)
+                  :bucket (bucket-id tex-l3-tfrag)
                   :level-index #x3
-                  :level-texture-page #x2
-                  :texture-user #x4
+                  :texture-user (texture-enable-mask-u32 tfrag)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-109)
+                  :bucket (bucket-id tex-l4-tfrag)
                   :level-index #x4
-                  :level-texture-page #x2
-                  :texture-user #x4
+                  :texture-user (texture-enable-mask-u32 tfrag)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-118)
+                  :bucket (bucket-id tex-l5-tfrag)
                   :level-index #x5
-                  :level-texture-page #x2
-                  :texture-user #x4
+                  :texture-user (texture-enable-mask-u32 tfrag)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-127)
-                  :level-texture-page #x3
-                  :texture-user #x8
+                  :bucket (bucket-id tex-l0-shrub)
+                  :level-texture-page (tpage-category-u32 shrub)
+                  :texture-user (texture-enable-mask-u32 shrub)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-137)
+                  :bucket (bucket-id tex-l1-shrub)
                   :level-index #x1
-                  :level-texture-page #x3
-                  :texture-user #x8
+                  :level-texture-page (tpage-category-u32 shrub)
+                  :texture-user (texture-enable-mask-u32 shrub)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-147)
+                  :bucket (bucket-id tex-l2-shrub)
                   :level-index #x2
-                  :level-texture-page #x3
-                  :texture-user #x8
+                  :level-texture-page (tpage-category-u32 shrub)
+                  :texture-user (texture-enable-mask-u32 shrub)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-157)
+                  :bucket (bucket-id tex-l3-shrub)
                   :level-index #x3
-                  :level-texture-page #x3
-                  :texture-user #x8
+                  :level-texture-page (tpage-category-u32 shrub)
+                  :texture-user (texture-enable-mask-u32 shrub)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-167)
+                  :bucket (bucket-id tex-l4-shrub)
                   :level-index #x4
-                  :level-texture-page #x3
-                  :texture-user #x8
+                  :level-texture-page (tpage-category-u32 shrub)
+                  :texture-user (texture-enable-mask-u32 shrub)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-177)
+                  :bucket (bucket-id tex-l5-shrub)
                   :level-index #x5
-                  :level-texture-page #x3
-                  :texture-user #x8
-                  )
-             (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-187) :level-index #x6 :texture-user #x1)
-             (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-191)
-                  :level-index #x6
-                  :level-texture-page #x2
-                  :texture-user #x4
+                  :level-texture-page (tpage-category-u32 shrub)
+                  :texture-user (texture-enable-mask-u32 shrub)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-196)
-                  :level-texture-page #x1
-                  :texture-user #x2
+                  :bucket (bucket-id tex-l0-alpha)
+                  :level-texture-page (tpage-category-u32 alpha)
+                  :texture-user (texture-enable-mask-u32 alpha)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-200)
+                  :bucket (bucket-id tex-l1-alpha)
                   :level-index #x1
-                  :level-texture-page #x1
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 alpha)
+                  :texture-user (texture-enable-mask-u32 alpha)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-204)
+                  :bucket (bucket-id tex-l2-alpha)
                   :level-index #x2
-                  :level-texture-page #x1
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 alpha)
+                  :texture-user (texture-enable-mask-u32 alpha)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-208)
+                  :bucket (bucket-id tex-l3-alpha)
                   :level-index #x3
-                  :level-texture-page #x1
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 alpha)
+                  :texture-user (texture-enable-mask-u32 alpha)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-212)
+                  :bucket (bucket-id tex-l4-alpha)
                   :level-index #x4
-                  :level-texture-page #x1
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 alpha)
+                  :texture-user (texture-enable-mask-u32 alpha)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-216)
+                  :bucket (bucket-id tex-l5-alpha)
                   :level-index #x5
-                  :level-texture-page #x1
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 alpha)
+                  :texture-user (texture-enable-mask-u32 alpha)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-220)
+                  :bucket (bucket-id tex-lcom-tfrag)
                   :level-index #x6
-                  :level-texture-page #x1
-                  :texture-user #x2
+                  :texture-user (texture-enable-mask-u32 tfrag)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-224)
-                  :level-texture-page #x6
-                  :texture-user #x2
+                  :bucket (bucket-id tex-lcom-shrub)
+                  :level-index #x6
+                  :level-texture-page (tpage-category-u32 shrub)
+                  :texture-user (texture-enable-mask-u32 shrub)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-228)
+                  :bucket (bucket-id tex-l0-pris)
+                  :level-texture-page (tpage-category-u32 pris)
+                  :texture-user (texture-enable-mask-u32 pris)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-l1-pris)
                   :level-index #x1
-                  :level-texture-page #x6
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 pris)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-232)
+                  :bucket (bucket-id tex-l2-pris)
                   :level-index #x2
-                  :level-texture-page #x6
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 pris)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-236)
+                  :bucket (bucket-id tex-l3-pris)
                   :level-index #x3
-                  :level-texture-page #x6
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 pris)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-240)
+                  :bucket (bucket-id tex-l4-pris)
                   :level-index #x4
-                  :level-texture-page #x6
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 pris)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-244)
+                  :bucket (bucket-id tex-l5-pris)
                   :level-index #x5
-                  :level-texture-page #x6
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 pris)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-248)
+                  :bucket (bucket-id tex-lcom-pris)
                   :level-index #x6
-                  :level-texture-page #x6
-                  :texture-user #x2
+                  :level-texture-page (tpage-category-u32 pris)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-252)
-                  :level-texture-page #x4
-                  :texture-user #x10
+                  :bucket (bucket-id tex-l0-pris2)
+                  :level-texture-page (tpage-category-u32 pris2)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-261)
+                  :bucket (bucket-id tex-l1-pris2)
                   :level-index #x1
-                  :level-texture-page #x4
-                  :texture-user #x10
+                  :level-texture-page (tpage-category-u32 pris2)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-270)
+                  :bucket (bucket-id tex-l2-pris2)
                   :level-index #x2
-                  :level-texture-page #x4
-                  :texture-user #x10
+                  :level-texture-page (tpage-category-u32 pris2)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-279)
+                  :bucket (bucket-id tex-l3-pris2)
                   :level-index #x3
-                  :level-texture-page #x4
-                  :texture-user #x10
+                  :level-texture-page (tpage-category-u32 pris2)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-288)
+                  :bucket (bucket-id tex-l4-pris2)
                   :level-index #x4
-                  :level-texture-page #x4
-                  :texture-user #x10
+                  :level-texture-page (tpage-category-u32 pris2)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-297)
+                  :bucket (bucket-id tex-l5-pris2)
                   :level-index #x5
-                  :level-texture-page #x4
-                  :texture-user #x10
+                  :level-texture-page (tpage-category-u32 pris2)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-306)
+                  :bucket (bucket-id tex-lcom-pris2)
                   :level-index #x6
-                  :level-texture-page #x4
-                  :texture-user #x10
+                  :level-texture-page (tpage-category-u32 pris2)
+                  :texture-user (texture-enable-mask-u32 pris)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-309)
-                  :level-index #x6
-                  :level-texture-page #x9
-                  :texture-user #x100
+                  :bucket (bucket-id tex-l0-water)
+                  :level-texture-page (tpage-category-u32 water)
+                  :texture-user (texture-enable-mask-u32 water)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-312)
-                  :level-texture-page #x7
-                  :texture-user #x40
-                  )
-             (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-312)
+                  :bucket (bucket-id tex-l1-water)
                   :level-index #x1
-                  :level-texture-page #x7
-                  :texture-user #x40
+                  :level-texture-page (tpage-category-u32 water)
+                  :texture-user (texture-enable-mask-u32 water)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-312)
+                  :bucket (bucket-id tex-l2-water)
                   :level-index #x2
-                  :level-texture-page #x7
-                  :texture-user #x40
+                  :level-texture-page (tpage-category-u32 water)
+                  :texture-user (texture-enable-mask-u32 water)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-312)
+                  :bucket (bucket-id tex-l3-water)
                   :level-index #x3
-                  :level-texture-page #x7
-                  :texture-user #x40
+                  :level-texture-page (tpage-category-u32 water)
+                  :texture-user (texture-enable-mask-u32 water)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-312)
+                  :bucket (bucket-id tex-l4-water)
                   :level-index #x4
-                  :level-texture-page #x7
-                  :texture-user #x40
+                  :level-texture-page (tpage-category-u32 water)
+                  :texture-user (texture-enable-mask-u32 water)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-312)
+                  :bucket (bucket-id tex-l5-water)
                   :level-index #x5
-                  :level-texture-page #x7
-                  :texture-user #x40
+                  :level-texture-page (tpage-category-u32 water)
+                  :texture-user (texture-enable-mask-u32 water)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-312)
+                  :bucket (bucket-id tex-lcom-water)
                   :level-index #x6
-                  :level-texture-page #x7
-                  :texture-user #x40
+                  :level-texture-page (tpage-category-u32 water)
+                  :texture-user (texture-enable-mask-u32 water)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-316)
-                  :level-texture-page #x5
-                  :texture-user #x20
+                  :bucket (bucket-id tex-lcom-sky-post)
+                  :level-index #x6
+                  :level-texture-page (tpage-category-u32 sky)
+                  :texture-user (texture-enable-mask-u32 sky)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-316)
+                  :bucket (bucket-id tex-all-sprite)
+                  :level-texture-page (tpage-category-u32 sprite)
+                  :texture-user (texture-enable-mask-u32 sprite)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-sprite)
                   :level-index #x1
-                  :level-texture-page #x5
-                  :texture-user #x20
+                  :level-texture-page (tpage-category-u32 sprite)
+                  :texture-user (texture-enable-mask-u32 sprite)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-316)
+                  :bucket (bucket-id tex-all-sprite)
                   :level-index #x2
-                  :level-texture-page #x5
-                  :texture-user #x20
+                  :level-texture-page (tpage-category-u32 sprite)
+                  :texture-user (texture-enable-mask-u32 sprite)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-316)
+                  :bucket (bucket-id tex-all-sprite)
                   :level-index #x3
-                  :level-texture-page #x5
-                  :texture-user #x20
+                  :level-texture-page (tpage-category-u32 sprite)
+                  :texture-user (texture-enable-mask-u32 sprite)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-316)
+                  :bucket (bucket-id tex-all-sprite)
                   :level-index #x4
-                  :level-texture-page #x5
-                  :texture-user #x20
+                  :level-texture-page (tpage-category-u32 sprite)
+                  :texture-user (texture-enable-mask-u32 sprite)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-316)
+                  :bucket (bucket-id tex-all-sprite)
                   :level-index #x5
-                  :level-texture-page #x5
-                  :texture-user #x20
+                  :level-texture-page (tpage-category-u32 sprite)
+                  :texture-user (texture-enable-mask-u32 sprite)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-316)
+                  :bucket (bucket-id tex-all-sprite)
                   :level-index #x6
-                  :level-texture-page #x5
-                  :texture-user #x20
+                  :level-texture-page (tpage-category-u32 sprite)
+                  :texture-user (texture-enable-mask-u32 sprite)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
-                  :level-texture-page #x8
-                  :texture-user #x80
+                  :bucket (bucket-id tex-all-warp)
+                  :level-texture-page (tpage-category-u32 warp)
+                  :texture-user (texture-enable-mask-u32 warp)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
+                  :bucket (bucket-id tex-all-warp)
                   :level-index #x1
-                  :level-texture-page #x8
-                  :texture-user #x80
+                  :level-texture-page (tpage-category-u32 warp)
+                  :texture-user (texture-enable-mask-u32 warp)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
+                  :bucket (bucket-id tex-all-warp)
                   :level-index #x2
-                  :level-texture-page #x8
-                  :texture-user #x80
+                  :level-texture-page (tpage-category-u32 warp)
+                  :texture-user (texture-enable-mask-u32 warp)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
+                  :bucket (bucket-id tex-all-warp)
                   :level-index #x3
-                  :level-texture-page #x8
-                  :texture-user #x80
+                  :level-texture-page (tpage-category-u32 warp)
+                  :texture-user (texture-enable-mask-u32 warp)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
+                  :bucket (bucket-id tex-all-warp)
                   :level-index #x4
-                  :level-texture-page #x8
-                  :texture-user #x80
+                  :level-texture-page (tpage-category-u32 warp)
+                  :texture-user (texture-enable-mask-u32 warp)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
+                  :bucket (bucket-id tex-all-warp)
                   :level-index #x5
-                  :level-texture-page #x8
-                  :texture-user #x80
+                  :level-texture-page (tpage-category-u32 warp)
+                  :texture-user (texture-enable-mask-u32 warp)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
+                  :bucket (bucket-id tex-all-warp)
                   :level-index #x6
-                  :level-texture-page #x8
-                  :texture-user #x80
+                  :level-texture-page (tpage-category-u32 warp)
+                  :texture-user (texture-enable-mask-u32 warp)
                   )
              (new 'static 'texture-page-translate-item
-                  :bucket (bucket-id bucket-319)
+                  :bucket (bucket-id tex-all-map)
+                  :level-texture-page (tpage-category-u32 map)
+                  :texture-user (texture-enable-mask-u32 map)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-map)
+                  :level-index #x1
+                  :level-texture-page (tpage-category-u32 map)
+                  :texture-user (texture-enable-mask-u32 map)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-map)
+                  :level-index #x2
+                  :level-texture-page (tpage-category-u32 map)
+                  :texture-user (texture-enable-mask-u32 map)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-map)
+                  :level-index #x3
+                  :level-texture-page (tpage-category-u32 map)
+                  :texture-user (texture-enable-mask-u32 map)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-map)
+                  :level-index #x4
+                  :level-texture-page (tpage-category-u32 map)
+                  :texture-user (texture-enable-mask-u32 map)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-map)
+                  :level-index #x5
+                  :level-texture-page (tpage-category-u32 map)
+                  :texture-user (texture-enable-mask-u32 map)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-map)
                   :level-index #x6
-                  :level-texture-page #x3
-                  :texture-user #x80
+                  :level-texture-page (tpage-category-u32 map)
+                  :texture-user (texture-enable-mask-u32 map)
+                  )
+             (new 'static 'texture-page-translate-item
+                  :bucket (bucket-id tex-all-map)
+                  :level-index #x6
+                  :level-texture-page (tpage-category-u32 alpha)
+                  :texture-user (texture-enable-mask-u32 map)
                   )
              )
         )
@@ -731,3 +761,6 @@
 (define *grey-scale-base* (new 'static 'texture-base))
 (define *map-texture-base* (new 'static 'texture-base))
 
+(define-extern texture-page-default-allocate (function texture-pool texture-page kheap int texture-page))
+(define-extern texture-page-login  (function texture-id (function texture-pool texture-page kheap int texture-page) kheap texture-page-dir-entry))
+(define-extern lookup-texture-by-id (function texture-id texture))
diff --git a/goal_src/jak2/engine/gfx/texture/texture-upload.gc b/goal_src/jak2/engine/gfx/texture/texture-upload.gc
index e874085440..b2dd472518 100644
--- a/goal_src/jak2/engine/gfx/texture/texture-upload.gc
+++ b/goal_src/jak2/engine/gfx/texture/texture-upload.gc
@@ -5,5 +5,27 @@
 ;; name in dgo: texture-upload
 ;; dgos: ART, GAME
 
+;; this file is loaded immediately before boot textures are loaded.
+
 ;; DECOMP BEGINS
 
+(define *generic-envmap-texture* (lookup-texture-by-id (new 'static 'texture-id :index #x2 :page #x1f)))
+(define *default-envmap-shader* (new 'global 'adgif-shader))
+
+(let ((gp-0 *default-envmap-shader*))
+  (let ((a1-1 *generic-envmap-texture*))
+    (adgif-shader<-texture! gp-0 a1-1)
+    )
+  (set! (-> gp-0 tex1) (new 'static 'gs-tex1 :mmag #x1 :mmin #x1))
+  (set! (-> gp-0 clamp) (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp)))
+  (set! (-> gp-0 alpha) (new 'static 'gs-alpha :b #x2 :c #x1 :d #x1))
+  (set! (-> gp-0 prims 1) (gs-reg64 tex0-1))
+  (set! (-> gp-0 prims 3) (gs-reg64 tex1-1))
+  (set! (-> gp-0 prims 5) (gs-reg64 miptbp1-1))
+  (set! (-> gp-0 clamp-reg) (gs-reg64 clamp-1))
+  (set! (-> gp-0 prims 9) (gs-reg64 alpha-1))
+  )
+
+(set! (-> *texture-pool* allocate-func) texture-page-common-boot-allocate)
+
+(kmemopen global "tpages")
diff --git a/goal_src/jak2/engine/gfx/texture/texture.gc b/goal_src/jak2/engine/gfx/texture/texture.gc
index c680fbc60d..247c01f690 100644
--- a/goal_src/jak2/engine/gfx/texture/texture.gc
+++ b/goal_src/jak2/engine/gfx/texture/texture.gc
@@ -5,9 +5,2535 @@
 ;; name in dgo: texture
 ;; dgos: ENGINE, GAME
 
-;; DECOMP BEGINS
+;; Jak 2 texture system:
+;; At a high level, the responsibility of the texture system is to make sure that each renderer
+;; can use the textures it needs: the texture should be in VRAM at the right point in time, and
+;; the renderer must know where the texture is in VRAM.
+
+;; An oversimplified explanation is that each "bucket" in the rendering system needs a single
+;; "texture page" (tpage) loaded into VRAM. Each level has a tpage for each category, where the
+;; categories are:
+
+;; tfrag (background tie/tfrag)
+;; pris  (foreground)
+;; shrub (background shrub)
+;; alpha
+;; water
+;; warp
+;; pris2
+;; sprite
+;; map
+;; sky
+
+;; From the point of view of the rendering code, this oversimplification is basically true.
+;; Renderers use textures by sending "adgif shaders" to the GS. These tell the GS how to use
+;; the texture (mipmapping, size, format) and the location of the texture in VRAM (tbp).
+;; When levels load, they must "log in" their adgif shaders with the texture system, and the texture
+;; system will modify these in place so that things work.
+
+;; However, behind the scenes, there are many tricks.
+
+;; Texture data falls into two categories:
+;; - boot
+;; - common
+
+;; "boot"   textures are ones that are loaded on boot, transferred to VRAM, and live there forever.
+;; "common" textures are ones that are loaded as they are needed. There's an area in VRAM
+;;          called the "common segment" that holds these.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; basic texture page methods
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; each "texture page" is a group of textures that are (from the point of view of renderers)
+;; loaded all at once to vram, and contain all the textures needed for one category in one level.
+
+;; however, the texture system does some tricks:
+;; texture pages are divided into three "segments". The smaller number segments contain high
+;; resolution mipmaps of textures (needed for close up), and the high number segments contain lower ones.
+;; by looking at the distance to the closest object, we can figure out if the near textures
+;; are needed or not, and skip segments if needed.
+
+;; additionally, some texture pages have a chunk system that allows more specific control.
+
+(defmethod print texture-page ((obj texture-page))
+  "Print a texture page with name and size."
+  (format #t "#<texture-page ~S :length ~D :dest #x~X :size ~DK @ #x~X>"
+    (-> obj name)
+    (-> obj length)
+    (shr (-> obj segment 0 dest) 6)
+    (shr (+ (-> obj size) 255) 8)
+    obj
+    )
+  obj
+  )
+
+(defmethod length texture-page ((obj texture-page))
+  "Get the number of textures in a texture-page."
+  (-> obj length)
+  )
+
+(defmethod asize-of texture-page ((obj texture-page))
+  "Get the size, in bytes, of a texture-page.
+   Note that this does not include the texture objects, or the texture data."
+  (the-as int (+ (-> obj type size) (* (-> obj length) 4)))
+  )
+
+(defmethod mem-usage texture-page ((obj texture-page) (arg0 memory-usage-block) (arg1 int))
+  "Get the amount of memory used by a texture page, including texture and texture data."
+  (set! (-> arg0 length) (max 83 (-> arg0 length)))
+  (set! (-> arg0 data 82 name) "texture")
+  (+! (-> arg0 data 82 count) (-> obj length))
+  ;; note: in jak 1 this + was a - for reasons I do not understand.
+  (let ((v1-7 (+ (asize-of obj) (* (-> obj dram-size) 4))))
+    ;; also add the size of the texture objects.
+    (dotimes (a0-6 (-> obj length))
+      (if (-> obj data a0-6)
+          (+! v1-7 112)
+          )
+      )
+    (+! (-> arg0 data 82 used) v1-7)
+    (+! (-> arg0 data 82 total) (logand -16 (+ v1-7 15)))
+    )
+  obj
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; texture upload dma
+;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun texture-bpp ((tex-fmt gs-psm))
+  "Get the number of bits per pixel for a texture format."
+  (case tex-fmt
+    (((gs-psm mt8))
+     8
+     )
+    (((gs-psm mt4))
+     4
+     )
+    (((gs-psm ct16) (gs-psm ct16s) (gs-psm mz16) (gs-psm mz16s))
+     16
+     )
+    (else
+      32
+      )
+    )
+  )
+
+(defun texture-qwc ((width int) (height int) (tex-fmt gs-psm))
+  "Get the number of quadwords (16-bytes), rounded up, for a given texture size/format."
+  (let ((v1-0 (texture-bpp tex-fmt)))
+    (/ (+ (* (* width height) v1-0) 127) 128)
+    )
+  )
+
+(defun physical-address ((ptr pointer))
+  "Convert a pointer (possibly to the uncached mapping) to a 'physical address' that "
+  (logand #xfffffff ptr)
+  )
+
+(defun dma-buffer-add-ref-texture ((dma-buf dma-buffer) (tex-data-ptr pointer) (width int) (height int) (tex-fmt gs-psm))
+  "Add a texture upload to a dma buffer that refers to texture data.
+   This does not copy the texture data, but instead inserts a refernce.
+   This also assumes that the GS is currently set up for the right type of image upload."
+  (let ((padr (physical-address tex-data-ptr))
+        (qwc-remaining (texture-qwc width height tex-fmt))
+        )
+    ;; break up transfer into 0x7fff quadword chunks.
+    (while (> qwc-remaining 0)
+      (let ((qwc-transfer (min #x7fff qwc-remaining)))
+        (let ((eop (if (= qwc-remaining qwc-transfer)
+                       1
+                       0
+                       )
+                   )
+              )
+          (let* ((a2-2 dma-buf)
+                 (a3-1 (the-as object (-> a2-2 base)))
+                 )
+            (set! (-> (the-as dma-packet a3-1) dma) (new 'static 'dma-tag :qwc #x1 :id (dma-tag-id cnt)))
+            (set! (-> (the-as dma-packet a3-1) vif0) (new 'static 'vif-tag))
+            (set! (-> (the-as dma-packet a3-1) vif1) (new 'static 'vif-tag :imm #x1 :cmd (vif-cmd direct) :msk #x1))
+            (set! (-> a2-2 base) (&+ (the-as pointer a3-1) 16))
+            )
+          (let* ((a2-3 dma-buf)
+                 (a3-3 (the-as object (-> a2-3 base)))
+                 )
+            (set! (-> (the-as gs-gif-tag a3-3) tag)
+                  (new 'static 'gif-tag64 :flg (gif-flag image) :eop eop :nloop qwc-transfer)
+                  )
+            (set! (-> (the-as gs-gif-tag a3-3) regs) (new 'static 'gif-tag-regs))
+            (set! (-> a2-3 base) (&+ (the-as pointer a3-3) 16))
+            )
+          )
+        (let* ((a1-9 dma-buf)
+               (a2-4 (the-as object (-> a1-9 base)))
+               )
+          (set! (-> (the-as dma-packet a2-4) dma)
+                (new 'static 'dma-tag :id (dma-tag-id ref) :addr (the-as int padr) :qwc qwc-transfer)
+                )
+          (set! (-> (the-as dma-packet a2-4) vif0) (new 'static 'vif-tag))
+          (set! (-> (the-as dma-packet a2-4) vif1)
+                (new 'static 'vif-tag :cmd (vif-cmd direct) :msk #x1 :imm qwc-transfer)
+                )
+          (set! (-> a1-9 base) (&+ (the-as pointer a2-4) 16))
+          )
+        (&+! padr (* qwc-transfer 16))
+        (set! qwc-remaining (- qwc-remaining qwc-transfer))
+        )
+      )
+    )
+  (none)
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; basic texture methods
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; each texture is just some metadata about a texture, including its location in vram
+;; and format settings.
+
+(defmethod print texture ((obj texture))
+  (format #t "#<texture ~20S psm: ~6S  ~4D x ~4D  num-mips: ~D :size ~4DK "
+    (-> obj name)
+    (psm->string (-> obj psm)) ;; format
+    (-> obj w)
+    (-> obj h)
+    (-> obj num-mips)
+    (shr (-> obj size) 8)
+    )
+  ;; print the location and size of each mip level
+  (dotimes (s5-1 (the-as int (-> obj num-mips)))
+    (format #t " #x~X/~X" (-> obj dest s5-1) (-> obj width s5-1))
+    )
+  ;; print clut (color look up table) location in vram
+  (if (< (texture-bpp (-> obj psm)) 16)
+      (format #t " :clut #x~X/1" (-> obj clutdest))
+      )
+  (format #t " @ #x~X>" obj)
+  obj
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; texture memory layout
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; The GS uses a crazy memory layout. Read the manual for more details.
+;; these functions are wrong and unused, though the ct32-24-block-table is right
+;; and used in the eye code.
+
+(defun gs-find-block ((bx int) (by int) (fmt gs-psm))
+  (cond
+    ((= fmt (gs-psm ct32))
+     (-> ct32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm ct24))
+     (-> ct32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm ct16))
+     (-> ct16-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm ct16s))
+     (-> ct16s-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm mz32))
+     (-> mz32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm mz24))
+     (-> mz32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm mz16))
+     (-> mz16-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm mz16s))
+     (-> mz16s-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm mt8))
+     (-> mt8-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm mt4))
+     (-> mt4-block-table (+ bx (* by 4)))
+     )
+    (else
+      0
+      )
+    )
+  )
+
+(defun gs-page-width ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24) (gs-psm ct16) (gs-psm ct16s))
+     64
+     )
+    (((gs-psm mt8) (gs-psm mt4))
+     128
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+(defun gs-page-height ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24))
+     32
+     )
+    (((gs-psm ct16) (gs-psm ct16s))
+     64
+     )
+    (((gs-psm mt8))
+     64
+     )
+    (((gs-psm mt4))
+     128
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+(defun gs-block-width ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24))
+     8
+     )
+    (((gs-psm ct16) (gs-psm ct16s) (gs-psm mt8))
+     16
+     )
+    (((gs-psm mt4))
+     32
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+(defun gs-block-height ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24) (gs-psm ct16) (gs-psm ct16s))
+     8
+     )
+    (((gs-psm mt8) (gs-psm mt4))
+     16
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+(defun gs-largest-block ((arg0 int) (arg1 int) (arg2 gs-psm))
+  (let* ((s5-0 (gs-block-width arg2))
+         (v1-0 (gs-block-height arg2))
+         (a0-6 (* (/ (+ s5-0 -1 arg0) s5-0) s5-0))
+         (a1-4 (* (/ (+ v1-0 -1 arg1) v1-0) v1-0))
+         (s5-1 (/ a0-6 s5-0))
+         (s3-1 (/ a1-4 v1-0))
+         (s4-1 0)
+         )
+    (dotimes (s2-0 s5-1)
+      (dotimes (s1-0 s3-1)
+        (set! s4-1 (max s4-1 (gs-find-block s2-0 s1-0 arg2)))
+        )
+      )
+    s4-1
+    )
+  )
+
+(defun gs-blocks-used ((arg0 int) (arg1 int) (arg2 gs-psm))
+  (let* ((s4-0 (gs-page-width arg2))
+         (v1-0 (gs-page-height arg2))
+         (a0-6 (* (/ (+ s4-0 -1 arg0) s4-0) s4-0))
+         (a1-4 (* (/ (+ v1-0 -1 arg1) v1-0) v1-0))
+         (s3-0 (/ a0-6 s4-0))
+         (s1-0 (/ a1-4 v1-0))
+         (a0-9 (- arg0 (* (+ s3-0 -1) s4-0)))
+         (a1-7 (- arg1 (* (+ s1-0 -1) v1-0)))
+         )
+    (if (or (< a0-9 s4-0) (< a1-7 v1-0))
+        (+ (gs-largest-block a0-9 a1-7 arg2) 1 (* (+ (* s3-0 s1-0) -1) 32))
+        (* (* s1-0 s3-0) 32)
+        )
+    )
+  )
+
+;;;;;;;;;;;;;;;;;
+;; texture pool
+;;;;;;;;;;;;;;;;;
+
+;; the "texture-pool" is the global manager of textures.
+;; among other things, it tracks which page is uploaded in each vram "page"
+;;  (confusingly a texture-page is many vram "pages" big)
+;; The vram is divided into 128 vram pages, and the texture system will skip uploads
+;; if a vram page already has the desired texture.
+
+;; there are "default" textures, these only live in vram
+;; "common" textures are just normal level textures that get uploaded as needed
+;; "common-page" textures are common textures that the engine can easily request for
+;; special cases, like displaying a splash screen.
+
+(defmethod new texture-pool ((allocation symbol) (type-to-make type))
+  "Allocate and initialize a texture-pool."
+  (initialize! (object-new allocation type-to-make (the-as int (-> type-to-make size))))
+  )
+
+
+;; internally, the texture-pool has a bump allocator for vram. This assigns vram to various boot textures/segments
+;; at boot time and isn't used at run-time. VRAM is often resued for multiple textures in a single frame,
+;; and the common segment does more complicated management at runtime.
+
+(defmethod allocate-vram-words! texture-pool ((obj texture-pool) (num-words int))
+  "Allocate the given number of vram words."
+  (let ((v0-0 (-> obj cur)))
+    (+! (-> obj cur) num-words)
+    v0-0
+    )
+  )
+
+;; "common page"
+;;  The "common page" system is a weird way to have special hard-coded textures for the engine
+;;  for weird things like splash screens. These go in the common segment.
+
+;; In jak 2, there are only 2 common page textures.
+
+;; The "common" thing about these textures is that they are used by the engine directly, and
+;; not any specific level/art-group.
+;; So it's reasonable for them to hardcode tpage-ids here.
+
+(defmethod get-common-page-slot-by-id texture-pool ((obj texture-pool) (tpage-id int))
+  "Check to see if the given tpage should go in the common page list.
+   If so, return the slot. Otherwise, return -1."
+  (case tpage-id
+    ((33)
+     1
+     )
+    ((34)
+     2
+     )
+    (else
+      -1
+      )
+    )
+  )
+
+(defmethod initialize! texture-pool ((obj texture-pool))
+  "Initialize or reset the state of the texture-pool."
+  ;; reset allocator
+  (set! (-> obj cur) 0)
+  (set! (-> obj top) (-> obj cur))
+  ;; set the allocation function to default-allocate.
+  (set! (-> obj allocate-func) texture-page-default-allocate)
+  ;; allocate some textures for effects, etc
+  (allocate-defaults obj)
+  ;; allocate the font palette.
+  (format #t "font-palette start #x~x~%" (/ (-> obj cur) 64))
+  (set! (-> obj font-palette) (allocate-vram-words! obj 64))
+  (format #t "font-palette end #x~x~%" (/ (-> obj cur) 64))
+
+  ;; reset common-page texture-pages
+  (dotimes (v1-8 32)
+    (set! (-> obj common-page v1-8) (the-as texture-page 0))
+    )
+
+  ;; request no common-pages
+  (set! (-> obj common-page-mask) 0)
+
+  ;; enable uploads for all textures
+  (set! (-> obj texture-enable-user-menu)
+        (texture-enable-mask tfrag pris shrub alpha water warp sprite map sky)
+        )
+  (set! (-> obj texture-enable-user) (texture-enable-mask tfrag pris shrub alpha water warp sprite map sky))
+  ;; mark all vram slots as unoccupied.
+  (dotimes (v1-13 128)
+    (set! (-> obj ids v1-13) (the-as uint 0))
+    )
+  obj
+  )
+
+(defmethod get-leftover-block-count texture-page ((obj texture-page) (num-segments int) (upload-offset int))
+  "Unused and somewhat useless function to figure out how many blocks we overflow into the next page.
+   This could be used with gs-largest-block to figure out how much of a page we use if we don't fit
+   exactly."
+  (let ((offset upload-offset))
+    (dotimes (i num-segments)
+      (+! offset (-> obj segment i size))
+      )
+    (logand (/ offset 64) 63)
+    )
+  )
+
+(defmethod print-usage texture-pool ((obj texture-pool))
+  "Print out how much of a texture-pool is used.
+   This is not quite right because it does not count the frame or z buffer as used space."
+  (format #t "--------------------~%")
+  (format #t "texture pool ~DK - ~DK (~DK used, ~DK free)~%"
+    (/ (-> obj top) 256)
+    (/ (-> obj cur) 256)
+    (/ (- (-> obj cur) (-> obj top)) 256)
+    (/ (- #xfa000 (-> obj cur)) 256)
+    )
+  (format #t "--------------------~%")
+  obj
+  )
+
+(defmethod allocate-segment texture-pool ((obj texture-pool) (seg texture-pool-segment) (num-words int))
+  "Assign vram to the given segment."
+  (set! (-> seg size) (the-as uint num-words))
+  (set! (-> seg dest) (the-as uint (allocate-vram-words! obj num-words)))
+  seg
+  )
+
+(defmethod allocate-defaults texture-pool ((obj texture-pool))
+  "Assign vram for the texture system."
+
+  ;; this "common" segment is about 1 MB and will hold basically all textures.
+  ;; unlike jak 1, there's no near textures. instead, there's just a lot more uploads.
+  ;; this seems like it would put a huge pressure on vram usage because these uploads
+  ;; aren't free.
+  (format #t "texture start #x~x~%" (/ (-> obj cur) 64))
+  (allocate-segment obj (-> obj segment-common) #x3e000)
+  (format #t "texture end #x~x~%" (/ (-> obj cur) 64))
+
+  ;; these "dynamic" textures are written to by renderers, and they have a fixed address.
+  ;; notice that some of them overlap each other.
+  (set! (-> *ocean-envmap-texture-base* vram-word) (the-as uint (allocate-vram-words! obj #x9400)))
+  (set! (-> *ocean-envmap-texture-base* vram-block) (shr (-> *ocean-envmap-texture-base* vram-word) 6))
+  (set! (-> *ocean-envmap-texture-base* vram-page) (shr (-> *ocean-envmap-texture-base* vram-word) 11))
+  (set! (-> *ocean-texture-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *ocean-texture-base* vram-block) (shr (-> *ocean-texture-base* vram-word) 6))
+  (set! (-> *ocean-texture-base* vram-page) (shr (-> *ocean-texture-base* vram-word) 11))
+  (set! (-> *grey-scale-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *grey-scale-base* vram-block) (shr (-> *grey-scale-base* vram-word) 6))
+  (set! (-> *grey-scale-base* vram-page) (shr (-> *grey-scale-base* vram-word) 11))
+  (set! (-> *eyes-texture-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *eyes-texture-base* vram-block) (shr (-> *eyes-texture-base* vram-word) 6))
+  (set! (-> *eyes-texture-base* vram-page) (shr (-> *eyes-texture-base* vram-word) 11))
+  (set! (-> *map-texture-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *map-texture-base* vram-block) (shr (-> *map-texture-base* vram-word) 6))
+  (set! (-> *map-texture-base* vram-page) (shr (-> *map-texture-base* vram-word) 11))
+  (set! (-> *skull-gem-texture-base* vram-word) (+ #x9000 (-> *ocean-envmap-texture-base* vram-word)))
+  (set! (-> *skull-gem-texture-base* vram-block) (shr (-> *skull-gem-texture-base* vram-word) 6))
+  (set! (-> *skull-gem-texture-base* vram-page) (shr (-> *skull-gem-texture-base* vram-word) 11))
+  (format #t "dynamic end #x~x~%" (/ (-> obj cur) 64))
+  0
+  (none)
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; texture page allocation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; these functions assign texture-pages to vram.
+;; unlike the functions above, these
+;; - happen at runtime, as levels are loaded/unloaded.
+;; - may assign multiple textures to the same vram address
+;; it's ok for two textures to be mapped to the same vram address as
+;; long as they are in different pages.
+
+(defmethod remove-data-from-heap texture-page ((obj texture-page) (heap kheap))
+  "Remove a texture-page's data from main memory.
+   This is intended to be run on textures that are permanently in VRAM.
+   This only works if the texture-page was the last thing added to the heap,
+   and does NO checking to make sure this is the case.
+   The texture-page and texture records are kept (just metadata), the actual image data is discarded."
+  (set! (-> heap current) (-> obj segment 0 block-data))
+  obj
+  )
+
+(defun texture-page-default-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  "Allocate a texture to be permanently stored in VRAM, and remove it from main memory.
+  This is only safe to call if the most recently loaded thing is this texture.
+  This will perform texture uploads, so this should not be called during drawing."
+
+  ;; for each segment, permanently allocate VRAM
+  (dotimes (seg 3)
+    (let ((vram-loc (allocate-vram-words! pool (the-as int (-> tpage segment seg size)))))
+      ;; and adjust the texture so it points to the allocated vram
+      (relocate-dests! tpage vram-loc seg)
+      )
+    )
+
+  ;; load to VRAM
+  (upload-now! tpage (tex-upload-mode seg0-1-2))
+
+  ;; and remove image data from main memory.
+  (remove-data-from-heap tpage heap)
+
+  ;; for accurate accounting of memory
+  (set! (-> tpage dram-size) (the-as uint 0))
+
+  ;; clear masks for each texture
+  (dotimes (tex-idx (-> tpage length))
+    (let ((tex (-> tpage data tex-idx)))
+      (when tex
+        (dotimes (mask-idx 3)
+          (dotimes (mask-word 3)
+            (set! (-> tex masks data mask-idx mask data mask-word) 0)
+            ;(set! (-> (the-as texture (+ (+ (* mask-idx 16) (* mask-word 4)) (the-as int tex))) masks data 0 mask x) 0)
+            )
+          )
+        )
+      )
+    )
+  tpage
+  )
+
+(defun texture-page-common-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  "Set up a texture that will be uploaded to VRAM as needed by the texture system.
+   These will go in the 'common' segment.
+   No upload is actually done."
+
+  (let ((vram-loc (-> pool segment-common dest)))
+    (dotimes (seg 3)
+      ;; set up the VRAM address of the segment
+      (relocate-dests! tpage (the-as int vram-loc) seg)
+      ;; don't put the segments on top of each other, they need to be spaced out
+      ;; so they can be all loaded at once.
+      (+! vram-loc (-> tpage segment seg size))
+      )
+    )
+
+  ;; this texture stays in main memory
+  ;; and is uploaded again and again as needed
+  ;; so the dram-size is the full size.
+  (set! (-> tpage dram-size) (-> tpage size))
+  tpage
+  )
+
+(defun texture-page-font-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  "Special allocation for the font textures.
+   These are temporarily loaded to the common segment, then later moved."
+
+  ;; set up their dest to go in common
+  (texture-page-common-allocate pool tpage heap tpage-id)
+
+  ;; upload them to common segment now
+  (upload-now! tpage (tex-upload-mode seg0-1-2))
+
+  ;; kick out of main memory now that they are in VRAM
+  (remove-data-from-heap tpage heap)
+  (set! (-> tpage dram-size) (the-as uint 0))
+
+  ;; clear masks. is this actually needed for font?
+  (dotimes (tex-idx (-> tpage length))
+    (let ((tex (-> tpage data tex-idx)))
+      (when tex
+        (dotimes (mask-idx 3)
+          (dotimes (mask-word 3)
+            (set! (-> tex masks data mask-idx mask data mask-word) 0)
+            ;(set! (-> (the-as texture (+ (+ (* mask-idx 16) (* mask-word 4)) (the-as int tex))) masks data 0 mask x) 0)
+            )
+          )
+        )
+      )
+    )
+  tpage
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;
+;; level combo set up
+;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; several renderers don't have separate buckets per level:
+;; warp, hud, and sprite
+
+;; so for these renderers, we need to make "combo" layouts where VRAM
+;; is filled with pages from all levels.
+
+;; For sprite and hud, it's the responsibility of the renderer to update adgifs to
+;; point to new locations and levels are added/removed.
+
+;; For warp, it's the responsibility of the texture system to update adgifs.
+
+(defmethod lay-out-sprite-tex texture-pool ((obj texture-pool))
+  "Lay out sprite textures from all levels so all can fit into
+   VRAM at the same time."
+
+  ;; this assumes that the common-segment starts at 0.
+  (let ((vram-loc 0))
+    ;; loop over all active levels
+    (countdown (level-idx 7)
+      (let ((lev (-> *level* level level-idx)))
+        (when (or (= (-> lev status) 'active)
+                  (= (-> lev status) 'alive)
+                  (= (-> lev status) 'loaded)
+                  (= (-> lev status) 'reserved)
+                  )
+          ;; get the sprite tpage
+          (let ((tpage (-> lev texture-page 7)))
+            (when tpage
+              ;; add each segment
+              (dotimes (seg 3)
+                (relocate-dests! tpage vram-loc seg)
+                (+! vram-loc (-> tpage segment seg size))
+                )
+              ;; don't forget to align textures.
+              ;; they do some tricks with segments to let them pack tightly,
+              ;; but these can't be done here where the neighbor levels are unknown.
+              (set! vram-loc (shl (sar (+ vram-loc 4095) 12) 12))
+              )
+            )
+          )
+        )
+
+      ;; check for out of memory.
+      (if (< #x3e000 vram-loc)
+          (format 0 "ERROR: Ran out of texture memory for SPRITE ~dk of 992k" (/ vram-loc 64))
+          )
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod lay-out-hud-tex texture-pool ((obj texture-pool))
+  "Lay out hud/map textures from all levels so all can fit into
+   VRAM at the same time."
+  (let ((level-idx 0))
+    (countdown (vram-loc 7)
+      (let ((lev (-> *level* level vram-loc)))
+        (when (or (= (-> lev status) 'active)
+                  (= (-> lev status) 'alive)
+                  (= (-> lev status) 'loaded)
+                  (= (-> lev status) 'reserved)
+                  )
+          (let ((tpage (-> lev texture-page 8)))
+            (when tpage
+              (dotimes (seg 3)
+                (relocate-dests! tpage level-idx seg)
+                (+! level-idx (-> tpage segment seg size))
+                )
+              (set! level-idx (shl (sar (+ level-idx 4095) 12) 12))
+              )
+            )
+          )
+        )
+      )
+    (if (< #x3e000 level-idx)
+        (format 0 "ERROR: Ran out of texture memory for HUD ~dk of 992k" (/ level-idx 64))
+        )
+    )
+  0
+  (none)
+  )
+
+;; for warp, we do the same as above, but we also update all references to textures
+;; to point to the new ones.
+
+;; When levels load, they log in their adgifs (references to textures), which does two things:
+;; - at login time, the adgif is adjusted to point to the texture.
+;; - if the texture moves, the texture system can iterate through all adgifs referencing the texture
+;;   and update them. The texture system stores a linked list of adgifs per texture in the texture-page-dir.
+
+(defmethod lay-out-warp-tex texture-pool ((obj texture-pool))
+  "Lay out warp textures from all levels so all can fit into
+   VRAM at the same time.
+   Also update all adgifs."
+
+  ;; again, assume that common-segment starts at 0
+  (let ((vram-loc 0))
+    ;; iterate over active levels
+    (countdown (level-idx 7)
+      (let ((lev (-> *level* level level-idx)))
+        (when (or (= (-> lev status) 'active)
+                  (= (-> lev status) 'alive)
+                  (= (-> lev status) 'loaded)
+                  (= (-> lev status) 'reserved)
+                  )
+          ;; get the warp tpage for this level
+          (let ((tpage (-> lev texture-page 5)))
+            (when tpage
+              ;; the "base" address is the vram address of the start of this tpage
+              ;; we're moving it from old to new. Initially, dest is 0, so this works
+              ;; even on the first time
+              (let ((old-dest-base (-> tpage segment 0 dest))
+                    (new-dest-base vram-loc)
+                    )
+                ;; loop over segments in tpage, assign them to unique vram
+                (dotimes (s1-0 3)
+                  (relocate-dests! tpage vram-loc s1-0)
+                  (+! vram-loc (-> tpage segment s1-0 size))
+                  )
+                ;; align after tpage (see note above)
+                (set! vram-loc (shl (sar (+ vram-loc 4095) 12) 12))
+
+                ;; figure out how much tbp should be adjusted by. instead of figuring out tbp from scratch,
+                ;; we can just adjust the current value (on the first run, this will assume each tpage is loaded at 0
+                ;; because this is how they are logged in by the level system)
+                (let ((tbp-adjust (shr (- new-dest-base (the-as int old-dest-base)) 6)))
+                  ;; only if we actually move
+                  (when (nonzero? tbp-adjust)
+                    ;; for each texture
+                    (dotimes (texture-idx (-> tpage length))
+                      ;; grab the first adgif-shader by looking in *texture-page-dir* for this tpage and texture-idx.
+                      ;; the pointers don't store the lower 4 bits and assume 16-byte alignment for adgif-shader objects.
+                      (let ((adgif-iter
+                              (the-as
+                                adgif-shader
+                                (* (-> (the-as shader-ptr (-> *texture-page-dir* entries (-> tpage id) link next texture-idx)) shader) 16)
+                                )
+                              )
+                            )
+                        ;; iterate through list, bumping tbp and cbp (clut vram addr)
+                        (while (nonzero? (the-as uint adgif-iter))
+                          (+! (-> adgif-iter tex0 tbp0) tbp-adjust)
+                          (+! (-> adgif-iter tex0 cbp) tbp-adjust)
+                          (set! adgif-iter (the-as adgif-shader (* (-> adgif-iter next shader) 16)))
+                          )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    (if (< #xa000 vram-loc)
+        (format 0 "ERROR: Ran out of texture memory for WARP ~dk of 160k" (/ vram-loc 64))
+        )
+    )
+  0
+  (none)
+  )
+
+(defmethod clear-ids texture-pool ((obj texture-pool))
+  "Forget everything we have in VRAM and invalidate all caching
+   of common-segment textures."
+
+  ;; this ids array tracks what the current texture-page loaded in each vram "chunk".
+  (dotimes (v1-0 128)
+    (set! (-> obj ids v1-0) (the-as uint 0))
+    )
+  0
+  (none)
+  )
+
+(defmethod update-sprites texture-pool ((obj texture-pool))
+  "Redo the layout of sprite textures. This should be done when
+   a new level is added that needs new sprite textures, or a level
+   is unloaded and its sprite textures are no longer available."
+
+  ;; assign texture to vram addresses
+  (lay-out-sprite-tex obj)
+
+  ;; forget all previous ids, don't want to reuse the old sprite textures
+  ;; as it may have the wrong layout.
+  (clear-ids obj)
+
+  ;; flag that we no longer need to update this.
+  (set! (-> obj update-sprites-flag) #f)
+  (none)
+  )
+
+(defmethod update-warp-and-hud texture-pool ((obj texture-pool))
+  "Redo the layout of warp/hud/map textures. This should be done when
+   a new level is added that needs new sprite textures, or a level
+   is unloaded and its sprite textures are no longer available."
+  (lay-out-hud-tex obj)
+  (lay-out-warp-tex obj)
+  (clear-ids obj)
+  (set! (-> obj update-flag) #f)
+  (none)
+  )
+
+(defmethod mark-hud-warp-sprite-dirty texture-pool ((obj texture-pool))
+  "Mark that we should update sprite/warp/hud/map before the next use.
+   This should happen when any level is loaded/unloaded."
+  (set! (-> obj update-sprites-flag) #t)
+  (set! (-> obj update-flag) #t)
+  (none)
+  )
+
+
+(defun texture-page-common-boot-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  "Set up texture that is loaded at boot."
+
+  ;; first, see if it's a common-page texture.
+  (let ((common-page-slot-id (get-common-page-slot-by-id pool tpage-id)))
+    (cond
+      ((>= common-page-slot-id 0)
+       ;; if so, put it in the common-page.
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> pool common-page common-page-slot-id) tpage)
+       )
+      ;; these next cases check for "default-level" textures.
+      ;; these are common-segment textures that are loaded at boot, and
+      ;; stay with the "default-level" always.
+      ((= tpage-id 917)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 0) tpage)
+       )
+      ((= tpage-id 918)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 1) tpage)
+       )
+      ((= tpage-id 1106)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 4) tpage)
+       )
+      ((= tpage-id 1141)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 9) tpage)
+       )
+      ((= tpage-id 12)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 7) tpage)
+       )
+      ((= tpage-id 1658)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 8) tpage)
+       )
+      ((= tpage-id 2841)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 5) tpage)
+       )
+      ((= tpage-id 2932)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 2) tpage)
+       )
+      ((= tpage-id 3219)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 3) tpage)
+       )
+      ((= tpage-id 3076)
+       (texture-page-font-allocate pool tpage heap tpage-id)
+       )
+      (else
+        ;; this texture goes in VRAM permanently.
+        (set! (-> *texture-pool* allocate-func) texture-page-default-allocate)
+        (texture-page-default-allocate pool tpage heap tpage-id)
+        )
+      )
+    )
+  (set! (-> tpage dram-size) (-> tpage size))
+  tpage
+  )
+
+
+;;;;;;;;;;;;;;;;;;
+;; tpage upload
+;;;;;;;;;;;;;;;;;;
+
+;; these functions load tpages using the dma-buffer-add-ref-texture
+;; and set up the GS for uploads.
+;; the texture-pages are designed in a very special way that allows large uploads
+;; to be chained together, so there is a bunch of logic to group together consecutive
+;; uploads.
+
+(defun upload-vram-data ((buf dma-buffer) (dest int) (data pointer) (height int) (width int))
+  "Generate DMA data to upload texture. This simply sets up a texture upload to happen in the future.
+   The texture data itself is referenced, not copied into the dma-buffer."
+  (while (> height 0)
+    (let ((height-this-time (min 2048 height)))
+      (let* ((v1-1 buf)
+             (a0-1 (the-as dma-packet (-> v1-1 base)))
+             )
+        (set! (-> a0-1 dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+        (set! (-> a0-1 vif0) (new 'static 'vif-tag))
+        (set! (-> a0-1 vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> v1-1 base) (the-as pointer (&+ a0-1 16)))
+        )
+      (let* ((v1-2 buf)
+             (a0-3 (the-as gs-gif-tag (-> v1-2 base)))
+             )
+        (set! (-> a0-3 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+        (set! (-> a0-3 regs) GIF_REGS_ALL_AD)
+        (set! (-> v1-2 base) (the-as pointer (&+ a0-3 16)))
+        )
+      (let* ((v1-3 buf)
+             (a0-5 (-> v1-3 base))
+             )
+        (set! (-> (the-as (pointer gs-bitbltbuf) a0-5) 0) (new 'static 'gs-bitbltbuf :dbw (/ width 64) :dbp dest))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 1) (gs-reg64 bitbltbuf))
+        (set! (-> (the-as (pointer gs-trxpos) a0-5) 2) (new 'static 'gs-trxpos))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 3) (gs-reg64 trxpos))
+        (set! (-> (the-as (pointer gs-trxreg) a0-5) 4) (new 'static 'gs-trxreg :rrw width :rrh height-this-time))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 5) (gs-reg64 trxreg))
+        (set! (-> (the-as (pointer gs-trxdir) a0-5) 6) (new 'static 'gs-trxdir))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 7) (gs-reg64 trxdir))
+        (set! (-> v1-3 base) (&+ a0-5 64))
+        )
+      (dma-buffer-add-ref-texture buf data width height-this-time (gs-psm ct32))
+      )
+    (+! dest 4096)
+    (&+! data #x100000)
+    (+! height -2048)
+    )
+  (none)
+  )
+
+(defun upload-vram-pages ((pool texture-pool)
+                          (dest-seg texture-pool-segment)
+                          (tpage texture-page)
+                          (mode tex-upload-mode)
+                          (bucket bucket-id)
+                          )
+  "Build DMA for uploading the given texture-page, only uploading as needed."
+  (local-vars
+    (data-ptr pointer)
+    (vram-ptr uint)
+    (tpage-num-chunks int)
+    (chunks-pending int)
+    (first-chunk int)
+    (tpage-id uint)
+    )
+  (if (not tpage)
+      (return 0)
+      )
+  ;; count total uploaded, for statistics
+  (let ((num-chunks 0))
+    (let* ((dma-buf (-> *display* frames (-> *display* on-screen) global-buf))
+           (s4-0 (-> dma-buf base))
+           )
+
+      ;; the data in main memory to upload
+      (set! data-ptr (-> tpage segment 0 block-data))
+
+      ;; where to send the data in VRAM
+      (set! vram-ptr (shr (-> tpage segment 0 dest) 12))
+
+      ;; the total number of chunks we want to upload (assume just seg 0)
+      (set! tpage-num-chunks (the-as int (-> tpage segment 0 size)))
+
+      ;; the number of chunks in a row to upload
+      (set! chunks-pending 0)
+
+      ;; the index of the first chunk to upload in the combo above
+      (set! first-chunk 0)
+
+      (set! tpage-id (-> tpage id))
+
+      ;; adjust based on the mode requested
+      (case mode
+            (((tex-upload-mode none))
+             ;; why even bother...
+             (return 0)
+             )
+            (((tex-upload-mode seg0))
+             )
+            (((tex-upload-mode seg0-1))
+             ;; add seg 1
+             (set! tpage-num-chunks (the-as int (+ tpage-num-chunks (-> tpage segment 1 size))))
+             )
+            (((tex-upload-mode seg0-1-2))
+             ;; all segs
+             (set! tpage-num-chunks (the-as int (-> tpage size)))
+             )
+            (((tex-upload-mode seg2))
+             ;; just seg2
+             (set! data-ptr (-> tpage segment 2 block-data))
+             (set! vram-ptr (shr (-> tpage segment 2 dest) 12))
+             (set! tpage-num-chunks (the-as int (-> tpage segment 2 size)))
+             )
+            )
+      ;; align, and truncate if we would go past the segment max
+      (set! tpage-num-chunks (shr (min (the-as int (-> dest-seg size)) (the-as int (+ tpage-num-chunks 4095))) 12))
+
+      ;; this loop builds runs of consecutive chunks.
+      (dotimes (s1-0 tpage-num-chunks)
+        ;; where to put this chunk in vram
+        (let ((v1-28 (+ vram-ptr s1-0)))
+          (cond
+            ((zero? chunks-pending) ;; nothing in the run:
+
+             ;; doesn't match what's in vram. need to upload, so start a run.
+             (when (!= (-> pool ids v1-28) tpage-id)
+               (set! first-chunk s1-0)
+               (set! (-> pool ids v1-28) tpage-id)
+               (set! chunks-pending (+ chunks-pending 1))
+               )
+             )
+            ;; otherwise, we have chunks pending.
+            ;; and, in this case, we don't need to upload. so this breaks the combo
+            ;; and we should upload whatever is pending.
+            ((= (-> pool ids v1-28) tpage-id)
+             (upload-vram-data
+               dma-buf
+               (the-as int (* (+ vram-ptr first-chunk) 64))
+               (&+ data-ptr (shl first-chunk 14))
+               (* chunks-pending 32)
+               128
+               )
+             (+! num-chunks chunks-pending) ;; track total for stats
+             (set! chunks-pending 0)
+             0
+             )
+            (else
+              ;; continue the run.
+              (set! (-> pool ids v1-28) tpage-id)
+              (set! chunks-pending (+ chunks-pending 1))
+              )
+            )
+          )
+        )
+
+      ;; done looping, upload any remaining run.
+      (when (nonzero? chunks-pending)
+        (upload-vram-data
+          dma-buf
+          (the-as int (* (+ vram-ptr first-chunk) 64))
+          (&+ data-ptr (shl first-chunk 14))
+          (* chunks-pending 32)
+          128
+          )
+        (+! num-chunks chunks-pending)
+        )
+
+      ;; add a texflush.
+      (let* ((v1-51 dma-buf)
+             (a0-24 (the-as dma-packet (-> v1-51 base)))
+             )
+        (set! (-> a0-24 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+        (set! (-> a0-24 vif0) (new 'static 'vif-tag))
+        (set! (-> a0-24 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> v1-51 base) (the-as pointer (&+ a0-24 16)))
+        )
+      (let* ((v1-52 dma-buf)
+             (a0-26 (the-as gs-gif-tag (-> v1-52 base)))
+             )
+        (set! (-> a0-26 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+        (set! (-> a0-26 regs) GIF_REGS_ALL_AD)
+        (set! (-> v1-52 base) (the-as pointer (&+ a0-26 16)))
+        )
+      (let* ((v1-53 dma-buf)
+             (a0-28 (-> v1-53 base))
+             )
+        (set! (-> (the-as (pointer int64) a0-28) 0) 1)
+        (set! (-> (the-as (pointer gs-reg64) a0-28) 1) (gs-reg64 texflush))
+        (set! (-> v1-53 base) (&+ a0-28 16))
+        )
+      (let ((a3-3 (-> dma-buf base)))
+        (let ((v1-54 (the-as dma-packet (-> dma-buf base))))
+          (set! (-> v1-54 dma) (new 'static 'dma-tag :id (dma-tag-id next)))
+          (set! (-> v1-54 vif0) (new 'static 'vif-tag))
+          (set! (-> v1-54 vif1) (new 'static 'vif-tag))
+          (set! (-> dma-buf base) (the-as pointer (&+ v1-54 16)))
+          )
+        (dma-bucket-insert-tag
+          (-> *display* frames (-> *display* on-screen) bucket-group)
+          bucket
+          s4-0
+          (the-as (pointer dma-tag) a3-3)
+          )
+        )
+      )
+    (shl num-chunks 14)
+    )
+  )
+
+(defun update-vram-pages ((pool texture-pool) (dest-seg texture-pool-segment) (tpage texture-page) (mode tex-upload-mode))
+  "Copy-pasta version of the above function that just sets ids, but does no uploads."
+  (-> tpage segment 0 block-data)
+  (let ((vram-ptr (shr (-> tpage segment 0 dest) 12))
+        (tpage-num-chunks (-> tpage segment 0 size))
+        (chunks-pending 0)
+        )
+    0
+    (let ((tpage-id (-> tpage id)))
+      (cond
+        ((= mode (tex-upload-mode none))
+         (return 0)
+         )
+        ((= mode (tex-upload-mode seg0))
+         )
+        ((= mode (tex-upload-mode seg0-1))
+         (+! tpage-num-chunks (-> tpage segment 1 size))
+         )
+        ((= mode (tex-upload-mode seg0-1-2))
+         (set! tpage-num-chunks (-> tpage size))
+         )
+        ((= mode (tex-upload-mode seg2))
+         (-> tpage segment 2 block-data)
+         (set! vram-ptr (shr (-> tpage segment 2 dest) 12))
+         (set! tpage-num-chunks (-> tpage segment 2 size))
+         )
+        )
+      (let ((adjusted-num-chunks (shr (min (the-as int (-> dest-seg size)) (the-as int (+ tpage-num-chunks 4095))) 12)))
+        (dotimes (chunk-idx adjusted-num-chunks)
+          (let ((chunk-ptr (+ vram-ptr chunk-idx)))
+            (cond
+              ((zero? chunks-pending)
+               (when (!= (-> pool ids chunk-ptr) tpage-id)
+                 (set! (-> pool ids chunk-ptr) tpage-id)
+                 (+! chunks-pending 1)
+                 )
+               )
+              ((= (-> pool ids chunk-ptr) tpage-id)
+               (set! chunks-pending 0)
+               )
+              (else
+                (set! (-> pool ids chunk-ptr) tpage-id)
+                (+! chunks-pending 1)
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  0
+  )
+
+(defun upload-vram-pages-pris ((pool texture-pool)
+                               (dest-seg texture-pool-segment)
+                               (tpage texture-page)
+                               (bucket bucket-id)
+                               (mask (pointer int32))
+                               )
+  "Build DMA for uploading the given texture-page, only uploading as needed.
+   Unlike the normal upload-vram-pages, this just takes an array of mask bits,
+   and only uploads seg 0 (there is no upload mode).
+   See upload-vram-pages for some more details."
+  (local-vars
+    (data-ptr pointer)
+    (vram-ptr uint)
+    (tpage-num-chunks int)
+    (chunks-pending int)
+    (first-chunk int)
+    (tpage-id uint)
+    (should-upload symbol)
+    )
+  (if (not tpage)
+      (return 0)
+      )
+  (let ((total-chunks-uploaded 0))
+    (let* ((dma-buf (-> *display* frames (-> *display* on-screen) global-buf))
+           (s4-0 (-> dma-buf base))
+           )
+      (set! data-ptr (-> tpage segment 0 block-data))
+      (set! vram-ptr (shr (-> tpage segment 0 dest) 12))
+      (set! tpage-num-chunks (the-as int (-> tpage size)))
+      (set! chunks-pending 0)
+      (set! first-chunk 0)
+      (set! tpage-id (-> tpage id))
+
+      ;; align and truncate
+      (set! tpage-num-chunks (shr (min (the-as int (-> dest-seg size)) (the-as int (+ tpage-num-chunks 4095))) 12))
+
+      ;; loop over chunks, building runs of consecutive uploads.
+      (dotimes (chunk-idx tpage-num-chunks)
+        (let ((chunk-dest (+ vram-ptr chunk-idx)))
+          (let ((mask-work (-> mask (/ chunk-idx 32))))
+            (set! should-upload (logtest? mask-work (ash 1 (logand chunk-idx 31))))
+            )
+          (cond
+            ((zero? chunks-pending)
+             (when (and (!= (-> pool ids chunk-dest) tpage-id) should-upload)
+               (set! first-chunk chunk-idx)
+               (set! (-> pool ids chunk-dest) tpage-id)
+               (set! chunks-pending (+ chunks-pending 1))
+               )
+             )
+            ((or (= (-> pool ids chunk-dest) tpage-id) (not should-upload))
+             (upload-vram-data
+               dma-buf
+               (the-as int (* (+ vram-ptr first-chunk) 64))
+               (&+ data-ptr (shl first-chunk 14))
+               (* chunks-pending 32)
+               128
+               )
+             (+! total-chunks-uploaded chunks-pending)
+             (set! chunks-pending 0)
+             0
+             )
+            (else
+              (set! (-> pool ids chunk-dest) tpage-id)
+              (set! chunks-pending (+ chunks-pending 1))
+              )
+            )
+          )
+        )
+      (when (nonzero? chunks-pending)
+        (upload-vram-data
+          dma-buf
+          (the-as int (* (+ vram-ptr first-chunk) 64))
+          (&+ data-ptr (shl first-chunk 14))
+          (* chunks-pending 32)
+          128
+          )
+        (+! total-chunks-uploaded chunks-pending)
+        )
+      (let* ((v1-40 dma-buf)
+             (a0-27 (the-as dma-packet (-> v1-40 base)))
+             )
+        (set! (-> a0-27 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+        (set! (-> a0-27 vif0) (new 'static 'vif-tag))
+        (set! (-> a0-27 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> v1-40 base) (the-as pointer (&+ a0-27 16)))
+        )
+      (let* ((v1-41 dma-buf)
+             (a0-29 (the-as gs-gif-tag (-> v1-41 base)))
+             )
+        (set! (-> a0-29 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+        (set! (-> a0-29 regs) GIF_REGS_ALL_AD)
+        (set! (-> v1-41 base) (the-as pointer (&+ a0-29 16)))
+        )
+      (let* ((v1-42 dma-buf)
+             (a0-31 (-> v1-42 base))
+             )
+        (set! (-> (the-as (pointer int64) a0-31) 0) 1)
+        (set! (-> (the-as (pointer gs-reg64) a0-31) 1) (gs-reg64 texflush))
+        (set! (-> v1-42 base) (&+ a0-31 16))
+        )
+      (let ((a3-5 (-> dma-buf base)))
+        (let ((v1-43 (the-as dma-packet (-> dma-buf base))))
+          (set! (-> v1-43 dma) (new 'static 'dma-tag :id (dma-tag-id next)))
+          (set! (-> v1-43 vif0) (new 'static 'vif-tag))
+          (set! (-> v1-43 vif1) (new 'static 'vif-tag))
+          (set! (-> dma-buf base) (the-as pointer (&+ v1-43 16)))
+          )
+        (dma-bucket-insert-tag
+          (-> *display* frames (-> *display* on-screen) bucket-group)
+          bucket
+          s4-0
+          (the-as (pointer dma-tag) a3-5)
+          )
+        )
+      )
+    (shl total-chunks-uploaded 14)
+    )
+  )
+
+;;;;;;;;;;;;;;;;;
+;; level texture
+;;;;;;;;;;;;;;;;;
+
+(defun texture-page-level-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  "Allocate function for level textures."
+
+  ;; a bit of a hack: we assume that textures come immediately after the last code of a level,
+  ;; so if we see that code-memory-end isn't set, set it here.
+  (if (zero? (-> *level* loading-level code-memory-end))
+      (set! (-> *level* loading-level code-memory-end) (the-as pointer tpage))
+      )
+
+  ;; see if we got a common-page texture
+  (let ((common-page-slot-id (get-common-page-slot-by-id pool tpage-id)))
+    (cond
+      ((>= common-page-slot-id 0)
+       ;; we did! allocate as normal
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       ;; and add to common-page
+       (set! (-> pool common-page common-page-slot-id) tpage)
+       )
+      (else
+        ;; otherwise just add like normal
+        ;; note: unlike jak 1, there's no "near page" that levels use.
+        ;; it's all in the common segment.
+        (texture-page-common-allocate pool tpage heap tpage-id)
+        )
+      )
+    )
+  tpage
+  )
+
+(defun texture-page-size-check ((pool texture-pool) (lev level) (silent symbol))
+  "Check sizes for level textures, return a mask with a bit set for each failing tpage."
+
+  ;; note that with jak 2's "combo" textures for warp/sprite/hud, we can't
+  ;; detect out of VRAM until we actually we have all levels and try to layout the combo.
+
+  (let ((gp-0 0))
+    (let ((v1-0 (-> lev texture-page 0)))
+      (when v1-0
+        (if (< (the-as uint #x3e000) (-> v1-0 size))
+            (set! gp-0 (logior gp-0 1))
+            )
+        (if (not silent)
+            (format #t "~Tlevel ~10S TFRAG  tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-0 name)
+              (shr (-> v1-0 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-2 (-> lev texture-page 1)))
+      (when v1-2
+        (if (< (the-as uint #x3e000) (-> v1-2 size))
+            (set! gp-0 (logior gp-0 2))
+            )
+        (if (not silent)
+            (format #t "~Tlevel ~10S PRIS  tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-2 name)
+              (shr (-> v1-2 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-4 (-> lev texture-page 6)))
+      (when v1-4
+        (if (< (the-as uint #x3e000) (-> v1-4 size))
+            (set! gp-0 (logior gp-0 64))
+            )
+        (if (not silent)
+            (format #t "~Tlevel ~10S PRIS2 tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-4 name)
+              (shr (-> v1-4 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-6 (-> lev texture-page 2)))
+      (when v1-6
+        (if (< (the-as uint #x3e000) (-> v1-6 size))
+            (set! gp-0 (logior gp-0 4))
+            )
+        (if (not silent)
+            (format #t "~Tlevel ~10S SHRUB tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-6 name)
+              (shr (-> v1-6 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-8 (-> lev texture-page 3)))
+      (when v1-8
+        (if (< (the-as uint #x3e000) (-> v1-8 size))
+            (set! gp-0 (logior gp-0 8))
+            )
+        (if (not silent)
+            (format #t "~Tlevel ~10S ALPHA tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-8 name)
+              (shr (-> v1-8 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-10 (-> lev texture-page 4)))
+      (when v1-10
+        (if (< (the-as uint #x3e000) (-> v1-10 size))
+            (set! gp-0 (logior gp-0 16))
+            )
+        (if (not silent)
+            (format #t "~Tlevel ~10S WATER tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-10 name)
+              (shr (-> v1-10 size) 8)
+              992
+              )
+            )
+        )
+      )
+
+    ;; just print sizes.
+    (let ((v1-12 (-> lev texture-page 7)))
+      (when v1-12
+        (if (not silent)
+            (format #t "~Tlevel ~10S SPRITE tpage ~A uses ~DKK~%" (-> lev name) (-> v1-12 name) (shr (-> v1-12 size) 8))
+            )
+        )
+      )
+    (let ((v1-14 (-> lev texture-page 8)))
+      (when v1-14
+        (if (not silent)
+            (format #t "~Tlevel ~10S HUD tpage ~A uses ~DKK~%" (-> lev name) (-> v1-14 name) (shr (-> v1-14 size) 8))
+            )
+        )
+      )
+    (let ((v1-16 (-> lev texture-page 5)))
+      (when v1-16
+        (if (not silent)
+            (format #t "~Tlevel ~10S WARP tpage ~A uses ~DKK~%" (-> lev name) (-> v1-16 name) (shr (-> v1-16 size) 8))
+            )
+        )
+      )
+    gp-0
+    )
+  )
+
+(defmethod login-level-textures texture-pool ((pool texture-pool) (lev level) (num-tpage-ids int) (tpage-ids (pointer texture-id)))
+  "After all tpages are loaded, call this function to set up level textures.
+   It'll call texture-page-login on each tpage, and set up texture-page field of level."
+
+  ;; the properly set up texture pages will be stored here. for now, set to #f
+  (dotimes (v1-0 18)
+    (set! (-> lev texture-page v1-0) #f)
+    )
+
+  ;; iterate through the tpage indices given to us by the bsp-header. There's one per tpage category.
+  ;; we might have loaded texture in the wrong order, this will untangle that.
+  ;; it'll also make sure that the login succeeds.
+  ;; note that unlike jak 1, this won't call texture-page-login for texture-pages that we didn't get.
+  (dotimes (lev-tex-idx num-tpage-ids)
+    ;; get the tpage-id in the bsp
+    (let ((tpage-id (-> tpage-ids lev-tex-idx)))
+      (when (and (nonzero? tpage-id) (< lev-tex-idx 18))
+        ;; now loop through the tpages that were loaded as part of this level, and find one that matches:
+        (dotimes (loaded-tpage-idx (-> lev loaded-texture-page-count))
+          ;; check for match
+          (when (= (-> lev loaded-texture-page loaded-tpage-idx id) (-> tpage-id page))
+            ;; confirm that this tpage matches the one in the directory.
+            (let ((logged-in-tpage-id (texture-page-login tpage-id texture-page-common-allocate loading-level)))
+              ;; if we got a successful login, and there tpage matches the bsp one
+              (if (and logged-in-tpage-id (= (-> logged-in-tpage-id page) (-> lev loaded-texture-page loaded-tpage-idx)))
+                  ;; so store it as successful!
+                  (set! (-> lev texture-page lev-tex-idx) (-> logged-in-tpage-id page))
+                  )
+              )
+            (goto cfg-20)
+            )
+          )
+        )
+      )
+    (label cfg-20)
+    )
+
+  ;; check for oversize. if so print errors.
+  (let ((a2-3 (texture-page-size-check pool lev #t)))
+    (when (nonzero? a2-3)
+      (format #t "--------------------  tpage overflow error #x~X~%" a2-3)
+      (texture-page-size-check pool lev #f)
+      (format #t "--------------------~%")
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod add-level-tpage-dma texture-pool ((pool texture-pool) (lev level) (cat tpage-category) (bucket bucket-id))
+  "Add dma to upload a tpage of a level."
+  (with-pp
+    ;; get the tpage from the level
+    (let ((tpage (-> lev texture-page cat)))
+
+      ;; closest object no longer used at all, it's all masks!
+      (-> lev closest-object-array cat)
+
+      (when (and tpage (nonzero? tpage))
+        (case cat ;; different logic for different categories
+          (((tpage-category tfrag))
+           ;; I guess we have two categories here, grab both and or their masks.
+           (let ((v1-7 (-> lev texture-mask 0))
+                 (a0-2 (-> lev texture-mask 11))
+                 )
+             (dotimes (a1-1 3)
+               (logior! (-> v1-7 mask data a1-1) (-> a0-2 mask data a1-1))
+               )
+             )
+           ;; upload with masks! the terribly named -pris function just means it takes a mask
+           ;; instead of the old seg0,1,2 system.
+           (set! (-> lev upload-size 0) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask))
+                                          )
+                 )
+           )
+          (((tpage-category shrub))
+           ;; shrub: works just light tfrag
+           (let ((v1-11 (-> lev texture-mask 2))
+                 (a0-6 (-> lev texture-mask 13))
+                 )
+             (dotimes (a1-3 3)
+               (logior! (-> v1-11 mask data a1-3) (-> a0-6 mask data a1-3))
+               )
+             )
+           (set! (-> lev upload-size 2) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask 2))
+                                          )
+                 )
+           )
+          (((tpage-category alpha))
+           ;; alpha has some special cases
+           (cond
+             ((= (-> lev index) 6) ;; default level
+              ;; if the auto-save-icon-flag is set, upload the alpha texture and clear flag.
+              (if (not (-> *bigmap* auto-save-icon-flag))
+                  (set! (-> lev upload-size 8)
+                        (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                        )
+                  )
+              (set! (-> *bigmap* auto-save-icon-flag) #f)
+              )
+             (else
+               ;; otherwise, use the usual logic.
+               (let ((t0-13 (-> lev texture-mask 3)))
+                 (let ((v1-22 (-> lev texture-mask 14)))
+                   (dotimes (a0-12 3)
+                     (logior! (-> t0-13 mask data a0-12) (-> v1-22 mask data a0-12))
+                     )
+                   )
+                 (set! (-> lev upload-size 3)
+                       (upload-vram-pages-pris pool (-> pool segment-common) tpage bucket (the-as (pointer int32) t0-13))
+                       )
+                 )
+               )
+             )
+           )
+          (((tpage-category pris))
+           ;; pris work like normal, but only 1 tpage.
+           (set! (-> lev upload-size 1) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask 12))
+                                          )
+                 )
+           )
+          (((tpage-category water))
+           ;; water is like normal, 1 tpage.
+           (let ((t0-15 (-> lev texture-mask 4)))
+             (let ((v1-27 (-> lev texture-mask 15)))
+               (dotimes (a0-19 3)
+                 (logior! (-> t0-15 mask data a0-19) (-> v1-27 mask data a0-19))
+                 )
+               )
+             (set! (-> lev upload-size 4)
+                   (upload-vram-pages-pris pool (-> pool segment-common) tpage bucket (the-as (pointer int32) t0-15))
+                   )
+             )
+           )
+          (((tpage-category warp))
+           ;; warp has no masks, just uploads all
+           (set! (-> lev upload-size 5)
+                 (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                 )
+           )
+          (((tpage-category pris2))
+           ;; pris2 is normal, 1 tpage.
+           (set! (-> lev upload-size 6) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask 17))
+                                          )
+                 )
+           )
+          (((tpage-category sprite))
+           ;; sprite skips uploads if the level isn't drawing, but otherwise uploads the whole thing.
+           (if (or (= (-> lev display?) 'display) (= (-> lev display?) 'actor) (= (-> lev index) 6))
+               (set! (-> lev upload-size 7)
+                     (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                     )
+               )
+           )
+          (((tpage-category map))
+           ;; map doesn't use masks for the default level.
+           (cond
+             ((= (-> lev index) 6)
+              (set! (-> lev upload-size 8)
+                    (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                    )
+              )
+             (else
+               (let ((t0-20 (-> lev texture-mask cat)))
+                 (set! (-> lev upload-size 8)
+                       (upload-vram-pages-pris pool (-> pool segment-common) tpage bucket (the-as (pointer int32) t0-20))
+                       )
+                 )
+               )
+             )
+           )
+          (((tpage-category sky))
+           ;; sky uploads the whole thing.
+           (set! (-> lev upload-size 9)
+                 (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                 )
+           )
+          )
+
+        ;; next, update anims, if needed
+        (let ((s2-0 (-> lev texture-anim-array cat)))
+          (cond
+            ((= cat (tpage-category warp))
+             ;; warps put all their update-texture-anim's with the default level:
+             (when (= (-> lev index) 6)
+               (dotimes (s2-1 7)
+                 (let ((v1-54 (-> *level* level s2-1)))
+                   (when (or (= (-> v1-54 status) 'active) (= (-> v1-54 status) 'reserved))
+                     (if (-> v1-54 texture-anim-array 5)
+                         (update-texture-anim bucket)
+                         )
+                     )
+                   )
+                 )
+               )
+             )
+            ((= cat (tpage-category sky))
+             ;; hack for a certain level here...
+             (cond
+               ((and (level-get-target-inside *level*) (= (-> (level-get-target-inside *level*) info taskname) 'nest))
+                (let ((f30-0 (-> pp clock seconds-per-frame)))
+                  (set! (-> pp clock seconds-per-frame) (* 10.0 (-> pp clock seconds-per-frame)))
+                  (if s2-0
+                      (update-texture-anim bucket)
+                      )
+                  (set! (-> pp clock seconds-per-frame) f30-0)
+                  )
+                )
+               (else
+                 (if s2-0
+                     (update-texture-anim bucket)
+                     )
+                 )
+               )
+             )
+            (else
+              ;; otherwise, just update if there's any anims.
+              (if s2-0
+                  (update-texture-anim bucket)
+                  )
+              )
+            )
+          )
+        )
+      )
+
+    ;; unclear what can set these yet, but levels can request that certain vram is dirty
+    (let ((v1-77 (-> lev texture-dirty-masks cat)))
+      (dotimes (a0-58 128)
+        (let ((a2-2 (-> v1-77 mask data (/ a0-58 32))))
+          (when (logtest? a2-2 (ash 1 (logand a0-58 31)))
+            (set! (-> pool ids a0-58) (the-as uint 0))
+            0
+            )
+          )
+        )
+      (set! (-> v1-77 mask quad) (the-as uint128 0))
+      )
+    0
+    0
+    (none)
+    )
+  )
+
+(defun set-skull-gem-masks ()
+  "Set the default-level texture-mask to include masks from three skull gem textures."
+  (local-vars (v0-3 uint128) (v1-2 uint128) (v1-3 uint128))
+  (let ((gp-0 (-> *level* default-level texture-mask)))
+    (let* ((s5-0 (lookup-texture-by-id (new 'static 'texture-id :index #x28 :page #x395)))
+           (s4-0 (lookup-texture-by-id (new 'static 'texture-id :index #x25 :page #x395)))
+           (a0-4 (lookup-texture-by-id (new 'static 'texture-id :index #x26 :page #x395)))
+           (v1-1 (-> gp-0 0 mask quad))
+           (a1-0 (-> s5-0 masks data 0 mask quad))
+           (a2-0 (-> s4-0 masks data 0 mask quad))
+           (a0-5 (-> a0-4 masks data 0 mask quad))
+           )
+      (.por v1-2 v1-1 a1-0)
+      (.por v1-3 v1-2 a2-0)
+      (.por v0-3 v1-3 a0-5)
+      )
+    (set! (-> gp-0 0 mask quad) v0-3)
+    )
+  (none)
+  )
+
+(defun upload-textures ((arg0 texture-pool))
+  "Build DMA for all texture uploads.
+   This should be called after all drawing is done and all masks/distances are set."
+
+  ;; set up skull-gem stuff, not yet understood
+  (cond
+    ((not (-> *blit-displays-work* screen-copied))
+     (set-skull-gem-masks)
+     (set! (-> *level* default-level texture-anim-array 0) *skull-gem-texture-anim-array*)
+     )
+    (else
+      (set! (-> *level* default-level texture-anim-array 0) #f)
+      )
+    )
+
+  ;; clear upload-size
+  (dotimes (lev-idx 7)
+    (let ((lev (-> *level* level lev-idx)))
+      (when (or (= (-> lev status) 'active) (= (-> lev status) 'reserved))
+        (dotimes (a1-6 18)
+          (set! (-> lev upload-size a1-6) 0)
+          )
+        )
+      )
+    )
+
+  ;; loop over tpages, using texture-page-translate to get all of them.
+  (dotimes (num-tpage (-> *texture-page-translate* length))
+    (let* ((tpage-info (-> *texture-page-translate* num-tpage))
+           (src-level (-> *level* draw-level (-> tpage-info level-index)))
+           )
+      (when (= num-tpage 63) ;; ??
+        (nop!)
+        (nop!)
+        0
+        )
+      (when (and src-level (logtest? (-> *texture-pool* texture-enable-user) (-> tpage-info texture-user)))
+        (cond
+          ((= (-> tpage-info level-index) 6)
+           ;; always upload default-level textures
+           (add-level-tpage-dma
+             arg0
+             src-level
+             (the-as tpage-category (-> tpage-info level-texture-page))
+             (-> tpage-info bucket)
+             )
+           )
+          (else
+            ;; otherwise, only upload level textures if not in mneu-mode.
+            (if (not (-> *blit-displays-work* menu-mode))
+                (add-level-tpage-dma
+                  arg0
+                  src-level
+                  (the-as tpage-category (-> tpage-info level-texture-page))
+                  (-> tpage-info bucket)
+                  )
+                )
+            )
+          )
+        )
+      )
+    )
+
+  ;; reset masks and closest array for the next frame!
+  (dotimes (v1-16 7)
+    (let ((a0-30 (-> *level* level v1-16)))
+      (when (or (= (-> a0-30 status) 'active) (= (-> a0-30 status) 'reserved))
+        (dotimes (a1-15 18)
+          (set! (-> a0-30 closest-object-array a1-15) 4095996000.0)
+          (set! (-> a0-30 texture-mask a1-15 mask quad) (the-as uint128 0))
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; texture DMA outside of main DMA list
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; there are a few places at boot where we need to do uploads/copies
+;; without using the main DMA list.
+
+;; to hold the dma chain - doesn't hold textures, just DMA :ref tags and similar.
+(kmemopen global "texture-dma-buffers")
+(define *txt-dma-list* (new 'global 'dma-buffer 4096))
+(kmemclose)
+
+(defmethod upload-now! texture-page ((obj texture-page) (arg0 tex-upload-mode))
+  "Send the given texture-page to VRAM right now. This function doesn't return until
+   it has happened, and only should be used during boot."
+
+   (#when PC_PORT
+     ;; load it to the PC Port's texture pool.
+     (__pc-texture-upload-now obj arg0)
+     )
+
+  (let ((gp-0 *txt-dma-list*))
+    (let ((v1-0 gp-0))
+      (set! (-> v1-0 base) (-> v1-0 data))
+      (set! (-> v1-0 end) (&-> v1-0 data-buffer (-> v1-0 allocated-length)))
+      )
+    (add-to-dma-buffer obj gp-0 arg0)
+    (let* ((v1-3 gp-0)
+           (a0-1 (the-as dma-packet (-> v1-3 base)))
+           )
+      (set! (-> a0-1 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+      (set! (-> a0-1 vif0) (new 'static 'vif-tag))
+      (set! (-> a0-1 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+      (set! (-> v1-3 base) (the-as pointer (&+ a0-1 16)))
+      )
+    (let* ((v1-4 gp-0)
+           (a0-3 (the-as gs-gif-tag (-> v1-4 base)))
+           )
+      (set! (-> a0-3 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+      (set! (-> a0-3 regs) GIF_REGS_ALL_AD)
+      (set! (-> v1-4 base) (the-as pointer (&+ a0-3 16)))
+      )
+    (let* ((v1-5 gp-0)
+           (a0-5 (-> v1-5 base))
+           )
+      (set! (-> (the-as (pointer int64) a0-5) 0) 1)
+      (set! (-> (the-as (pointer gs-reg64) a0-5) 1) (gs-reg64 texflush))
+      (set! (-> v1-5 base) (&+ a0-5 16))
+      )
+    (let* ((v1-6 gp-0)
+           (a0-7 (the-as object (-> v1-6 base)))
+           )
+      (set! (-> (the-as dma-packet a0-7) dma) (new 'static 'dma-tag :id (dma-tag-id end)))
+      (set! (-> (the-as (pointer int64) a0-7) 1) 0)
+      (set! (-> v1-6 base) (&+ (the-as pointer a0-7) 16))
+      )
+    ;; the actual send
+    (#unless PC_PORT
+             (dma-buffer-send-chain (the-as dma-bank-source #x1000a000) gp-0)
+             )
+    )
+  ;; wait for dma to finish.
+  (dma-sync (the-as pointer #x1000a000) 0 0)
+  (none)
+  )
+
+(defmethod add-to-dma-buffer texture-page ((obj texture-page) (arg0 dma-buffer) (arg1 tex-upload-mode))
+  "Add upload data for a texture-page. This is a simple version for non common-segment textures."
+  (local-vars (sv-16 int))
+  (let ((v1-0 arg1))
+    (set! sv-16 (cond
+                  ((= v1-0 (tex-upload-mode none))
+                   0
+                   )
+                  ((= v1-0 (tex-upload-mode seg0-1))
+                   (the-as int (+ (-> obj segment 0 size) (-> obj segment 1 size)))
+                   )
+                  ((= v1-0 (tex-upload-mode seg0-1-2))
+                   (the-as int (-> obj size))
+                   )
+                  (else
+                    (the-as int (-> obj segment (the-as int arg1) size))
+                    )
+                  )
+          )
+    )
+  (let* ((v1-7 (max 0 (the-as int arg1)))
+         (a3-4 (* (/ (+ (/ sv-16 64) 63) 64) 32))
+         (t1-0 (shr (-> obj segment v1-7 dest) 6))
+         (a2-10 (-> obj segment v1-7 block-data))
+         )
+    (upload-vram-data arg0 (the-as int t1-0) a2-10 a3-4 128)
+    )
+  sv-16
+  )
+
+(defun texture-relocate ((dma-buff dma-buffer) (tex texture) (dest-loc int) (dest-fmt gs-psm) (clut-dst int))
+   "Move a texture in VRAM. Unrelated to the texture-relocate-later, which moves textures in RAM.
+   Will try to move the whole thing, including the clut, assuming you provide a destination for it.
+   Note that this uses the format/width stuff properly, so it will be slower, but won't scramble your texture."
+
+
+   (#when PC_PORT
+     ;; as far as I know this is only used for fonts which have 1 mip level.
+     (__pc-texture-relocate (/ dest-loc 64) (-> tex dest 0) dest-fmt)
+     )
+   (dotimes (v1-0 (the-as int (-> tex num-mips)))
+    (let ((t1-1 (ash (-> tex w) (- v1-0)))
+          (t2-3 (ash (-> tex h) (- v1-0)))
+          )
+      (let* ((t3-2 dma-buff)
+             (t4-0 (the-as object (-> t3-2 base)))
+             )
+        (set! (-> (the-as dma-packet t4-0) dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+        (set! (-> (the-as dma-packet t4-0) vif0) (new 'static 'vif-tag))
+        (set! (-> (the-as dma-packet t4-0) vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> t3-2 base) (&+ (the-as pointer t4-0) 16))
+        )
+      (let* ((t3-3 dma-buff)
+             (t4-2 (the-as object (-> t3-3 base)))
+             )
+        (set! (-> (the-as gs-gif-tag t4-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+        (set! (-> (the-as gs-gif-tag t4-2) regs) GIF_REGS_ALL_AD)
+        (set! (-> t3-3 base) (&+ (the-as pointer t4-2) 16))
+        )
+      (let* ((t3-4 dma-buff)
+             (t4-4 (-> t3-4 base))
+             )
+        (set! (-> (the-as (pointer gs-bitbltbuf) t4-4) 0) (new 'static 'gs-bitbltbuf
+                                                            :sbp (-> tex dest v1-0)
+                                                            :sbw (-> tex width v1-0)
+                                                            :spsm (the-as int (-> tex psm))
+                                                            :dbp (/ dest-loc 64)
+                                                            :dbw (-> tex width v1-0)
+                                                            :dpsm (the-as int dest-fmt)
+                                                            )
+              )
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 1) (gs-reg64 bitbltbuf))
+        (set! (-> (the-as (pointer gs-trxpos) t4-4) 2) (new 'static 'gs-trxpos))
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 3) (gs-reg64 trxpos))
+        (set! (-> (the-as (pointer gs-trxreg) t4-4) 4) (new 'static 'gs-trxreg :rrw t1-1 :rrh t2-3))
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 5) (gs-reg64 trxreg))
+        (set! (-> (the-as (pointer gs-trxdir) t4-4) 6) (new 'static 'gs-trxdir :xdir #x2))
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 7) (gs-reg64 trxdir))
+        (set! (-> t3-4 base) (&+ t4-4 64))
+        )
+      )
+    (set! (-> tex dest v1-0) (the-as uint (/ dest-loc 64)))
+    )
+  (cond
+    ((< clut-dst 0)
+     )
+    ((= (-> tex psm) (gs-psm mt4))
+     (let* ((v1-7 dma-buff)
+            (a2-2 (the-as object (-> v1-7 base)))
+            )
+       (set! (-> (the-as dma-packet a2-2) dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+       (set! (-> (the-as dma-packet a2-2) vif0) (new 'static 'vif-tag))
+       (set! (-> (the-as dma-packet a2-2) vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+       (set! (-> v1-7 base) (&+ (the-as pointer a2-2) 16))
+       )
+     (let* ((v1-8 dma-buff)
+            (a2-4 (the-as object (-> v1-8 base)))
+            )
+       (set! (-> (the-as gs-gif-tag a2-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+       (set! (-> (the-as gs-gif-tag a2-4) regs) GIF_REGS_ALL_AD)
+       (set! (-> v1-8 base) (&+ (the-as pointer a2-4) 16))
+       )
+     (let* ((v1-9 dma-buff)
+            (a2-6 (-> v1-9 base))
+            )
+       (set! (-> (the-as (pointer gs-bitbltbuf) a2-6) 0) (new 'static 'gs-bitbltbuf
+                                                           :sbw #x1
+                                                           :dbw #x1
+                                                           :dpsm (-> tex clutpsm)
+                                                           :dbp (/ clut-dst 64)
+                                                           :spsm (-> tex clutpsm)
+                                                           :sbp (-> tex clutdest)
+                                                           )
+             )
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 1) (gs-reg64 bitbltbuf))
+       (set! (-> (the-as (pointer gs-trxpos) a2-6) 2) (new 'static 'gs-trxpos))
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 3) (gs-reg64 trxpos))
+       (set! (-> (the-as (pointer gs-trxreg) a2-6) 4) (new 'static 'gs-trxreg :rrw #x8 :rrh #x2))
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 5) (gs-reg64 trxreg))
+       (set! (-> (the-as (pointer gs-trxdir) a2-6) 6) (new 'static 'gs-trxdir :xdir #x2))
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 7) (gs-reg64 trxdir))
+       (set! (-> v1-9 base) (&+ a2-6 64))
+       )
+     (set! (-> tex clutdest) (the-as uint (/ clut-dst 64)))
+     )
+    ((= (-> tex psm) (gs-psm mt8))
+     (let* ((v1-13 dma-buff)
+            (a2-9 (the-as object (-> v1-13 base)))
+            )
+       (set! (-> (the-as dma-packet a2-9) dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+       (set! (-> (the-as dma-packet a2-9) vif0) (new 'static 'vif-tag))
+       (set! (-> (the-as dma-packet a2-9) vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+       (set! (-> v1-13 base) (&+ (the-as pointer a2-9) 16))
+       )
+     (let* ((v1-14 dma-buff)
+            (a2-11 (the-as object (-> v1-14 base)))
+            )
+       (set! (-> (the-as gs-gif-tag a2-11) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+       (set! (-> (the-as gs-gif-tag a2-11) regs) GIF_REGS_ALL_AD)
+       (set! (-> v1-14 base) (&+ (the-as pointer a2-11) 16))
+       )
+     (let* ((v1-15 dma-buff)
+            (a2-13 (-> v1-15 base))
+            )
+       (set! (-> (the-as (pointer gs-bitbltbuf) a2-13) 0) (new 'static 'gs-bitbltbuf
+                                                            :sbw #x2
+                                                            :dbw #x2
+                                                            :dpsm (-> tex clutpsm)
+                                                            :dbp (/ clut-dst 64)
+                                                            :spsm (-> tex clutpsm)
+                                                            :sbp (-> tex clutdest)
+                                                            )
+             )
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 1) (gs-reg64 bitbltbuf))
+       (set! (-> (the-as (pointer gs-trxpos) a2-13) 2) (new 'static 'gs-trxpos))
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 3) (gs-reg64 trxpos))
+       (set! (-> (the-as (pointer gs-trxreg) a2-13) 4) (new 'static 'gs-trxreg :rrw #x10 :rrh #x10))
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 5) (gs-reg64 trxreg))
+       (set! (-> (the-as (pointer gs-trxdir) a2-13) 6) (new 'static 'gs-trxdir :xdir #x2))
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 7) (gs-reg64 trxdir))
+       (set! (-> v1-15 base) (&+ a2-13 64))
+       )
+     (set! (-> tex clutdest) (the-as uint (/ clut-dst 64)))
+     )
+    )
+  (set! (-> tex psm) dest-fmt)
+  dma-buff
+  )
+
+(defmethod setup-font-texture texture-pool ((obj texture-pool))
+  "Do relocations of font textures."
+  (local-vars (sv-16 int) (sv-20 int))
+  (let ((s3-0 (-> obj font-palette)))
+    (set! sv-16 (-> obj cur))
+    (set! sv-20 (/ s3-0 64))
+    (let ((s5-0
+            (texture-page-login (new 'static 'texture-id :index #x1 :page #xc04) texture-page-default-allocate global)
+            )
+          )
+      (if (and s5-0 (-> s5-0 page))
+          (set! sv-16 (the-as int (-> s5-0 page segment 0 dest)))
+          )
+      (let ((s4-0 *txt-dma-list*))
+        (let ((v1-6 s4-0))
+          (set! (-> v1-6 base) (-> v1-6 data))
+          (set! (-> v1-6 end) (&-> v1-6 data-buffer (-> v1-6 allocated-length)))
+          )
+        (let ((s2-0 (lookup-texture-by-id (new 'static 'texture-id :index #x1 :page #xc04)))
+              (s1-0 #xc2000)
+              (s0-0 36)
+              )
+          (set! (-> s2-0 h) 320)
+          (texture-relocate s4-0 s2-0 s1-0 (the-as gs-psm s0-0) s3-0)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-0-tmpl)) s2-0 s1-0 s0-0 sv-20)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-2-tmpl)) s2-0 s1-0 s0-0 sv-20)
+          )
+        (let ((s3-1 (lookup-texture-by-id (new 'static 'texture-id :page #xc04)))
+              (s2-1 #xc2000)
+              (s1-1 44)
+              )
+          (set! (-> s3-1 h) 320)
+          (texture-relocate s4-0 s3-1 s2-1 (the-as gs-psm s1-1) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-1-tmpl)) s3-1 s2-1 s1-1 sv-20)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-3-tmpl)) s3-1 s2-1 s1-1 sv-20)
+          )
+        (let ((s3-2 (lookup-texture-by-id (new 'static 'texture-id :index #x4 :page #xc04)))
+              (s2-2 #x90000)
+              (s1-2 36)
+              )
+          (set! (-> s3-2 h) 800)
+          (texture-relocate s4-0 s3-2 s2-2 (the-as gs-psm s1-2) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-0-tmpl)) s3-2 s2-2 s1-2 sv-20)
+          )
+        (let ((s3-3 (lookup-texture-by-id (new 'static 'texture-id :index #x2 :page #xc04)))
+              (s2-3 #x90000)
+              (s1-3 44)
+              )
+          (set! (-> s3-3 h) 800)
+          (texture-relocate s4-0 s3-3 s2-3 (the-as gs-psm s1-3) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-1-tmpl)) s3-3 s2-3 s1-3 sv-20)
+          )
+        (let ((s3-4 (lookup-texture-by-id (new 'static 'texture-id :index #x5 :page #xc04)))
+              (s2-4 #x5e000)
+              (s1-4 36)
+              )
+          (set! (-> s3-4 h) 800)
+          (texture-relocate s4-0 s3-4 s2-4 (the-as gs-psm s1-4) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-2-tmpl)) s3-4 s2-4 s1-4 sv-20)
+          )
+        (let ((s3-5 (lookup-texture-by-id (new 'static 'texture-id :index #x3 :page #xc04)))
+              (s2-5 #x5e000)
+              (s1-5 44)
+              )
+          (set! (-> s3-5 h) 800)
+          (texture-relocate s4-0 s3-5 s2-5 (the-as gs-psm s1-5) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-3-tmpl)) s3-5 s2-5 s1-5 sv-20)
+          )
+        (let* ((v1-28 s4-0)
+               (a0-26 (the-as dma-packet (-> v1-28 base)))
+               )
+          (set! (-> a0-26 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+          (set! (-> a0-26 vif0) (new 'static 'vif-tag))
+          (set! (-> a0-26 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+          (set! (-> v1-28 base) (the-as pointer (&+ a0-26 16)))
+          )
+        (let* ((v1-29 s4-0)
+               (a0-28 (the-as gs-gif-tag (-> v1-29 base)))
+               )
+          (set! (-> a0-28 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+          (set! (-> a0-28 regs) GIF_REGS_ALL_AD)
+          (set! (-> v1-29 base) (the-as pointer (&+ a0-28 16)))
+          )
+        (let* ((v1-30 s4-0)
+               (a0-30 (-> v1-30 base))
+               )
+          (set! (-> (the-as (pointer int64) a0-30) 0) 1)
+          (set! (-> (the-as (pointer gs-reg64) a0-30) 1) (gs-reg64 texflush))
+          (set! (-> v1-30 base) (&+ a0-30 16))
+          )
+        (let* ((v1-31 s4-0)
+               (a0-32 (the-as object (-> v1-31 base)))
+               )
+          (set! (-> (the-as dma-packet a0-32) dma) (new 'static 'dma-tag :id (dma-tag-id end)))
+          (set! (-> (the-as (pointer int64) a0-32) 1) 0)
+          (set! (-> v1-31 base) (&+ (the-as pointer a0-32) 16))
+          )
+        (#unless PC_PORT
+          (dma-buffer-send-chain (the-as dma-bank-source #x10009000) s4-0)
+          )
+        )
+      (dma-sync (the-as pointer #x10009000) 0 0)
+      (if (and s5-0 (-> s5-0 page) (= (-> obj cur) (+ sv-16 (-> s5-0 page size))))
+          (set! (-> obj cur) sv-16)
+          (format 0 "ERROR: could not resize texture pool to remove gamefont.~%")
+          )
+      )
+    )
+  0
+  (none)
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; basic methods for texture-page-dir
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; the texture-page-dir contains an entry per texture page, for every texture page that we will ever see.
+;; at runtime, the level system will allocate link arrays per page. Each page has an array of "link"s, with
+;; one link per texture. The link is the head of a linked list through all the static adgif-shaders of the
+;; level.
+
+(defmethod asize-of texture-page-dir ((obj texture-page-dir))
+  "Get the size in memory of a texture-page-dir, just the main array, not allocated link stuff."
+  (the-as int (+ (-> texture-page-dir size) (* 12 (+ (-> obj length) -1))))
+  )
+
+(defmethod length texture-page-dir ((obj texture-page-dir))
+  "Get the number of elements."
+  (-> obj length)
+  )
+
+(defmethod relocate texture-page-dir ((obj texture-page-dir) (arg0 kheap) (arg1 (pointer uint8)))
+  "Set up a texture-page-dir when it is loaded."
+  ;; there's just one of these, just set the global one to this.
+  (set! *texture-page-dir* obj)
+  (none)
+  )
+
+(defmethod relocate-dests! texture-page ((obj texture-page) (new-dest int) (segs int))
+  "Update a texture-page so the texture-page and all its textures point to a new vram
+   address."
+  (let ((new-tbp (shr new-dest 6))
+        (old-tbp (shr (-> obj segment segs dest) 6))
+        )
+    (when (!= new-tbp old-tbp)
+      (dotimes (tex-idx (-> obj length))
+        (when (-> obj data tex-idx)
+          (let* ((tex (-> obj data tex-idx))
+                 (num-mips (-> tex num-mips))
+                 )
+            (if (zero? segs)
+                (set! (-> tex clutdest) (+ (- (-> tex clutdest) old-tbp) new-tbp))
+                )
+            (dotimes (mip-idx (the-as int num-mips))
+              (let ((t4-0 mip-idx)
+                    (t5-0 num-mips)
+                    )
+                (if (= segs (if (>= (the-as uint 2) t5-0)
+                                (+ (- -1 t4-0) t5-0)
+                                (max 0 (- 2 t4-0))
+                                )
+                       )
+                    (set! (-> tex dest mip-idx) (+ (- (-> tex dest mip-idx) old-tbp) new-tbp))
+                    )
+                )
+              )
+            )
+          )
+        )
+      (set! (-> obj segment segs dest) (the-as uint new-dest))
+      )
+    )
+  (none)
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; texture-page management
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmethod relocate texture-page ((obj texture-page) (loading-heap kheap) (name (pointer uint8)))
+  "Set up a texture-page when it is loaded. This function is called by the linker when
+   loading is completed."
+
+  (cond
+    ;; version check!
+    ((or (not obj) (not (file-info-correct-version? (-> obj info) (file-kind tpage) 0)))
+     (the-as texture-page #f)
+     )
+    (else
+      (let ((loading-level (-> *level* loading-level)))
+        (when loading-level
+          ;; if we have a currently loading-level, put this in the loaded-texture-page list
+          (set! (-> loading-level loaded-texture-page (-> loading-level loaded-texture-page-count)) obj)
+          (+! (-> loading-level loaded-texture-page-count) 1)
+
+          ;; move from small-edge to small-center mode if we have 2 or more tpages, I guess?
+          (if (and (>= (-> loading-level loaded-texture-page-count) 2) (zero? (-> loading-level load-buffer-mode)))
+              (set! (-> loading-level load-buffer-mode) (load-buffer-mode small-center))
+              )
+          )
+        )
+
+      ;; set up dests (no idea why the tpage doesn't come with this set properly)
+      (set! (-> obj segment 1 dest) (-> obj segment 0 size))
+      (set! (-> obj segment 2 dest) (+ (-> obj segment 0 size) (-> obj segment 1 size)))
+      (let* ((tpage-id (-> obj id))
+             (dir-entry (-> *texture-page-dir* entries tpage-id))
+             )
+
+        ;; clear the memcpy later flag, the allocation function will set it if needed
+        ;; (I think this never happens in jak 2?)
+        (set! (-> *texture-relocate-later* memcpy) #f)
+
+        ;; do allocation!
+        ((-> *texture-pool* allocate-func) *texture-pool* obj loading-heap (the-as int tpage-id))
+        (cond
+          ((not (-> *texture-relocate-later* memcpy))
+           ;; not postponing texture memcpy, so it's safe to allocate links now.
+           ;; (otherwise its unsafe because we'll want to kick out the texture)
+           (set! (-> dir-entry page) obj)
+           (if (not (-> dir-entry link))
+               (set! (-> dir-entry link)
+                     (the-as texture-link (malloc 'loading-level (* (max (-> dir-entry length) (-> obj length)) 4)))
+                     )
+               )
+           )
+          (else
+            ;; postponing memcpy and link allocation, fill out our info.
+            (let ((v1-19 *texture-relocate-later*))
+              (set! (-> v1-19 entry) dir-entry)
+              (set! (-> v1-19 page) obj)
+              )
+            )
+          )
+        )
+      obj
+      )
+    )
+  )
+
+(defun relocate-later ()
+  "The other half to texture-relocate-later: this function does the pending memcpy."
+  (let ((gp-0 *texture-relocate-later*))
+    (let ((s5-0 (-> gp-0 entry))
+          (s4-0 (-> gp-0 page))
+          )
+      (ultimate-memcpy (the-as pointer (-> gp-0 dest)) (the-as pointer (-> gp-0 source)) (-> gp-0 move))
+      (set! (-> s5-0 page) s4-0)
+      (if (not (-> s5-0 link))
+          (set! (-> s5-0 link)
+                (the-as texture-link (malloc 'loading-level (* (max (-> s5-0 length) (-> s4-0 length)) 4)))
+                )
+          )
+      )
+    (set! (-> gp-0 memcpy) #f)
+    )
+  #f
+  )
+
+(defun texture-page-login ((tex-id texture-id) (alloc-func (function texture-pool texture-page kheap int texture-page)) (heap kheap))
+  "Get a texture-page-dir-entry for the given texture.
+   If the texture page is not loaded, it will attempt to load it with loado, which
+   would only succeed on development machines."
+
+  ;; make sure it's a valid tpage id
+  (when (and (nonzero? (-> tex-id page)) (< (-> tex-id page) (the-as uint (-> *texture-page-dir* length))))
+    ;; check the existing entry
+    (let ((dir-entry (-> *texture-page-dir* entries (-> tex-id page))))
+      (when (not (-> dir-entry page)) ;; empty entry, need to load!
+
+        ;; don't forget the old allocation function...
+        (let ((old-alloc-func (-> *texture-pool* allocate-func)))
+          (set! (-> *texture-pool* allocate-func) alloc-func)
+
+          ;; load and call relocate.
+          (let* ((name (make-file-name (file-kind tpage) (the-as string (* (-> tex-id page) 8)) 0 #f))
+                 (loaded-tpage (the-as texture-page (loado name heap)))
+                 )
+            (if loaded-tpage
+                (relocate loaded-tpage heap (charp-basename (-> name data)))
+                )
+            )
+          (set! (-> *texture-pool* allocate-func) old-alloc-func)
+          )
+        )
+      dir-entry
+      )
+    )
+  )
+
+(defun lookup-texture-by-id ((arg0 texture-id))
+  "Get a texture for the given texture-id.
+   This will do a load that only succeeds on development hardware if it doesn't exist."
+  (let ((a0-2 (texture-page-login arg0 texture-page-default-allocate loading-level))
+        (v1-0 (the-as texture-page #f))
+        )
+    (if (and a0-2 (begin (set! v1-0 (-> a0-2 page)) v1-0) (< (-> arg0 index) (the-as uint (-> v1-0 length))))
+        (-> v1-0 data (-> arg0 index))
+        )
+    )
+  )
+
+(defun lookup-texture-by-id-fast ((arg0 texture-id))
+  "Get a texture for the given id. return #f if it doesn't exist."
+  (let ((a1-2 (if (and (nonzero? (-> arg0 page)) (< (-> arg0 page) (the-as uint (-> *texture-page-dir* length))))
+                  (-> *texture-page-dir* entries (-> arg0 page))
+                  )
+              )
+        (v1-6 (the-as texture-page #f))
+        )
+    (if (and a1-2 (begin (set! v1-6 (-> a1-2 page)) v1-6) (< (-> arg0 index) (the-as uint (-> v1-6 length))))
+        (-> v1-6 data (-> arg0 index))
+        )
+    )
+  )
+
+(defun lookup-texture-by-name ((arg0 string) (arg1 string) (arg2 (pointer texture-page)))
+  "Get texture by name. Slow. Return #f if it doesn't exist."
+  (local-vars (sv-16 texture-page-dir))
+  (set! sv-16 *texture-page-dir*)
+  (dotimes (s3-0 (-> sv-16 length))
+    (let ((s2-0 (-> sv-16 entries s3-0 page)))
+      (when (and s2-0 (or (not arg1) (string= (-> s2-0 name) arg1)))
+        (dotimes (s1-0 (-> s2-0 length))
+          (let ((s0-0 (-> s2-0 data s1-0)))
+            (when (and s0-0 (string= (-> s0-0 name) arg0))
+              (if arg2
+                  (set! (-> arg2 0) s2-0)
+                  )
+              (return s0-0)
+              )
+            )
+          )
+        )
+      )
+    )
+  (the-as texture #f)
+  )
+
+(defun lookup-texture-id-by-name ((arg0 string) (arg1 string))
+  "Get texture id by name. Slow. Return 0 if it doesn't exist."
+  (local-vars (sv-16 texture-page-dir))
+  (set! sv-16 *texture-page-dir*)
+  (dotimes (gp-0 (-> sv-16 length))
+    (let ((s3-0 (-> sv-16 entries gp-0 page)))
+      (when (and s3-0 (or (not arg1) (string= (-> s3-0 name) arg1)))
+        (dotimes (s2-0 (-> s3-0 length))
+          (let ((v1-7 (-> s3-0 data s2-0)))
+            (if (and v1-7 (string= (-> v1-7 name) arg0))
+                (return (new 'static 'texture-id :page gp-0 :index s2-0))
+                )
+            )
+          )
+        )
+      )
+    )
+  (the-as texture-id 0)
+  )
+
+(defun lookup-level-texture-by-name ((arg0 string) (arg1 level) (arg2 (pointer texture-page)))
+  "Like lookup-texture-by-name, but will check texture-pages listed in this level first.
+   Unclear why these wouldn't be part of the texture-page-dir."
+  (dotimes (s3-0 18)
+    (let ((s2-0 (-> arg1 texture-page s3-0)))
+      (when (and s2-0 (nonzero? s2-0))
+        (dotimes (s1-0 (-> s2-0 length))
+          (let ((s0-0 (-> s2-0 data s1-0)))
+            (when (and s0-0 (string= (-> s0-0 name) arg0))
+              (if arg2
+                  (set! (-> arg2 0) s2-0)
+                  )
+              (return s0-0)
+              )
+            )
+          )
+        )
+      )
+    )
+  (lookup-texture-by-name arg0 (the-as string #f) arg2)
+  )
+
+(defmethod unload-page texture-pool ((obj texture-pool) (arg0 texture-page))
+  "Unload the given texture-page from the texture-page-dir."
+  (local-vars (a0-2 int))
+  (let ((v1-0 *texture-page-dir*))
+    (dotimes (a0-1 (-> v1-0 length))
+      (when (= arg0 (-> v1-0 entries a0-1 page))
+        (set! a0-2 a0-1)
+        (goto cfg-7)
+        )
+      )
+    (set! a0-2 -1)
+    (label cfg-7)
+    (when (>= a0-2 0)
+      (set! (-> v1-0 entries a0-2 page) #f)
+      (set! (-> v1-0 entries a0-2 link) #f)
+      )
+    )
+  0
+  (none)
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;
+;; adgif shader/link
+;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; debug menu shader editor
+(define *shader-list* '())
+(define *edit-shader* (new 'static 'texture-id))
+
+(defun link-texture-by-id ((arg0 texture-id) (arg1 adgif-shader))
+  "Link the adgif-shader to the texture specified."
+  (when (not (or (zero? (-> arg0 page)) (>= (-> arg0 page) (the-as uint (-> *texture-page-dir* length)))))
+    (let ((s4-0 (-> *texture-page-dir* entries (-> arg0 page))))
+      (if (not (-> s4-0 link))
+          (set! (-> s4-0 link) (the-as texture-link (malloc 'loading-level (* (-> s4-0 length) 4))))
+          )
+      (when (< (-> arg0 index) (the-as uint (-> s4-0 length)))
+        (set! (-> arg1 next shader) (-> s4-0 link next (-> arg0 index) shader))
+        (set! (-> s4-0 link next (-> arg0 index) shader) (shr (the-as int arg1) 4))
+        )
+      s4-0
+      )
+    )
+  )
+
+(defmethod unlink-shaders-in-heap texture-page-dir ((obj texture-page-dir) (heap kheap))
+  "Unlink all adgif shaders that are in heap.
+   This iterates through _everything_ so it is somewhat slow."
+  (local-vars (dist-past-end uint))
+  (let ((mem-start (-> heap base))
+        (mem-end (-> heap top-base))
+        )
+    (dotimes (entry-idx (-> obj length))
+      (let* ((entry (-> obj entries entry-idx))
+             (tex-page (-> entry page))
+             )
+        (when tex-page
+          (let ((link-arr (-> entry link next))
+                (tex-count (min (-> tex-page length) (-> entry length)))
+                )
+            0
+            (when link-arr
+              (dotimes (tex-idx tex-count)
+                (let ((link-slot (&-> link-arr 0))
+                      (shader (the-as adgif-shader (* (-> link-arr 0 shader) 16)))
+                      )
+                  (while (nonzero? (the-as uint shader))
+                    (b!
+                      (< (the-as int (- (the-as uint shader) (the-as uint mem-start))) 0)
+                      cfg-8
+                      :delay (set! dist-past-end (- (the-as uint shader) (the-as uint mem-end)))
+                      )
+                    (b! (>= (the-as int dist-past-end) 0) cfg-8 :delay (nop!))
+                    (let ((t4-2 (-> shader next)))
+                      (b! #t cfg-9 :delay (set! (-> link-slot 0) t4-2))
+                      )
+                    (label cfg-8)
+                    (set! link-slot (&-> shader next))
+                    (label cfg-9)
+                    (set! shader (the-as adgif-shader (* (-> shader next shader) 16)))
+                    )
+                  )
+                (set! link-arr (&-> link-arr 1))
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  0
+  )
 
 (defun adgif-shader<-texture! ((arg0 adgif-shader) (arg1 texture))
+  "Set up an adgif-shader from a texture."
   (set! (-> arg0 tex1 mxl) (+ (-> arg1 num-mips) -1))
   (set! (-> arg0 tex1 l) (-> arg1 mip-shift))
   (set! (-> arg0 tex1 mmag) (logand (-> arg1 tex1-control) 1))
@@ -49,6 +2575,170 @@
   arg0
   )
 
+(defun adgif-shader-update! ((arg0 adgif-shader) (arg1 texture))
+  "Update an adgif shader in response to a texture uv-dist change."
+  (let ((s5-0 (the int (/ 256.0 (-> arg1 uv-dist)))))
+    (case (-> arg0 tex1 l)
+      ((1)
+       (set! (-> arg0 tex1 k) (+ (logand (ash s5-0 (- 5 (log2 s5-0))) 31) -350 (* (log2 s5-0) 32)))
+       )
+      (else
+        (set! (-> arg0 tex1 k) (+ (logand (ash s5-0 (- 4 (log2 s5-0))) 15) -175 (* (log2 s5-0) 16)))
+        )
+      )
+    )
+  (none)
+  )
+
+;; combines the previous two functions.
+(def-mips2c adgif-shader<-texture-with-update! (function adgif-shader texture adgif-shader))
+
+(defun hack-texture ((arg0 texture))
+  "Some sort of uv-dist hack for hi-res mode."
+  (set! (-> arg0 uv-dist) 1000000.0)
+  (set! (-> arg0 masks data 0 mask w) (the-as int (+ 40960000.0 (-> arg0 masks data 0 dist))))
+  (let ((f0-4 (+ 40960000.0 (-> arg0 masks data 1 dist))))
+    (set! (-> arg0 masks data 1 mask w) (the-as int f0-4))
+    f0-4
+    )
+  )
+
+(define-extern level-remap-texture (function texture-id texture-id))
+
+
+(defun adgif-shader-login ((arg0 adgif-shader))
+  "Initialize an adgif-shader
+   confirm the texture exists, and add to texture system.
+   Use the level system to remap the texture-id in the adgif-shader.
+   If the texture doesn't exist, will load it with loado."
+
+  ;; only if we haven't done it before
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (set! (-> arg0 texture-id) (level-remap-texture (-> arg0 texture-id)))
+    (when (= (-> arg0 texture-id page) 2797)
+      (nop!)
+      (nop!)
+      0
+      )
+    ;; add us to list of adgifs for this texture
+    (link-texture-by-id (-> arg0 texture-id) arg0)
+    ;; find the texture
+    (let ((s5-0 (lookup-texture-by-id (-> arg0 texture-id))))
+      (cond
+        (s5-0
+          ;; hack! set some stuff differently if we're screenshotting
+          (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+              (hack-texture s5-0)
+              )
+          ;; set up this adgif shader from the texture.
+          (adgif-shader<-texture-with-update! arg0 s5-0)
+          )
+        (else
+          (format 0 "login<1> could not find texture ~X in obj ~A shader ~X~%"
+            (-> arg0 texture-id)
+            (-> *kernel-context* login-object)
+            arg0
+            )
+          )
+        )
+      s5-0
+      )
+    )
+  )
+
+(defun adgif-shader-login-no-remap ((arg0 adgif-shader))
+  "Initialize an adgif-shader like adgif-shader-login, but skips
+   the level-remap-texture system."
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (link-texture-by-id (-> arg0 texture-id) arg0)
+    (let ((s5-0 (lookup-texture-by-id (-> arg0 texture-id))))
+      (cond
+        (s5-0
+          (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+              (hack-texture s5-0)
+              )
+          (adgif-shader<-texture-with-update! arg0 s5-0)
+          )
+        (else
+          (format 0 "login<2> could not find texture ~X in obj ~A shader ~X~%"
+            (-> arg0 texture-id)
+            (-> *kernel-context* login-object)
+            arg0
+            )
+          )
+        )
+      s5-0
+      )
+    )
+  )
+
+(defun adgif-shader-login-fast ((arg0 adgif-shader))
+  "Initialize an adgif-shader and register with texture system, but doesn't handle missing textures.
+   Will remap with level info."
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (set! (-> arg0 texture-id) (level-remap-texture (-> arg0 texture-id)))
+    (let ((v1-4 (-> arg0 texture-id)))
+      (when (and (nonzero? (-> v1-4 page)) (< (-> v1-4 page) (the-as uint (-> *texture-page-dir* length))))
+        (let ((a0-9 (-> *texture-page-dir* entries (-> v1-4 page))))
+          (when (and (< (-> v1-4 index) (the-as uint (-> a0-9 length))) (-> a0-9 link))
+            (set! (-> arg0 next shader) (-> a0-9 link next (-> v1-4 index) shader))
+            (set! (-> a0-9 link next (-> v1-4 index) shader) (shr (the-as int arg0) 4))
+            )
+          (when (and (-> a0-9 page) (< (-> v1-4 index) (the-as uint (-> a0-9 page length))))
+            (let ((s5-0 (-> a0-9 page data (-> v1-4 index))))
+              (when s5-0
+                (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+                    (hack-texture s5-0)
+                    )
+                (adgif-shader<-texture-with-update! arg0 s5-0)
+                )
+              s5-0
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun adgif-shader-login-no-remap-fast ((arg0 adgif-shader))
+  "Initialize an adgif-shader and register with texture system, but doesn't handle missing textures.
+   Does not remap with level info."
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (let ((v1-4 (-> arg0 texture-id)))
+      (when (and (nonzero? (-> v1-4 page)) (< (-> v1-4 page) (the-as uint (-> *texture-page-dir* length))))
+        (let ((a0-8 (-> *texture-page-dir* entries (-> v1-4 page))))
+          (when (and (< (-> v1-4 index) (the-as uint (-> a0-8 length))) (-> a0-8 link))
+            (set! (-> arg0 next shader) (-> a0-8 link next (-> v1-4 index) shader))
+            (set! (-> a0-8 link next (-> v1-4 index) shader) (shr (the-as int arg0) 4))
+            )
+          (when (and (-> a0-8 page) (< (-> v1-4 index) (the-as uint (-> a0-8 page length))))
+            (let ((s5-0 (-> a0-8 page data (-> v1-4 index))))
+              (when s5-0
+                (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+                    (hack-texture s5-0)
+                    )
+                (adgif-shader<-texture-with-update! arg0 s5-0)
+                )
+              s5-0
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; when not debugging, use the "fast" ones.
+(when (not *debug-segment*)
+  (set! adgif-shader-login adgif-shader-login-fast)
+  (set! adgif-shader-login-no-remap adgif-shader-login-no-remap-fast)
+  )
+
 (defun adgif-shader<-texture-simple! ((arg0 adgif-shader) (arg1 texture))
   (set! (-> arg0 tex1) (new 'static 'gs-tex1 :mmag #x1 :mmin #x1))
   (set! (-> arg0 tex0 tfx) 0)
@@ -63,4 +2753,143 @@
   (set! (-> arg0 clamp-reg) (gs-reg64 clamp-1))
   (set! (-> arg0 prims 9) (gs-reg64 alpha-1))
   arg0
-  )
\ No newline at end of file
+  )
+
+(defun set-dirty-mask! ((arg0 level) (arg1 int) (arg2 int) (arg3 int))
+  "Set dirty bits for a levels textures. This tells the texture system to reupload the texture.
+   even if the old version is still in vram.
+   Sets bits arg2 -> arg3 for page arg1.
+   "
+  (let ((s4-0 (sar (+ arg2 #x3fff) 14))
+        (s5-0 (sar (+ arg3 #x3fff) 14))
+        (gp-0 (-> arg0 texture-dirty-masks arg1))
+        (v1-5 (new 'stack 'texture-mask))
+        )
+    (cond
+      ((< 64 s4-0)
+       (set! (-> v1-5 mask dword 0) (the-as uint -1))
+       (set! (-> v1-5 mask dword 1) (the-as uint (+ (ash 1 (+ s4-0 -64)) -1)))
+       )
+      (else
+        (set! (-> v1-5 mask dword 0) (the-as uint (+ (ash 1 s4-0) -1)))
+        )
+      )
+    (when (nonzero? s5-0)
+      (set! (-> v1-5 mask dword 1)
+            (logior (ash (-> v1-5 mask dword 1) s5-0) (ash (-> v1-5 mask dword 0) (+ s5-0 -64)))
+            )
+      (set! (-> v1-5 mask dword 0) (ash (-> v1-5 mask dword 0) s5-0))
+      )
+    (set! (-> gp-0 mask dword 0) (the-as uint (logior (-> gp-0 mask dword 0) (-> v1-5 mask dword 0))))
+    (set! (-> gp-0 mask dword 1) (the-as uint (logior (-> gp-0 mask dword 1) (-> v1-5 mask dword 1))))
+    )
+  0
+  (none)
+  )
+
+(defun-debug texture-page-dir-inspect ((arg0 texture-page-dir) (arg1 symbol))
+  (format #t "[~8x] ~A~%" arg0 (-> arg0 type))
+  (let ((v1-0 *texture-pool*))
+    (format
+      #t
+      "~Ttexture pool (~DK used, ~DK free)~%"
+      (/ (- (-> v1-0 cur) (-> v1-0 top)) 256)
+      (/ (- (shl (-> *video-params* display-fbp) 11) (-> v1-0 cur)) 256)
+      )
+    )
+  (dotimes (s4-0 (-> *level* length))
+    (let ((a1-3 (-> *level* level s4-0)))
+      (if (= (-> a1-3 status) 'active)
+          (texture-page-size-check *texture-pool* a1-3 #f)
+          )
+      )
+    )
+  (format #t "~Tlength: ~D~%" (-> arg0 length))
+  (format #t "~Tdata[~D]: @ #x~X~%" (-> arg0 length) (-> arg0 entries))
+  (dotimes (s4-1 (-> arg0 length))
+    (let ((s3-0 (-> arg0 entries s4-1 page))
+          (s2-0 (-> arg0 entries s4-1 link))
+          )
+      (cond
+        (s3-0
+          (format
+            #t
+            "~T  [~3D]   loaded ~S ~A~%"
+            s4-1
+            (if s2-0
+                "  linked"
+                "unlinked"
+                )
+            s3-0
+            )
+          )
+        (else
+          (if (= arg1 'full)
+              (format
+                #t
+                "~T  [~3D] unloaded ~S #<texture-page :length ~D>~%"
+                s4-1
+                (if s2-0
+                    "  linked"
+                    "unlinked"
+                    )
+                (-> arg0 entries s4-1 length)
+                )
+              )
+          )
+        )
+      (when (and (or s3-0 s2-0) arg1)
+        (dotimes (s1-0 (-> arg0 entries s4-1 length))
+          (cond
+            ((not s2-0)
+             (format #t "~T    [~3D]   unlinked" s1-0)
+             )
+            ((zero? (-> s2-0 next s1-0 shader))
+             (format #t "~T    [~3D]   UNUSED  " s1-0)
+             )
+            (else
+              (let ((t9-9 format)
+                    (a0-12 #t)
+                    (a1-10 "~T    [~3D] ~3D links ")
+                    (a2-11 s1-0)
+                    (a3-9 0)
+                    )
+                (let ((v1-40 (the-as object (* (-> s2-0 next s1-0 shader) 16))))
+                  (while (nonzero? (the-as uint v1-40))
+                    (nop!)
+                    (+! a3-9 1)
+                    (set! v1-40 (* (-> (the-as adgif-shader v1-40) next shader) 16))
+                    )
+                  )
+                (t9-9 a0-12 a1-10 a2-11 a3-9)
+                )
+              )
+            )
+          (cond
+            ((not s3-0)
+             (format #t " unloaded~%")
+             )
+            ((not (-> s3-0 data s1-0))
+             (format #t "    empty~%")
+             )
+            (else
+              (format #t " ~A~%" (-> s3-0 data s1-0))
+              )
+            )
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+
+(defmethod inspect texture-page-dir ((obj texture-page-dir))
+  (texture-page-dir-inspect obj #f)
+  obj
+  )
+
+(define *texture-pool* (new 'global 'texture-pool))
+
+
+
diff --git a/goal_src/jak2/engine/gfx/vu1-user-h.gc b/goal_src/jak2/engine/gfx/vu1-user-h.gc
index 52a7aed9fc..686106e85b 100644
--- a/goal_src/jak2/engine/gfx/vu1-user-h.gc
+++ b/goal_src/jak2/engine/gfx/vu1-user-h.gc
@@ -6,362 +6,392 @@
 ;; dgos: ENGINE, GAME
 
 ;; The DMA buckets
+;; name format:
+;;  <what renderer>-<what level>-<what tpage>
 (defenum bucket-id
   :type int32
   :bitfield #f
-  (bucket-0 0)
-  (bucket-1 1)
-  (bucket-2 2)
-  (bucket-3 3)     ;; blit displays
-  (bucket-4 4)     ;; tex
-  (bucket-5 5)     ;; sky
-  (bucket-6 6)     ;; ocean
 
-  (bucket-7 7)     ;; level 0 tex
-  (bucket-8 8)     ;; tfrag
-  (bucket-9 9)     ;; tie
-  (bucket-10 10)   ;; tie
-  (bucket-11 11)   ;; tfrag
-  (bucket-12 12)   ;; tie
-  (bucket-13 13)   ;; tie
-  (bucket-14 14)   ;; merc
-  (bucket-15 15)   ;; emerc
-  (bucket-16 16)   ;; mercneric
-  (bucket-17 17)   ;; tie
+  ;;;;;;;;;;
 
-  (bucket-18 18)   ;; tex
-  (bucket-19 19)   ;; tfrag
-  (bucket-20 20)   ;; tie
-  (bucket-21 21)   ;; tie
-  (bucket-22 22)   ;; tfrag
-  (bucket-23 23)   ;; tie
-  (bucket-24 24)   ;; tie
-  (bucket-25 25)   ;; merc
-  (bucket-26 26)   ;; emerc
-  (bucket-27 27)   ;; mercneric
-  (bucket-28 28)   ;; tie
+  (bucket-0      0)
+  (bucket-1      1)
+  (bucket-2      2)
+  (bucket-3      3)   ;; blit displays
+  (tex-lcom-sky-pre  4)   ;; tex
+  (bucket-5      5)   ;; sky
+  (bucket-6      6)   ;; ocean
 
-  (bucket-29 29)   ;; tex
-  (bucket-30 30)   ;; tfrag
-  (bucket-31 31)   ;; tie
-  (bucket-32 32)   ;; tie
-  (bucket-33 33)   ;; tfrag
-  (bucket-34 34)   ;; tie
-  (bucket-35 35)   ;; tie
-  (bucket-36 36)   ;; merc
-  (bucket-37 37)   ;; emerc
-  (bucket-38 38)   ;; mercneric
-  (bucket-39 39)   ;; tie
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; All levels with tfrag tpage
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-  (bucket-40 40)   ;; tex
-  (bucket-41 41)   ;; tfrag
-  (bucket-42 42)   ;; tie
-  (bucket-43 43)   ;; tie
-  (bucket-44 44)   ;; tfrag
-  (bucket-45 45)   ;; tie
-  (bucket-46 46)   ;; tie
-  (bucket-47 47)   ;; merc
-  (bucket-48 48)   ;; emerc
-  (bucket-49 49)   ;; mercneric
-  (bucket-50 50)   ;; tie
+  (tex-l0-tfrag      7)   ;; level 0 tex
+  (bucket-8          8)   ;; tfrag
+  (bucket-9          9)   ;; tie
+  (bucket-10        10)   ;; tie
+  (bucket-11        11)   ;; tfrag
+  (bucket-12        12)   ;; tie
+  (bucket-13        13)   ;; tie
+  (merc-l0-tfrag    14)   ;; merc
+  (emerc-l0-tfrag   15)   ;; emerc
+  (bucket-16        16)   ;; mercneric
+  (bucket-17        17)   ;; tie
 
-  (bucket-51 51)   ;; tex
-  (bucket-52 52)   ;; tfrag
-  (bucket-53 53)   ;; tie
-  (bucket-54 54)   ;; tie
-  (bucket-55 55)   ;; tfrag
-  (bucket-56 56)   ;; tie
-  (bucket-57 57)   ;; tie
-  (bucket-58 58)   ;; merc
-  (bucket-59 59)   ;; emerc
-  (bucket-60 60)   ;; mercneric
-  (bucket-61 61)   ;; tie
+  (tex-l1-tfrag     18)   ;; tex
+  (bucket-19        19)   ;; tfrag
+  (bucket-20        20)   ;; tie
+  (bucket-21        21)   ;; tie
+  (bucket-22        22)   ;; tfrag
+  (bucket-23        23)   ;; tie
+  (bucket-24        24)   ;; tie
+  (merc-l1-tfrag    25)   ;; merc
+  (emerc-l1-tfrag   26)   ;; emerc
+  (bucket-27        27)   ;; mercneric
+  (bucket-28        28)   ;; tie
 
-  (bucket-62 62)   ;; tex
-  (bucket-63 63)   ;; tfrag
-  (bucket-64 64)   ;; tie
-  (bucket-65 65)   ;; tie
-  (bucket-66 66)   ;; tfrag
-  (bucket-67 67)   ;; tie
-  (bucket-68 68)   ;; tie
-  (bucket-69 69)   ;; merc
-  (bucket-70 70)   ;; emerc
-  (bucket-71 71)   ;; mercneric
-  (bucket-72 72)   ;; tie
+  (tex-l2-tfrag     29)   ;; tex
+  (bucket-30        30)   ;; tfrag
+  (bucket-31        31)   ;; tie
+  (bucket-32        32)   ;; tie
+  (bucket-33        33)   ;; tfrag
+  (bucket-34        34)   ;; tie
+  (bucket-35        35)   ;; tie
+  (merc-l2-tfrag    36)   ;; merc
+  (emerc-l2-tfrag   37)   ;; emerc
+  (bucket-38        38)   ;; mercneric
+  (bucket-39        39)   ;; tie
 
-  (bucket-73 73)   ;; tex
-  (bucket-74 74)   ;; shrub
-  (bucket-75 75)   ;; shrub
-  (bucket-76 76)   ;; shrub
-  (bucket-77 77)   ;; shrub
-  (bucket-78 78)   ;; shrub
-  (bucket-79 79)   ;; merc
-  (bucket-80 80)   ;; emerc
-  (bucket-81 81)   ;; mercneric
+  (tex-l3-tfrag     40)   ;; tex
+  (bucket-41        41)   ;; tfrag
+  (bucket-42        42)   ;; tie
+  (bucket-43        43)   ;; tie
+  (bucket-44        44)   ;; tfrag
+  (bucket-45        45)   ;; tie
+  (bucket-46        46)   ;; tie
+  (merc-l3-tfrag    47)   ;; merc
+  (emerc-l3-tfrag   48)   ;; emerc
+  (bucket-49        49)   ;; mercneric
+  (bucket-50        50)   ;; tie
 
-  (bucket-82 82)   ;; tex
-  (bucket-83 83)   ;; shrub
-  (bucket-84 84)   ;; shrub
-  (bucket-85 85)   ;; shrub
-  (bucket-86 86)   ;; shrub
-  (bucket-87 87)   ;; shrub
-  (bucket-88 88)   ;; merc
-  (bucket-89 89)   ;; emerc
-  (bucket-90 90)   ;; mercneric
+  (tex-l4-tfrag     51)   ;; tex
+  (bucket-52        52)   ;; tfrag
+  (bucket-53        53)   ;; tie
+  (bucket-54        54)   ;; tie
+  (bucket-55        55)   ;; tfrag
+  (bucket-56        56)   ;; tie
+  (bucket-57        57)   ;; tie
+  (merc-l4-tfrag    58)   ;; merc
+  (emerc-l4-tfrag   59)   ;; emerc
+  (bucket-60        60)   ;; mercneric
+  (bucket-61        61)   ;; tie
 
-  (bucket-91 91)   ;; tex
-  (bucket-92 92)   ;; shrub
-  (bucket-93 93)   ;; shrub
-  (bucket-94 94)   ;; shrub
-  (bucket-95 95)   ;; shrub
-  (bucket-96 96)   ;; shrub
-  (bucket-97 97)   ;; merc
-  (bucket-98 98)   ;; emerc
-  (bucket-99 99)   ;; mercneric
+  (tex-l5-tfrag     62)   ;; tex
+  (bucket-63        63)   ;; tfrag
+  (bucket-64        64)   ;; tie
+  (bucket-65        65)   ;; tie
+  (bucket-66        66)   ;; tfrag
+  (bucket-67        67)   ;; tie
+  (bucket-68        68)   ;; tie
+  (merc-l5-tfrag    69)   ;; merc
+  (emerc-l5-tfrag   70)   ;; emerc
+  (bucket-71        71)   ;; mercneric
+  (bucket-72        72)   ;; tie
 
-  (bucket-100 100)  ;; tex
-  (bucket-101 101)  ;; shrub
-  (bucket-102 102)  ;; shrub
-  (bucket-103 103)  ;; shrub
-  (bucket-104 104)  ;; shrub
-  (bucket-105 105)  ;; shrub
-  (bucket-106 106)  ;; merc
-  (bucket-107 107)  ;; emerc
-  (bucket-108 108)  ;; mercneric
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; All levels with shrub tpage
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-  (bucket-109 109)  ;; tex
-  (bucket-110 110)  ;; shrub
-  (bucket-111 111)  ;; shrub
-  (bucket-112 112)  ;; shrub
-  (bucket-113 113)  ;; shrub
-  (bucket-114 114)  ;; shrub
-  (bucket-115 115)  ;; merc
-  (bucket-116 116)  ;; emerc
-  (bucket-117 117)  ;; mercneric
+  (tex-l0-shrub      73)   ;; tex
+  (bucket-74         74)   ;; shrub
+  (bucket-75         75)   ;; shrub
+  (bucket-76         76)   ;; shrub
+  (bucket-77         77)   ;; shrub
+  (bucket-78         78)   ;; shrub
+  (merc-l0-shrub     79)   ;; merc
+  (emerc-l0-shrub    80)   ;; emerc
+  (bucket-81         81)   ;; mercneric
 
-  (bucket-118 118)  ;; tex
-  (bucket-119 119)  ;; shrub
-  (bucket-120 120)  ;; shrub
-  (bucket-121 121)  ;; shrub
-  (bucket-122 122)  ;; shrub
-  (bucket-123 123)  ;; shrub
-  (bucket-124 124)  ;; merc
-  (bucket-125 125)  ;; emerc
-  (bucket-126 126)  ;; mercneric
+  (tex-l1-shrub      82)   ;; tex
+  (bucket-83         83)   ;; shrub
+  (bucket-84         84)   ;; shrub
+  (bucket-85         85)   ;; shrub
+  (bucket-86         86)   ;; shrub
+  (bucket-87         87)   ;; shrub
+  (merc-l1-shrub     88)   ;; merc
+  (emerc-l1-shrub    89)   ;; emerc
+  (bucket-90         90)   ;; mercneric
 
-  (bucket-127 127)  ;; tex
-  (bucket-128 128)  ;; tfrag
-  (bucket-129 129)  ;; tie
-  (bucket-130 130)  ;; tie
-  (bucket-131 131)  ;; merc
-  (bucket-132 132)  ;; emerc
-  (bucket-133 133)  ;; mercneric
-  (bucket-134 134)  ;; tfrag
-  (bucket-135 135)  ;; tie
-  (bucket-136 136)  ;; tie
+  (tex-l2-shrub      91)   ;; tex
+  (bucket-92         92)   ;; shrub
+  (bucket-93         93)   ;; shrub
+  (bucket-94         94)   ;; shrub
+  (bucket-95         95)   ;; shrub
+  (bucket-96         96)   ;; shrub
+  (merc-l2-shrub     97)   ;; merc
+  (emerc-l2-shrub    98)   ;; emerc
+  (bucket-99         99)   ;; mercneric
 
-  (bucket-137 137)  ;; tex
-  (bucket-138 138)  ;; tfrag
-  (bucket-139 139)  ;; tie
-  (bucket-140 140)  ;; tie
-  (bucket-141 141)  ;; merc
-  (bucket-142 142)  ;; emerc
-  (bucket-143 143)  ;; mercneric
-  (bucket-144 144)  ;; tfrag
-  (bucket-145 145)  ;; tie
-  (bucket-146 146)  ;; tie
+  (tex-l3-shrub     100)  ;; tex
+  (bucket-101       101)  ;; shrub
+  (bucket-102       102)  ;; shrub
+  (bucket-103       103)  ;; shrub
+  (bucket-104       104)  ;; shrub
+  (bucket-105       105)  ;; shrub
+  (merc-l3-shrub    106)  ;; merc
+  (emerc-l3-shrub   107)  ;; emerc
+  (bucket-108       108)  ;; mercneric
 
-  (bucket-147 147)  ;; tex
-  (bucket-148 148)  ;; tfrag
-  (bucket-149 149)  ;; tie
-  (bucket-150 150)  ;; tie
-  (bucket-151 151)  ;; merc
-  (bucket-152 152)  ;; emerc
-  (bucket-153 153)  ;; mercneric
-  (bucket-154 154)  ;; tfrag
-  (bucket-155 155)  ;; tie
-  (bucket-156 156)  ;; tie
+  (tex-l4-shrub     109)  ;; tex
+  (bucket-110       110)  ;; shrub
+  (bucket-111       111)  ;; shrub
+  (bucket-112       112)  ;; shrub
+  (bucket-113       113)  ;; shrub
+  (bucket-114       114)  ;; shrub
+  (merc-l4-shrub    115)  ;; merc
+  (emerc-l4-shrub   116)  ;; emerc
+  (bucket-117       117)  ;; mercneric
 
-  (bucket-157 157)  ;; tex
-  (bucket-158 158)  ;; tfrag
-  (bucket-159 159)  ;; tie
-  (bucket-160 160)  ;; tie
-  (bucket-161 161)  ;; merc
-  (bucket-162 162)  ;; emerc
-  (bucket-163 163)  ;; mercneric
-  (bucket-164 164)  ;; tfrag
-  (bucket-165 165)  ;; tie
-  (bucket-166 166)  ;; tie
+  (tex-l5-shrub     118)  ;; tex
+  (bucket-119       119)  ;; shrub
+  (bucket-120       120)  ;; shrub
+  (bucket-121       121)  ;; shrub
+  (bucket-122       122)  ;; shrub
+  (bucket-123       123)  ;; shrub
+  (merc-l5-shrub    124)  ;; merc
+  (emerc-l5-shrub   125)  ;; emerc
+  (bucket-126       126)  ;; mercneric
 
-  (bucket-167 167)  ;; tex
-  (bucket-168 168)  ;; tfrag
-  (bucket-169 169)  ;; tie
-  (bucket-170 170)  ;; tie
-  (bucket-171 171)  ;; merc
-  (bucket-172 172)  ;; emerc
-  (bucket-173 173)  ;; mercneric
-  (bucket-174 174)  ;; tfrag
-  (bucket-175 175)  ;; tie
-  (bucket-176 176)  ;; tie
+  (tex-l0-alpha     127)  ;; tex
+  (bucket-128       128)  ;; tfrag
+  (bucket-129       129)  ;; tie
+  (bucket-130       130)  ;; tie
+  (merc-l0-alpha    131)  ;; merc
+  (emerc-l0-alpha   132)  ;; emerc
+  (bucket-133       133)  ;; mercneric
+  (bucket-134       134)  ;; tfrag
+  (bucket-135       135)  ;; tie
+  (bucket-136       136)  ;; tie
 
-  (bucket-177 177)  ;; tex
-  (bucket-178 178)  ;; tfrag
-  (bucket-179 179)  ;; tie
-  (bucket-180 180)  ;; tie
-  (bucket-181 181)  ;; merc
-  (bucket-182 182)  ;; emerc
-  (bucket-183 183)  ;; mercneric
-  (bucket-184 184)  ;; tfrag
-  (bucket-185 185)  ;; tie
-  (bucket-186 186)  ;; tie
+  (tex-l1-alpha     137)  ;; tex
+  (bucket-138       138)  ;; tfrag
+  (bucket-139       139)  ;; tie
+  (bucket-140       140)  ;; tie
+  (merc-l1-alpha    141)  ;; merc
+  (emerc-l1-alpha   142)  ;; emerc
+  (bucket-143       143)  ;; mercneric
+  (bucket-144       144)  ;; tfrag
+  (bucket-145       145)  ;; tie
+  (bucket-146       146)  ;; tie
 
-  (bucket-187 187)  ;; tex
-  (bucket-188 188)  ;; merc
-  (bucket-189 189)  ;; emerc
-  (bucket-190 190)  ;; mercneric
-  (bucket-191 191)
-  (bucket-192 192)  ;; merc
-  (bucket-193 193)  ;; emerc
-  (bucket-194 194)  ;; mercneric
+  (tex-l2-alpha     147)  ;; tex
+  (bucket-148       148)  ;; tfrag
+  (bucket-149       149)  ;; tie
+  (bucket-150       150)  ;; tie
+  (merc-l2-alpha    151)  ;; merc
+  (emerc-l2-alpha   152)  ;; emerc
+  (bucket-153       153)  ;; mercneric
+  (bucket-154       154)  ;; tfrag
+  (bucket-155       155)  ;; tie
+  (bucket-156       156)  ;; tie
 
-  (bucket-195 195)  ;; shadow
+  (tex-l3-alpha     157)  ;; tex
+  (bucket-158       158)  ;; tfrag
+  (bucket-159       159)  ;; tie
+  (bucket-160       160)  ;; tie
+  (merc-l3-alpha    161)  ;; merc
+  (emerc-l3-alpha   162)  ;; emerc
+  (bucket-163       163)  ;; mercneric
+  (bucket-164       164)  ;; tfrag
+  (bucket-165       165)  ;; tie
+  (bucket-166       166)  ;; tie
 
-  (bucket-196 196)  ;; tex
-  (bucket-197 197)  ;; merc
-  (bucket-198 198)  ;; emerc
-  (bucket-199 199)  ;; mercneric
+  (tex-l4-alpha     167)  ;; tex
+  (bucket-168       168)  ;; tfrag
+  (bucket-169       169)  ;; tie
+  (bucket-170       170)  ;; tie
+  (merc-l4-alpha    171)  ;; merc
+  (emerc-l4-alpha   172)  ;; emerc
+  (bucket-173       173)  ;; mercneric
+  (bucket-174       174)  ;; tfrag
+  (bucket-175       175)  ;; tie
+  (bucket-176       176)  ;; tie
 
-  (bucket-200 200)  ;; tex
-  (bucket-201 201)  ;; merc
-  (bucket-202 202)  ;; emerc
-  (bucket-203 203)  ;; mercneric
+  (tex-l5-alpha     177)  ;; tex
+  (bucket-178       178)  ;; tfrag
+  (bucket-179       179)  ;; tie
+  (bucket-180       180)  ;; tie
+  (merc-l5-alpha    181)  ;; merc
+  (emerc-l5-alpha   182)  ;; emerc
+  (bucket-183       183)  ;; mercneric
+  (bucket-184       184)  ;; tfrag
+  (bucket-185       185)  ;; tie
+  (bucket-186       186)  ;; tie
 
-  (bucket-204 204)  ;; tex
-  (bucket-205 205)  ;; merc
-  (bucket-206 206)  ;; emerc
-  (bucket-207 207)  ;; mercneric
+  (tex-lcom-tfrag   187)  ;; tex
+  (merc-lcom-tfrag  188)  ;; merc
+  (emerc-lcom-tfrag 189)  ;; emerc
+  (bucket-190       190)  ;; mercneric
 
-  (bucket-208 208)  ;; tex
-  (bucket-209 209)  ;; merc
-  (bucket-210 210)  ;; emerc
-  (bucket-211 211)  ;; mercneric
+  (tex-lcom-shrub   191)  ;; tex
+  (merc-lcom-shrub  192)  ;; merc
+  (emerc-lcom-shrub 193)  ;; emerc
+  (bucket-194       194)  ;; mercneric
 
-  (bucket-212 212)  ;; tex
-  (bucket-213 213)  ;; merc
-  (bucket-214 214)  ;; emerc
-  (bucket-215 215)  ;; mercneric
+  (bucket-195       195)  ;; shadow
 
-  (bucket-216 216)  ;; tex
-  (bucket-217 217)  ;; merc
-  (bucket-218 218)  ;; emerc
-  (bucket-219 219)  ;; mercneric
+  (tex-l0-pris      196)  ;; tex
+  (merc-l0-pris     197)  ;; merc
+  (emerc-l0-pris    198)  ;; emerc
+  (bucket-199       199)  ;; mercneric
 
-  (bucket-220 220)  ;; tex
-  (bucket-221 221)  ;; merc
-  (bucket-222 222)  ;; emerc
-  (bucket-223 223)  ;; mercneric
-  (bucket-224 224)
-  (bucket-225 225)  ;; merc
-  (bucket-226 226)  ;; emerc
-  (bucket-227 227)  ;; mercneric
-  (bucket-228 228)
-  (bucket-229 229)  ;; merc
-  (bucket-230 230)  ;; emerc
-  (bucket-231 231)  ;; mercneric
-  (bucket-232 232)
-  (bucket-233 233)  ;; merc
-  (bucket-234 234)  ;; emerc
-  (bucket-235 235)  ;; mercneric
-  (bucket-236 236)
-  (bucket-237 237)  ;; merc
-  (bucket-238 238)  ;; emerc
-  (bucket-239 239)  ;; mercneric
-  (bucket-240 240)
-  (bucket-241 241)  ;; merc
-  (bucket-242 242)  ;; emerc
-  (bucket-243 243)  ;; mercneric
-  (bucket-244 244)
-  (bucket-245 245)  ;; merc
-  (bucket-246 246)  ;; emerc
-  (bucket-247 247)  ;; mercneric
-  (bucket-248 248)
-  (bucket-249 249)  ;; merc
-  (bucket-250 250)  ;; emerc
-  (bucket-251 251)  ;; mercneric
-  (bucket-252 252)  ;; tex
-  (bucket-253 253)  ;; merc
-  (bucket-254 254)  ;; mercneric
-  (bucket-255 255)  ;; tfrag
-  (bucket-256 256)
-  (bucket-257 257)
-  (bucket-258 258)
-  (bucket-259 259)  ;; tfrag
-  (bucket-260 260)
-  (bucket-261 261)  ;; tex
-  (bucket-262 262)  ;; merc
-  (bucket-263 263)  ;; mercneric
-  (bucket-264 264)  ;; tfrag
-  (bucket-265 265)
-  (bucket-266 266)
-  (bucket-267 267)
-  (bucket-268 268)  ;; tfrag
-  (bucket-269 269)
-  (bucket-270 270)  ;; tex
-  (bucket-271 271)  ;; merc
-  (bucket-272 272)  ;; mercneric
-  (bucket-273 273)  ;; tfrag
-  (bucket-274 274)
-  (bucket-275 275)
-  (bucket-276 276)
-  (bucket-277 277)  ;; tfrag
-  (bucket-278 278)
-  (bucket-279 279)  ;; tex
-  (bucket-280 280)  ;; merc
-  (bucket-281 281)  ;; mercneric
-  (bucket-282 282)  ;; tfrag
-  (bucket-283 283)
-  (bucket-284 284)
-  (bucket-285 285)
-  (bucket-286 286)  ;; tfrag
-  (bucket-287 287)
-  (bucket-288 288)  ;; tex
-  (bucket-289 289)  ;; merc
-  (bucket-290 290)  ;; mercneric
-  (bucket-291 291)  ;; tfrag
-  (bucket-292 292)
-  (bucket-293 293)
-  (bucket-294 294)
-  (bucket-295 295)  ;; tfrag
-  (bucket-296 296)
-  (bucket-297 297)  ;; tex
-  (bucket-298 298)  ;; merc
-  (bucket-299 299)  ;; mercneric
-  (bucket-300 300)  ;; tfrag
-  (bucket-301 301)
-  (bucket-302 302)
-  (bucket-303 303)
-  (bucket-304 304)  ;; tfrag
-  (bucket-305 305)
-  (bucket-306 306)  ;; tex
-  (bucket-307 307)  ;; merc
-  (bucket-308 308)  ;; mercneric
-  (bucket-309 309)
+  (tex-l1-pris      200)  ;; tex
+  (merc-l1-pris     201)  ;; merc
+  (emerc-l1-pris    202)  ;; emerc
+  (bucket-203       203)  ;; mercneric
 
-  (bucket-310 310)  ;; ocean
-  (bucket-311 311)  ;; depth-cue
-  (bucket-312 312)
-  (bucket-313 313)  ;; particles
-  (bucket-314 314)  ;; shadow
-  (bucket-315 315)  ;; effects
-  (bucket-316 316)  ;; tex
-  (bucket-317 317)  ;; mercneric
-  (bucket-318 318)  ;; debug, no zbuf
-  (bucket-319 319)  ;; tex
-  (bucket-320 320)  ;; hud
-  (bucket-321 321)  ;; hud letterbox, no zbuf
-  (bucket-322 322)  ;; hud
-  (bucket-323 323)  ;; hud
-  (bucket-324 324)  ;; debug
+  (tex-l2-pris      204)  ;; tex
+  (merc-l2-pris     205)  ;; merc
+  (emerc-l2-pris    206)  ;; emerc
+  (bucket-207       207)  ;; mercneric
+
+  (tex-l3-pris      208)  ;; tex
+  (merc-l3-pris     209)  ;; merc
+  (emerc-l3-pris    210)  ;; emerc
+  (bucket-211       211)  ;; mercneric
+
+  (tex-l4-pris      212)  ;; tex
+  (merc-l4-pris     213)  ;; merc
+  (emerc-l4-pris    214)  ;; emerc
+  (bucket-215       215)  ;; mercneric
+
+  (tex-l5-pris      216)  ;; tex
+  (merc-l5-pris     217)  ;; merc
+  (emerc-l5-pris    218)  ;; emerc
+  (bucket-219       219)  ;; mercneric
+
+  (tex-lcom-pris    220)  ;; tex
+  (merc-lcom-pris   221)  ;; merc
+  (emerc-lcom-pris  222)  ;; emerc
+  (bucket-223       223)  ;; mercneric
+
+  (tex-l0-pris2     224)  ;; tex
+  (merc-l0-pris2    225)  ;; merc
+  (emerc-l0-pris2   226)  ;; emerc
+  (bucket-227       227)  ;; mercneric
+
+  (tex-l1-pris2     228)  ;; tex
+  (merc-l1-pris2    229)  ;; merc
+  (emerc-l1-pris2   230)  ;; emerc
+  (bucket-231       231)  ;; mercneric
+
+  (tex-l2-pris2     232)  ;; tex
+  (merc-l2-pris2    233)  ;; merc
+  (emerc-l2-pris2   234)  ;; emerc
+  (bucket-235       235)  ;; mercneric
+
+  (tex-l3-pris2     236)  ;; tex
+  (merc-l3-pris2    237)  ;; merc
+  (emerc-l3-pris2   238)  ;; emerc
+  (bucket-239       239)  ;; mercneric
+
+  (tex-l4-pris2     240)  ;; tex
+  (merc-l4-pris2    241)  ;; merc
+  (emerc-l4-pris2   242)  ;; emerc
+  (bucket-243       243)  ;; mercneric
+
+  (tex-l5-pris2     244)  ;; tex
+  (merc-l5-pris2    245)  ;; merc
+  (emerc-l5-pris2   246)  ;; emerc
+  (bucket-247       247)  ;; mercneric
+
+  (tex-lcom-pris2   248)  ;; tex
+  (merc-lcom-pris2  249)  ;; merc
+  (emerc-lcom-pris2 250)  ;; emerc
+  (bucket-251       251)  ;; mercneric
+
+  (tex-l0-water     252)  ;; tex
+  (merc-l0-water    253)  ;; merc
+  (bucket-254       254)  ;; mercneric
+  (bucket-255       255)  ;; tfrag
+  (bucket-256       256)
+  (bucket-257       257)
+  (bucket-258       258)
+  (bucket-259       259)  ;; tfrag
+  (bucket-260       260)
+
+  (tex-l1-water     261)  ;; tex
+  (merc-l1-water    262)  ;; merc
+  (bucket-263       263)  ;; mercneric
+  (bucket-264       264)  ;; tfrag
+  (bucket-265       265)
+  (bucket-266       266)
+  (bucket-267       267)
+  (bucket-268       268)  ;; tfrag
+  (bucket-269       269)
+
+  (tex-l2-water     270)  ;; tex
+  (merc-l2-water    271)  ;; merc
+  (bucket-272       272)  ;; mercneric
+  (bucket-273       273)  ;; tfrag
+  (bucket-274       274)
+  (bucket-275       275)
+  (bucket-276       276)
+  (bucket-277       277)  ;; tfrag
+  (bucket-278       278)
+
+  (tex-l3-water     279)  ;; tex
+  (merc-l3-water    280)  ;; merc
+  (bucket-281       281)  ;; mercneric
+  (bucket-282       282)  ;; tfrag
+  (bucket-283       283)
+  (bucket-284       284)
+  (bucket-285       285)
+  (bucket-286       286)  ;; tfrag
+  (bucket-287       287)
+
+  (tex-l4-water     288)  ;; tex
+  (merc-l4-water    289)  ;; merc
+  (bucket-290       290)  ;; mercneric
+  (bucket-291       291)  ;; tfrag
+  (bucket-292       292)
+  (bucket-293       293)
+  (bucket-294       294)
+  (bucket-295       295)  ;; tfrag
+  (bucket-296       296)
+
+  (tex-l5-water     297)  ;; tex
+  (merc-l5-water    298)  ;; merc
+  (bucket-299       299)  ;; mercneric
+  (bucket-300       300)  ;; tfrag
+  (bucket-301       301)
+  (bucket-302       302)
+  (bucket-303       303)
+  (bucket-304       304)  ;; tfrag
+  (bucket-305       305)
+
+  (tex-lcom-water   306)  ;; tex
+  (merc-lcom-water  307)  ;; merc
+  (bucket-308       308)  ;; mercneric
+
+  (tex-lcom-sky-post 309)
+
+  (bucket-310       310)  ;; ocean
+  (bucket-311       311)  ;; depth-cue
+
+  (tex-all-sprite   312)
+  (bucket-313       313)  ;; particles
+  (bucket-314       314)  ;; shadow
+  (bucket-315       315)  ;; effects
+  (tex-all-warp     316)  ;; tex
+  (bucket-317       317)  ;; mercneric
+  (bucket-318       318)  ;; debug, no zbuf
+  (tex-all-map      319)  ;; tex
+  (bucket-320       320)  ;; hud
+  (bucket-321       321)  ;; hud letterbox, no zbuf
+  (bucket-322       322)  ;; hud
+  (bucket-323       323)  ;; hud
+  (bucket-324   324)  ;; debug
   (debug-no-zbuf 325)  ;; debug
   (debug-unknown-326 326)  ;; debug
   )
@@ -406,6 +436,34 @@
   (rn34)
   )
 
+(defenum texture-enable-mask
+  :type uint64
+  :bitfield #t
+  (tfrag  0)
+  (pris   1)
+  (shrub  2)
+  (alpha  3)
+  (water  4)
+  (warp   5)
+  (sprite 6)
+  (map    7)
+  (sky    8)
+  (tex9   9)
+  (tex10 10)
+  (tex11 11)
+  (tex12 12)
+  (tex13 13)
+  (tex14 14)
+  (tex15 15)
+  (tex16 16)
+  )
+
+(defenum texture-enable-mask-u32
+  :type uint32
+  :bitfield #t
+  :copy-entries texture-enable-mask
+  )
+
 (defenum tpage-category
   :type int8
   (tfrag  0)
@@ -420,6 +478,10 @@
   (sky    9)
   )
 
+(defenum tpage-category-u32
+  :type uint32
+  :copy-entries tpage-category
+  )
 ;; DECOMP BEGINS
 
 
diff --git a/goal_src/jak2/engine/level/bsp-h.gc b/goal_src/jak2/engine/level/bsp-h.gc
index ed036ddbab..a4cd64d682 100644
--- a/goal_src/jak2/engine/level/bsp-h.gc
+++ b/goal_src/jak2/engine/level/bsp-h.gc
@@ -196,3 +196,4 @@
 
 
 
+(define-extern level-remap-texture (function texture-id texture-id))
diff --git a/goal_src/jak2/engine/level/bsp.gc b/goal_src/jak2/engine/level/bsp.gc
index e0b09794c7..0848803cce 100644
--- a/goal_src/jak2/engine/level/bsp.gc
+++ b/goal_src/jak2/engine/level/bsp.gc
@@ -7,3 +7,33 @@
 
 ;; DECOMP BEGINS
 
+(defun level-remap-texture ((arg0 texture-id))
+  (let ((v1-1 (-> *level* log-in-level-bsp)))
+    (when v1-1
+      (let* ((a3-0 (-> v1-1 texture-remap-table-len))
+             (v1-2 (the-as object (-> v1-1 texture-remap-table)))
+             (t0-0 (the-as (pointer uint64) v1-2))
+             (a1-1 (the-as uint #xfffffff8))
+             (a2-1 (logand (new 'static 'texture-id :index #xfff :page #xfff) arg0))
+             (a3-2 (the-as object (&+ t0-0 (* a3-0 8))))
+             )
+        (label cfg-2)
+        (b! (= v1-2 a3-2) cfg-8 :delay (nop!))
+        (let ((t0-3 (the-as object (logand (/ (+ (the-as int v1-2) (the-as int a3-2)) 2) a1-1))))
+          (let ((t1-1 (- (-> (the-as (pointer uint32) t0-3) 0) a2-1)))
+            (b! (zero? t1-1) cfg-7 :delay (nop!))
+            (b! (< (the-as int t1-1) 0) cfg-6 :delay (nop!))
+            )
+          (b! #t cfg-2 :delay (set! a3-2 (the-as (pointer uint64) t0-3)))
+          (label cfg-6)
+          (b! #t cfg-2 :delay (set! v1-2 (+ (the-as int t0-3) 8)))
+          (label cfg-7)
+          (set! arg0 (the-as texture-id (logior (-> (the-as (pointer uint32) t0-3) 1) 20)))
+          )
+        )
+      (label cfg-8)
+      0
+      )
+    )
+  (the-as texture-id arg0)
+  )
\ No newline at end of file
diff --git a/goal_src/jak2/engine/level/level-h.gc b/goal_src/jak2/engine/level/level-h.gc
index 2ac5224a31..6214a4044f 100644
--- a/goal_src/jak2/engine/level/level-h.gc
+++ b/goal_src/jak2/engine/level/level-h.gc
@@ -335,7 +335,7 @@
    (load-time             float                           :offset-assert 156)
    (load-login-time       float                           :offset-assert 160)
    (draw-level-count      int32                           :offset-assert 164)
-   (draw-level            basic                 7         :offset-assert 168)
+   (draw-level            level                 7         :offset-assert 168)
    (draw-index-map        uint8                 7         :offset-assert 196)
    (load-order            uint64                          :offset-assert 208)
    (pad                   uint8                 30        :offset-assert 216)
diff --git a/goal_src/jak2/engine/level/level.gc b/goal_src/jak2/engine/level/level.gc
index 5f22a9b62e..be73725adc 100644
--- a/goal_src/jak2/engine/level/level.gc
+++ b/goal_src/jak2/engine/level/level.gc
@@ -15,6 +15,19 @@
      (start-debug "loading GAME.DGO~%")
      (load-package "game" global)
      (play-boot)
+
+     ;; wait 10 frames and then turn on profile bars.
+     ;; they get shut off as part of startup, so we can't do it here.
+     (process-spawn-function
+       process
+       (lambda ()
+         (dotimes (i 10)
+           (suspend)
+           )
+         (set! *display-profile* #t)
+         (set! *stats-profile-bars* #t))
+       )
+
      )
   )
 
diff --git a/goal_src/jak2/engine/math/matrix.gc b/goal_src/jak2/engine/math/matrix.gc
index ef56b203d4..260e81c063 100644
--- a/goal_src/jak2/engine/math/matrix.gc
+++ b/goal_src/jak2/engine/math/matrix.gc
@@ -235,50 +235,47 @@
   arg0
   )
 
-(defun matrix-transpose! ((arg0 matrix) (arg1 matrix))
+(defun matrix-transpose! ((dst matrix) (src matrix))
   "Set dst = src^T. src and dst can be the same."
   (local-vars
-    (v1-0 uint128)
-    (v1-1 uint128)
-    (v1-2 uint128)
-    (a1-1 uint128)
-    (a2-1 uint128)
-    (t0-1 uint128)
-    )
-  (nop!)
-  (nop!)
-  (let ((t0-0 (-> arg1 quad 0)))
-    (nop!)
-    (let ((t1-0 (-> arg1 quad 1)))
-      (nop!)
-      (let ((a2-0 (-> arg1 quad 2)))
-        (.pextlw v1-0 t1-0 t0-0)
-        (let ((a3-0 (-> arg1 trans quad)))
-          (.pextuw a1-1 t1-0 t0-0)
-          ;; (.mov r0-0 f31-0)
-          (.pextlw t0-1 a3-0 a2-0)
-          ;; (.mov r0-1 f31-0)
-          (.pextuw a2-1 a3-0 a2-0)
-          )
-        )
+   (v1-0 uint128)
+   (v1-1 uint128)
+   (v1-2 uint128)
+   (a1-1 uint128)
+   (a2-1 uint128)
+   (a3-1 uint128)
+   (a3-2 uint128)
+   (t0-1 uint128)
+   )
+  (let ((t0-0 (-> src vector 0 quad)))
+   (let ((t1-0 (-> src vector 1 quad)))
+    (let ((a2-0 (-> src vector 2 quad)))
+     (.pextlw v1-0 t1-0 t0-0)
+     (let ((a3-0 (-> src vector 3 quad)))
+      (.pextuw a1-1 t1-0 t0-0)
+      ;; (.mov r0-0 f31-0) not sure what this weird thing is.
+      ;; it has no effect, but they use it instead of nop sometimes?
+      (.pextlw t0-1 a3-0 a2-0)
+      ;; (.mov r0-1 f31-0)
+      (.pextuw a2-1 a3-0 a2-0)
       )
+     )
     )
+   )
   ;; (.mov r0-2 f31-0)
-  (let ((a3-1 (make-u128 t0-1 v1-0)))
-    ;; (.mov r0-3 f31-0)
-    (.pcpyud v1-1 v1-0 t0-1)
-    (set! (-> arg0 quad 0) (the-as uint128 a3-1))
-    )
-  (let ((a3-2 (make-u128 a2-1 a1-1)))
-    (set! (-> arg0 quad 1) v1-1)
-    (.pcpyud v1-2 a1-1 a2-1)
-    (set! (-> arg0 quad 2) (the-as uint128 a3-2))
-    )
-  (nop!)
-  (set! (-> arg0 trans quad) v1-2)
-  arg0
+  (.pcpyld a3-1 t0-1 v1-0)
+  ;; (.mov r0-3 f31-0)
+  (.pcpyud v1-1 v1-0 t0-1)
+  (set! (-> dst vector 0 quad) a3-1)
+  (.pcpyld a3-2 a2-1 a1-1)
+  (set! (-> dst vector 1 quad) v1-1)
+  (.pcpyud v1-2 a1-1 a2-1)
+  (set! (-> dst vector 2 quad) a3-2)
+  (set! (-> dst vector 3 quad) v1-2)
+  dst
   )
 
+
 (defun matrix-inverse-of-rot-trans! ((arg0 matrix) (arg1 matrix))
   "Set dst = src^-1, assuming src is a homogeneous tranform with only rotation/translation.
    NOTE: THIS FUNCTION REQUIRES dst != src"
diff --git a/goal_src/jak2/engine/math/vector-h.gc b/goal_src/jak2/engine/math/vector-h.gc
index 0ed8557e2a..026f745631 100644
--- a/goal_src/jak2/engine/math/vector-h.gc
+++ b/goal_src/jak2/engine/math/vector-h.gc
@@ -223,7 +223,7 @@
   )
 
 (deftype vector4w (structure)
-  ((data  uint32  4 :offset-assert   0)
+  ((data  int32  4  :offset-assert   0)
    (x     int32     :offset          0)
    (y     int32     :offset          4)
    (z     int32     :offset          8)
diff --git a/goal_src/jak2/engine/sound/gsound.gc b/goal_src/jak2/engine/sound/gsound.gc
index caf3c54b50..cbf37f0bbd 100644
--- a/goal_src/jak2/engine/sound/gsound.gc
+++ b/goal_src/jak2/engine/sound/gsound.gc
@@ -588,7 +588,7 @@
              )
            )
        (when v1-2
-         (set! sv-32 (string->sound-name (the-as string (-> (the-as (pointer uint32) (+ #xff37 (the-as int v1-2)))))))
+         (set! sv-32 (string->sound-name (symbol->string v1-2)))
          (set! sv-48 (res-lump-data (the-as res-lump arg0) 'cycle-speed (pointer float)))
          (set! sv-16 *ambient-spec*)
          (set! sv-64 (new 'static 'res-tag))
diff --git a/goal_src/jak2/engine/util/profile.gc b/goal_src/jak2/engine/util/profile.gc
index 9dc405d13a..4a637aab11 100644
--- a/goal_src/jak2/engine/util/profile.gc
+++ b/goal_src/jak2/engine/util/profile.gc
@@ -110,43 +110,43 @@
 
 (defun profile-texture-test ((arg0 bucket-id))
   "Is this a texture bucket?"
-  (or (= arg0 (bucket-id bucket-4))
-      (= arg0 (bucket-id bucket-7))
-      (= arg0 (bucket-id bucket-18))
-      (= arg0 (bucket-id bucket-29))
-      (= arg0 (bucket-id bucket-40))
-      (= arg0 (bucket-id bucket-51))
-      (= arg0 (bucket-id bucket-62))
-      (= arg0 (bucket-id bucket-73))
-      (= arg0 (bucket-id bucket-82))
-      (= arg0 (bucket-id bucket-91))
-      (= arg0 (bucket-id bucket-100))
-      (= arg0 (bucket-id bucket-109))
-      (= arg0 (bucket-id bucket-118))
-      (= arg0 (bucket-id bucket-127))
-      (= arg0 (bucket-id bucket-137))
-      (= arg0 (bucket-id bucket-147))
-      (= arg0 (bucket-id bucket-157))
-      (= arg0 (bucket-id bucket-167))
-      (= arg0 (bucket-id bucket-177))
-      (= arg0 (bucket-id bucket-187))
-      (= arg0 (bucket-id bucket-196))
-      (= arg0 (bucket-id bucket-200))
-      (= arg0 (bucket-id bucket-204))
-      (= arg0 (bucket-id bucket-208))
-      (= arg0 (bucket-id bucket-212))
-      (= arg0 (bucket-id bucket-216))
-      (= arg0 (bucket-id bucket-220))
-      (= arg0 (bucket-id bucket-252))
-      (= arg0 (bucket-id bucket-261))
-      (= arg0 (bucket-id bucket-270))
-      (= arg0 (bucket-id bucket-279))
-      (= arg0 (bucket-id bucket-288))
-      (= arg0 (bucket-id bucket-297))
-      (= arg0 (bucket-id bucket-306))
-      (= arg0 (bucket-id bucket-312))
-      (= arg0 (bucket-id bucket-316))
-      (= arg0 (bucket-id bucket-319))
+  (or (= arg0 (bucket-id tex-lcom-sky-pre))
+      (= arg0 (bucket-id tex-l0-tfrag))
+      (= arg0 (bucket-id tex-l1-tfrag))
+      (= arg0 (bucket-id tex-l2-tfrag))
+      (= arg0 (bucket-id tex-l3-tfrag))
+      (= arg0 (bucket-id tex-l4-tfrag))
+      (= arg0 (bucket-id tex-l5-tfrag))
+      (= arg0 (bucket-id tex-l0-shrub))
+      (= arg0 (bucket-id tex-l1-shrub))
+      (= arg0 (bucket-id tex-l2-shrub))
+      (= arg0 (bucket-id tex-l3-shrub))
+      (= arg0 (bucket-id tex-l4-shrub))
+      (= arg0 (bucket-id tex-l5-shrub))
+      (= arg0 (bucket-id tex-l0-alpha))
+      (= arg0 (bucket-id tex-l1-alpha))
+      (= arg0 (bucket-id tex-l2-alpha))
+      (= arg0 (bucket-id tex-l3-alpha))
+      (= arg0 (bucket-id tex-l4-alpha))
+      (= arg0 (bucket-id tex-l5-alpha))
+      (= arg0 (bucket-id tex-lcom-tfrag))
+      (= arg0 (bucket-id tex-l0-pris))
+      (= arg0 (bucket-id tex-l1-pris))
+      (= arg0 (bucket-id tex-l2-pris))
+      (= arg0 (bucket-id tex-l3-pris))
+      (= arg0 (bucket-id tex-l4-pris))
+      (= arg0 (bucket-id tex-l5-pris))
+      (= arg0 (bucket-id tex-lcom-pris))
+      (= arg0 (bucket-id tex-l0-water))
+      (= arg0 (bucket-id tex-l1-water))
+      (= arg0 (bucket-id tex-l2-water))
+      (= arg0 (bucket-id tex-l3-water))
+      (= arg0 (bucket-id tex-l4-water))
+      (= arg0 (bucket-id tex-l5-water))
+      (= arg0 (bucket-id tex-lcom-water))
+      (= arg0 (bucket-id tex-all-sprite))
+      (= arg0 (bucket-id tex-all-warp))
+      (= arg0 (bucket-id tex-all-map))
       )
   )
 
@@ -252,86 +252,86 @@
 
 (defun profile-merc-test ((arg0 bucket-id))
   "Is this a merc bucket?"
-  (or (= arg0 (bucket-id bucket-14))
-      (= arg0 (bucket-id bucket-25))
-      (= arg0 (bucket-id bucket-36))
-      (= arg0 (bucket-id bucket-47))
-      (= arg0 (bucket-id bucket-58))
-      (= arg0 (bucket-id bucket-69))
-      (= arg0 (bucket-id bucket-79))
-      (= arg0 (bucket-id bucket-88))
-      (= arg0 (bucket-id bucket-97))
-      (= arg0 (bucket-id bucket-106))
-      (= arg0 (bucket-id bucket-115))
-      (= arg0 (bucket-id bucket-124))
-      (= arg0 (bucket-id bucket-131))
-      (= arg0 (bucket-id bucket-141))
-      (= arg0 (bucket-id bucket-151))
-      (= arg0 (bucket-id bucket-161))
-      (= arg0 (bucket-id bucket-171))
-      (= arg0 (bucket-id bucket-181))
-      (= arg0 (bucket-id bucket-188))
-      (= arg0 (bucket-id bucket-192))
-      (= arg0 (bucket-id bucket-197))
-      (= arg0 (bucket-id bucket-201))
-      (= arg0 (bucket-id bucket-205))
-      (= arg0 (bucket-id bucket-209))
-      (= arg0 (bucket-id bucket-213))
-      (= arg0 (bucket-id bucket-217))
-      (= arg0 (bucket-id bucket-221))
-      (= arg0 (bucket-id bucket-225))
-      (= arg0 (bucket-id bucket-229))
-      (= arg0 (bucket-id bucket-233))
-      (= arg0 (bucket-id bucket-237))
-      (= arg0 (bucket-id bucket-241))
-      (= arg0 (bucket-id bucket-245))
-      (= arg0 (bucket-id bucket-249))
-      (= arg0 (bucket-id bucket-253))
-      (= arg0 (bucket-id bucket-262))
-      (= arg0 (bucket-id bucket-271))
-      (= arg0 (bucket-id bucket-280))
-      (= arg0 (bucket-id bucket-289))
-      (= arg0 (bucket-id bucket-298))
-      (= arg0 (bucket-id bucket-307))
+  (or (= arg0 (bucket-id merc-l0-tfrag))
+      (= arg0 (bucket-id merc-l1-tfrag))
+      (= arg0 (bucket-id merc-l2-tfrag))
+      (= arg0 (bucket-id merc-l3-tfrag))
+      (= arg0 (bucket-id merc-l4-tfrag))
+      (= arg0 (bucket-id merc-l5-tfrag))
+      (= arg0 (bucket-id merc-l0-shrub))
+      (= arg0 (bucket-id merc-l1-shrub))
+      (= arg0 (bucket-id merc-l2-shrub))
+      (= arg0 (bucket-id merc-l3-shrub))
+      (= arg0 (bucket-id merc-l4-shrub))
+      (= arg0 (bucket-id merc-l5-shrub))
+      (= arg0 (bucket-id merc-l0-alpha))
+      (= arg0 (bucket-id merc-l1-alpha))
+      (= arg0 (bucket-id merc-l2-alpha))
+      (= arg0 (bucket-id merc-l3-alpha))
+      (= arg0 (bucket-id merc-l4-alpha))
+      (= arg0 (bucket-id merc-l5-alpha))
+      (= arg0 (bucket-id merc-lcom-tfrag))
+      (= arg0 (bucket-id merc-lcom-shrub))
+      (= arg0 (bucket-id merc-l0-pris))
+      (= arg0 (bucket-id merc-l1-pris))
+      (= arg0 (bucket-id merc-l2-pris))
+      (= arg0 (bucket-id merc-l3-pris))
+      (= arg0 (bucket-id merc-l4-pris))
+      (= arg0 (bucket-id merc-l5-pris))
+      (= arg0 (bucket-id merc-lcom-pris))
+      (= arg0 (bucket-id merc-l0-pris2))
+      (= arg0 (bucket-id merc-l1-pris2))
+      (= arg0 (bucket-id merc-l2-pris2))
+      (= arg0 (bucket-id merc-l3-pris2))
+      (= arg0 (bucket-id merc-l4-pris2))
+      (= arg0 (bucket-id merc-l5-pris2))
+      (= arg0 (bucket-id merc-lcom-pris2))
+      (= arg0 (bucket-id merc-l0-water))
+      (= arg0 (bucket-id merc-l1-water))
+      (= arg0 (bucket-id merc-l2-water))
+      (= arg0 (bucket-id merc-l3-water))
+      (= arg0 (bucket-id merc-l4-water))
+      (= arg0 (bucket-id merc-l5-water))
+      (= arg0 (bucket-id merc-lcom-water))
       )
   )
 
 (defun profile-emerc-test ((arg0 bucket-id))
   "Is this an emerc bucket?"
-  (or (= arg0 (bucket-id bucket-15))
-      (= arg0 (bucket-id bucket-26))
-      (= arg0 (bucket-id bucket-37))
-      (= arg0 (bucket-id bucket-48))
-      (= arg0 (bucket-id bucket-59))
-      (= arg0 (bucket-id bucket-70))
-      (= arg0 (bucket-id bucket-80))
-      (= arg0 (bucket-id bucket-89))
-      (= arg0 (bucket-id bucket-98))
-      (= arg0 (bucket-id bucket-107))
-      (= arg0 (bucket-id bucket-116))
-      (= arg0 (bucket-id bucket-125))
-      (= arg0 (bucket-id bucket-132))
-      (= arg0 (bucket-id bucket-142))
-      (= arg0 (bucket-id bucket-152))
-      (= arg0 (bucket-id bucket-162))
-      (= arg0 (bucket-id bucket-172))
-      (= arg0 (bucket-id bucket-182))
-      (= arg0 (bucket-id bucket-189))
-      (= arg0 (bucket-id bucket-193))
-      (= arg0 (bucket-id bucket-198))
-      (= arg0 (bucket-id bucket-202))
-      (= arg0 (bucket-id bucket-206))
-      (= arg0 (bucket-id bucket-210))
-      (= arg0 (bucket-id bucket-214))
-      (= arg0 (bucket-id bucket-218))
-      (= arg0 (bucket-id bucket-222))
-      (= arg0 (bucket-id bucket-226))
-      (= arg0 (bucket-id bucket-230))
-      (= arg0 (bucket-id bucket-234))
-      (= arg0 (bucket-id bucket-238))
-      (= arg0 (bucket-id bucket-242))
-      (= arg0 (bucket-id bucket-246))
-      (= arg0 (bucket-id bucket-250))
+  (or (= arg0 (bucket-id emerc-l0-tfrag))
+      (= arg0 (bucket-id emerc-l1-tfrag))
+      (= arg0 (bucket-id emerc-l2-tfrag))
+      (= arg0 (bucket-id emerc-l3-tfrag))
+      (= arg0 (bucket-id emerc-l4-tfrag))
+      (= arg0 (bucket-id emerc-l5-tfrag))
+      (= arg0 (bucket-id emerc-l0-shrub))
+      (= arg0 (bucket-id emerc-l1-shrub))
+      (= arg0 (bucket-id emerc-l2-shrub))
+      (= arg0 (bucket-id emerc-l3-shrub))
+      (= arg0 (bucket-id emerc-l4-shrub))
+      (= arg0 (bucket-id emerc-l5-shrub))
+      (= arg0 (bucket-id emerc-l0-alpha))
+      (= arg0 (bucket-id emerc-l1-alpha))
+      (= arg0 (bucket-id emerc-l2-alpha))
+      (= arg0 (bucket-id emerc-l3-alpha))
+      (= arg0 (bucket-id emerc-l4-alpha))
+      (= arg0 (bucket-id emerc-l5-alpha))
+      (= arg0 (bucket-id emerc-lcom-tfrag))
+      (= arg0 (bucket-id emerc-lcom-shrub))
+      (= arg0 (bucket-id emerc-l0-pris))
+      (= arg0 (bucket-id emerc-l1-pris))
+      (= arg0 (bucket-id emerc-l2-pris))
+      (= arg0 (bucket-id emerc-l3-pris))
+      (= arg0 (bucket-id emerc-l4-pris))
+      (= arg0 (bucket-id emerc-l5-pris))
+      (= arg0 (bucket-id emerc-lcom-pris))
+      (= arg0 (bucket-id emerc-l0-pris2))
+      (= arg0 (bucket-id emerc-l1-pris2))
+      (= arg0 (bucket-id emerc-l2-pris2))
+      (= arg0 (bucket-id emerc-l3-pris2))
+      (= arg0 (bucket-id emerc-l4-pris2))
+      (= arg0 (bucket-id emerc-l5-pris2))
+      (= arg0 (bucket-id emerc-lcom-pris2))
       )
   )
 
@@ -521,6 +521,7 @@
                 (let ((v1-87 (- (-> s0-0 end-time) (-> s0-0 start-time)))
                       (a1-2 (-> s0-0 name))
                       )
+                  ;; (format 0 "vu ~D elapsed ~D (~D ~D) ~%" s2-0 v1-87 (-> s0-0 end-time) (-> s0-0 start-time))
                   (dotimes (a0-29 (-> s4-0 count))
                     (when (= (-> s4-0 data a0-29 name) a1-2)
                       (+! (-> s4-0 data a0-29 vu-count) 1)
@@ -565,25 +566,7 @@
          (a0-3 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a0-3) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x9))
-    (set! (-> (the-as gs-gif-tag a0-3) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a0-3) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a0-3) 16))
     )
   (let* ((v1-2 arg0)
diff --git a/goal_src/jak2/kernel-defs.gc b/goal_src/jak2/kernel-defs.gc
index cf198e24d5..15f6271334 100644
--- a/goal_src/jak2/kernel-defs.gc
+++ b/goal_src/jak2/kernel-defs.gc
@@ -158,6 +158,10 @@
 (define-extern syncv (function int int))
 (define-extern __pc-get-mips2c (function string function))
 
+(define-extern dma-sync (function pointer int int int))
+
+(define-extern __pc-texture-upload-now (function object object none))
+(define-extern __pc-texture-relocate (function object object object none))
 
 ;; PC stuff
 (defenum pc-prof-event
diff --git a/goalc/debugger/Debugger.cpp b/goalc/debugger/Debugger.cpp
index c64762a2bb..5bff933f7c 100644
--- a/goalc/debugger/Debugger.cpp
+++ b/goalc/debugger/Debugger.cpp
@@ -666,7 +666,6 @@ void Debugger::read_symbol_table_jak2() {
       bytes_read += 128;
       // just in case
       str_buff[127] = '\0';
-      fmt::print("got {}\n", str_buff);
 
       // GOAL sym - s7
       auto sym_offset = s32(offset + st_base + BASIC_OFFSET) - s32(m_debug_context.s7);
diff --git a/scripts/shell/decomp.sh b/scripts/shell/decomp.sh
index b76dc618fa..70456cbf09 100755
--- a/scripts/shell/decomp.sh
+++ b/scripts/shell/decomp.sh
@@ -3,4 +3,4 @@
 # Directory of this script
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 
-"${DIR}"/../../build/decompiler/decompiler "${DIR}"/../../decompiler/config/jak1_ntsc_black_label.jsonc "${DIR}"/../../iso_data "${DIR}"/../../decompiler_out
+ "${DIR}"/../../build/decompiler/decompiler "${DIR}"/../../decompiler/config/jak1_ntsc_black_label.jsonc "${DIR}"/../../iso_data "${DIR}"/../../decompiler_out
diff --git a/test/decompiler/reference/jak1/decompiler-macros.gc b/test/decompiler/reference/jak1/decompiler-macros.gc
index aa11ce3a1e..3c6f8d6a32 100644
--- a/test/decompiler/reference/jak1/decompiler-macros.gc
+++ b/test/decompiler/reference/jak1/decompiler-macros.gc
@@ -1283,4 +1283,23 @@
   )
 
 
-
+(defconstant GIF_REGS_ALL_AD
+  (new 'static 'gif-tag-regs
+       :regs0 (gif-reg-id a+d)
+       :regs1 (gif-reg-id a+d)
+       :regs2 (gif-reg-id a+d)
+       :regs3 (gif-reg-id a+d)
+       :regs4 (gif-reg-id a+d)
+       :regs5 (gif-reg-id a+d)
+       :regs6 (gif-reg-id a+d)
+       :regs7 (gif-reg-id a+d)
+       :regs8 (gif-reg-id a+d)
+       :regs9 (gif-reg-id a+d)
+       :regs10 (gif-reg-id a+d)
+       :regs11 (gif-reg-id a+d)
+       :regs12 (gif-reg-id a+d)
+       :regs13 (gif-reg-id a+d)
+       :regs14 (gif-reg-id a+d)
+       :regs15 (gif-reg-id a+d)
+       )
+  )
\ No newline at end of file
diff --git a/test/decompiler/reference/jak1/engine/anim/joint_REF.gc b/test/decompiler/reference/jak1/engine/anim/joint_REF.gc
index 9518cbd0c1..1999e4451b 100644
--- a/test/decompiler/reference/jak1/engine/anim/joint_REF.gc
+++ b/test/decompiler/reference/jak1/engine/anim/joint_REF.gc
@@ -1055,7 +1055,7 @@
        )
       (else
         (let ((a2-3 (matrix-from-control-channel!
-                      (the-as matrix (+ 16 (the-as int (the-as terrain-context #x70000000))))
+                      (the-as matrix (-> (the-as terrain-context #x70000000) work))
                       arg2
                       (the-as joint-control-channel arg1)
                       )
@@ -1213,7 +1213,7 @@
 ;; INFO: Used lq/sq
 (defun cspace<-matrix-no-push-joint! ((arg0 cspace) (arg1 joint-control))
   (let ((v1-2 (matrix-from-control!
-                (the-as matrix-stack (+ 80 (the-as int (the-as terrain-context #x70000000))))
+                (-> (the-as terrain-context #x70000000) work foreground joint-work joint-stack)
                 (-> arg0 joint)
                 arg1
                 'no-push
diff --git a/test/decompiler/reference/jak1/engine/debug/memory-usage_REF.gc b/test/decompiler/reference/jak1/engine/debug/memory-usage_REF.gc
index fb983b7f71..a98594a53b 100644
--- a/test/decompiler/reference/jak1/engine/debug/memory-usage_REF.gc
+++ b/test/decompiler/reference/jak1/engine/debug/memory-usage_REF.gc
@@ -174,7 +174,7 @@
         (set! (-> gp-0 length) (max 96 (-> gp-0 length)))
         (set! (-> gp-0 data 95 name) "heap-total")
         (+! (-> gp-0 data 95 count) 1)
-        (let ((v1-34 (+ (- -4 (the-as int arg0)) (the-as int (-> arg0 heap-cur)))))
+        (let ((v1-34 (+ (the-as uint (- -4 (the-as int arg0))) (the-as uint (-> arg0 heap-cur)))))
           (+! (-> gp-0 data 95 used) v1-34)
           (+! (-> gp-0 data 95 total) (logand -16 (+ v1-34 15)))
           )
diff --git a/test/decompiler/reference/jak1/engine/draw/drawable_REF.gc b/test/decompiler/reference/jak1/engine/draw/drawable_REF.gc
index 16b801fff9..9997437733 100644
--- a/test/decompiler/reference/jak1/engine/draw/drawable_REF.gc
+++ b/test/decompiler/reference/jak1/engine/draw/drawable_REF.gc
@@ -578,8 +578,10 @@
     (set! sv-16 arg0)
     (logclear! (-> arg1 status) (draw-status was-drawn))
     (when (zero? (logand (-> arg1 status) (draw-status hidden no-anim no-skeleton-update)))
-      (let ((s4-0 (the-as vector (+ 48 (the-as int (the-as terrain-context #x70000000)))))
-            (vu-lgt (the-as vu-lights (+ 64 (the-as int (the-as terrain-context #x70000000)))))
+      (let ((s4-0 (-> (the-as terrain-context #x70000000) work foreground joint-work temp-mtx vector 2))
+            (vu-lgt
+              (the-as vu-lights (-> (the-as terrain-context #x70000000) work foreground joint-work temp-mtx vector 3))
+              )
             (tod *time-of-day-context*)
             )
         (.lvf vf16 (&-> arg1 origin quad))
@@ -731,7 +733,7 @@
             (.lvf vf26 (&-> at-0 camera-rot vector 2 quad))
             (.lvf vf27 (&-> at-0 camera-rot vector 3 quad))
             )
-          (let ((v1-42 (the-as vector (+ 176 (the-as int (the-as terrain-context #x70000000))))))
+          (let ((v1-42 (-> (the-as terrain-context #x70000000) work foreground joint-work joint-stack data 1 vector 1)))
             (.lvf vf15 (&-> s4-0 quad))
             (.mul.w.vf acc vf27 vf0)
             (.add.mul.x.vf acc vf24 vf15 acc)
@@ -1091,26 +1093,7 @@
              (a0-29 (the-as object (-> v1-115 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-29) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x3))
-        (set! (-> (the-as gs-gif-tag a0-29) regs)
-              (new 'static 'gif-tag-regs
-                :regs0 (gif-reg-id a+d)
-                :regs1 (gif-reg-id a+d)
-                :regs2 (gif-reg-id a+d)
-                :regs3 (gif-reg-id a+d)
-                :regs4 (gif-reg-id a+d)
-                :regs5 (gif-reg-id a+d)
-                :regs6 (gif-reg-id a+d)
-                :regs7 (gif-reg-id a+d)
-                :regs8 (gif-reg-id a+d)
-                :regs9 (gif-reg-id a+d)
-                :regs10 (gif-reg-id a+d)
-                :regs11 (gif-reg-id a+d)
-                :regs12 (gif-reg-id a+d)
-                :regs13 (gif-reg-id a+d)
-                :regs14 (gif-reg-id a+d)
-                :regs15 (gif-reg-id a+d)
-                )
-              )
+        (set! (-> (the-as gs-gif-tag a0-29) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-115 base) (&+ (the-as pointer a0-29) 16))
         )
       (let* ((v1-116 s5-2)
@@ -1170,26 +1153,7 @@
                  (a0-45 (the-as object (-> v1-138 base)))
                  )
             (set! (-> (the-as gs-gif-tag a0-45) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x3))
-            (set! (-> (the-as gs-gif-tag a0-45) regs)
-                  (new 'static 'gif-tag-regs
-                    :regs0 (gif-reg-id a+d)
-                    :regs1 (gif-reg-id a+d)
-                    :regs2 (gif-reg-id a+d)
-                    :regs3 (gif-reg-id a+d)
-                    :regs4 (gif-reg-id a+d)
-                    :regs5 (gif-reg-id a+d)
-                    :regs6 (gif-reg-id a+d)
-                    :regs7 (gif-reg-id a+d)
-                    :regs8 (gif-reg-id a+d)
-                    :regs9 (gif-reg-id a+d)
-                    :regs10 (gif-reg-id a+d)
-                    :regs11 (gif-reg-id a+d)
-                    :regs12 (gif-reg-id a+d)
-                    :regs13 (gif-reg-id a+d)
-                    :regs14 (gif-reg-id a+d)
-                    :regs15 (gif-reg-id a+d)
-                    )
-                  )
+            (set! (-> (the-as gs-gif-tag a0-45) regs) GIF_REGS_ALL_AD)
             (set! (-> v1-138 base) (&+ (the-as pointer a0-45) 16))
             )
           (let* ((v1-139 s5-3)
@@ -1400,25 +1364,7 @@
            (t1-2 (the-as object (-> a3-4 base)))
            )
       (set! (-> (the-as gs-gif-tag t1-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-      (set! (-> (the-as gs-gif-tag t1-2) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag t1-2) regs) GIF_REGS_ALL_AD)
       (set! (-> a3-4 base) (&+ (the-as pointer t1-2) 16))
       )
     (let* ((a3-5 t0-0)
diff --git a/test/decompiler/reference/jak1/engine/draw/process-drawable_REF.gc b/test/decompiler/reference/jak1/engine/draw/process-drawable_REF.gc
index 2550d09e7f..31a3a275b3 100644
--- a/test/decompiler/reference/jak1/engine/draw/process-drawable_REF.gc
+++ b/test/decompiler/reference/jak1/engine/draw/process-drawable_REF.gc
@@ -302,7 +302,7 @@
         (let ((s4-0 (+ s5-0 2)))
           (+ s4-0 1)
           ((-> obj skel generate-frame-function)
-           (the-as (inline-array vector) (+ 2416 (the-as int (the-as terrain-context #x70000000))))
+           (the-as (inline-array vector) (-> (the-as terrain-context #x70000000) work foreground joint-work mtx-acc))
            s4-0
            obj
            )
diff --git a/test/decompiler/reference/jak1/engine/game/generic-obs_REF.gc b/test/decompiler/reference/jak1/engine/game/generic-obs_REF.gc
index 036ae1f9ae..2100b0defb 100644
--- a/test/decompiler/reference/jak1/engine/game/generic-obs_REF.gc
+++ b/test/decompiler/reference/jak1/engine/game/generic-obs_REF.gc
@@ -1492,7 +1492,7 @@
                )
            )
           ((= (-> s2-0 -1) symbol)
-           (set! s4-0 (-> (&+ s2-0 #xff38) 0))
+           (set! s4-0 (-> (&-> s2-0 16334) 0))
            (set! s3-0 (lookup-part-group-pointer-by-name (the-as string s4-0)))
            (if s3-0
                (set! (-> s5-1 0) s3-0)
diff --git a/test/decompiler/reference/jak1/engine/game/main_REF.gc b/test/decompiler/reference/jak1/engine/game/main_REF.gc
index cef7adaaa0..5bc7e520cb 100644
--- a/test/decompiler/reference/jak1/engine/game/main_REF.gc
+++ b/test/decompiler/reference/jak1/engine/game/main_REF.gc
@@ -1190,26 +1190,7 @@
                      (a0-79 (the-as object (-> v1-173 base)))
                      )
                 (set! (-> (the-as gs-gif-tag a0-79) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x9))
-                (set! (-> (the-as gs-gif-tag a0-79) regs)
-                      (new 'static 'gif-tag-regs
-                        :regs0 (gif-reg-id a+d)
-                        :regs1 (gif-reg-id a+d)
-                        :regs2 (gif-reg-id a+d)
-                        :regs3 (gif-reg-id a+d)
-                        :regs4 (gif-reg-id a+d)
-                        :regs5 (gif-reg-id a+d)
-                        :regs6 (gif-reg-id a+d)
-                        :regs7 (gif-reg-id a+d)
-                        :regs8 (gif-reg-id a+d)
-                        :regs9 (gif-reg-id a+d)
-                        :regs10 (gif-reg-id a+d)
-                        :regs11 (gif-reg-id a+d)
-                        :regs12 (gif-reg-id a+d)
-                        :regs13 (gif-reg-id a+d)
-                        :regs14 (gif-reg-id a+d)
-                        :regs15 (gif-reg-id a+d)
-                        )
-                      )
+                (set! (-> (the-as gs-gif-tag a0-79) regs) GIF_REGS_ALL_AD)
                 (set! (-> v1-173 base) (&+ (the-as pointer a0-79) 16))
                 )
               (let* ((v1-174 debug-buf)
diff --git a/test/decompiler/reference/jak1/engine/gfx/background_REF.gc b/test/decompiler/reference/jak1/engine/gfx/background_REF.gc
index f7fdbca8cd..afacde2c66 100644
--- a/test/decompiler/reference/jak1/engine/gfx/background_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/background_REF.gc
@@ -190,7 +190,7 @@
                     (when (not (or (zero? s0-0) (= s4-1 s0-0)))
                       (flush-cache 0)
                       (time-of-day-interp-colors-scratch
-                        (the-as (pointer rgba) (+ 6160 (the-as int (the-as terrain-context #x70000000))))
+                        (the-as (pointer rgba) (-> (the-as terrain-context #x70000000) work foreground joint-work tq-acc 75 quat))
                         s0-0
                         (-> s1-0 mood)
                         )
diff --git a/test/decompiler/reference/jak1/engine/gfx/depth-cue_REF.gc b/test/decompiler/reference/jak1/engine/gfx/depth-cue_REF.gc
index cc9192a474..0398cd85e9 100644
--- a/test/decompiler/reference/jak1/engine/gfx/depth-cue_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/depth-cue_REF.gc
@@ -47,25 +47,7 @@
          (t1-2 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag t1-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x3))
-    (set! (-> (the-as gs-gif-tag t1-2) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag t1-2) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer t1-2) 16))
     )
   (let* ((v1-2 arg0)
@@ -133,25 +115,7 @@
              (t6-2 (the-as object (-> t5-1 base)))
              )
         (set! (-> (the-as gs-gif-tag t6-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
-        (set! (-> (the-as gs-gif-tag t6-2) regs) (new 'static 'gif-tag-regs
-                                                   :regs0 (gif-reg-id a+d)
-                                                   :regs1 (gif-reg-id a+d)
-                                                   :regs2 (gif-reg-id a+d)
-                                                   :regs3 (gif-reg-id a+d)
-                                                   :regs4 (gif-reg-id a+d)
-                                                   :regs5 (gif-reg-id a+d)
-                                                   :regs6 (gif-reg-id a+d)
-                                                   :regs7 (gif-reg-id a+d)
-                                                   :regs8 (gif-reg-id a+d)
-                                                   :regs9 (gif-reg-id a+d)
-                                                   :regs10 (gif-reg-id a+d)
-                                                   :regs11 (gif-reg-id a+d)
-                                                   :regs12 (gif-reg-id a+d)
-                                                   :regs13 (gif-reg-id a+d)
-                                                   :regs14 (gif-reg-id a+d)
-                                                   :regs15 (gif-reg-id a+d)
-                                                   )
-              )
+        (set! (-> (the-as gs-gif-tag t6-2) regs) GIF_REGS_ALL_AD)
         (set! (-> t5-1 base) (&+ (the-as pointer t6-2) 16))
         )
       (let* ((t5-2 arg0)
@@ -191,25 +155,7 @@
              (t6-18 (the-as object (-> t5-8 base)))
              )
         (set! (-> (the-as gs-gif-tag t6-18) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
-        (set! (-> (the-as gs-gif-tag t6-18) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag t6-18) regs) GIF_REGS_ALL_AD)
         (set! (-> t5-8 base) (&+ (the-as pointer t6-18) 16))
         )
       (let* ((t5-9 arg0)
@@ -276,25 +222,7 @@
              (t6-2 (the-as object (-> t5-1 base)))
              )
         (set! (-> (the-as gs-gif-tag t6-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x5))
-        (set! (-> (the-as gs-gif-tag t6-2) regs) (new 'static 'gif-tag-regs
-                                                   :regs0 (gif-reg-id a+d)
-                                                   :regs1 (gif-reg-id a+d)
-                                                   :regs2 (gif-reg-id a+d)
-                                                   :regs3 (gif-reg-id a+d)
-                                                   :regs4 (gif-reg-id a+d)
-                                                   :regs5 (gif-reg-id a+d)
-                                                   :regs6 (gif-reg-id a+d)
-                                                   :regs7 (gif-reg-id a+d)
-                                                   :regs8 (gif-reg-id a+d)
-                                                   :regs9 (gif-reg-id a+d)
-                                                   :regs10 (gif-reg-id a+d)
-                                                   :regs11 (gif-reg-id a+d)
-                                                   :regs12 (gif-reg-id a+d)
-                                                   :regs13 (gif-reg-id a+d)
-                                                   :regs14 (gif-reg-id a+d)
-                                                   :regs15 (gif-reg-id a+d)
-                                                   )
-              )
+        (set! (-> (the-as gs-gif-tag t6-2) regs) GIF_REGS_ALL_AD)
         (set! (-> t5-1 base) (&+ (the-as pointer t6-2) 16))
         )
       (let* ((t5-2 arg0)
@@ -336,25 +264,7 @@
              (t6-18 (the-as object (-> t5-8 base)))
              )
         (set! (-> (the-as gs-gif-tag t6-18) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x5))
-        (set! (-> (the-as gs-gif-tag t6-18) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag t6-18) regs) GIF_REGS_ALL_AD)
         (set! (-> t5-8 base) (&+ (the-as pointer t6-18) 16))
         )
       (let* ((t5-9 arg0)
@@ -427,25 +337,7 @@
                (a2-2 (the-as object (-> a1-8 base)))
                )
           (set! (-> (the-as gs-gif-tag a2-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x6))
-          (set! (-> (the-as gs-gif-tag a2-2) regs) (new 'static 'gif-tag-regs
-                                                     :regs0 (gif-reg-id a+d)
-                                                     :regs1 (gif-reg-id a+d)
-                                                     :regs2 (gif-reg-id a+d)
-                                                     :regs3 (gif-reg-id a+d)
-                                                     :regs4 (gif-reg-id a+d)
-                                                     :regs5 (gif-reg-id a+d)
-                                                     :regs6 (gif-reg-id a+d)
-                                                     :regs7 (gif-reg-id a+d)
-                                                     :regs8 (gif-reg-id a+d)
-                                                     :regs9 (gif-reg-id a+d)
-                                                     :regs10 (gif-reg-id a+d)
-                                                     :regs11 (gif-reg-id a+d)
-                                                     :regs12 (gif-reg-id a+d)
-                                                     :regs13 (gif-reg-id a+d)
-                                                     :regs14 (gif-reg-id a+d)
-                                                     :regs15 (gif-reg-id a+d)
-                                                     )
-                )
+          (set! (-> (the-as gs-gif-tag a2-2) regs) GIF_REGS_ALL_AD)
           (set! (-> a1-8 base) (&+ (the-as pointer a2-2) 16))
           )
         (let* ((a1-9 s4-0)
@@ -494,25 +386,7 @@
                  (a0-4 (the-as object (-> v1-20 base)))
                  )
             (set! (-> (the-as gs-gif-tag a0-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-            (set! (-> (the-as gs-gif-tag a0-4) regs) (new 'static 'gif-tag-regs
-                                                       :regs0 (gif-reg-id a+d)
-                                                       :regs1 (gif-reg-id a+d)
-                                                       :regs2 (gif-reg-id a+d)
-                                                       :regs3 (gif-reg-id a+d)
-                                                       :regs4 (gif-reg-id a+d)
-                                                       :regs5 (gif-reg-id a+d)
-                                                       :regs6 (gif-reg-id a+d)
-                                                       :regs7 (gif-reg-id a+d)
-                                                       :regs8 (gif-reg-id a+d)
-                                                       :regs9 (gif-reg-id a+d)
-                                                       :regs10 (gif-reg-id a+d)
-                                                       :regs11 (gif-reg-id a+d)
-                                                       :regs12 (gif-reg-id a+d)
-                                                       :regs13 (gif-reg-id a+d)
-                                                       :regs14 (gif-reg-id a+d)
-                                                       :regs15 (gif-reg-id a+d)
-                                                       )
-                  )
+            (set! (-> (the-as gs-gif-tag a0-4) regs) GIF_REGS_ALL_AD)
             (set! (-> v1-20 base) (&+ (the-as pointer a0-4) 16))
             )
           (let* ((v1-21 s4-0)
diff --git a/test/decompiler/reference/jak1/engine/gfx/eye_REF.gc b/test/decompiler/reference/jak1/engine/gfx/eye_REF.gc
index cecf00db02..93fc85ee44 100644
--- a/test/decompiler/reference/jak1/engine/gfx/eye_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/eye_REF.gc
@@ -72,25 +72,7 @@
                (a0-8 (the-as object (-> v1-13 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-8) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-          (set! (-> (the-as gs-gif-tag a0-8) regs) (new 'static 'gif-tag-regs
-                                                     :regs0 (gif-reg-id a+d)
-                                                     :regs1 (gif-reg-id a+d)
-                                                     :regs2 (gif-reg-id a+d)
-                                                     :regs3 (gif-reg-id a+d)
-                                                     :regs4 (gif-reg-id a+d)
-                                                     :regs5 (gif-reg-id a+d)
-                                                     :regs6 (gif-reg-id a+d)
-                                                     :regs7 (gif-reg-id a+d)
-                                                     :regs8 (gif-reg-id a+d)
-                                                     :regs9 (gif-reg-id a+d)
-                                                     :regs10 (gif-reg-id a+d)
-                                                     :regs11 (gif-reg-id a+d)
-                                                     :regs12 (gif-reg-id a+d)
-                                                     :regs13 (gif-reg-id a+d)
-                                                     :regs14 (gif-reg-id a+d)
-                                                     :regs15 (gif-reg-id a+d)
-                                                     )
-                )
+          (set! (-> (the-as gs-gif-tag a0-8) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-13 base) (&+ (the-as pointer a0-8) 16))
           )
         (let* ((v1-14 arg0)
@@ -127,25 +109,7 @@
                  (a2-9 (the-as object (-> a1-23 base)))
                  )
             (set! (-> (the-as gs-gif-tag a2-9) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-            (set! (-> (the-as gs-gif-tag a2-9) regs) (new 'static 'gif-tag-regs
-                                                       :regs0 (gif-reg-id a+d)
-                                                       :regs1 (gif-reg-id a+d)
-                                                       :regs2 (gif-reg-id a+d)
-                                                       :regs3 (gif-reg-id a+d)
-                                                       :regs4 (gif-reg-id a+d)
-                                                       :regs5 (gif-reg-id a+d)
-                                                       :regs6 (gif-reg-id a+d)
-                                                       :regs7 (gif-reg-id a+d)
-                                                       :regs8 (gif-reg-id a+d)
-                                                       :regs9 (gif-reg-id a+d)
-                                                       :regs10 (gif-reg-id a+d)
-                                                       :regs11 (gif-reg-id a+d)
-                                                       :regs12 (gif-reg-id a+d)
-                                                       :regs13 (gif-reg-id a+d)
-                                                       :regs14 (gif-reg-id a+d)
-                                                       :regs15 (gif-reg-id a+d)
-                                                       )
-                  )
+            (set! (-> (the-as gs-gif-tag a2-9) regs) GIF_REGS_ALL_AD)
             (set! (-> a1-23 base) (&+ (the-as pointer a2-9) 16))
             )
           (let* ((a1-24 arg0)
@@ -185,25 +149,7 @@
                  (a2-19 (the-as object (-> a1-30 base)))
                  )
             (set! (-> (the-as gs-gif-tag a2-19) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-            (set! (-> (the-as gs-gif-tag a2-19) regs) (new 'static 'gif-tag-regs
-                                                        :regs0 (gif-reg-id a+d)
-                                                        :regs1 (gif-reg-id a+d)
-                                                        :regs2 (gif-reg-id a+d)
-                                                        :regs3 (gif-reg-id a+d)
-                                                        :regs4 (gif-reg-id a+d)
-                                                        :regs5 (gif-reg-id a+d)
-                                                        :regs6 (gif-reg-id a+d)
-                                                        :regs7 (gif-reg-id a+d)
-                                                        :regs8 (gif-reg-id a+d)
-                                                        :regs9 (gif-reg-id a+d)
-                                                        :regs10 (gif-reg-id a+d)
-                                                        :regs11 (gif-reg-id a+d)
-                                                        :regs12 (gif-reg-id a+d)
-                                                        :regs13 (gif-reg-id a+d)
-                                                        :regs14 (gif-reg-id a+d)
-                                                        :regs15 (gif-reg-id a+d)
-                                                        )
-                  )
+            (set! (-> (the-as gs-gif-tag a2-19) regs) GIF_REGS_ALL_AD)
             (set! (-> a1-30 base) (&+ (the-as pointer a2-19) 16))
             )
           (let* ((a1-31 arg0)
@@ -245,25 +191,7 @@
              (a0-34 (the-as object (-> v1-25 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-34) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-        (set! (-> (the-as gs-gif-tag a0-34) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag a0-34) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-25 base) (&+ (the-as pointer a0-34) 16))
         )
       (let* ((v1-26 arg0)
@@ -304,25 +232,7 @@
                  (a2-29 (the-as object (-> a1-46 base)))
                  )
             (set! (-> (the-as gs-gif-tag a2-29) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-            (set! (-> (the-as gs-gif-tag a2-29) regs) (new 'static 'gif-tag-regs
-                                                        :regs0 (gif-reg-id a+d)
-                                                        :regs1 (gif-reg-id a+d)
-                                                        :regs2 (gif-reg-id a+d)
-                                                        :regs3 (gif-reg-id a+d)
-                                                        :regs4 (gif-reg-id a+d)
-                                                        :regs5 (gif-reg-id a+d)
-                                                        :regs6 (gif-reg-id a+d)
-                                                        :regs7 (gif-reg-id a+d)
-                                                        :regs8 (gif-reg-id a+d)
-                                                        :regs9 (gif-reg-id a+d)
-                                                        :regs10 (gif-reg-id a+d)
-                                                        :regs11 (gif-reg-id a+d)
-                                                        :regs12 (gif-reg-id a+d)
-                                                        :regs13 (gif-reg-id a+d)
-                                                        :regs14 (gif-reg-id a+d)
-                                                        :regs15 (gif-reg-id a+d)
-                                                        )
-                  )
+            (set! (-> (the-as gs-gif-tag a2-29) regs) GIF_REGS_ALL_AD)
             (set! (-> a1-46 base) (&+ (the-as pointer a2-29) 16))
             )
           (let* ((a1-47 arg0)
@@ -367,25 +277,7 @@
                  (a2-39 (the-as object (-> a1-53 base)))
                  )
             (set! (-> (the-as gs-gif-tag a2-39) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-            (set! (-> (the-as gs-gif-tag a2-39) regs) (new 'static 'gif-tag-regs
-                                                        :regs0 (gif-reg-id a+d)
-                                                        :regs1 (gif-reg-id a+d)
-                                                        :regs2 (gif-reg-id a+d)
-                                                        :regs3 (gif-reg-id a+d)
-                                                        :regs4 (gif-reg-id a+d)
-                                                        :regs5 (gif-reg-id a+d)
-                                                        :regs6 (gif-reg-id a+d)
-                                                        :regs7 (gif-reg-id a+d)
-                                                        :regs8 (gif-reg-id a+d)
-                                                        :regs9 (gif-reg-id a+d)
-                                                        :regs10 (gif-reg-id a+d)
-                                                        :regs11 (gif-reg-id a+d)
-                                                        :regs12 (gif-reg-id a+d)
-                                                        :regs13 (gif-reg-id a+d)
-                                                        :regs14 (gif-reg-id a+d)
-                                                        :regs15 (gif-reg-id a+d)
-                                                        )
-                  )
+            (set! (-> (the-as gs-gif-tag a2-39) regs) GIF_REGS_ALL_AD)
             (set! (-> a1-53 base) (&+ (the-as pointer a2-39) 16))
             )
           (let* ((a1-54 arg0)
@@ -428,25 +320,7 @@
            (a0-52 (the-as object (-> v1-40 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-52) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-52) regs) (new 'static 'gif-tag-regs
-                                                  :regs0 (gif-reg-id a+d)
-                                                  :regs1 (gif-reg-id a+d)
-                                                  :regs2 (gif-reg-id a+d)
-                                                  :regs3 (gif-reg-id a+d)
-                                                  :regs4 (gif-reg-id a+d)
-                                                  :regs5 (gif-reg-id a+d)
-                                                  :regs6 (gif-reg-id a+d)
-                                                  :regs7 (gif-reg-id a+d)
-                                                  :regs8 (gif-reg-id a+d)
-                                                  :regs9 (gif-reg-id a+d)
-                                                  :regs10 (gif-reg-id a+d)
-                                                  :regs11 (gif-reg-id a+d)
-                                                  :regs12 (gif-reg-id a+d)
-                                                  :regs13 (gif-reg-id a+d)
-                                                  :regs14 (gif-reg-id a+d)
-                                                  :regs15 (gif-reg-id a+d)
-                                                  )
-            )
+      (set! (-> (the-as gs-gif-tag a0-52) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-40 base) (&+ (the-as pointer a0-52) 16))
       )
     (let* ((v1-41 arg0)
@@ -492,25 +366,7 @@
                (a2-49 (the-as object (-> a1-71 base)))
                )
           (set! (-> (the-as gs-gif-tag a2-49) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-          (set! (-> (the-as gs-gif-tag a2-49) regs) (new 'static 'gif-tag-regs
-                                                      :regs0 (gif-reg-id a+d)
-                                                      :regs1 (gif-reg-id a+d)
-                                                      :regs2 (gif-reg-id a+d)
-                                                      :regs3 (gif-reg-id a+d)
-                                                      :regs4 (gif-reg-id a+d)
-                                                      :regs5 (gif-reg-id a+d)
-                                                      :regs6 (gif-reg-id a+d)
-                                                      :regs7 (gif-reg-id a+d)
-                                                      :regs8 (gif-reg-id a+d)
-                                                      :regs9 (gif-reg-id a+d)
-                                                      :regs10 (gif-reg-id a+d)
-                                                      :regs11 (gif-reg-id a+d)
-                                                      :regs12 (gif-reg-id a+d)
-                                                      :regs13 (gif-reg-id a+d)
-                                                      :regs14 (gif-reg-id a+d)
-                                                      :regs15 (gif-reg-id a+d)
-                                                      )
-                )
+          (set! (-> (the-as gs-gif-tag a2-49) regs) GIF_REGS_ALL_AD)
           (set! (-> a1-71 base) (&+ (the-as pointer a2-49) 16))
           )
         (let* ((a1-72 arg0)
@@ -555,25 +411,7 @@
                (a2-59 (the-as object (-> a1-81 base)))
                )
           (set! (-> (the-as gs-gif-tag a2-59) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-          (set! (-> (the-as gs-gif-tag a2-59) regs) (new 'static 'gif-tag-regs
-                                                      :regs0 (gif-reg-id a+d)
-                                                      :regs1 (gif-reg-id a+d)
-                                                      :regs2 (gif-reg-id a+d)
-                                                      :regs3 (gif-reg-id a+d)
-                                                      :regs4 (gif-reg-id a+d)
-                                                      :regs5 (gif-reg-id a+d)
-                                                      :regs6 (gif-reg-id a+d)
-                                                      :regs7 (gif-reg-id a+d)
-                                                      :regs8 (gif-reg-id a+d)
-                                                      :regs9 (gif-reg-id a+d)
-                                                      :regs10 (gif-reg-id a+d)
-                                                      :regs11 (gif-reg-id a+d)
-                                                      :regs12 (gif-reg-id a+d)
-                                                      :regs13 (gif-reg-id a+d)
-                                                      :regs14 (gif-reg-id a+d)
-                                                      :regs15 (gif-reg-id a+d)
-                                                      )
-                )
+          (set! (-> (the-as gs-gif-tag a2-59) regs) GIF_REGS_ALL_AD)
           (set! (-> a1-81 base) (&+ (the-as pointer a2-59) 16))
           )
         (let* ((a1-82 arg0)
@@ -628,25 +466,7 @@
            (a0-6 (the-as object (-> v1-4 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-6) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-6) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag a0-6) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-4 base) (&+ (the-as pointer a0-6) 16))
       )
     (let* ((v1-5 s5-0)
@@ -689,25 +509,7 @@
            (a0-21 (the-as object (-> v1-16 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-21) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-21) regs) (new 'static 'gif-tag-regs
-                                                  :regs0 (gif-reg-id a+d)
-                                                  :regs1 (gif-reg-id a+d)
-                                                  :regs2 (gif-reg-id a+d)
-                                                  :regs3 (gif-reg-id a+d)
-                                                  :regs4 (gif-reg-id a+d)
-                                                  :regs5 (gif-reg-id a+d)
-                                                  :regs6 (gif-reg-id a+d)
-                                                  :regs7 (gif-reg-id a+d)
-                                                  :regs8 (gif-reg-id a+d)
-                                                  :regs9 (gif-reg-id a+d)
-                                                  :regs10 (gif-reg-id a+d)
-                                                  :regs11 (gif-reg-id a+d)
-                                                  :regs12 (gif-reg-id a+d)
-                                                  :regs13 (gif-reg-id a+d)
-                                                  :regs14 (gif-reg-id a+d)
-                                                  :regs15 (gif-reg-id a+d)
-                                                  )
-            )
+      (set! (-> (the-as gs-gif-tag a0-21) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-16 base) (&+ (the-as pointer a0-21) 16))
       )
     (let* ((v1-17 s5-1)
@@ -750,25 +552,7 @@
            (a0-36 (the-as object (-> v1-28 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-36) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-36) regs) (new 'static 'gif-tag-regs
-                                                  :regs0 (gif-reg-id a+d)
-                                                  :regs1 (gif-reg-id a+d)
-                                                  :regs2 (gif-reg-id a+d)
-                                                  :regs3 (gif-reg-id a+d)
-                                                  :regs4 (gif-reg-id a+d)
-                                                  :regs5 (gif-reg-id a+d)
-                                                  :regs6 (gif-reg-id a+d)
-                                                  :regs7 (gif-reg-id a+d)
-                                                  :regs8 (gif-reg-id a+d)
-                                                  :regs9 (gif-reg-id a+d)
-                                                  :regs10 (gif-reg-id a+d)
-                                                  :regs11 (gif-reg-id a+d)
-                                                  :regs12 (gif-reg-id a+d)
-                                                  :regs13 (gif-reg-id a+d)
-                                                  :regs14 (gif-reg-id a+d)
-                                                  :regs15 (gif-reg-id a+d)
-                                                  )
-            )
+      (set! (-> (the-as gs-gif-tag a0-36) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-28 base) (&+ (the-as pointer a0-36) 16))
       )
     (let* ((v1-29 s5-2)
@@ -890,25 +674,7 @@
            (a0-87 (the-as object (-> v1-81 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-87) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-87) regs) (new 'static 'gif-tag-regs
-                                                  :regs0 (gif-reg-id a+d)
-                                                  :regs1 (gif-reg-id a+d)
-                                                  :regs2 (gif-reg-id a+d)
-                                                  :regs3 (gif-reg-id a+d)
-                                                  :regs4 (gif-reg-id a+d)
-                                                  :regs5 (gif-reg-id a+d)
-                                                  :regs6 (gif-reg-id a+d)
-                                                  :regs7 (gif-reg-id a+d)
-                                                  :regs8 (gif-reg-id a+d)
-                                                  :regs9 (gif-reg-id a+d)
-                                                  :regs10 (gif-reg-id a+d)
-                                                  :regs11 (gif-reg-id a+d)
-                                                  :regs12 (gif-reg-id a+d)
-                                                  :regs13 (gif-reg-id a+d)
-                                                  :regs14 (gif-reg-id a+d)
-                                                  :regs15 (gif-reg-id a+d)
-                                                  )
-            )
+      (set! (-> (the-as gs-gif-tag a0-87) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-81 base) (&+ (the-as pointer a0-87) 16))
       )
     (let* ((v1-82 s5-4)
@@ -949,25 +715,7 @@
            (a0-102 (the-as object (-> v1-93 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-102) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-102) regs) (new 'static 'gif-tag-regs
-                                                   :regs0 (gif-reg-id a+d)
-                                                   :regs1 (gif-reg-id a+d)
-                                                   :regs2 (gif-reg-id a+d)
-                                                   :regs3 (gif-reg-id a+d)
-                                                   :regs4 (gif-reg-id a+d)
-                                                   :regs5 (gif-reg-id a+d)
-                                                   :regs6 (gif-reg-id a+d)
-                                                   :regs7 (gif-reg-id a+d)
-                                                   :regs8 (gif-reg-id a+d)
-                                                   :regs9 (gif-reg-id a+d)
-                                                   :regs10 (gif-reg-id a+d)
-                                                   :regs11 (gif-reg-id a+d)
-                                                   :regs12 (gif-reg-id a+d)
-                                                   :regs13 (gif-reg-id a+d)
-                                                   :regs14 (gif-reg-id a+d)
-                                                   :regs15 (gif-reg-id a+d)
-                                                   )
-            )
+      (set! (-> (the-as gs-gif-tag a0-102) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-93 base) (&+ (the-as pointer a0-102) 16))
       )
     (let* ((v1-94 s5-5)
@@ -1008,25 +756,7 @@
            (a0-117 (the-as object (-> v1-105 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-117) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-117) regs) (new 'static 'gif-tag-regs
-                                                   :regs0 (gif-reg-id a+d)
-                                                   :regs1 (gif-reg-id a+d)
-                                                   :regs2 (gif-reg-id a+d)
-                                                   :regs3 (gif-reg-id a+d)
-                                                   :regs4 (gif-reg-id a+d)
-                                                   :regs5 (gif-reg-id a+d)
-                                                   :regs6 (gif-reg-id a+d)
-                                                   :regs7 (gif-reg-id a+d)
-                                                   :regs8 (gif-reg-id a+d)
-                                                   :regs9 (gif-reg-id a+d)
-                                                   :regs10 (gif-reg-id a+d)
-                                                   :regs11 (gif-reg-id a+d)
-                                                   :regs12 (gif-reg-id a+d)
-                                                   :regs13 (gif-reg-id a+d)
-                                                   :regs14 (gif-reg-id a+d)
-                                                   :regs15 (gif-reg-id a+d)
-                                                   )
-            )
+      (set! (-> (the-as gs-gif-tag a0-117) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-105 base) (&+ (the-as pointer a0-117) 16))
       )
     (let* ((v1-106 s5-6)
diff --git a/test/decompiler/reference/jak1/engine/gfx/generic/generic-vu1_REF.gc b/test/decompiler/reference/jak1/engine/gfx/generic/generic-vu1_REF.gc
index 792645b72c..50ea707c36 100644
--- a/test/decompiler/reference/jak1/engine/gfx/generic/generic-vu1_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/generic/generic-vu1_REF.gc
@@ -68,25 +68,7 @@
            (a0-4 (the-as gs-gif-tag (-> v1-4 base)))
            )
       (set! (-> a0-4 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-      (set! (-> a0-4 regs) (new 'static 'gif-tag-regs
-                             :regs0 (gif-reg-id a+d)
-                             :regs1 (gif-reg-id a+d)
-                             :regs2 (gif-reg-id a+d)
-                             :regs3 (gif-reg-id a+d)
-                             :regs4 (gif-reg-id a+d)
-                             :regs5 (gif-reg-id a+d)
-                             :regs6 (gif-reg-id a+d)
-                             :regs7 (gif-reg-id a+d)
-                             :regs8 (gif-reg-id a+d)
-                             :regs9 (gif-reg-id a+d)
-                             :regs10 (gif-reg-id a+d)
-                             :regs11 (gif-reg-id a+d)
-                             :regs12 (gif-reg-id a+d)
-                             :regs13 (gif-reg-id a+d)
-                             :regs14 (gif-reg-id a+d)
-                             :regs15 (gif-reg-id a+d)
-                             )
-            )
+      (set! (-> a0-4 regs) GIF_REGS_ALL_AD)
       (set! (-> v1-4 base) (the-as pointer (&+ a0-4 16)))
       )
     (let* ((v1-5 arg0)
diff --git a/test/decompiler/reference/jak1/engine/gfx/hw/display_REF.gc b/test/decompiler/reference/jak1/engine/gfx/hw/display_REF.gc
index 6cb190bb94..443f503617 100644
--- a/test/decompiler/reference/jak1/engine/gfx/hw/display_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/hw/display_REF.gc
@@ -562,25 +562,7 @@
            (gif (the-as gs-gif-tag (-> v1-2 base)))
            )
       (set! (-> gif tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-      (set! (-> gif regs) (new 'static 'gif-tag-regs
-                            :regs0 (gif-reg-id a+d)
-                            :regs1 (gif-reg-id a+d)
-                            :regs2 (gif-reg-id a+d)
-                            :regs3 (gif-reg-id a+d)
-                            :regs4 (gif-reg-id a+d)
-                            :regs5 (gif-reg-id a+d)
-                            :regs6 (gif-reg-id a+d)
-                            :regs7 (gif-reg-id a+d)
-                            :regs8 (gif-reg-id a+d)
-                            :regs9 (gif-reg-id a+d)
-                            :regs10 (gif-reg-id a+d)
-                            :regs11 (gif-reg-id a+d)
-                            :regs12 (gif-reg-id a+d)
-                            :regs13 (gif-reg-id a+d)
-                            :regs14 (gif-reg-id a+d)
-                            :regs15 (gif-reg-id a+d)
-                            )
-            )
+      (set! (-> gif regs) GIF_REGS_ALL_AD)
       (set! (-> v1-2 base) (&+ (the-as pointer gif) 16))
       )
     (let* ((v1-3 dma-buf)
@@ -627,25 +609,7 @@
            (gif (the-as gs-gif-tag (-> v1-2 base)))
            )
       (set! (-> gif tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-      (set! (-> gif regs) (new 'static 'gif-tag-regs
-                            :regs0 (gif-reg-id a+d)
-                            :regs1 (gif-reg-id a+d)
-                            :regs2 (gif-reg-id a+d)
-                            :regs3 (gif-reg-id a+d)
-                            :regs4 (gif-reg-id a+d)
-                            :regs5 (gif-reg-id a+d)
-                            :regs6 (gif-reg-id a+d)
-                            :regs7 (gif-reg-id a+d)
-                            :regs8 (gif-reg-id a+d)
-                            :regs9 (gif-reg-id a+d)
-                            :regs10 (gif-reg-id a+d)
-                            :regs11 (gif-reg-id a+d)
-                            :regs12 (gif-reg-id a+d)
-                            :regs13 (gif-reg-id a+d)
-                            :regs14 (gif-reg-id a+d)
-                            :regs15 (gif-reg-id a+d)
-                            )
-            )
+      (set! (-> gif regs) GIF_REGS_ALL_AD)
       (set! (-> v1-2 base) (&+ (the-as pointer gif) 16))
       )
     (let* ((v1-3 dma-buf)
@@ -697,25 +661,7 @@
            (gif (the-as gs-gif-tag (-> a3-2 base)))
            )
       (set! (-> gif tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-      (set! (-> gif regs) (new 'static 'gif-tag-regs
-                            :regs0 (gif-reg-id a+d)
-                            :regs1 (gif-reg-id a+d)
-                            :regs2 (gif-reg-id a+d)
-                            :regs3 (gif-reg-id a+d)
-                            :regs4 (gif-reg-id a+d)
-                            :regs5 (gif-reg-id a+d)
-                            :regs6 (gif-reg-id a+d)
-                            :regs7 (gif-reg-id a+d)
-                            :regs8 (gif-reg-id a+d)
-                            :regs9 (gif-reg-id a+d)
-                            :regs10 (gif-reg-id a+d)
-                            :regs11 (gif-reg-id a+d)
-                            :regs12 (gif-reg-id a+d)
-                            :regs13 (gif-reg-id a+d)
-                            :regs14 (gif-reg-id a+d)
-                            :regs15 (gif-reg-id a+d)
-                            )
-            )
+      (set! (-> gif regs) GIF_REGS_ALL_AD)
       (set! (-> a3-2 base) (&+ (the-as pointer gif) 16))
       )
     (let ((gif-data (the-as (pointer uint64) (-> dma-buf base))))
diff --git a/test/decompiler/reference/jak1/engine/gfx/hw/gs_REF.gc b/test/decompiler/reference/jak1/engine/gfx/hw/gs_REF.gc
index 8e960cccad..d161b73a04 100644
--- a/test/decompiler/reference/jak1/engine/gfx/hw/gs_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/hw/gs_REF.gc
@@ -805,25 +805,7 @@
          (gif-tag (the-as gs-gif-tag (-> buff-ptr5 base)))
          )
     (set! (-> gif-tag tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x9))
-    (set! (-> gif-tag regs) (new 'static 'gif-tag-regs
-                              :regs0 (gif-reg-id a+d)
-                              :regs1 (gif-reg-id a+d)
-                              :regs2 (gif-reg-id a+d)
-                              :regs3 (gif-reg-id a+d)
-                              :regs4 (gif-reg-id a+d)
-                              :regs5 (gif-reg-id a+d)
-                              :regs6 (gif-reg-id a+d)
-                              :regs7 (gif-reg-id a+d)
-                              :regs8 (gif-reg-id a+d)
-                              :regs9 (gif-reg-id a+d)
-                              :regs10 (gif-reg-id a+d)
-                              :regs11 (gif-reg-id a+d)
-                              :regs12 (gif-reg-id a+d)
-                              :regs13 (gif-reg-id a+d)
-                              :regs14 (gif-reg-id a+d)
-                              :regs15 (gif-reg-id a+d)
-                              )
-          )
+    (set! (-> gif-tag regs) GIF_REGS_ALL_AD)
     (set! (-> buff-ptr5 base) (&+ (the-as pointer gif-tag) 16))
     )
   (let* ((buff-ptr3 buff)
diff --git a/test/decompiler/reference/jak1/engine/gfx/merc/merc_REF.gc b/test/decompiler/reference/jak1/engine/gfx/merc/merc_REF.gc
index 818d32c043..131634956e 100644
--- a/test/decompiler/reference/jak1/engine/gfx/merc/merc_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/merc/merc_REF.gc
@@ -445,25 +445,7 @@
                (a0-8 (the-as object (-> v1-9 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-8) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-          (set! (-> (the-as gs-gif-tag a0-8) regs) (new 'static 'gif-tag-regs
-                                                     :regs0 (gif-reg-id a+d)
-                                                     :regs1 (gif-reg-id a+d)
-                                                     :regs2 (gif-reg-id a+d)
-                                                     :regs3 (gif-reg-id a+d)
-                                                     :regs4 (gif-reg-id a+d)
-                                                     :regs5 (gif-reg-id a+d)
-                                                     :regs6 (gif-reg-id a+d)
-                                                     :regs7 (gif-reg-id a+d)
-                                                     :regs8 (gif-reg-id a+d)
-                                                     :regs9 (gif-reg-id a+d)
-                                                     :regs10 (gif-reg-id a+d)
-                                                     :regs11 (gif-reg-id a+d)
-                                                     :regs12 (gif-reg-id a+d)
-                                                     :regs13 (gif-reg-id a+d)
-                                                     :regs14 (gif-reg-id a+d)
-                                                     :regs15 (gif-reg-id a+d)
-                                                     )
-                )
+          (set! (-> (the-as gs-gif-tag a0-8) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-9 base) (&+ (the-as pointer a0-8) 16))
           )
         (let* ((v1-10 dma-buf)
diff --git a/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-near_REF.gc b/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-near_REF.gc
index 229a57508f..ecbed78cdc 100644
--- a/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-near_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-near_REF.gc
@@ -649,25 +649,7 @@
          (a0-3 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a0-3) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-    (set! (-> (the-as gs-gif-tag a0-3) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a0-3) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (the-as pointer (the-as dma-packet (&+ (the-as pointer a0-3) 16))))
     )
   (let* ((v1-2 arg0)
diff --git a/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-texture_REF.gc b/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-texture_REF.gc
index fb8e2cfdf4..dda6b38e19 100644
--- a/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-texture_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/ocean/ocean-texture_REF.gc
@@ -243,25 +243,7 @@
              (a0-17 (the-as object (-> v1-14 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-17) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x6))
-        (set! (-> (the-as gs-gif-tag a0-17) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag a0-17) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-14 base) (&+ (the-as pointer a0-17) 16))
         )
       (let* ((s1-1 arg0)
@@ -308,25 +290,7 @@
              (a0-37 (the-as object (-> v1-36 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-37) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> (the-as gs-gif-tag a0-37) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag a0-37) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-36 base) (&+ (the-as pointer a0-37) 16))
         )
       (let* ((s3-1 arg0)
@@ -362,25 +326,7 @@
              (a0-56 (the-as object (-> v1-51 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-56) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> (the-as gs-gif-tag a0-56) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag a0-56) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-51 base) (&+ (the-as pointer a0-56) 16))
         )
       (let* ((s4-3 arg0)
@@ -416,25 +362,7 @@
              (a0-75 (the-as object (-> v1-66 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-75) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> (the-as gs-gif-tag a0-75) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag a0-75) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-66 base) (&+ (the-as pointer a0-75) 16))
         )
       (let* ((s4-4 arg0)
@@ -470,25 +398,7 @@
              (a0-95 (the-as object (-> v1-81 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-95) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> (the-as gs-gif-tag a0-95) regs) (new 'static 'gif-tag-regs
-                                                    :regs0 (gif-reg-id a+d)
-                                                    :regs1 (gif-reg-id a+d)
-                                                    :regs2 (gif-reg-id a+d)
-                                                    :regs3 (gif-reg-id a+d)
-                                                    :regs4 (gif-reg-id a+d)
-                                                    :regs5 (gif-reg-id a+d)
-                                                    :regs6 (gif-reg-id a+d)
-                                                    :regs7 (gif-reg-id a+d)
-                                                    :regs8 (gif-reg-id a+d)
-                                                    :regs9 (gif-reg-id a+d)
-                                                    :regs10 (gif-reg-id a+d)
-                                                    :regs11 (gif-reg-id a+d)
-                                                    :regs12 (gif-reg-id a+d)
-                                                    :regs13 (gif-reg-id a+d)
-                                                    :regs14 (gif-reg-id a+d)
-                                                    :regs15 (gif-reg-id a+d)
-                                                    )
-              )
+        (set! (-> (the-as gs-gif-tag a0-95) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-81 base) (&+ (the-as pointer a0-95) 16))
         )
       (let* ((s4-5 arg0)
@@ -524,25 +434,7 @@
              (a0-115 (the-as object (-> v1-96 base)))
              )
         (set! (-> (the-as gs-gif-tag a0-115) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> (the-as gs-gif-tag a0-115) regs) (new 'static 'gif-tag-regs
-                                                     :regs0 (gif-reg-id a+d)
-                                                     :regs1 (gif-reg-id a+d)
-                                                     :regs2 (gif-reg-id a+d)
-                                                     :regs3 (gif-reg-id a+d)
-                                                     :regs4 (gif-reg-id a+d)
-                                                     :regs5 (gif-reg-id a+d)
-                                                     :regs6 (gif-reg-id a+d)
-                                                     :regs7 (gif-reg-id a+d)
-                                                     :regs8 (gif-reg-id a+d)
-                                                     :regs9 (gif-reg-id a+d)
-                                                     :regs10 (gif-reg-id a+d)
-                                                     :regs11 (gif-reg-id a+d)
-                                                     :regs12 (gif-reg-id a+d)
-                                                     :regs13 (gif-reg-id a+d)
-                                                     :regs14 (gif-reg-id a+d)
-                                                     :regs15 (gif-reg-id a+d)
-                                                     )
-              )
+        (set! (-> (the-as gs-gif-tag a0-115) regs) GIF_REGS_ALL_AD)
         (set! (-> v1-96 base) (&+ (the-as pointer a0-115) 16))
         )
       (let* ((s4-6 arg0)
diff --git a/test/decompiler/reference/jak1/engine/gfx/sky/sky-tng_REF.gc b/test/decompiler/reference/jak1/engine/gfx/sky/sky-tng_REF.gc
index f7aa2c42d0..405f356d1a 100644
--- a/test/decompiler/reference/jak1/engine/gfx/sky/sky-tng_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/sky/sky-tng_REF.gc
@@ -600,25 +600,7 @@
                (a0-13 (the-as object (-> v1-15 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-13) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x3))
-          (set! (-> (the-as gs-gif-tag a0-13) regs) (new 'static 'gif-tag-regs
-                                                      :regs0 (gif-reg-id a+d)
-                                                      :regs1 (gif-reg-id a+d)
-                                                      :regs2 (gif-reg-id a+d)
-                                                      :regs3 (gif-reg-id a+d)
-                                                      :regs4 (gif-reg-id a+d)
-                                                      :regs5 (gif-reg-id a+d)
-                                                      :regs6 (gif-reg-id a+d)
-                                                      :regs7 (gif-reg-id a+d)
-                                                      :regs8 (gif-reg-id a+d)
-                                                      :regs9 (gif-reg-id a+d)
-                                                      :regs10 (gif-reg-id a+d)
-                                                      :regs11 (gif-reg-id a+d)
-                                                      :regs12 (gif-reg-id a+d)
-                                                      :regs13 (gif-reg-id a+d)
-                                                      :regs14 (gif-reg-id a+d)
-                                                      :regs15 (gif-reg-id a+d)
-                                                      )
-                )
+          (set! (-> (the-as gs-gif-tag a0-13) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-15 base) (&+ (the-as pointer a0-13) 16))
           )
         (let* ((v1-16 s4-0)
@@ -649,25 +631,7 @@
                  (a0-19 (the-as object (-> v1-21 base)))
                  )
             (set! (-> (the-as gs-gif-tag a0-19) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
-            (set! (-> (the-as gs-gif-tag a0-19) regs) (new 'static 'gif-tag-regs
-                                                        :regs0 (gif-reg-id a+d)
-                                                        :regs1 (gif-reg-id a+d)
-                                                        :regs2 (gif-reg-id a+d)
-                                                        :regs3 (gif-reg-id a+d)
-                                                        :regs4 (gif-reg-id a+d)
-                                                        :regs5 (gif-reg-id a+d)
-                                                        :regs6 (gif-reg-id a+d)
-                                                        :regs7 (gif-reg-id a+d)
-                                                        :regs8 (gif-reg-id a+d)
-                                                        :regs9 (gif-reg-id a+d)
-                                                        :regs10 (gif-reg-id a+d)
-                                                        :regs11 (gif-reg-id a+d)
-                                                        :regs12 (gif-reg-id a+d)
-                                                        :regs13 (gif-reg-id a+d)
-                                                        :regs14 (gif-reg-id a+d)
-                                                        :regs15 (gif-reg-id a+d)
-                                                        )
-                  )
+            (set! (-> (the-as gs-gif-tag a0-19) regs) GIF_REGS_ALL_AD)
             (set! (-> v1-21 base) (&+ (the-as pointer a0-19) 16))
             )
           (let* ((s3-0 s4-0)
@@ -714,25 +678,7 @@
                  (a0-34 (the-as object (-> v1-53 base)))
                  )
             (set! (-> (the-as gs-gif-tag a0-34) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x5))
-            (set! (-> (the-as gs-gif-tag a0-34) regs) (new 'static 'gif-tag-regs
-                                                        :regs0 (gif-reg-id a+d)
-                                                        :regs1 (gif-reg-id a+d)
-                                                        :regs2 (gif-reg-id a+d)
-                                                        :regs3 (gif-reg-id a+d)
-                                                        :regs4 (gif-reg-id a+d)
-                                                        :regs5 (gif-reg-id a+d)
-                                                        :regs6 (gif-reg-id a+d)
-                                                        :regs7 (gif-reg-id a+d)
-                                                        :regs8 (gif-reg-id a+d)
-                                                        :regs9 (gif-reg-id a+d)
-                                                        :regs10 (gif-reg-id a+d)
-                                                        :regs11 (gif-reg-id a+d)
-                                                        :regs12 (gif-reg-id a+d)
-                                                        :regs13 (gif-reg-id a+d)
-                                                        :regs14 (gif-reg-id a+d)
-                                                        :regs15 (gif-reg-id a+d)
-                                                        )
-                  )
+            (set! (-> (the-as gs-gif-tag a0-34) regs) GIF_REGS_ALL_AD)
             (set! (-> v1-53 base) (&+ (the-as pointer a0-34) 16))
             )
           (let* ((s3-2 s4-0)
@@ -945,25 +891,7 @@
                      (a0-21 (the-as object (-> v1-32 base)))
                      )
                 (set! (-> (the-as gs-gif-tag a0-21) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-                (set! (-> (the-as gs-gif-tag a0-21) regs) (new 'static 'gif-tag-regs
-                                                            :regs0 (gif-reg-id a+d)
-                                                            :regs1 (gif-reg-id a+d)
-                                                            :regs2 (gif-reg-id a+d)
-                                                            :regs3 (gif-reg-id a+d)
-                                                            :regs4 (gif-reg-id a+d)
-                                                            :regs5 (gif-reg-id a+d)
-                                                            :regs6 (gif-reg-id a+d)
-                                                            :regs7 (gif-reg-id a+d)
-                                                            :regs8 (gif-reg-id a+d)
-                                                            :regs9 (gif-reg-id a+d)
-                                                            :regs10 (gif-reg-id a+d)
-                                                            :regs11 (gif-reg-id a+d)
-                                                            :regs12 (gif-reg-id a+d)
-                                                            :regs13 (gif-reg-id a+d)
-                                                            :regs14 (gif-reg-id a+d)
-                                                            :regs15 (gif-reg-id a+d)
-                                                            )
-                      )
+                (set! (-> (the-as gs-gif-tag a0-21) regs) GIF_REGS_ALL_AD)
                 (set! (-> v1-32 base) (&+ (the-as pointer a0-21) 16))
                 )
               (let* ((v1-33 s2-0)
diff --git a/test/decompiler/reference/jak1/engine/gfx/sprite/sprite-distort_REF.gc b/test/decompiler/reference/jak1/engine/gfx/sprite/sprite-distort_REF.gc
index 15ad8e455f..bd6a5f7af5 100644
--- a/test/decompiler/reference/jak1/engine/gfx/sprite/sprite-distort_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/sprite/sprite-distort_REF.gc
@@ -117,25 +117,7 @@
          (a2-2 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a2-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x6))
-    (set! (-> (the-as gs-gif-tag a2-2) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a2-2) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a2-2) 16))
     )
   (let* ((v1-2 arg0)
diff --git a/test/decompiler/reference/jak1/engine/gfx/sprite/sprite_REF.gc b/test/decompiler/reference/jak1/engine/gfx/sprite/sprite_REF.gc
index 7cc60ff779..a664596644 100644
--- a/test/decompiler/reference/jak1/engine/gfx/sprite/sprite_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/sprite/sprite_REF.gc
@@ -850,25 +850,7 @@
              (giftag (the-as gs-gif-tag (-> v1-14 base)))
              )
         (set! (-> giftag tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> giftag regs) (new 'static 'gif-tag-regs
-                                 :regs0 (gif-reg-id a+d)
-                                 :regs1 (gif-reg-id a+d)
-                                 :regs2 (gif-reg-id a+d)
-                                 :regs3 (gif-reg-id a+d)
-                                 :regs4 (gif-reg-id a+d)
-                                 :regs5 (gif-reg-id a+d)
-                                 :regs6 (gif-reg-id a+d)
-                                 :regs7 (gif-reg-id a+d)
-                                 :regs8 (gif-reg-id a+d)
-                                 :regs9 (gif-reg-id a+d)
-                                 :regs10 (gif-reg-id a+d)
-                                 :regs11 (gif-reg-id a+d)
-                                 :regs12 (gif-reg-id a+d)
-                                 :regs13 (gif-reg-id a+d)
-                                 :regs14 (gif-reg-id a+d)
-                                 :regs15 (gif-reg-id a+d)
-                                 )
-              )
+        (set! (-> giftag regs) GIF_REGS_ALL_AD)
         (set! (-> v1-14 base) (&+ (the-as pointer giftag) 16))
         )
       (let* ((v1-15 dma-buff)
diff --git a/test/decompiler/reference/jak1/engine/gfx/texture_REF.gc b/test/decompiler/reference/jak1/engine/gfx/texture_REF.gc
index d6af9fd8b4..bcf253f44a 100644
--- a/test/decompiler/reference/jak1/engine/gfx/texture_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/texture_REF.gc
@@ -926,25 +926,7 @@
              (gif (the-as gs-gif-tag (-> v1-48 base)))
              )
         (set! (-> gif tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-        (set! (-> gif regs) (new 'static 'gif-tag-regs
-                              :regs0 (gif-reg-id a+d)
-                              :regs1 (gif-reg-id a+d)
-                              :regs2 (gif-reg-id a+d)
-                              :regs3 (gif-reg-id a+d)
-                              :regs4 (gif-reg-id a+d)
-                              :regs5 (gif-reg-id a+d)
-                              :regs6 (gif-reg-id a+d)
-                              :regs7 (gif-reg-id a+d)
-                              :regs8 (gif-reg-id a+d)
-                              :regs9 (gif-reg-id a+d)
-                              :regs10 (gif-reg-id a+d)
-                              :regs11 (gif-reg-id a+d)
-                              :regs12 (gif-reg-id a+d)
-                              :regs13 (gif-reg-id a+d)
-                              :regs14 (gif-reg-id a+d)
-                              :regs15 (gif-reg-id a+d)
-                              )
-              )
+        (set! (-> gif regs) GIF_REGS_ALL_AD)
         (set! (-> v1-48 base) (&+ (the-as pointer gif) 16))
         )
       (let* ((v1-49 dma-buf)
@@ -1103,25 +1085,7 @@
              (gif (the-as gs-gif-tag (-> v1-53 base)))
              )
         (set! (-> gif tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-        (set! (-> gif regs) (new 'static 'gif-tag-regs
-                              :regs0 (gif-reg-id a+d)
-                              :regs1 (gif-reg-id a+d)
-                              :regs2 (gif-reg-id a+d)
-                              :regs3 (gif-reg-id a+d)
-                              :regs4 (gif-reg-id a+d)
-                              :regs5 (gif-reg-id a+d)
-                              :regs6 (gif-reg-id a+d)
-                              :regs7 (gif-reg-id a+d)
-                              :regs8 (gif-reg-id a+d)
-                              :regs9 (gif-reg-id a+d)
-                              :regs10 (gif-reg-id a+d)
-                              :regs11 (gif-reg-id a+d)
-                              :regs12 (gif-reg-id a+d)
-                              :regs13 (gif-reg-id a+d)
-                              :regs14 (gif-reg-id a+d)
-                              :regs15 (gif-reg-id a+d)
-                              )
-              )
+        (set! (-> gif regs) GIF_REGS_ALL_AD)
         (set! (-> v1-53 base) (&+ (the-as pointer gif) 16))
         )
       (let* ((v1-54 dma-buf)
@@ -1830,25 +1794,7 @@
            (a0-3 (the-as object (-> v1-4 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-3) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-3) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag a0-3) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-4 base) (&+ (the-as pointer a0-3) 16))
       )
     (let* ((v1-5 gp-0)
@@ -1956,25 +1902,7 @@
              (gs-pkt (the-as gs-gif-tag (-> t3-3 base)))
              )
         (set! (-> gs-pkt tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
-        (set! (-> gs-pkt regs) (new 'static 'gif-tag-regs
-                                 :regs0 (gif-reg-id a+d)
-                                 :regs1 (gif-reg-id a+d)
-                                 :regs2 (gif-reg-id a+d)
-                                 :regs3 (gif-reg-id a+d)
-                                 :regs4 (gif-reg-id a+d)
-                                 :regs5 (gif-reg-id a+d)
-                                 :regs6 (gif-reg-id a+d)
-                                 :regs7 (gif-reg-id a+d)
-                                 :regs8 (gif-reg-id a+d)
-                                 :regs9 (gif-reg-id a+d)
-                                 :regs10 (gif-reg-id a+d)
-                                 :regs11 (gif-reg-id a+d)
-                                 :regs12 (gif-reg-id a+d)
-                                 :regs13 (gif-reg-id a+d)
-                                 :regs14 (gif-reg-id a+d)
-                                 :regs15 (gif-reg-id a+d)
-                                 )
-              )
+        (set! (-> gs-pkt regs) GIF_REGS_ALL_AD)
         (set! (-> t3-3 base) (&+ (the-as pointer gs-pkt) 16))
         )
       (let* ((t3-4 dma-buff)
@@ -2017,25 +1945,7 @@
             (a2-4 (the-as object (-> v1-8 base)))
             )
        (set! (-> (the-as gs-gif-tag a2-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
-       (set! (-> (the-as gs-gif-tag a2-4) regs) (new 'static 'gif-tag-regs
-                                                  :regs0 (gif-reg-id a+d)
-                                                  :regs1 (gif-reg-id a+d)
-                                                  :regs2 (gif-reg-id a+d)
-                                                  :regs3 (gif-reg-id a+d)
-                                                  :regs4 (gif-reg-id a+d)
-                                                  :regs5 (gif-reg-id a+d)
-                                                  :regs6 (gif-reg-id a+d)
-                                                  :regs7 (gif-reg-id a+d)
-                                                  :regs8 (gif-reg-id a+d)
-                                                  :regs9 (gif-reg-id a+d)
-                                                  :regs10 (gif-reg-id a+d)
-                                                  :regs11 (gif-reg-id a+d)
-                                                  :regs12 (gif-reg-id a+d)
-                                                  :regs13 (gif-reg-id a+d)
-                                                  :regs14 (gif-reg-id a+d)
-                                                  :regs15 (gif-reg-id a+d)
-                                                  )
-             )
+       (set! (-> (the-as gs-gif-tag a2-4) regs) GIF_REGS_ALL_AD)
        (set! (-> v1-8 base) (&+ (the-as pointer a2-4) 16))
        )
      (let* ((v1-9 dma-buff)
@@ -2074,25 +1984,7 @@
             (a2-11 (the-as object (-> v1-14 base)))
             )
        (set! (-> (the-as gs-gif-tag a2-11) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
-       (set! (-> (the-as gs-gif-tag a2-11) regs) (new 'static 'gif-tag-regs
-                                                   :regs0 (gif-reg-id a+d)
-                                                   :regs1 (gif-reg-id a+d)
-                                                   :regs2 (gif-reg-id a+d)
-                                                   :regs3 (gif-reg-id a+d)
-                                                   :regs4 (gif-reg-id a+d)
-                                                   :regs5 (gif-reg-id a+d)
-                                                   :regs6 (gif-reg-id a+d)
-                                                   :regs7 (gif-reg-id a+d)
-                                                   :regs8 (gif-reg-id a+d)
-                                                   :regs9 (gif-reg-id a+d)
-                                                   :regs10 (gif-reg-id a+d)
-                                                   :regs11 (gif-reg-id a+d)
-                                                   :regs12 (gif-reg-id a+d)
-                                                   :regs13 (gif-reg-id a+d)
-                                                   :regs14 (gif-reg-id a+d)
-                                                   :regs15 (gif-reg-id a+d)
-                                                   )
-             )
+       (set! (-> (the-as gs-gif-tag a2-11) regs) GIF_REGS_ALL_AD)
        (set! (-> v1-14 base) (&+ (the-as pointer a2-11) 16))
        )
      (let* ((v1-15 dma-buff)
@@ -2217,25 +2109,7 @@
                (a0-20 (the-as object (-> v1-16 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-20) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-          (set! (-> (the-as gs-gif-tag a0-20) regs) (new 'static 'gif-tag-regs
-                                                      :regs0 (gif-reg-id a+d)
-                                                      :regs1 (gif-reg-id a+d)
-                                                      :regs2 (gif-reg-id a+d)
-                                                      :regs3 (gif-reg-id a+d)
-                                                      :regs4 (gif-reg-id a+d)
-                                                      :regs5 (gif-reg-id a+d)
-                                                      :regs6 (gif-reg-id a+d)
-                                                      :regs7 (gif-reg-id a+d)
-                                                      :regs8 (gif-reg-id a+d)
-                                                      :regs9 (gif-reg-id a+d)
-                                                      :regs10 (gif-reg-id a+d)
-                                                      :regs11 (gif-reg-id a+d)
-                                                      :regs12 (gif-reg-id a+d)
-                                                      :regs13 (gif-reg-id a+d)
-                                                      :regs14 (gif-reg-id a+d)
-                                                      :regs15 (gif-reg-id a+d)
-                                                      )
-                )
+          (set! (-> (the-as gs-gif-tag a0-20) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-16 base) (&+ (the-as pointer a0-20) 16))
           )
         (let* ((v1-17 dma-buff)
diff --git a/test/decompiler/reference/jak1/engine/gfx/tfrag/tfrag_REF.gc b/test/decompiler/reference/jak1/engine/gfx/tfrag/tfrag_REF.gc
index 2e79ddef9a..49c75dba0b 100644
--- a/test/decompiler/reference/jak1/engine/gfx/tfrag/tfrag_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/tfrag/tfrag_REF.gc
@@ -361,25 +361,7 @@
          (a0-4 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a0-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-    (set! (-> (the-as gs-gif-tag a0-4) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a0-4) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a0-4) 16))
     )
   (let* ((v1-2 arg0)
@@ -465,25 +447,7 @@
          (a0-4 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a0-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-    (set! (-> (the-as gs-gif-tag a0-4) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a0-4) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a0-4) 16))
     )
   (let* ((v1-2 arg0)
diff --git a/test/decompiler/reference/jak1/engine/gfx/tie/tie_REF.gc b/test/decompiler/reference/jak1/engine/gfx/tie/tie_REF.gc
index bd9ba4d5c1..5c87d95e20 100644
--- a/test/decompiler/reference/jak1/engine/gfx/tie/tie_REF.gc
+++ b/test/decompiler/reference/jak1/engine/gfx/tie/tie_REF.gc
@@ -375,25 +375,7 @@
            (a0-4 (the-as object (-> v1-4 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a0-4) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag a0-4) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-4 base) (the-as pointer (&+ (the-as gs-gif-tag a0-4) 16)))
       )
     (let* ((v1-5 arg0)
@@ -466,25 +448,7 @@
            (a1-2 (the-as object (-> v1-4 base)))
            )
       (set! (-> (the-as gs-gif-tag a1-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-      (set! (-> (the-as gs-gif-tag a1-2) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag a1-2) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-4 base) (&+ (the-as pointer a1-2) 16))
       )
     (let* ((v1-5 arg0)
diff --git a/test/decompiler/reference/jak1/engine/level/load-boundary_REF.gc b/test/decompiler/reference/jak1/engine/level/load-boundary_REF.gc
index a709627674..f04cff9fbf 100644
--- a/test/decompiler/reference/jak1/engine/level/load-boundary_REF.gc
+++ b/test/decompiler/reference/jak1/engine/level/load-boundary_REF.gc
@@ -348,25 +348,7 @@
            (a0-7 (the-as object (-> v1-9 base)))
            )
       (set! (-> (the-as gs-gif-tag a0-7) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x3))
-      (set! (-> (the-as gs-gif-tag a0-7) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag a0-7) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-9 base) (&+ (the-as pointer a0-7) 16))
       )
     (let* ((v1-10 s5-0)
diff --git a/test/decompiler/reference/jak1/engine/sound/gsound_REF.gc b/test/decompiler/reference/jak1/engine/sound/gsound_REF.gc
index e55bbbb409..ef7d910fd3 100644
--- a/test/decompiler/reference/jak1/engine/sound/gsound_REF.gc
+++ b/test/decompiler/reference/jak1/engine/sound/gsound_REF.gc
@@ -634,7 +634,7 @@
              )
            )
        (when bc
-         (set! sv-32 (string->sound-name (the-as string (-> (the-as (pointer uint32) (+ #xff38 (the-as int bc)))))))
+         (set! sv-32 (string->sound-name (symbol->string bc)))
          (set! sv-48 (res-lump-data (the-as res-lump arg0) 'cycle-speed (pointer float)))
          (set! sv-16 *ambient-spec*)
          (set! sv-64 (new 'static 'res-tag))
@@ -662,7 +662,7 @@
      (set! sv-16 (the-as sound-spec arg0))
      )
     ((symbol)
-     (set! sv-32 (string->sound-name (the-as string (-> (the-as (pointer uint32) (+ #xff38 (the-as int arg0)))))))
+     (set! sv-32 (string->sound-name (symbol->string arg0)))
      )
     ((string)
      (set! sv-32 (string->sound-name (the-as string arg0)))
diff --git a/test/decompiler/reference/jak2/decompiler-macros.gc b/test/decompiler/reference/jak2/decompiler-macros.gc
index eb4cd6f57b..2495aa70d5 100644
--- a/test/decompiler/reference/jak2/decompiler-macros.gc
+++ b/test/decompiler/reference/jak2/decompiler-macros.gc
@@ -898,3 +898,23 @@
   `(ja :eval? #f :chan ,chan :group! ,group! :num! ,num! :param0 ,param0 :param1 ,param1 :num-func ,num-func :frame-num ,frame-num :frame-interp ,frame-interp :dist ,dist)
   )
 
+(defconstant GIF_REGS_ALL_AD
+  (new 'static 'gif-tag-regs
+       :regs0 (gif-reg-id a+d)
+       :regs1 (gif-reg-id a+d)
+       :regs2 (gif-reg-id a+d)
+       :regs3 (gif-reg-id a+d)
+       :regs4 (gif-reg-id a+d)
+       :regs5 (gif-reg-id a+d)
+       :regs6 (gif-reg-id a+d)
+       :regs7 (gif-reg-id a+d)
+       :regs8 (gif-reg-id a+d)
+       :regs9 (gif-reg-id a+d)
+       :regs10 (gif-reg-id a+d)
+       :regs11 (gif-reg-id a+d)
+       :regs12 (gif-reg-id a+d)
+       :regs13 (gif-reg-id a+d)
+       :regs14 (gif-reg-id a+d)
+       :regs15 (gif-reg-id a+d)
+       )
+  )
\ No newline at end of file
diff --git a/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc b/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc
index 69f826f5e8..84772da69d 100644
--- a/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc
+++ b/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc
@@ -279,16 +279,16 @@
 
 ;; definition for function camera-line2d
 (defun camera-line2d ((arg0 vector4w) (arg1 vector4w))
-  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 x) (* (+ (-> arg0 x) 1792) 16))
+  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 x) (the-as int (* (+ (-> arg0 x) 1792) 16)))
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 y)
-        (* (- 2256 (-> (the-as cam-dbg-scratch arg0) linevec4w 0 y)) 16)
+        (the-as int (* (- 2256 (the-as int (-> (the-as cam-dbg-scratch arg0) linevec4w 0 y))) 16))
         )
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 z) #x7fffff)
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1 x)
-        (* (+ (-> (the-as cam-dbg-scratch arg1) linevec4w 0 x) 1792) 16)
+        (the-as int (* (+ (-> (the-as cam-dbg-scratch arg1) linevec4w 0 x) 1792) 16))
         )
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1 y)
-        (* (- 2256 (-> (the-as cam-dbg-scratch arg1) linevec4w 0 y)) 16)
+        (the-as int (* (- 2256 (the-as int (-> (the-as cam-dbg-scratch arg1) linevec4w 0 y))) 16))
         )
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1 z) #x7fffff)
   (cam-line-dma)
@@ -316,11 +316,11 @@
               )
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) 20)
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x)
-              (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x)
+              (the-as int (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x))
               )
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
         (camera-line2d
-          (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
           (the-as vector4w (+ 64 #x70000000))
           )
         )
@@ -331,11 +331,11 @@
               )
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
         (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y)
-              (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y)
+              (the-as int (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y))
               )
         (camera-line2d
-          (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-          (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+          (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
           )
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) 20)
@@ -343,32 +343,32 @@
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) 20)
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) (+ (the int (* f28-0 f24-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 0 y) 20)
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 x) (+ (the int (* f26-0 f30-0)) 20))
       (set! (-> (the-as cam-dbg-scratch #x70000000) plotvec 1 y) (+ (the int (* f28-0 f24-0)) 20))
       (camera-line2d
-        (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-        (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+        (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+        (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
         )
       (let ((v1-64 (-> arg5 quad)))
         (set! (-> (the-as cam-dbg-scratch #x70000000) color quad) v1-64)
@@ -385,8 +385,8 @@
                 (+ (the int (* f28-0 (- (arg4 (+ arg0 (* f30-0 (/ (the float s3-1) (* f26-0 f30-0))))) arg2))) 20)
                 )
           (camera-line2d
-            (the-as vector4w (+ 48 (the-as int (the-as cam-dbg-scratch #x70000000))))
-            (the-as vector4w (+ 64 (the-as int (the-as cam-dbg-scratch #x70000000))))
+            (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) plotvec))
+            (-> (the-as cam-dbg-scratch #x70000000) plotvec 1)
             )
           (+! s3-1 1)
           )
@@ -414,17 +414,17 @@
 ;; WARN: Return type mismatch int vs none.
 ;; WARN: Function camera-line-draw has a return type of none, but the expression builder found a return statement.
 (defun camera-line-draw ((arg0 vector) (arg1 vector))
-  (set! (-> (the-as (pointer uint128) (+ 80 (the-as int (the-as cam-dbg-scratch #x70000000))))) (-> arg0 quad))
-  (set! (-> (the-as (pointer uint128) (+ 96 (the-as int (the-as cam-dbg-scratch #x70000000))))) (-> arg1 quad))
+  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 0 quad) (-> arg0 quad))
+  (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 1 quad) (-> arg1 quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 0 w) (the-as int 1.0))
   (set! (-> (the-as cam-dbg-scratch #x70000000) linevec 1 w) (the-as int 1.0))
   (transform-float-point
-    (the-as vector (+ 80 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) linevec))
     (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) linevec4w))
     )
   (transform-float-point
-    (the-as vector (+ 96 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector4w (+ 16 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) linevec 1))
+    (-> (the-as cam-dbg-scratch #x70000000) linevec4w 1)
     )
   (cond
     ((< (the-as uint #xe00000) (the-as uint (-> (the-as cam-dbg-scratch #x70000000) linevec4w 0 z)))
@@ -450,20 +450,20 @@
 
 ;; definition for function camera-line-rel
 (defun camera-line-rel ((arg0 vector) (arg1 vector) (arg2 vector4w))
-  (vector+! (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg0 arg1)
-  (camera-line arg0 (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg2)
+  (vector+! (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg0 arg1)
+  (camera-line arg0 (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg2)
   (none)
   )
 
 ;; definition for function camera-line-rel-len
 (defun camera-line-rel-len ((arg0 vector) (arg1 vector) (arg2 float) (arg3 vector4w))
-  (vector-normalize-copy! (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg1 arg2)
+  (vector-normalize-copy! (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg1 arg2)
   (vector+!
-    (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) rel-vec)
+    (-> (the-as cam-dbg-scratch #x70000000) rel-vec)
     arg0
     )
-  (camera-line arg0 (the-as vector (+ 112 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg3)
+  (camera-line arg0 (-> (the-as cam-dbg-scratch #x70000000) rel-vec) arg3)
   (none)
   )
 
@@ -504,12 +504,12 @@
               (+ (-> arg0 z) (* (sin (* 6553.6 (the float s3-0))) f28-1))
               )
         (camera-line-draw
-          (the-as vector (+ 128 (the-as int (the-as cam-dbg-scratch #x70000000))))
-          (the-as vector (+ 144 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-start)
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-end)
           )
         (camera-line-draw
-          (the-as vector (+ 128 (the-as int (the-as cam-dbg-scratch #x70000000))))
-          (the-as vector (+ 160 (the-as int (the-as cam-dbg-scratch #x70000000))))
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-start)
+          (-> (the-as cam-dbg-scratch #x70000000) sphere-v-down)
           )
         )
       )
@@ -520,62 +520,62 @@
 
 ;; definition for function camera-cross
 (defun camera-cross ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector4w) (arg4 meters))
-  (vector-normalize-copy! (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg0 arg4)
+  (vector-normalize-copy! (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec)) arg0 arg4)
   (vector+!
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (vector-!
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (camera-line
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg3
     )
   (vector-cross!
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     arg1
     )
-  (vector-normalize! (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg4)
+  (vector-normalize! (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec)) arg4)
   (vector+!
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (vector-!
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (camera-line
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg3
     )
   (vector-cross!
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     arg0
     )
-  (vector-normalize! (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000)))) arg4)
+  (vector-normalize! (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec)) arg4)
   (vector+!
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (vector-!
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg2
-    (the-as vector (+ 192 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) crossvec))
     )
   (camera-line
-    (the-as vector (+ 208 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 224 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) crossvec 2)
     arg3
     )
   (none)
@@ -586,59 +586,47 @@
 ;; WARN: Return type mismatch int vs none.
 (defun camera-bounding-box-draw ((arg0 bounding-box) (arg1 basic) (arg2 rgba))
   (camera-line-setup (new 'static 'vector4w :x #x7f :y #x7f :z #x7f :w #x80))
-  (set! (-> (the-as (pointer uint128) (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 min quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 0 quad) (-> arg0 min quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 0 x) (-> arg0 max x))
-  (set! (-> (the-as (pointer uint128) (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 min quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1 quad) (-> arg0 min quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1 y) (-> arg0 max y))
-  (set! (-> (the-as (pointer uint128) (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 min quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2 quad) (-> arg0 min quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2 z) (-> arg0 max z))
-  (set! (-> (the-as (pointer uint128) (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 max quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3 quad) (-> arg0 max quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3 x) (-> arg0 min x))
-  (set! (-> (the-as (pointer uint128) (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 max quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4 quad) (-> arg0 max quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4 y) (-> arg0 min y))
-  (set! (-> (the-as (pointer uint128) (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> arg0 max quad)
-        )
+  (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5 quad) (-> arg0 max quad))
   (set! (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5 z) (-> arg0 min z))
-  (camera-line-draw (-> arg0 min) (the-as vector (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 min) (the-as vector (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 min) (the-as vector (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 max) (the-as vector (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 max) (the-as vector (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-  (camera-line-draw (-> arg0 max) (the-as vector (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000)))))
+  (camera-line-draw (-> arg0 min) (the-as vector (-> (the-as cam-dbg-scratch #x70000000) bboxvec)))
+  (camera-line-draw (-> arg0 min) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1))
+  (camera-line-draw (-> arg0 min) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2))
+  (camera-line-draw (-> arg0 max) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3))
+  (camera-line-draw (-> arg0 max) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4))
+  (camera-line-draw (-> arg0 max) (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5))
   (camera-line-draw
-    (the-as vector (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) bboxvec))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4)
     )
   (camera-line-draw
-    (the-as vector (+ 304 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 4)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2)
     )
   (camera-line-draw
-    (the-as vector (+ 272 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 2)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3)
     )
   (camera-line-draw
-    (the-as vector (+ 288 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 3)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1)
     )
   (camera-line-draw
-    (the-as vector (+ 256 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 1)
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5)
     )
   (camera-line-draw
-    (the-as vector (+ 320 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (the-as vector (+ 240 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) bboxvec 5)
+    (the-as vector (-> (the-as cam-dbg-scratch #x70000000) bboxvec))
     )
   0
   (none)
@@ -809,7 +797,7 @@
          (vf4 :class vf)
          )
     (init-vf0-vector)
-    (let ((v1-1 (the-as object (+ 336 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-1 (the-as (object vector) (-> (the-as cam-dbg-scratch #x70000000) fov-vv))))
       (let ((t2-1 arg2)
             (t3-0 arg1)
             (f0-0 arg3)
@@ -825,7 +813,7 @@
       (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111)
       (.svf (the-as (pointer uint128) (&-> (the-as (pointer vector) v1-1) 0)) vf4)
       )
-    (let ((v1-3 (the-as object (+ 352 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-3 (the-as object (-> (the-as cam-dbg-scratch #x70000000) fov-vv 1))))
       (let ((t2-4 arg2)
             (t3-1 arg0)
             (f0-1 arg3)
@@ -841,7 +829,7 @@
       (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111)
       (.svf (the-as (pointer uint128) (&-> (the-as (pointer vector) v1-3) 0)) vf4)
       )
-    (let ((v1-5 (the-as object (+ 368 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-5 (the-as object (-> (the-as cam-dbg-scratch #x70000000) fov-vv 2))))
       (let ((a3-3 arg2)
             (f0-2 arg4)
             )
@@ -856,7 +844,7 @@
       (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111)
       (.svf (the-as (pointer uint128) (&-> (the-as (pointer vector) v1-5) 0)) vf4)
       )
-    (let ((v1-7 (the-as object (+ 384 (the-as int (the-as cam-dbg-scratch #x70000000))))))
+    (let ((v1-7 (the-as object (-> (the-as cam-dbg-scratch #x70000000) fov-vv 3))))
       (let ((a0-3 arg2)
             (f0-3 arg4)
             )
@@ -873,16 +861,16 @@
       )
     (camera-line-setup arg5)
     (camera-line-draw
-      (the-as vector (+ 336 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 352 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (the-as vector (-> (the-as cam-dbg-scratch #x70000000) fov-vv))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 1)
       )
     (camera-line-draw
-      (the-as vector (+ 352 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 368 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 1)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 2)
       )
     (camera-line-draw
-      (the-as vector (+ 368 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 384 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 2)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vv 3)
       )
     (none)
     )
@@ -892,102 +880,98 @@
 ;; INFO: Used lq/sq
 ;; WARN: Return type mismatch none vs symbol.
 (defun camera-fov-frame ((arg0 matrix) (arg1 vector) (arg2 float) (arg3 float) (arg4 float) (arg5 vector4w))
+  (vector-float*! (-> (the-as cam-dbg-scratch #x70000000) fov-vert) (-> arg0 vector 1) (* arg3 (tan arg2)))
   (vector-float*!
-    (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-    (-> arg0 vector 1)
-    (* arg3 (tan arg2))
-    )
-  (vector-float*!
-    (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
     (the-as vector (-> arg0 vector))
     (* arg4 (tan arg2))
     )
   (vector+!
-    (the-as vector (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-src)
     (-> arg0 vector 2)
     (vector+!
-      (the-as vector (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-src)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-src) 1.0)
   (vector+!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector-!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (camera-fov-draw
-    (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-    (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
     arg1
     4096.0
     20480.0
     arg5
     )
-  (set! (-> (the-as (pointer uint128) (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> (the-as vector4w (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) quad)
+  (set! (-> (the-as cam-dbg-scratch #x70000000) fov-src quad)
+        (-> (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) fov-dest)) quad)
         )
   (vector-!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector+!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (camera-fov-draw
-    (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-    (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
     arg1
     4096.0
     20480.0
     arg5
     )
-  (set! (-> (the-as (pointer uint128) (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> (the-as vector4w (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) quad)
+  (set! (-> (the-as cam-dbg-scratch #x70000000) fov-src quad)
+        (-> (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) fov-dest)) quad)
         )
   (vector-!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector-!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (camera-fov-draw
-    (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-    (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+    (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
     arg1
     4096.0
     20480.0
     arg5
     )
-  (set! (-> (the-as (pointer uint128) (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))))
-        (-> (the-as vector4w (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) quad)
+  (set! (-> (the-as cam-dbg-scratch #x70000000) fov-src quad)
+        (-> (the-as vector4w (-> (the-as cam-dbg-scratch #x70000000) fov-dest)) quad)
         )
   (vector+!
-    (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
+    (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
     (-> arg0 vector 2)
     (vector+!
-      (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 432 (the-as int (the-as cam-dbg-scratch #x70000000))))
-      (the-as vector (+ 448 (the-as int (the-as cam-dbg-scratch #x70000000))))
+      (-> (the-as cam-dbg-scratch #x70000000) fov-dest)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-vert)
+      (-> (the-as cam-dbg-scratch #x70000000) fov-horz)
       )
     )
-  (vector-normalize! (the-as vector (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))) 1.0)
+  (vector-normalize! (-> (the-as cam-dbg-scratch #x70000000) fov-dest) 1.0)
   (the-as symbol (camera-fov-draw
-                   (+ 400 (the-as int (the-as cam-dbg-scratch #x70000000)))
-                   (+ 416 (the-as int (the-as cam-dbg-scratch #x70000000)))
+                   (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-src))
+                   (the-as int (-> (the-as cam-dbg-scratch #x70000000) fov-dest))
                    arg1
                    4096.0
                    20480.0
diff --git a/test/decompiler/reference/jak2/engine/debug/debug_REF.gc b/test/decompiler/reference/jak2/engine/debug/debug_REF.gc
index 25dd9ecbe0..4e0e2733a8 100644
--- a/test/decompiler/reference/jak2/engine/debug/debug_REF.gc
+++ b/test/decompiler/reference/jak2/engine/debug/debug_REF.gc
@@ -327,8 +327,8 @@
                           'stack
                           'font-context
                           *font-default-matrix*
-                          (the-as int (+ (-> screen-offset x) -1792 (/ (-> screen-pos x) 16)))
-                          (the-as int (+ (-> screen-offset y) -1855 (/ (-> screen-pos y) 16)))
+                          (the-as int (+ (-> screen-offset x) -1792 (/ (the-as int (-> screen-pos x)) 16)))
+                          (the-as int (+ (-> screen-offset y) -1855 (/ (the-as int (-> screen-pos y)) 16)))
                           0.0
                           color
                           (font-flags shadow kerning)
@@ -336,7 +336,7 @@
                         )
               )
           (let ((v1-10 font-ctx))
-            (set! (-> v1-10 origin z) (the float (/ (-> screen-pos z) 16)))
+            (set! (-> v1-10 origin z) (the float (/ (the-as int (-> screen-pos z)) 16)))
             )
           (draw-string text buf font-ctx)
           )
@@ -720,11 +720,11 @@
           )
       (set! (-> p0 quad) (-> start quad))
       (set! (-> p1 quad) (-> end quad))
-      (set! (-> p0 x) (* (+ (-> p0 x) 2048) 16))
-      (set! (-> p0 y) (* -16 (- 2048 (-> p0 y))))
+      (set! (-> p0 x) (the-as int (* (+ (-> p0 x) 2048) 16)))
+      (set! (-> p0 y) (* -16 (the-as int (- 2048 (the-as int (-> p0 y))))))
       (set! (-> p0 z) #x7fffff)
-      (set! (-> p1 x) (* (+ (-> p1 x) 2048) 16))
-      (set! (-> p1 y) (* -16 (- 2048 (-> p1 y))))
+      (set! (-> p1 x) (the-as int (* (+ (-> p1 x) 2048) 16)))
+      (set! (-> p1 y) (* -16 (the-as int (- 2048 (the-as int (-> p1 y))))))
       (set! (-> p1 z) #x7fffff)
       (let ((a0-18 (the-as (pointer uint64) (-> buf base))))
         (let* ((a1-7 buf)
diff --git a/test/decompiler/reference/jak2/engine/debug/default-menu_REF.gc b/test/decompiler/reference/jak2/engine/debug/default-menu_REF.gc
index 9cc4338bba..939348e189 100644
--- a/test/decompiler/reference/jak2/engine/debug/default-menu_REF.gc
+++ b/test/decompiler/reference/jak2/engine/debug/default-menu_REF.gc
@@ -885,7 +885,7 @@
 ;; definition for function dm-texture-user-set-pick-func
 (defun dm-texture-user-set-pick-func ((arg0 int) (arg1 debug-menu-msg))
   (if (= arg1 (debug-menu-msg press))
-      (set! (-> *texture-pool* texture-enable-user-menu) (the-as uint arg0))
+      (set! (-> *texture-pool* texture-enable-user-menu) (the-as texture-enable-mask arg0))
       )
   (= (-> *texture-pool* texture-enable-user-menu) arg0)
   )
@@ -933,7 +933,7 @@
             (let ((s0-0 (the-as object (* (-> (dynamic-array-field-access v1-12 next PLACEHOLDER) shader) 16))))
               (while (nonzero? (the-as uint s0-0))
                 (adgif-shader-update! (the-as adgif-shader s0-0) s1-0)
-                (&-> (the-as adgif-shader s0-0) reg-2)
+                (&-> (the-as adgif-shader s0-0) next)
                 (set! s0-0 (* (-> (the-as adgif-shader s0-0) next shader) 16))
                 )
               )
@@ -2781,8 +2781,7 @@
 
 ;; definition for function debug-menu-make-task-sub-menu
 ;; INFO: Used lq/sq
-;; WARN: Return type mismatch pair vs debug-menu-node.
-(defun debug-menu-make-task-sub-menu ((arg0 debug-menu-context))
+(defun debug-menu-make-task-sub-menu ((arg0 symbol))
   (local-vars
     (sv-16 (function symbol type object object pair))
     (sv-32 symbol)
@@ -2832,7 +2831,7 @@
           )
         )
       )
-    (the-as debug-menu-node (cons 'menu (cons (-> (the-as (pointer uint32) (+ #xff37 (the-as int arg0)))) gp-0)))
+    (cons 'menu (cons (symbol->string arg0) gp-0))
     )
   )
 
@@ -2873,8 +2872,8 @@
               (s0-0 debug-menu-make-from-template)
               )
           (set! sv-16 arg0)
-          (let ((a1-2 (debug-menu-make-task-sub-menu (the-as debug-menu-context a0-3))))
-            (s2-0 s1-0 (s0-0 sv-16 (the-as pair a1-2)))
+          (let ((a1-2 (debug-menu-make-task-sub-menu (the-as symbol a0-3))))
+            (s2-0 s1-0 (s0-0 sv-16 a1-2))
             )
           )
         (set! s3-0 (cdr s3-0))
diff --git a/test/decompiler/reference/jak2/engine/gfx/hw/display_REF.gc b/test/decompiler/reference/jak2/engine/gfx/hw/display_REF.gc
index a47feaed7e..b74c8a9909 100644
--- a/test/decompiler/reference/jak2/engine/gfx/hw/display_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/hw/display_REF.gc
@@ -314,25 +314,7 @@
            (t3-2 (the-as object (-> v1-2 base)))
            )
       (set! (-> (the-as gs-gif-tag t3-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-      (set! (-> (the-as gs-gif-tag t3-2) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag t3-2) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-2 base) (&+ (the-as pointer t3-2) 16))
       )
     (let* ((v1-3 arg0)
@@ -377,25 +359,7 @@
            (t5-2 (the-as object (-> v1-2 base)))
            )
       (set! (-> (the-as gs-gif-tag t5-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-      (set! (-> (the-as gs-gif-tag t5-2) regs) (new 'static 'gif-tag-regs
-                                                 :regs0 (gif-reg-id a+d)
-                                                 :regs1 (gif-reg-id a+d)
-                                                 :regs2 (gif-reg-id a+d)
-                                                 :regs3 (gif-reg-id a+d)
-                                                 :regs4 (gif-reg-id a+d)
-                                                 :regs5 (gif-reg-id a+d)
-                                                 :regs6 (gif-reg-id a+d)
-                                                 :regs7 (gif-reg-id a+d)
-                                                 :regs8 (gif-reg-id a+d)
-                                                 :regs9 (gif-reg-id a+d)
-                                                 :regs10 (gif-reg-id a+d)
-                                                 :regs11 (gif-reg-id a+d)
-                                                 :regs12 (gif-reg-id a+d)
-                                                 :regs13 (gif-reg-id a+d)
-                                                 :regs14 (gif-reg-id a+d)
-                                                 :regs15 (gif-reg-id a+d)
-                                                 )
-            )
+      (set! (-> (the-as gs-gif-tag t5-2) regs) GIF_REGS_ALL_AD)
       (set! (-> v1-2 base) (&+ (the-as pointer t5-2) 16))
       )
     (let* ((v1-3 arg0)
@@ -441,25 +405,7 @@
          (a2-3 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a2-3) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x7))
-    (set! (-> (the-as gs-gif-tag a2-3) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a2-3) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a2-3) 16))
     )
   (let* ((v1-2 arg1)
diff --git a/test/decompiler/reference/jak2/engine/gfx/merc/emerc_REF.gc b/test/decompiler/reference/jak2/engine/gfx/merc/emerc_REF.gc
index 5caed6dcf3..3f6db0210f 100644
--- a/test/decompiler/reference/jak2/engine/gfx/merc/emerc_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/merc/emerc_REF.gc
@@ -69,25 +69,7 @@
                (a0-6 (the-as object (-> v1-13 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-6) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
-          (set! (-> (the-as gs-gif-tag a0-6) regs) (new 'static 'gif-tag-regs
-                                                     :regs0 (gif-reg-id a+d)
-                                                     :regs1 (gif-reg-id a+d)
-                                                     :regs2 (gif-reg-id a+d)
-                                                     :regs3 (gif-reg-id a+d)
-                                                     :regs4 (gif-reg-id a+d)
-                                                     :regs5 (gif-reg-id a+d)
-                                                     :regs6 (gif-reg-id a+d)
-                                                     :regs7 (gif-reg-id a+d)
-                                                     :regs8 (gif-reg-id a+d)
-                                                     :regs9 (gif-reg-id a+d)
-                                                     :regs10 (gif-reg-id a+d)
-                                                     :regs11 (gif-reg-id a+d)
-                                                     :regs12 (gif-reg-id a+d)
-                                                     :regs13 (gif-reg-id a+d)
-                                                     :regs14 (gif-reg-id a+d)
-                                                     :regs15 (gif-reg-id a+d)
-                                                     )
-                )
+          (set! (-> (the-as gs-gif-tag a0-6) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-13 base) (&+ (the-as pointer a0-6) 16))
           )
         (let* ((v1-14 dma-buf)
@@ -115,137 +97,173 @@
 ;; WARN: Return type mismatch int vs none.
 (defun emerc-vu1-init-buffers ()
   (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask emerc))
-    (emerc-vu1-init-buffer (bucket-id bucket-15) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-26) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-37) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-48) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-59) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-70) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
     (emerc-vu1-init-buffer
-      (bucket-id bucket-189)
+      (bucket-id emerc-l0-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-198)
+      (bucket-id emerc-l1-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-202)
+      (bucket-id emerc-l2-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-206)
+      (bucket-id emerc-l3-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-210)
+      (bucket-id emerc-l4-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-214)
+      (bucket-id emerc-l5-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-218)
+      (bucket-id emerc-lcom-tfrag)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-222)
-      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
-      0
-      )
-    (emerc-vu1-init-buffer (bucket-id bucket-80) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-89) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer (bucket-id bucket-98) (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal)) 0)
-    (emerc-vu1-init-buffer
-      (bucket-id bucket-107)
+      (bucket-id emerc-l0-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-116)
+      (bucket-id emerc-l1-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-125)
+      (bucket-id emerc-l2-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-193)
+      (bucket-id emerc-l3-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-132)
+      (bucket-id emerc-l4-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-142)
+      (bucket-id emerc-l5-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-152)
+      (bucket-id emerc-lcom-pris)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-162)
+      (bucket-id emerc-l0-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-172)
+      (bucket-id emerc-l1-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-182)
+      (bucket-id emerc-l2-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-226)
+      (bucket-id emerc-l3-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-230)
+      (bucket-id emerc-l4-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-234)
+      (bucket-id emerc-l5-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-238)
+      (bucket-id emerc-lcom-shrub)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-242)
+      (bucket-id emerc-l0-alpha)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-246)
+      (bucket-id emerc-l1-alpha)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
     (emerc-vu1-init-buffer
-      (bucket-id bucket-250)
+      (bucket-id emerc-l2-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l3-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l4-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l5-alpha)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l0-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l1-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l2-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l3-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l4-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-l5-pris2)
+      (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
+      0
+      )
+    (emerc-vu1-init-buffer
+      (bucket-id emerc-lcom-pris2)
       (new 'static 'gs-test :zte #x1 :ztst (gs-ztest greater-equal))
       0
       )
diff --git a/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc b/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc
index d105e119d4..7017a4a1fc 100644
--- a/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc
@@ -608,25 +608,7 @@
                (a0-6 (the-as object (-> v1-13 base)))
                )
           (set! (-> (the-as gs-gif-tag a0-6) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-          (set! (-> (the-as gs-gif-tag a0-6) regs) (new 'static 'gif-tag-regs
-                                                     :regs0 (gif-reg-id a+d)
-                                                     :regs1 (gif-reg-id a+d)
-                                                     :regs2 (gif-reg-id a+d)
-                                                     :regs3 (gif-reg-id a+d)
-                                                     :regs4 (gif-reg-id a+d)
-                                                     :regs5 (gif-reg-id a+d)
-                                                     :regs6 (gif-reg-id a+d)
-                                                     :regs7 (gif-reg-id a+d)
-                                                     :regs8 (gif-reg-id a+d)
-                                                     :regs9 (gif-reg-id a+d)
-                                                     :regs10 (gif-reg-id a+d)
-                                                     :regs11 (gif-reg-id a+d)
-                                                     :regs12 (gif-reg-id a+d)
-                                                     :regs13 (gif-reg-id a+d)
-                                                     :regs14 (gif-reg-id a+d)
-                                                     :regs15 (gif-reg-id a+d)
-                                                     )
-                )
+          (set! (-> (the-as gs-gif-tag a0-6) regs) GIF_REGS_ALL_AD)
           (set! (-> v1-13 base) (&+ (the-as pointer a0-6) 16))
           )
         (let* ((v1-14 dma-buf)
@@ -666,47 +648,47 @@
 ;; WARN: Return type mismatch int vs none.
 (defun merc-vu1-init-buffers ()
   (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask merc))
-    (merc-vu1-init-buffer (bucket-id bucket-14) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-25) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-36) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-47) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-58) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-69) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-188) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-197) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-201) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-205) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-209) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-213) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-217) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-221) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-79) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-88) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-97) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-106) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-115) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-124) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-192) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-131) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-141) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-151) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-161) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-171) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-181) 1 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-225) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-229) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-233) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-237) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-241) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-245) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-249) 0 #t)
-    (merc-vu1-init-buffer (bucket-id bucket-253) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-262) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-271) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-280) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-289) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-298) 1 #f)
-    (merc-vu1-init-buffer (bucket-id bucket-307) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l0-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-tfrag) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-pris) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-shrub) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-alpha) 1 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l1-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l2-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l3-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l4-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l5-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-pris2) 0 #t)
+    (merc-vu1-init-buffer (bucket-id merc-l0-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l1-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l2-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l3-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l4-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-l5-water) 1 #f)
+    (merc-vu1-init-buffer (bucket-id merc-lcom-water) 1 #f)
     )
   0
   (none)
diff --git a/test/decompiler/reference/jak2/engine/gfx/mood/mood-funcs2_REF.gc b/test/decompiler/reference/jak2/engine/gfx/mood/mood-funcs2_REF.gc
index fbb8e7ba25..ade305ad90 100644
--- a/test/decompiler/reference/jak2/engine/gfx/mood/mood-funcs2_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/mood/mood-funcs2_REF.gc
@@ -249,7 +249,7 @@
           (vector-lerp!
             (the-as vector (-> arg0 times))
             (the-as vector (-> arg0 times))
-            (the-as vector (+ #x83ac (the-as int *level*)))
+            (the-as vector (-> *level* default-level mood-context times))
             f0-5
             )
           )
@@ -803,7 +803,7 @@
           (set! (-> s5-0 clock-moon) (the-as uint (the int (rand-vu-float-range 64.0 192.0))))
           )
         (if (and (-> s5-0 door) (zero? (logand (-> s5-0 door extra perm status) (entity-perm-status subtask-complete))))
-            (set! (-> arg0 times 0 quad) (-> (the-as (pointer uint128) (+ #x83ac (the-as int *level*)))))
+            (set! (-> arg0 times 0 quad) (-> *level* default-level mood-context times 0 quad))
             )
         )
       (let ((a0-121 (new 'stack-no-clear 'sphere))
@@ -819,7 +819,7 @@
           (vector-lerp!
             (the-as vector (-> arg0 times))
             (the-as vector (-> arg0 times))
-            (the-as vector (+ #x83ac (the-as int *level*)))
+            (the-as vector (-> *level* default-level mood-context times))
             f0-76
             )
           )
diff --git a/test/decompiler/reference/jak2/engine/gfx/mood/mood_REF.gc b/test/decompiler/reference/jak2/engine/gfx/mood/mood_REF.gc
index dd6e69c691..619537e50f 100644
--- a/test/decompiler/reference/jak2/engine/gfx/mood/mood_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/mood/mood_REF.gc
@@ -548,7 +548,7 @@
           )
         )
       (let ((v1-5 (-> arg0 times))
-            (a0-2 (the-as (inline-array vector) (+ #x83ac (the-as int *level*))))
+            (a0-2 (-> *level* default-level mood-context times))
             )
         (dotimes (a1-6 5)
           (set! (-> v1-5 0 quad) (-> a0-2 0 quad))
@@ -579,9 +579,9 @@
           (set! a2-3 (-> (the-as mood-context a2-3) current-fog fog-dists))
           )
         )
-      (set! (-> arg0 times 0 quad) (-> (the-as (pointer uint128) (+ #x83ac (the-as int *level*)))))
+      (set! (-> arg0 times 0 quad) (-> *level* default-level mood-context times 0 quad))
       (when arg1
-        (set! (-> arg0 times 1 quad) (-> (the-as (pointer uint128) (+ #x83bc (the-as int *level*)))))
+        (set! (-> arg0 times 1 quad) (-> *level* default-level mood-context times 1 quad))
         (set! (-> arg0 times 1 w) 1.0)
         )
       )
diff --git a/test/decompiler/reference/jak2/engine/gfx/sprite/particles/sparticle-launcher_REF.gc b/test/decompiler/reference/jak2/engine/gfx/sprite/particles/sparticle-launcher_REF.gc
index 7e033d6ce5..a35556c26a 100644
--- a/test/decompiler/reference/jak2/engine/gfx/sprite/particles/sparticle-launcher_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/sprite/particles/sparticle-launcher_REF.gc
@@ -3054,7 +3054,7 @@
     (s5-0 sp-field-init-spec)
     (s5-1 none)
     (t9-0 (function sparticle-launcher sp-field-id sp-field-init-spec))
-    (t9-1 (function string symbol texture-id))
+    (t9-1 (function string string texture-id))
     (t9-2 (function sparticle-launcher sp-field-id sp-field-init-spec))
     (t9-3 (function object type symbol))
     (t9-4 none)
diff --git a/test/decompiler/reference/jak2/engine/gfx/sprite/sprite-distort_REF.gc b/test/decompiler/reference/jak2/engine/gfx/sprite/sprite-distort_REF.gc
index db307ca13c..650a5a5f80 100644
--- a/test/decompiler/reference/jak2/engine/gfx/sprite/sprite-distort_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/sprite/sprite-distort_REF.gc
@@ -134,25 +134,7 @@
          (a1-2 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a1-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x6))
-    (set! (-> (the-as gs-gif-tag a1-2) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a1-2) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a1-2) 16))
     )
   (let* ((v1-2 dma-buff)
diff --git a/test/decompiler/reference/jak2/engine/gfx/sprite/sprite_REF.gc b/test/decompiler/reference/jak2/engine/gfx/sprite/sprite_REF.gc
index c2807bc019..3eb1e49299 100644
--- a/test/decompiler/reference/jak2/engine/gfx/sprite/sprite_REF.gc
+++ b/test/decompiler/reference/jak2/engine/gfx/sprite/sprite_REF.gc
@@ -812,25 +812,7 @@
              (giftag (the-as gs-gif-tag (-> v1-18 base)))
              )
         (set! (-> giftag tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2))
-        (set! (-> giftag regs) (new 'static 'gif-tag-regs
-                                 :regs0 (gif-reg-id a+d)
-                                 :regs1 (gif-reg-id a+d)
-                                 :regs2 (gif-reg-id a+d)
-                                 :regs3 (gif-reg-id a+d)
-                                 :regs4 (gif-reg-id a+d)
-                                 :regs5 (gif-reg-id a+d)
-                                 :regs6 (gif-reg-id a+d)
-                                 :regs7 (gif-reg-id a+d)
-                                 :regs8 (gif-reg-id a+d)
-                                 :regs9 (gif-reg-id a+d)
-                                 :regs10 (gif-reg-id a+d)
-                                 :regs11 (gif-reg-id a+d)
-                                 :regs12 (gif-reg-id a+d)
-                                 :regs13 (gif-reg-id a+d)
-                                 :regs14 (gif-reg-id a+d)
-                                 :regs15 (gif-reg-id a+d)
-                                 )
-              )
+        (set! (-> giftag regs) GIF_REGS_ALL_AD)
         (set! (-> v1-18 base) (the-as pointer (&+ giftag 16)))
         )
       (let* ((v1-19 dma-buff)
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 656bbe475e..7d03568192 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
@@ -62,8 +62,8 @@
    (common-page-mask         int32                                                                 :offset-assert 180)
    (update-sprites-flag      symbol                                                                :offset-assert 184)
    (update-flag              symbol                                                                :offset-assert 188)
-   (texture-enable-user      uint64                                                                :offset-assert 192)
-   (texture-enable-user-menu uint64                                                                :offset-assert 200)
+   (texture-enable-user      texture-enable-mask                                                   :offset-assert 192)
+   (texture-enable-user-menu texture-enable-mask                                                   :offset-assert 200)
    (ids                      uint32                                                      128       :offset-assert 208)
    )
   :method-count-assert 26
@@ -72,21 +72,21 @@
   (:methods
     (new (symbol type) _type_ 0)
     (initialize! (_type_) _type_ 9)
-    (texture-pool-method-10 () none 10)
-    (texture-pool-method-11 () none 11)
-    (allocate-defaults! (_type_) none 12)
+    (print-usage (_type_) _type_ 10)
+    (setup-font-texture (_type_) none 11)
+    (allocate-defaults (_type_) none 12)
     (login-level-textures (_type_ level int (pointer texture-id)) none 13)
-    (texture-pool-method-14 () none 14)
+    (add-level-tpage-dma (_type_ level tpage-category bucket-id) none 14)
     (allocate-vram-words! (_type_ int) int 15)
-    (allocate-segment! (_type_ texture-pool-segment int) texture-pool-segment 16)
-    (texture-pool-method-17 () none 17)
-    (texture-pool-method-18 (_type_ int) int 18)
+    (allocate-segment (_type_ texture-pool-segment int) texture-pool-segment 16)
+    (unload-page (_type_ texture-page) none 17)
+    (get-common-page-slot-by-id (_type_ int) int 18)
     (update-warp-and-hud (_type_) none 19)
     (update-sprites (_type_) none 20)
-    (flag-update-and-sprite (_type_) none 21)
-    (relocate-sprite-dests! (_type_) none 22)
-    (relocate-hud-dests! (_type_) none 23)
-    (relocate-warp-dests! (_type_) none 24)
+    (mark-hud-warp-sprite-dirty (_type_) none 21)
+    (lay-out-sprite-tex (_type_) none 22)
+    (lay-out-hud-tex (_type_) none 23)
+    (lay-out-warp-tex (_type_) none 24)
     (clear-ids (_type_) none 25)
     )
   )
@@ -284,7 +284,7 @@
 ;; definition of type texture-page
 (deftype texture-page (basic)
   ((info      file-info                      :offset-assert   4)
-   (name      basic                          :offset-assert   8)
+   (name      string                         :offset-assert   8)
    (id        uint32                         :offset-assert  12)
    (length    int32                          :offset-assert  16)
    (mip0-size uint32                         :offset-assert  20)
@@ -298,11 +298,12 @@
   :size-assert         #x80
   :flag-assert         #xe00000080
   (:methods
-    (remove-from-heap (_type_ kheap) _type_ 9)
+    (relocate (_type_ kheap (pointer uint8)) texture-page :replace 7)
+    (remove-data-from-heap (_type_ kheap) _type_ 9)
     (get-leftover-block-count (_type_ int int) int 10)
     (relocate-dests! (_type_ int int) none 11)
-    (texture-page-method-12 () none 12)
-    (upload-now! (_type_ int) none 13)
+    (add-to-dma-buffer (_type_ dma-buffer tex-upload-mode) int 12)
+    (upload-now! (_type_ tex-upload-mode) none 13)
     )
   )
 
@@ -396,7 +397,7 @@
   :flag-assert         #xa00000014
   (:methods
     (relocate (_type_ kheap (pointer uint8)) none :replace 7)
-    (unlink-textures-in-heap! (_type_ kheap) int 9)
+    (unlink-shaders-in-heap (_type_ kheap) int 9)
     )
   )
 
@@ -850,10 +851,10 @@
 
 ;; definition of type texture-page-translate-item
 (deftype texture-page-translate-item (structure)
-  ((bucket             bucket-id  :offset-assert   0)
-   (level-index        uint32     :offset-assert   4)
-   (level-texture-page uint32     :offset-assert   8)
-   (texture-user       uint32     :offset-assert  12)
+  ((bucket             bucket-id                :offset-assert   0)
+   (level-index        uint32                   :offset-assert   4)
+   (level-texture-page tpage-category-u32       :offset-assert   8)
+   (texture-user       texture-enable-mask-u32  :offset-assert  12)
    )
   :method-count-assert 9
   :size-assert         #x10
@@ -877,357 +878,383 @@
 
 ;; definition for symbol *texture-page-translate*, type (array texture-page-translate-item)
 (define *texture-page-translate*
-  (the-as (array texture-page-translate-item)
-    (new 'static 'boxed-array :type texture-page-translate-item
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-4)
-        :level-index #x6
-        :level-texture-page #x9
-        :texture-user #x100
-        )
-      (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-7) :texture-user #x1)
-      (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-18) :level-index #x1 :texture-user #x1)
-      (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-29) :level-index #x2 :texture-user #x1)
-      (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-40) :level-index #x3 :texture-user #x1)
-      (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-51) :level-index #x4 :texture-user #x1)
-      (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-62) :level-index #x5 :texture-user #x1)
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-73)
-        :level-texture-page #x2
-        :texture-user #x4
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-82)
-        :level-index #x1
-        :level-texture-page #x2
-        :texture-user #x4
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-91)
-        :level-index #x2
-        :level-texture-page #x2
-        :texture-user #x4
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-100)
-        :level-index #x3
-        :level-texture-page #x2
-        :texture-user #x4
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-109)
-        :level-index #x4
-        :level-texture-page #x2
-        :texture-user #x4
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-118)
-        :level-index #x5
-        :level-texture-page #x2
-        :texture-user #x4
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-127)
-        :level-texture-page #x3
-        :texture-user #x8
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-137)
-        :level-index #x1
-        :level-texture-page #x3
-        :texture-user #x8
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-147)
-        :level-index #x2
-        :level-texture-page #x3
-        :texture-user #x8
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-157)
-        :level-index #x3
-        :level-texture-page #x3
-        :texture-user #x8
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-167)
-        :level-index #x4
-        :level-texture-page #x3
-        :texture-user #x8
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-177)
-        :level-index #x5
-        :level-texture-page #x3
-        :texture-user #x8
-        )
-      (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-187) :level-index #x6 :texture-user #x1)
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-191)
-        :level-index #x6
-        :level-texture-page #x2
-        :texture-user #x4
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-196)
-        :level-texture-page #x1
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-200)
-        :level-index #x1
-        :level-texture-page #x1
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-204)
-        :level-index #x2
-        :level-texture-page #x1
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-208)
-        :level-index #x3
-        :level-texture-page #x1
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-212)
-        :level-index #x4
-        :level-texture-page #x1
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-216)
-        :level-index #x5
-        :level-texture-page #x1
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-220)
-        :level-index #x6
-        :level-texture-page #x1
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-224)
-        :level-texture-page #x6
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-228)
-        :level-index #x1
-        :level-texture-page #x6
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-232)
-        :level-index #x2
-        :level-texture-page #x6
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-236)
-        :level-index #x3
-        :level-texture-page #x6
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-240)
-        :level-index #x4
-        :level-texture-page #x6
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-244)
-        :level-index #x5
-        :level-texture-page #x6
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-248)
-        :level-index #x6
-        :level-texture-page #x6
-        :texture-user #x2
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-252)
-        :level-texture-page #x4
-        :texture-user #x10
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-261)
-        :level-index #x1
-        :level-texture-page #x4
-        :texture-user #x10
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-270)
-        :level-index #x2
-        :level-texture-page #x4
-        :texture-user #x10
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-279)
-        :level-index #x3
-        :level-texture-page #x4
-        :texture-user #x10
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-288)
-        :level-index #x4
-        :level-texture-page #x4
-        :texture-user #x10
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-297)
-        :level-index #x5
-        :level-texture-page #x4
-        :texture-user #x10
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-306)
-        :level-index #x6
-        :level-texture-page #x4
-        :texture-user #x10
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-309)
-        :level-index #x6
-        :level-texture-page #x9
-        :texture-user #x100
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-312)
-        :level-texture-page #x7
-        :texture-user #x40
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-312)
-        :level-index #x1
-        :level-texture-page #x7
-        :texture-user #x40
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-312)
-        :level-index #x2
-        :level-texture-page #x7
-        :texture-user #x40
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-312)
-        :level-index #x3
-        :level-texture-page #x7
-        :texture-user #x40
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-312)
-        :level-index #x4
-        :level-texture-page #x7
-        :texture-user #x40
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-312)
-        :level-index #x5
-        :level-texture-page #x7
-        :texture-user #x40
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-312)
-        :level-index #x6
-        :level-texture-page #x7
-        :texture-user #x40
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-316)
-        :level-texture-page #x5
-        :texture-user #x20
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-316)
-        :level-index #x1
-        :level-texture-page #x5
-        :texture-user #x20
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-316)
-        :level-index #x2
-        :level-texture-page #x5
-        :texture-user #x20
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-316)
-        :level-index #x3
-        :level-texture-page #x5
-        :texture-user #x20
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-316)
-        :level-index #x4
-        :level-texture-page #x5
-        :texture-user #x20
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-316)
-        :level-index #x5
-        :level-texture-page #x5
-        :texture-user #x20
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-316)
-        :level-index #x6
-        :level-texture-page #x5
-        :texture-user #x20
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-texture-page #x8
-        :texture-user #x80
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-index #x1
-        :level-texture-page #x8
-        :texture-user #x80
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-index #x2
-        :level-texture-page #x8
-        :texture-user #x80
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-index #x3
-        :level-texture-page #x8
-        :texture-user #x80
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-index #x4
-        :level-texture-page #x8
-        :texture-user #x80
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-index #x5
-        :level-texture-page #x8
-        :texture-user #x80
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-index #x6
-        :level-texture-page #x8
-        :texture-user #x80
-        )
-      (new 'static 'texture-page-translate-item
-        :bucket (bucket-id bucket-319)
-        :level-index #x6
-        :level-texture-page #x3
-        :texture-user #x80
-        )
-      )
-    )
+  (the-as (array texture-page-translate-item) (new 'static 'boxed-array :type texture-page-translate-item
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-lcom-sky-pre)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 sky)
+                                                  :texture-user (texture-enable-mask-u32 sky)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l0-tfrag)
+                                                  :texture-user (texture-enable-mask-u32 tfrag)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l1-tfrag)
+                                                  :level-index #x1
+                                                  :texture-user (texture-enable-mask-u32 tfrag)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l2-tfrag)
+                                                  :level-index #x2
+                                                  :texture-user (texture-enable-mask-u32 tfrag)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l3-tfrag)
+                                                  :level-index #x3
+                                                  :texture-user (texture-enable-mask-u32 tfrag)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l4-tfrag)
+                                                  :level-index #x4
+                                                  :texture-user (texture-enable-mask-u32 tfrag)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l5-tfrag)
+                                                  :level-index #x5
+                                                  :texture-user (texture-enable-mask-u32 tfrag)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l0-shrub)
+                                                  :level-texture-page (tpage-category-u32 shrub)
+                                                  :texture-user (texture-enable-mask-u32 shrub)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l1-shrub)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 shrub)
+                                                  :texture-user (texture-enable-mask-u32 shrub)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l2-shrub)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 shrub)
+                                                  :texture-user (texture-enable-mask-u32 shrub)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l3-shrub)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 shrub)
+                                                  :texture-user (texture-enable-mask-u32 shrub)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l4-shrub)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 shrub)
+                                                  :texture-user (texture-enable-mask-u32 shrub)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l5-shrub)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 shrub)
+                                                  :texture-user (texture-enable-mask-u32 shrub)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l0-alpha)
+                                                  :level-texture-page (tpage-category-u32 alpha)
+                                                  :texture-user (texture-enable-mask-u32 alpha)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l1-alpha)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 alpha)
+                                                  :texture-user (texture-enable-mask-u32 alpha)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l2-alpha)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 alpha)
+                                                  :texture-user (texture-enable-mask-u32 alpha)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l3-alpha)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 alpha)
+                                                  :texture-user (texture-enable-mask-u32 alpha)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l4-alpha)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 alpha)
+                                                  :texture-user (texture-enable-mask-u32 alpha)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l5-alpha)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 alpha)
+                                                  :texture-user (texture-enable-mask-u32 alpha)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-lcom-tfrag)
+                                                  :level-index #x6
+                                                  :texture-user (texture-enable-mask-u32 tfrag)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-lcom-shrub)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 shrub)
+                                                  :texture-user (texture-enable-mask-u32 shrub)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l0-pris)
+                                                  :level-texture-page (tpage-category-u32 pris)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l1-pris)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 pris)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l2-pris)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 pris)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l3-pris)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 pris)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l4-pris)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 pris)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l5-pris)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 pris)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-lcom-pris)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 pris)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l0-pris2)
+                                                  :level-texture-page (tpage-category-u32 pris2)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l1-pris2)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 pris2)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l2-pris2)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 pris2)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l3-pris2)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 pris2)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l4-pris2)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 pris2)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l5-pris2)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 pris2)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-lcom-pris2)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 pris2)
+                                                  :texture-user (texture-enable-mask-u32 pris)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l0-water)
+                                                  :level-texture-page (tpage-category-u32 water)
+                                                  :texture-user (texture-enable-mask-u32 water)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l1-water)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 water)
+                                                  :texture-user (texture-enable-mask-u32 water)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l2-water)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 water)
+                                                  :texture-user (texture-enable-mask-u32 water)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l3-water)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 water)
+                                                  :texture-user (texture-enable-mask-u32 water)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l4-water)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 water)
+                                                  :texture-user (texture-enable-mask-u32 water)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-l5-water)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 water)
+                                                  :texture-user (texture-enable-mask-u32 water)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-lcom-water)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 water)
+                                                  :texture-user (texture-enable-mask-u32 water)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-lcom-sky-post)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 sky)
+                                                  :texture-user (texture-enable-mask-u32 sky)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-sprite)
+                                                  :level-texture-page (tpage-category-u32 sprite)
+                                                  :texture-user (texture-enable-mask-u32 sprite)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-sprite)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 sprite)
+                                                  :texture-user (texture-enable-mask-u32 sprite)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-sprite)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 sprite)
+                                                  :texture-user (texture-enable-mask-u32 sprite)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-sprite)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 sprite)
+                                                  :texture-user (texture-enable-mask-u32 sprite)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-sprite)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 sprite)
+                                                  :texture-user (texture-enable-mask-u32 sprite)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-sprite)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 sprite)
+                                                  :texture-user (texture-enable-mask-u32 sprite)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-sprite)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 sprite)
+                                                  :texture-user (texture-enable-mask-u32 sprite)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-warp)
+                                                  :level-texture-page (tpage-category-u32 warp)
+                                                  :texture-user (texture-enable-mask-u32 warp)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-warp)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 warp)
+                                                  :texture-user (texture-enable-mask-u32 warp)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-warp)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 warp)
+                                                  :texture-user (texture-enable-mask-u32 warp)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-warp)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 warp)
+                                                  :texture-user (texture-enable-mask-u32 warp)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-warp)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 warp)
+                                                  :texture-user (texture-enable-mask-u32 warp)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-warp)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 warp)
+                                                  :texture-user (texture-enable-mask-u32 warp)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-warp)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 warp)
+                                                  :texture-user (texture-enable-mask-u32 warp)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-texture-page (tpage-category-u32 map)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-index #x1
+                                                  :level-texture-page (tpage-category-u32 map)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-index #x2
+                                                  :level-texture-page (tpage-category-u32 map)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-index #x3
+                                                  :level-texture-page (tpage-category-u32 map)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-index #x4
+                                                  :level-texture-page (tpage-category-u32 map)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-index #x5
+                                                  :level-texture-page (tpage-category-u32 map)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 map)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                (new 'static 'texture-page-translate-item
+                                                  :bucket (bucket-id tex-all-map)
+                                                  :level-index #x6
+                                                  :level-texture-page (tpage-category-u32 alpha)
+                                                  :texture-user (texture-enable-mask-u32 map)
+                                                  )
+                                                )
+                                              )
   )
 
 ;; definition for symbol *eyes-texture-base*, type texture-base
diff --git a/test/decompiler/reference/jak2/engine/gfx/texture/texture-upload_REF.gc b/test/decompiler/reference/jak2/engine/gfx/texture/texture-upload_REF.gc
new file mode 100644
index 0000000000..66e92c35cd
--- /dev/null
+++ b/test/decompiler/reference/jak2/engine/gfx/texture/texture-upload_REF.gc
@@ -0,0 +1,33 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *generic-envmap-texture*, type texture
+(define *generic-envmap-texture* (lookup-texture-by-id (new 'static 'texture-id :index #x2 :page #x1f)))
+
+;; definition for symbol *default-envmap-shader*, type adgif-shader
+(define *default-envmap-shader* (new 'global 'adgif-shader))
+
+;; failed to figure out what this is:
+(let ((gp-0 *default-envmap-shader*))
+  (let ((a1-1 *generic-envmap-texture*))
+    (adgif-shader<-texture! gp-0 a1-1)
+    )
+  (set! (-> gp-0 tex1) (new 'static 'gs-tex1 :mmag #x1 :mmin #x1))
+  (set! (-> gp-0 clamp) (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp)))
+  (set! (-> gp-0 alpha) (new 'static 'gs-alpha :b #x2 :c #x1 :d #x1))
+  (set! (-> gp-0 prims 1) (gs-reg64 tex0-1))
+  (set! (-> gp-0 prims 3) (gs-reg64 tex1-1))
+  (set! (-> gp-0 prims 5) (gs-reg64 miptbp1-1))
+  (set! (-> gp-0 clamp-reg) (gs-reg64 clamp-1))
+  (set! (-> gp-0 prims 9) (gs-reg64 alpha-1))
+  )
+
+;; failed to figure out what this is:
+(set! (-> *texture-pool* allocate-func) texture-page-common-boot-allocate)
+
+;; failed to figure out what this is:
+(kmemopen global "tpages")
+
+
+
+
diff --git a/test/decompiler/reference/jak2/engine/gfx/texture/texture_REF.gc b/test/decompiler/reference/jak2/engine/gfx/texture/texture_REF.gc
new file mode 100644
index 0000000000..258e09d19f
--- /dev/null
+++ b/test/decompiler/reference/jak2/engine/gfx/texture/texture_REF.gc
@@ -0,0 +1,2472 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for method 2 of type texture-page
+(defmethod print texture-page ((obj texture-page))
+  (format
+    #t
+    "#<texture-page ~S :length ~D :dest #x~X :size ~DK @ #x~X>"
+    (-> obj name)
+    (-> obj length)
+    (shr (-> obj segment 0 dest) 6)
+    (shr (+ (-> obj size) 255) 8)
+    obj
+    )
+  obj
+  )
+
+;; definition for method 4 of type texture-page
+(defmethod length texture-page ((obj texture-page))
+  (-> obj length)
+  )
+
+;; definition for method 5 of type texture-page
+;; WARN: Return type mismatch uint vs int.
+(defmethod asize-of texture-page ((obj texture-page))
+  (the-as int (+ (-> obj type size) (* (-> obj length) 4)))
+  )
+
+;; definition for method 8 of type texture-page
+(defmethod mem-usage texture-page ((obj texture-page) (arg0 memory-usage-block) (arg1 int))
+  (set! (-> arg0 length) (max 83 (-> arg0 length)))
+  (set! (-> arg0 data 82 name) "texture")
+  (+! (-> arg0 data 82 count) (-> obj length))
+  (let ((v1-7 (+ (asize-of obj) (* (-> obj dram-size) 4))))
+    (dotimes (a0-6 (-> obj length))
+      (if (-> obj data a0-6)
+          (+! v1-7 112)
+          )
+      )
+    (+! (-> arg0 data 82 used) v1-7)
+    (+! (-> arg0 data 82 total) (logand -16 (+ v1-7 15)))
+    )
+  obj
+  )
+
+;; definition for function texture-bpp
+(defun texture-bpp ((tex-fmt gs-psm))
+  (case tex-fmt
+    (((gs-psm mt8))
+     8
+     )
+    (((gs-psm mt4))
+     4
+     )
+    (((gs-psm ct16) (gs-psm ct16s) (gs-psm mz16) (gs-psm mz16s))
+     16
+     )
+    (else
+      32
+      )
+    )
+  )
+
+;; definition for function texture-qwc
+(defun texture-qwc ((width int) (height int) (tex-fmt gs-psm))
+  (let ((v1-0 (texture-bpp tex-fmt)))
+    (/ (+ (* (* width height) v1-0) 127) 128)
+    )
+  )
+
+;; definition for function physical-address
+(defun physical-address ((ptr pointer))
+  (logand #xfffffff ptr)
+  )
+
+;; definition for function dma-buffer-add-ref-texture
+;; WARN: Return type mismatch symbol vs none.
+(defun dma-buffer-add-ref-texture ((dma-buf dma-buffer) (tex-data-ptr pointer) (width int) (height int) (tex-fmt gs-psm))
+  (let ((padr (physical-address tex-data-ptr))
+        (qwc-remaining (texture-qwc width height tex-fmt))
+        )
+    (while (> qwc-remaining 0)
+      (let ((qwc-transfer (min #x7fff qwc-remaining)))
+        (let ((eop (if (= qwc-remaining qwc-transfer)
+                       1
+                       0
+                       )
+                   )
+              )
+          (let* ((a2-2 dma-buf)
+                 (a3-1 (the-as object (-> a2-2 base)))
+                 )
+            (set! (-> (the-as dma-packet a3-1) dma) (new 'static 'dma-tag :qwc #x1 :id (dma-tag-id cnt)))
+            (set! (-> (the-as dma-packet a3-1) vif0) (new 'static 'vif-tag))
+            (set! (-> (the-as dma-packet a3-1) vif1) (new 'static 'vif-tag :imm #x1 :cmd (vif-cmd direct) :msk #x1))
+            (set! (-> a2-2 base) (&+ (the-as pointer a3-1) 16))
+            )
+          (let* ((a2-3 dma-buf)
+                 (a3-3 (the-as object (-> a2-3 base)))
+                 )
+            (set! (-> (the-as gs-gif-tag a3-3) tag)
+                  (new 'static 'gif-tag64 :flg (gif-flag image) :eop eop :nloop qwc-transfer)
+                  )
+            (set! (-> (the-as gs-gif-tag a3-3) regs) (new 'static 'gif-tag-regs))
+            (set! (-> a2-3 base) (&+ (the-as pointer a3-3) 16))
+            )
+          )
+        (let* ((a1-9 dma-buf)
+               (a2-4 (the-as object (-> a1-9 base)))
+               )
+          (set! (-> (the-as dma-packet a2-4) dma)
+                (new 'static 'dma-tag :id (dma-tag-id ref) :addr (the-as int padr) :qwc qwc-transfer)
+                )
+          (set! (-> (the-as dma-packet a2-4) vif0) (new 'static 'vif-tag))
+          (set! (-> (the-as dma-packet a2-4) vif1)
+                (new 'static 'vif-tag :cmd (vif-cmd direct) :msk #x1 :imm qwc-transfer)
+                )
+          (set! (-> a1-9 base) (&+ (the-as pointer a2-4) 16))
+          )
+        (&+! padr (* qwc-transfer 16))
+        (set! qwc-remaining (- qwc-remaining qwc-transfer))
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 2 of type texture
+(defmethod print texture ((obj texture))
+  (format
+    #t
+    "#<texture ~20S psm: ~6S  ~4D x ~4D  num-mips: ~D :size ~4DK "
+    (-> obj name)
+    (psm->string (-> obj psm))
+    (-> obj w)
+    (-> obj h)
+    (-> obj num-mips)
+    (shr (-> obj size) 8)
+    )
+  (dotimes (s5-1 (the-as int (-> obj num-mips)))
+    (format #t " #x~X/~X" (-> obj dest s5-1) (-> obj width s5-1))
+    )
+  (if (< (texture-bpp (-> obj psm)) 16)
+      (format #t " :clut #x~X/1" (-> obj clutdest))
+      )
+  (format #t " @ #x~X>" obj)
+  obj
+  )
+
+;; definition for function gs-find-block
+(defun gs-find-block ((bx int) (by int) (fmt gs-psm))
+  (cond
+    ((= fmt (gs-psm ct32))
+     (-> ct32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm ct24))
+     (-> ct32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm ct16))
+     (-> ct16-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm ct16s))
+     (-> ct16s-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm mz32))
+     (-> mz32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm mz24))
+     (-> mz32-24-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm mz16))
+     (-> mz16-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm mz16s))
+     (-> mz16s-block-table (+ bx (* by 4)))
+     )
+    ((= fmt (gs-psm mt8))
+     (-> mt8-block-table (+ bx (* by 8)))
+     )
+    ((= fmt (gs-psm mt4))
+     (-> mt4-block-table (+ bx (* by 4)))
+     )
+    (else
+      0
+      )
+    )
+  )
+
+;; definition for function gs-page-width
+(defun gs-page-width ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24) (gs-psm ct16) (gs-psm ct16s))
+     64
+     )
+    (((gs-psm mt8) (gs-psm mt4))
+     128
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+;; definition for function gs-page-height
+(defun gs-page-height ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24))
+     32
+     )
+    (((gs-psm ct16) (gs-psm ct16s))
+     64
+     )
+    (((gs-psm mt8))
+     64
+     )
+    (((gs-psm mt4))
+     128
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+;; definition for function gs-block-width
+(defun gs-block-width ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24))
+     8
+     )
+    (((gs-psm ct16) (gs-psm ct16s) (gs-psm mt8))
+     16
+     )
+    (((gs-psm mt4))
+     32
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+;; definition for function gs-block-height
+(defun gs-block-height ((arg0 gs-psm))
+  (case arg0
+    (((gs-psm ct32) (gs-psm ct24) (gs-psm ct16) (gs-psm ct16s))
+     8
+     )
+    (((gs-psm mt8) (gs-psm mt4))
+     16
+     )
+    (else
+      (format #t "Warning: Unknown block width for psm ~D~%" arg0)
+      1
+      )
+    )
+  )
+
+;; definition for function gs-largest-block
+(defun gs-largest-block ((arg0 int) (arg1 int) (arg2 gs-psm))
+  (let* ((s5-0 (gs-block-width arg2))
+         (v1-0 (gs-block-height arg2))
+         (a0-6 (* (/ (+ s5-0 -1 arg0) s5-0) s5-0))
+         (a1-4 (* (/ (+ v1-0 -1 arg1) v1-0) v1-0))
+         (s5-1 (/ a0-6 s5-0))
+         (s3-1 (/ a1-4 v1-0))
+         (s4-1 0)
+         )
+    (dotimes (s2-0 s5-1)
+      (dotimes (s1-0 s3-1)
+        (set! s4-1 (max s4-1 (gs-find-block s2-0 s1-0 arg2)))
+        )
+      )
+    s4-1
+    )
+  )
+
+;; definition for function gs-blocks-used
+(defun gs-blocks-used ((arg0 int) (arg1 int) (arg2 gs-psm))
+  (let* ((s4-0 (gs-page-width arg2))
+         (v1-0 (gs-page-height arg2))
+         (a0-6 (* (/ (+ s4-0 -1 arg0) s4-0) s4-0))
+         (a1-4 (* (/ (+ v1-0 -1 arg1) v1-0) v1-0))
+         (s3-0 (/ a0-6 s4-0))
+         (s1-0 (/ a1-4 v1-0))
+         (a0-9 (- arg0 (* (+ s3-0 -1) s4-0)))
+         (a1-7 (- arg1 (* (+ s1-0 -1) v1-0)))
+         )
+    (if (or (< a0-9 s4-0) (< a1-7 v1-0))
+        (+ (gs-largest-block a0-9 a1-7 arg2) 1 (* (+ (* s3-0 s1-0) -1) 32))
+        (* (* s1-0 s3-0) 32)
+        )
+    )
+  )
+
+;; definition for method 0 of type texture-pool
+(defmethod new texture-pool ((allocation symbol) (type-to-make type))
+  (initialize! (object-new allocation type-to-make (the-as int (-> type-to-make size))))
+  )
+
+;; definition for method 15 of type texture-pool
+(defmethod allocate-vram-words! texture-pool ((obj texture-pool) (arg0 int))
+  (let ((v0-0 (-> obj cur)))
+    (+! (-> obj cur) arg0)
+    v0-0
+    )
+  )
+
+;; definition for method 18 of type texture-pool
+(defmethod get-common-page-slot-by-id texture-pool ((obj texture-pool) (tpage-id int))
+  (case tpage-id
+    ((33)
+     1
+     )
+    ((34)
+     2
+     )
+    (else
+      -1
+      )
+    )
+  )
+
+;; definition for method 9 of type texture-pool
+(defmethod initialize! texture-pool ((obj texture-pool))
+  (set! (-> obj cur) 0)
+  (set! (-> obj top) (-> obj cur))
+  (set! (-> obj allocate-func) texture-page-default-allocate)
+  (allocate-defaults obj)
+  (format #t "font-palette start #x~x~%" (/ (-> obj cur) 64))
+  (set! (-> obj font-palette) (allocate-vram-words! obj 64))
+  (format #t "font-palette end #x~x~%" (/ (-> obj cur) 64))
+  (dotimes (v1-8 32)
+    (set! (-> obj common-page v1-8) (the-as texture-page 0))
+    )
+  (set! (-> obj common-page-mask) 0)
+  (set! (-> obj texture-enable-user-menu)
+        (texture-enable-mask tfrag pris shrub alpha water warp sprite map sky)
+        )
+  (set! (-> obj texture-enable-user) (texture-enable-mask tfrag pris shrub alpha water warp sprite map sky))
+  (dotimes (v1-13 128)
+    (set! (-> obj ids v1-13) (the-as uint 0))
+    )
+  obj
+  )
+
+;; definition for method 10 of type texture-page
+(defmethod get-leftover-block-count texture-page ((obj texture-page) (num-segments int) (upload-offset int))
+  (let ((offset upload-offset))
+    (dotimes (i num-segments)
+      (+! offset (-> obj segment i size))
+      )
+    (logand (/ offset 64) 63)
+    )
+  )
+
+;; definition for method 10 of type texture-pool
+(defmethod print-usage texture-pool ((obj texture-pool))
+  (format #t "--------------------~%")
+  (format
+    #t
+    "texture pool ~DK - ~DK (~DK used, ~DK free)~%"
+    (/ (-> obj top) 256)
+    (/ (-> obj cur) 256)
+    (/ (- (-> obj cur) (-> obj top)) 256)
+    (/ (- #xfa000 (-> obj cur)) 256)
+    )
+  (format #t "--------------------~%")
+  obj
+  )
+
+;; definition for method 16 of type texture-pool
+(defmethod allocate-segment texture-pool ((obj texture-pool) (seg texture-pool-segment) (num-words int))
+  (set! (-> seg size) (the-as uint num-words))
+  (set! (-> seg dest) (the-as uint (allocate-vram-words! obj num-words)))
+  seg
+  )
+
+;; definition for method 12 of type texture-pool
+;; WARN: Return type mismatch int vs none.
+(defmethod allocate-defaults texture-pool ((obj texture-pool))
+  (format #t "texture start #x~x~%" (/ (-> obj cur) 64))
+  (allocate-segment obj (-> obj segment-common) #x3e000)
+  (format #t "texture end #x~x~%" (/ (-> obj cur) 64))
+  (set! (-> *ocean-envmap-texture-base* vram-word) (the-as uint (allocate-vram-words! obj #x9400)))
+  (set! (-> *ocean-envmap-texture-base* vram-block) (shr (-> *ocean-envmap-texture-base* vram-word) 6))
+  (set! (-> *ocean-envmap-texture-base* vram-page) (shr (-> *ocean-envmap-texture-base* vram-word) 11))
+  (set! (-> *ocean-texture-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *ocean-texture-base* vram-block) (shr (-> *ocean-texture-base* vram-word) 6))
+  (set! (-> *ocean-texture-base* vram-page) (shr (-> *ocean-texture-base* vram-word) 11))
+  (set! (-> *grey-scale-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *grey-scale-base* vram-block) (shr (-> *grey-scale-base* vram-word) 6))
+  (set! (-> *grey-scale-base* vram-page) (shr (-> *grey-scale-base* vram-word) 11))
+  (set! (-> *eyes-texture-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *eyes-texture-base* vram-block) (shr (-> *eyes-texture-base* vram-word) 6))
+  (set! (-> *eyes-texture-base* vram-page) (shr (-> *eyes-texture-base* vram-word) 11))
+  (set! (-> *map-texture-base* vram-word) (+ (-> *ocean-envmap-texture-base* vram-word) 4096))
+  (set! (-> *map-texture-base* vram-block) (shr (-> *map-texture-base* vram-word) 6))
+  (set! (-> *map-texture-base* vram-page) (shr (-> *map-texture-base* vram-word) 11))
+  (set! (-> *skull-gem-texture-base* vram-word) (+ #x9000 (-> *ocean-envmap-texture-base* vram-word)))
+  (set! (-> *skull-gem-texture-base* vram-block) (shr (-> *skull-gem-texture-base* vram-word) 6))
+  (set! (-> *skull-gem-texture-base* vram-page) (shr (-> *skull-gem-texture-base* vram-word) 11))
+  (format #t "dynamic end #x~x~%" (/ (-> obj cur) 64))
+  0
+  (none)
+  )
+
+;; definition for method 9 of type texture-page
+(defmethod remove-data-from-heap texture-page ((obj texture-page) (heap kheap))
+  (set! (-> heap current) (-> obj segment 0 block-data))
+  obj
+  )
+
+;; definition for function texture-page-default-allocate
+(defun texture-page-default-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  (dotimes (seg 3)
+    (let ((vram-loc (allocate-vram-words! pool (the-as int (-> tpage segment seg size)))))
+      (relocate-dests! tpage vram-loc seg)
+      )
+    )
+  (upload-now! tpage (tex-upload-mode seg0-1-2))
+  (remove-data-from-heap tpage heap)
+  (set! (-> tpage dram-size) (the-as uint 0))
+  (dotimes (tex-idx (-> tpage length))
+    (let ((tex (-> tpage data tex-idx)))
+      (when tex
+        (dotimes (mask-idx 3)
+          (dotimes (mask-word 3)
+            (set! (-> (the-as texture (+ (+ (* mask-idx 16) (* mask-word 4)) (the-as int tex))) masks data 0 mask x) 0)
+            )
+          )
+        )
+      )
+    )
+  tpage
+  )
+
+;; definition for function texture-page-common-allocate
+(defun texture-page-common-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  (let ((vram-loc (-> pool segment-common dest)))
+    (dotimes (seg 3)
+      (relocate-dests! tpage (the-as int vram-loc) seg)
+      (+! vram-loc (-> tpage segment seg size))
+      )
+    )
+  (set! (-> tpage dram-size) (-> tpage size))
+  tpage
+  )
+
+;; definition for function texture-page-font-allocate
+(defun texture-page-font-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  (texture-page-common-allocate pool tpage heap tpage-id)
+  (upload-now! tpage (tex-upload-mode seg0-1-2))
+  (remove-data-from-heap tpage heap)
+  (set! (-> tpage dram-size) (the-as uint 0))
+  (dotimes (tex-idx (-> tpage length))
+    (let ((tex (-> tpage data tex-idx)))
+      (when tex
+        (dotimes (mask-idx 3)
+          (dotimes (mask-word 3)
+            (set! (-> (the-as texture (+ (+ (* mask-idx 16) (* mask-word 4)) (the-as int tex))) masks data 0 mask x) 0)
+            )
+          )
+        )
+      )
+    )
+  tpage
+  )
+
+;; definition for method 22 of type texture-pool
+;; WARN: Return type mismatch int vs none.
+(defmethod lay-out-sprite-tex texture-pool ((obj texture-pool))
+  (let ((vram-loc 0))
+    (countdown (level-idx 7)
+      (let ((lev (-> *level* level level-idx)))
+        (when (or (= (-> lev status) 'active)
+                  (= (-> lev status) 'alive)
+                  (= (-> lev status) 'loaded)
+                  (= (-> lev status) 'reserved)
+                  )
+          (let ((tpage (-> lev texture-page 7)))
+            (when tpage
+              (dotimes (seg 3)
+                (relocate-dests! tpage vram-loc seg)
+                (+! vram-loc (-> tpage segment seg size))
+                )
+              (set! vram-loc (shl (sar (+ vram-loc 4095) 12) 12))
+              )
+            )
+          )
+        )
+      (if (< #x3e000 vram-loc)
+          (format 0 "ERROR: Ran out of texture memory for SPRITE ~dk of 992k" (/ vram-loc 64))
+          )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 23 of type texture-pool
+;; WARN: Return type mismatch int vs none.
+(defmethod lay-out-hud-tex texture-pool ((obj texture-pool))
+  (let ((level-idx 0))
+    (countdown (vram-loc 7)
+      (let ((lev (-> *level* level vram-loc)))
+        (when (or (= (-> lev status) 'active)
+                  (= (-> lev status) 'alive)
+                  (= (-> lev status) 'loaded)
+                  (= (-> lev status) 'reserved)
+                  )
+          (let ((tpage (-> lev texture-page 8)))
+            (when tpage
+              (dotimes (seg 3)
+                (relocate-dests! tpage level-idx seg)
+                (+! level-idx (-> tpage segment seg size))
+                )
+              (set! level-idx (shl (sar (+ level-idx 4095) 12) 12))
+              )
+            )
+          )
+        )
+      )
+    (if (< #x3e000 level-idx)
+        (format 0 "ERROR: Ran out of texture memory for HUD ~dk of 992k" (/ level-idx 64))
+        )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 24 of type texture-pool
+;; WARN: Return type mismatch int vs none.
+(defmethod lay-out-warp-tex texture-pool ((obj texture-pool))
+  (let ((vram-loc 0))
+    (countdown (level-idx 7)
+      (let ((lev (-> *level* level level-idx)))
+        (when (or (= (-> lev status) 'active)
+                  (= (-> lev status) 'alive)
+                  (= (-> lev status) 'loaded)
+                  (= (-> lev status) 'reserved)
+                  )
+          (let ((tpage (-> lev texture-page 5)))
+            (when tpage
+              (let ((old-dest-base (-> tpage segment 0 dest))
+                    (new-dest-base vram-loc)
+                    )
+                (dotimes (s1-0 3)
+                  (relocate-dests! tpage vram-loc s1-0)
+                  (+! vram-loc (-> tpage segment s1-0 size))
+                  )
+                (set! vram-loc (shl (sar (+ vram-loc 4095) 12) 12))
+                (let ((new-tbp (shr (- new-dest-base (the-as int old-dest-base)) 6)))
+                  (when (nonzero? new-tbp)
+                    (dotimes (texture-idx (-> tpage length))
+                      (let ((adgif-iter
+                              (the-as
+                                object
+                                (* (-> (the-as shader-ptr (-> *texture-page-dir* entries (-> tpage id) link next texture-idx)) shader) 16)
+                                )
+                              )
+                            )
+                        (while (nonzero? (the-as uint adgif-iter))
+                          (+! (-> (the-as adgif-shader adgif-iter) tex0 tbp0) new-tbp)
+                          (+! (-> (the-as adgif-shader adgif-iter) tex0 cbp) new-tbp)
+                          (set! adgif-iter (* (-> (the-as adgif-shader adgif-iter) next shader) 16))
+                          )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    (if (< #xa000 vram-loc)
+        (format 0 "ERROR: Ran out of texture memory for WARP ~dk of 160k" (/ vram-loc 64))
+        )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 25 of type texture-pool
+;; WARN: Return type mismatch int vs none.
+(defmethod clear-ids texture-pool ((obj texture-pool))
+  (dotimes (v1-0 128)
+    (set! (-> obj ids v1-0) (the-as uint 0))
+    )
+  0
+  (none)
+  )
+
+;; definition for method 20 of type texture-pool
+;; WARN: Return type mismatch symbol vs none.
+(defmethod update-sprites texture-pool ((obj texture-pool))
+  (lay-out-sprite-tex obj)
+  (clear-ids obj)
+  (set! (-> obj update-sprites-flag) #f)
+  (none)
+  )
+
+;; definition for method 19 of type texture-pool
+;; WARN: Return type mismatch symbol vs none.
+(defmethod update-warp-and-hud texture-pool ((obj texture-pool))
+  (lay-out-hud-tex obj)
+  (lay-out-warp-tex obj)
+  (clear-ids obj)
+  (set! (-> obj update-flag) #f)
+  (none)
+  )
+
+;; definition for method 21 of type texture-pool
+;; WARN: Return type mismatch symbol vs none.
+(defmethod mark-hud-warp-sprite-dirty texture-pool ((obj texture-pool))
+  (set! (-> obj update-sprites-flag) #t)
+  (set! (-> obj update-flag) #t)
+  (none)
+  )
+
+;; definition for function texture-page-common-boot-allocate
+(defun texture-page-common-boot-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  (let ((common-page-slot-id (get-common-page-slot-by-id pool tpage-id)))
+    (cond
+      ((>= common-page-slot-id 0)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> pool common-page common-page-slot-id) tpage)
+       )
+      ((= tpage-id 917)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 0) tpage)
+       )
+      ((= tpage-id 918)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 1) tpage)
+       )
+      ((= tpage-id 1106)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 4) tpage)
+       )
+      ((= tpage-id 1141)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 9) tpage)
+       )
+      ((= tpage-id 12)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 7) tpage)
+       )
+      ((= tpage-id 1658)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 8) tpage)
+       )
+      ((= tpage-id 2841)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 5) tpage)
+       )
+      ((= tpage-id 2932)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 2) tpage)
+       )
+      ((= tpage-id 3219)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> *level* default-level texture-page 3) tpage)
+       )
+      ((= tpage-id 3076)
+       (texture-page-font-allocate pool tpage heap tpage-id)
+       )
+      (else
+        (set! (-> *texture-pool* allocate-func) texture-page-default-allocate)
+        (texture-page-default-allocate pool tpage heap tpage-id)
+        )
+      )
+    )
+  (set! (-> tpage dram-size) (-> tpage size))
+  tpage
+  )
+
+;; definition for function upload-vram-data
+;; WARN: Return type mismatch symbol vs none.
+(defun upload-vram-data ((buf dma-buffer) (dest int) (data pointer) (height int) (width int))
+  (while (> height 0)
+    (let ((height-this-time (min 2048 height)))
+      (let* ((v1-1 buf)
+             (a0-1 (the-as dma-packet (-> v1-1 base)))
+             )
+        (set! (-> a0-1 dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+        (set! (-> a0-1 vif0) (new 'static 'vif-tag))
+        (set! (-> a0-1 vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> v1-1 base) (the-as pointer (&+ a0-1 16)))
+        )
+      (let* ((v1-2 buf)
+             (a0-3 (the-as gs-gif-tag (-> v1-2 base)))
+             )
+        (set! (-> a0-3 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+        (set! (-> a0-3 regs) GIF_REGS_ALL_AD)
+        (set! (-> v1-2 base) (the-as pointer (&+ a0-3 16)))
+        )
+      (let* ((v1-3 buf)
+             (a0-5 (-> v1-3 base))
+             )
+        (set! (-> (the-as (pointer gs-bitbltbuf) a0-5) 0) (new 'static 'gs-bitbltbuf :dbw (/ width 64) :dbp dest))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 1) (gs-reg64 bitbltbuf))
+        (set! (-> (the-as (pointer gs-trxpos) a0-5) 2) (new 'static 'gs-trxpos))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 3) (gs-reg64 trxpos))
+        (set! (-> (the-as (pointer gs-trxreg) a0-5) 4) (new 'static 'gs-trxreg :rrw width :rrh height-this-time))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 5) (gs-reg64 trxreg))
+        (set! (-> (the-as (pointer gs-trxdir) a0-5) 6) (new 'static 'gs-trxdir))
+        (set! (-> (the-as (pointer gs-reg64) a0-5) 7) (gs-reg64 trxdir))
+        (set! (-> v1-3 base) (&+ a0-5 64))
+        )
+      (dma-buffer-add-ref-texture buf data width height-this-time (gs-psm ct32))
+      )
+    (+! dest 4096)
+    (&+! data #x100000)
+    (+! height -2048)
+    )
+  (none)
+  )
+
+;; definition for function upload-vram-pages
+(defun upload-vram-pages ((pool texture-pool)
+                 (dest-seg texture-pool-segment)
+                 (tpage texture-page)
+                 (mode tex-upload-mode)
+                 (bucket bucket-id)
+                 )
+  (local-vars
+    (data-ptr pointer)
+    (vram-ptr uint)
+    (tpage-num-chunks int)
+    (chunks-pending int)
+    (first-chunk int)
+    (tpage-id uint)
+    )
+  (if (not tpage)
+      (return 0)
+      )
+  (let ((num-chunks 0))
+    (let* ((dma-buf (-> *display* frames (-> *display* on-screen) global-buf))
+           (s4-0 (-> dma-buf base))
+           )
+      (set! data-ptr (-> tpage segment 0 block-data))
+      (set! vram-ptr (shr (-> tpage segment 0 dest) 12))
+      (set! tpage-num-chunks (the-as int (-> tpage segment 0 size)))
+      (set! chunks-pending 0)
+      (set! first-chunk 0)
+      (set! tpage-id (-> tpage id))
+      (case mode
+        (((tex-upload-mode none))
+         (return 0)
+         )
+        (((tex-upload-mode seg0))
+         )
+        (((tex-upload-mode seg0-1))
+         (set! tpage-num-chunks (the-as int (+ tpage-num-chunks (-> tpage segment 1 size))))
+         )
+        (((tex-upload-mode seg0-1-2))
+         (set! tpage-num-chunks (the-as int (-> tpage size)))
+         )
+        (((tex-upload-mode seg2))
+         (set! data-ptr (-> tpage segment 2 block-data))
+         (set! vram-ptr (shr (-> tpage segment 2 dest) 12))
+         (set! tpage-num-chunks (the-as int (-> tpage segment 2 size)))
+         )
+        )
+      (set! tpage-num-chunks (shr (min (the-as int (-> dest-seg size)) (the-as int (+ tpage-num-chunks 4095))) 12))
+      (dotimes (s1-0 tpage-num-chunks)
+        (let ((v1-28 (+ vram-ptr s1-0)))
+          (cond
+            ((zero? chunks-pending)
+             (when (!= (-> pool ids v1-28) tpage-id)
+               (set! first-chunk s1-0)
+               (set! (-> pool ids v1-28) tpage-id)
+               (set! chunks-pending (+ chunks-pending 1))
+               )
+             )
+            ((= (-> pool ids v1-28) tpage-id)
+             (upload-vram-data
+               dma-buf
+               (the-as int (* (+ vram-ptr first-chunk) 64))
+               (&+ data-ptr (shl first-chunk 14))
+               (* chunks-pending 32)
+               128
+               )
+             (+! num-chunks chunks-pending)
+             (set! chunks-pending 0)
+             0
+             )
+            (else
+              (set! (-> pool ids v1-28) tpage-id)
+              (set! chunks-pending (+ chunks-pending 1))
+              )
+            )
+          )
+        )
+      (when (nonzero? chunks-pending)
+        (upload-vram-data
+          dma-buf
+          (the-as int (* (+ vram-ptr first-chunk) 64))
+          (&+ data-ptr (shl first-chunk 14))
+          (* chunks-pending 32)
+          128
+          )
+        (+! num-chunks chunks-pending)
+        )
+      (let* ((v1-51 dma-buf)
+             (a0-24 (the-as dma-packet (-> v1-51 base)))
+             )
+        (set! (-> a0-24 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+        (set! (-> a0-24 vif0) (new 'static 'vif-tag))
+        (set! (-> a0-24 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> v1-51 base) (the-as pointer (&+ a0-24 16)))
+        )
+      (let* ((v1-52 dma-buf)
+             (a0-26 (the-as gs-gif-tag (-> v1-52 base)))
+             )
+        (set! (-> a0-26 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+        (set! (-> a0-26 regs) GIF_REGS_ALL_AD)
+        (set! (-> v1-52 base) (the-as pointer (&+ a0-26 16)))
+        )
+      (let* ((v1-53 dma-buf)
+             (a0-28 (-> v1-53 base))
+             )
+        (set! (-> (the-as (pointer int64) a0-28) 0) 1)
+        (set! (-> (the-as (pointer gs-reg64) a0-28) 1) (gs-reg64 texflush))
+        (set! (-> v1-53 base) (&+ a0-28 16))
+        )
+      (let ((a3-3 (-> dma-buf base)))
+        (let ((v1-54 (the-as dma-packet (-> dma-buf base))))
+          (set! (-> v1-54 dma) (new 'static 'dma-tag :id (dma-tag-id next)))
+          (set! (-> v1-54 vif0) (new 'static 'vif-tag))
+          (set! (-> v1-54 vif1) (new 'static 'vif-tag))
+          (set! (-> dma-buf base) (the-as pointer (&+ v1-54 16)))
+          )
+        (dma-bucket-insert-tag
+          (-> *display* frames (-> *display* on-screen) bucket-group)
+          bucket
+          s4-0
+          (the-as (pointer dma-tag) a3-3)
+          )
+        )
+      )
+    (shl num-chunks 14)
+    )
+  )
+
+;; definition for function update-vram-pages
+(defun update-vram-pages ((pool texture-pool) (dest-seg texture-pool-segment) (tpage texture-page) (mode tex-upload-mode))
+  (-> tpage segment 0 block-data)
+  (let ((vram-ptr (shr (-> tpage segment 0 dest) 12))
+        (tpage-num-chunks (-> tpage segment 0 size))
+        (chunks-pending 0)
+        )
+    0
+    (let ((tpage-id (-> tpage id)))
+      (cond
+        ((= mode (tex-upload-mode none))
+         (return 0)
+         )
+        ((= mode (tex-upload-mode seg0))
+         )
+        ((= mode (tex-upload-mode seg0-1))
+         (+! tpage-num-chunks (-> tpage segment 1 size))
+         )
+        ((= mode (tex-upload-mode seg0-1-2))
+         (set! tpage-num-chunks (-> tpage size))
+         )
+        ((= mode (tex-upload-mode seg2))
+         (-> tpage segment 2 block-data)
+         (set! vram-ptr (shr (-> tpage segment 2 dest) 12))
+         (set! tpage-num-chunks (-> tpage segment 2 size))
+         )
+        )
+      (let ((adjusted-num-chunks (shr (min (the-as int (-> dest-seg size)) (the-as int (+ tpage-num-chunks 4095))) 12)))
+        (dotimes (chunk-idx adjusted-num-chunks)
+          (let ((chunk-ptr (+ vram-ptr chunk-idx)))
+            (cond
+              ((zero? chunks-pending)
+               (when (!= (-> pool ids chunk-ptr) tpage-id)
+                 (set! (-> pool ids chunk-ptr) tpage-id)
+                 (+! chunks-pending 1)
+                 )
+               )
+              ((= (-> pool ids chunk-ptr) tpage-id)
+               (set! chunks-pending 0)
+               )
+              (else
+                (set! (-> pool ids chunk-ptr) tpage-id)
+                (+! chunks-pending 1)
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  0
+  )
+
+;; definition for function upload-vram-pages-pris
+(defun upload-vram-pages-pris ((pool texture-pool)
+                      (dest-seg texture-pool-segment)
+                      (tpage texture-page)
+                      (bucket bucket-id)
+                      (arg4 (pointer int32))
+                      )
+  (local-vars
+    (data-ptr pointer)
+    (vram-ptr uint)
+    (tpage-num-chunks int)
+    (chunks-pending int)
+    (first-chunk int)
+    (tpage-id uint)
+    (should-upload symbol)
+    )
+  (if (not tpage)
+      (return 0)
+      )
+  (let ((total-chunks-uploaded 0))
+    (let* ((dma-buf (-> *display* frames (-> *display* on-screen) global-buf))
+           (s4-0 (-> dma-buf base))
+           )
+      (set! data-ptr (-> tpage segment 0 block-data))
+      (set! vram-ptr (shr (-> tpage segment 0 dest) 12))
+      (set! tpage-num-chunks (the-as int (-> tpage size)))
+      (set! chunks-pending 0)
+      (set! first-chunk 0)
+      (set! tpage-id (-> tpage id))
+      (set! tpage-num-chunks (shr (min (the-as int (-> dest-seg size)) (the-as int (+ tpage-num-chunks 4095))) 12))
+      (dotimes (chunk-idx tpage-num-chunks)
+        (let ((chunk-dest (+ vram-ptr chunk-idx)))
+          (let ((mask-work (-> arg4 (/ chunk-idx 32))))
+            (set! should-upload (logtest? mask-work (ash 1 (logand chunk-idx 31))))
+            )
+          (cond
+            ((zero? chunks-pending)
+             (when (and (!= (-> pool ids chunk-dest) tpage-id) should-upload)
+               (set! first-chunk chunk-idx)
+               (set! (-> pool ids chunk-dest) tpage-id)
+               (set! chunks-pending (+ chunks-pending 1))
+               )
+             )
+            ((or (= (-> pool ids chunk-dest) tpage-id) (not should-upload))
+             (upload-vram-data
+               dma-buf
+               (the-as int (* (+ vram-ptr first-chunk) 64))
+               (&+ data-ptr (shl first-chunk 14))
+               (* chunks-pending 32)
+               128
+               )
+             (+! total-chunks-uploaded chunks-pending)
+             (set! chunks-pending 0)
+             0
+             )
+            (else
+              (set! (-> pool ids chunk-dest) tpage-id)
+              (set! chunks-pending (+ chunks-pending 1))
+              )
+            )
+          )
+        )
+      (when (nonzero? chunks-pending)
+        (upload-vram-data
+          dma-buf
+          (the-as int (* (+ vram-ptr first-chunk) 64))
+          (&+ data-ptr (shl first-chunk 14))
+          (* chunks-pending 32)
+          128
+          )
+        (+! total-chunks-uploaded chunks-pending)
+        )
+      (let* ((v1-40 dma-buf)
+             (a0-27 (the-as dma-packet (-> v1-40 base)))
+             )
+        (set! (-> a0-27 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+        (set! (-> a0-27 vif0) (new 'static 'vif-tag))
+        (set! (-> a0-27 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> v1-40 base) (the-as pointer (&+ a0-27 16)))
+        )
+      (let* ((v1-41 dma-buf)
+             (a0-29 (the-as gs-gif-tag (-> v1-41 base)))
+             )
+        (set! (-> a0-29 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+        (set! (-> a0-29 regs) GIF_REGS_ALL_AD)
+        (set! (-> v1-41 base) (the-as pointer (&+ a0-29 16)))
+        )
+      (let* ((v1-42 dma-buf)
+             (a0-31 (-> v1-42 base))
+             )
+        (set! (-> (the-as (pointer int64) a0-31) 0) 1)
+        (set! (-> (the-as (pointer gs-reg64) a0-31) 1) (gs-reg64 texflush))
+        (set! (-> v1-42 base) (&+ a0-31 16))
+        )
+      (let ((a3-5 (-> dma-buf base)))
+        (let ((v1-43 (the-as dma-packet (-> dma-buf base))))
+          (set! (-> v1-43 dma) (new 'static 'dma-tag :id (dma-tag-id next)))
+          (set! (-> v1-43 vif0) (new 'static 'vif-tag))
+          (set! (-> v1-43 vif1) (new 'static 'vif-tag))
+          (set! (-> dma-buf base) (the-as pointer (&+ v1-43 16)))
+          )
+        (dma-bucket-insert-tag
+          (-> *display* frames (-> *display* on-screen) bucket-group)
+          bucket
+          s4-0
+          (the-as (pointer dma-tag) a3-5)
+          )
+        )
+      )
+    (shl total-chunks-uploaded 14)
+    )
+  )
+
+;; definition for function texture-page-level-allocate
+(defun texture-page-level-allocate ((pool texture-pool) (tpage texture-page) (heap kheap) (tpage-id int))
+  (if (zero? (-> *level* loading-level code-memory-end))
+      (set! (-> *level* loading-level code-memory-end) (the-as pointer tpage))
+      )
+  (let ((common-page-slot-id (get-common-page-slot-by-id pool tpage-id)))
+    (cond
+      ((>= common-page-slot-id 0)
+       (texture-page-common-allocate pool tpage heap tpage-id)
+       (set! (-> pool common-page common-page-slot-id) tpage)
+       )
+      (else
+        (texture-page-common-allocate pool tpage heap tpage-id)
+        )
+      )
+    )
+  tpage
+  )
+
+;; definition for function texture-page-size-check
+(defun texture-page-size-check ((pool texture-pool) (lev level) (silent symbol))
+  (let ((gp-0 0))
+    (let ((v1-0 (-> lev texture-page 0)))
+      (when v1-0
+        (if (< (the-as uint #x3e000) (-> v1-0 size))
+            (set! gp-0 (logior gp-0 1))
+            )
+        (if (not silent)
+            (format
+              #t
+              "~Tlevel ~10S TFRAG  tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-0 name)
+              (shr (-> v1-0 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-2 (-> lev texture-page 1)))
+      (when v1-2
+        (if (< (the-as uint #x3e000) (-> v1-2 size))
+            (set! gp-0 (logior gp-0 2))
+            )
+        (if (not silent)
+            (format
+              #t
+              "~Tlevel ~10S PRIS  tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-2 name)
+              (shr (-> v1-2 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-4 (-> lev texture-page 6)))
+      (when v1-4
+        (if (< (the-as uint #x3e000) (-> v1-4 size))
+            (set! gp-0 (logior gp-0 64))
+            )
+        (if (not silent)
+            (format
+              #t
+              "~Tlevel ~10S PRIS2 tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-4 name)
+              (shr (-> v1-4 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-6 (-> lev texture-page 2)))
+      (when v1-6
+        (if (< (the-as uint #x3e000) (-> v1-6 size))
+            (set! gp-0 (logior gp-0 4))
+            )
+        (if (not silent)
+            (format
+              #t
+              "~Tlevel ~10S SHRUB tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-6 name)
+              (shr (-> v1-6 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-8 (-> lev texture-page 3)))
+      (when v1-8
+        (if (< (the-as uint #x3e000) (-> v1-8 size))
+            (set! gp-0 (logior gp-0 8))
+            )
+        (if (not silent)
+            (format
+              #t
+              "~Tlevel ~10S ALPHA tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-8 name)
+              (shr (-> v1-8 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-10 (-> lev texture-page 4)))
+      (when v1-10
+        (if (< (the-as uint #x3e000) (-> v1-10 size))
+            (set! gp-0 (logior gp-0 16))
+            )
+        (if (not silent)
+            (format
+              #t
+              "~Tlevel ~10S WATER tpage ~A uses ~DK of common ~DK~%"
+              (-> lev name)
+              (-> v1-10 name)
+              (shr (-> v1-10 size) 8)
+              992
+              )
+            )
+        )
+      )
+    (let ((v1-12 (-> lev texture-page 7)))
+      (when v1-12
+        (if (not silent)
+            (format #t "~Tlevel ~10S SPRITE tpage ~A uses ~DKK~%" (-> lev name) (-> v1-12 name) (shr (-> v1-12 size) 8))
+            )
+        )
+      )
+    (let ((v1-14 (-> lev texture-page 8)))
+      (when v1-14
+        (if (not silent)
+            (format #t "~Tlevel ~10S HUD tpage ~A uses ~DKK~%" (-> lev name) (-> v1-14 name) (shr (-> v1-14 size) 8))
+            )
+        )
+      )
+    (let ((v1-16 (-> lev texture-page 5)))
+      (when v1-16
+        (if (not silent)
+            (format #t "~Tlevel ~10S WARP tpage ~A uses ~DKK~%" (-> lev name) (-> v1-16 name) (shr (-> v1-16 size) 8))
+            )
+        )
+      )
+    gp-0
+    )
+  )
+
+;; definition for method 13 of type texture-pool
+;; WARN: Return type mismatch int vs none.
+(defmethod login-level-textures texture-pool ((pool texture-pool) (lev level) (num-tpage-ids int) (tpage-ids (pointer texture-id)))
+  (dotimes (v1-0 18)
+    (set! (-> lev texture-page v1-0) #f)
+    )
+  (dotimes (lev-tex-ids num-tpage-ids)
+    (let ((tpage-id (-> tpage-ids lev-tex-ids)))
+      (when (and (nonzero? tpage-id) (< lev-tex-ids 18))
+        (dotimes (loaded-tpage-idx (-> lev loaded-texture-page-count))
+          (when (= (-> lev loaded-texture-page loaded-tpage-idx id) (-> tpage-id page))
+            (let ((logged-in-tpage-id (texture-page-login tpage-id texture-page-common-allocate loading-level)))
+              (if (and logged-in-tpage-id (= (-> logged-in-tpage-id page) (-> lev loaded-texture-page loaded-tpage-idx)))
+                  (set! (-> lev texture-page lev-tex-ids) (-> logged-in-tpage-id page))
+                  )
+              )
+            (goto cfg-20)
+            )
+          )
+        )
+      )
+    (label cfg-20)
+    )
+  (let ((a2-3 (texture-page-size-check pool lev #t)))
+    (when (nonzero? a2-3)
+      (format #t "--------------------  tpage overflow error #x~X~%" a2-3)
+      (texture-page-size-check pool lev #f)
+      (format #t "--------------------~%")
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 14 of type texture-pool
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod add-level-tpage-dma texture-pool ((pool texture-pool) (lev level) (cat tpage-category) (bucket bucket-id))
+  (with-pp
+    (let ((tpage (-> lev texture-page cat)))
+      (-> lev closest-object-array cat)
+      (when (and tpage (nonzero? tpage))
+        (case cat
+          (((tpage-category tfrag))
+           (let ((v1-7 (-> lev texture-mask))
+                 (a0-2 (-> lev texture-mask 11))
+                 )
+             (dotimes (a1-1 3)
+               (set! (-> (&-> v1-7 0 mask data a1-1) 0)
+                     (logior (-> (the-as (pointer int32) (&-> v1-7 0 mask data a1-1)) 0) (-> a0-2 mask data a1-1))
+                     )
+               )
+             )
+           (set! (-> lev upload-size 0) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask))
+                                          )
+                 )
+           )
+          (((tpage-category shrub))
+           (let ((v1-11 (-> lev texture-mask 2))
+                 (a0-6 (-> lev texture-mask 13))
+                 )
+             (dotimes (a1-3 3)
+               (logior! (-> v1-11 mask data a1-3) (-> a0-6 mask data a1-3))
+               )
+             )
+           (set! (-> lev upload-size 2) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask 2))
+                                          )
+                 )
+           )
+          (((tpage-category alpha))
+           (cond
+             ((= (-> lev index) 6)
+              (if (not (-> *bigmap* auto-save-icon-flag))
+                  (set! (-> lev upload-size 8)
+                        (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                        )
+                  )
+              (set! (-> *bigmap* auto-save-icon-flag) #f)
+              )
+             (else
+               (let ((t0-13 (-> lev texture-mask 3)))
+                 (let ((v1-22 (-> lev texture-mask 14)))
+                   (dotimes (a0-12 3)
+                     (logior! (-> t0-13 mask data a0-12) (-> v1-22 mask data a0-12))
+                     )
+                   )
+                 (set! (-> lev upload-size 3)
+                       (upload-vram-pages-pris pool (-> pool segment-common) tpage bucket (the-as (pointer int32) t0-13))
+                       )
+                 )
+               )
+             )
+           )
+          (((tpage-category pris))
+           (set! (-> lev upload-size 1) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask 12))
+                                          )
+                 )
+           )
+          (((tpage-category water))
+           (let ((t0-15 (-> lev texture-mask 4)))
+             (let ((v1-27 (-> lev texture-mask 15)))
+               (dotimes (a0-19 3)
+                 (logior! (-> t0-15 mask data a0-19) (-> v1-27 mask data a0-19))
+                 )
+               )
+             (set! (-> lev upload-size 4)
+                   (upload-vram-pages-pris pool (-> pool segment-common) tpage bucket (the-as (pointer int32) t0-15))
+                   )
+             )
+           )
+          (((tpage-category warp))
+           (set! (-> lev upload-size 5)
+                 (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                 )
+           )
+          (((tpage-category pris2))
+           (set! (-> lev upload-size 6) (upload-vram-pages-pris
+                                          pool
+                                          (-> pool segment-common)
+                                          tpage
+                                          bucket
+                                          (the-as (pointer int32) (-> lev texture-mask 17))
+                                          )
+                 )
+           )
+          (((tpage-category sprite))
+           (if (or (= (-> lev display?) 'display) (= (-> lev display?) 'actor) (= (-> lev index) 6))
+               (set! (-> lev upload-size 7)
+                     (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                     )
+               )
+           )
+          (((tpage-category map))
+           (cond
+             ((= (-> lev index) 6)
+              (set! (-> lev upload-size 8)
+                    (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                    )
+              )
+             (else
+               (let ((t0-20 (-> lev texture-mask cat)))
+                 (set! (-> lev upload-size 8)
+                       (upload-vram-pages-pris pool (-> pool segment-common) tpage bucket (the-as (pointer int32) t0-20))
+                       )
+                 )
+               )
+             )
+           )
+          (((tpage-category sky))
+           (set! (-> lev upload-size 9)
+                 (upload-vram-pages pool (-> pool segment-common) tpage (tex-upload-mode seg0-1-2) bucket)
+                 )
+           )
+          )
+        (let ((s2-0 (-> lev texture-anim-array cat)))
+          (cond
+            ((= cat (tpage-category warp))
+             (when (= (-> lev index) 6)
+               (dotimes (s2-1 7)
+                 (let ((v1-54 (-> *level* level s2-1)))
+                   (when (or (= (-> v1-54 status) 'active) (= (-> v1-54 status) 'reserved))
+                     (if (-> v1-54 texture-anim-array 5)
+                         (update-texture-anim bucket)
+                         )
+                     )
+                   )
+                 )
+               )
+             )
+            ((= cat (tpage-category sky))
+             (cond
+               ((and (level-get-target-inside *level*) (= (-> (level-get-target-inside *level*) info taskname) 'nest))
+                (let ((f30-0 (-> pp clock seconds-per-frame)))
+                  (set! (-> pp clock seconds-per-frame) (* 10.0 (-> pp clock seconds-per-frame)))
+                  (if s2-0
+                      (update-texture-anim bucket)
+                      )
+                  (set! (-> pp clock seconds-per-frame) f30-0)
+                  )
+                )
+               (else
+                 (if s2-0
+                     (update-texture-anim bucket)
+                     )
+                 )
+               )
+             )
+            (else
+              (if s2-0
+                  (update-texture-anim bucket)
+                  )
+              )
+            )
+          )
+        )
+      )
+    (let ((v1-77 (-> lev texture-dirty-masks cat)))
+      (dotimes (a0-58 128)
+        (let ((a2-2 (-> v1-77 mask data (/ a0-58 32))))
+          (when (logtest? a2-2 (ash 1 (logand a0-58 31)))
+            (set! (-> pool ids a0-58) (the-as uint 0))
+            0
+            )
+          )
+        )
+      (set! (-> v1-77 mask quad) (the-as uint128 0))
+      )
+    0
+    0
+    (none)
+    )
+  )
+
+;; definition for function set-skull-gem-masks
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch uint128 vs none.
+(defun set-skull-gem-masks ()
+  (local-vars (v0-3 uint128) (v1-2 uint128) (v1-3 uint128))
+  (let ((gp-0 (-> *level* default-level texture-mask)))
+    (let* ((s5-0 (lookup-texture-by-id (new 'static 'texture-id :index #x28 :page #x395)))
+           (s4-0 (lookup-texture-by-id (new 'static 'texture-id :index #x25 :page #x395)))
+           (a0-4 (lookup-texture-by-id (new 'static 'texture-id :index #x26 :page #x395)))
+           (v1-1 (-> gp-0 0 mask quad))
+           (a1-0 (-> s5-0 masks data 0 mask quad))
+           (a2-0 (-> s4-0 masks data 0 mask quad))
+           (a0-5 (-> a0-4 masks data 0 mask quad))
+           )
+      (.por v1-2 v1-1 a1-0)
+      (.por v1-3 v1-2 a2-0)
+      (.por v0-3 v1-3 a0-5)
+      )
+    (set! (-> gp-0 0 mask quad) v0-3)
+    )
+  (none)
+  )
+
+;; definition for function upload-textures
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defun upload-textures ((arg0 texture-pool))
+  (cond
+    ((not (-> *blit-displays-work* screen-copied))
+     (set-skull-gem-masks)
+     (set! (-> *level* default-level texture-anim-array 0) *skull-gem-texture-anim-array*)
+     )
+    (else
+      (set! (-> *level* default-level texture-anim-array 0) #f)
+      )
+    )
+  (dotimes (lev-idx 7)
+    (let ((lev (-> *level* level lev-idx)))
+      (when (or (= (-> lev status) 'active) (= (-> lev status) 'reserved))
+        (dotimes (a1-6 18)
+          (set! (-> lev upload-size a1-6) 0)
+          )
+        )
+      )
+    )
+  (dotimes (num-tpage (-> *texture-page-translate* length))
+    (let* ((tpage-info (-> *texture-page-translate* num-tpage))
+           (src-level (-> *level* draw-level (-> tpage-info level-index)))
+           )
+      (when (= num-tpage 63)
+        (nop!)
+        (nop!)
+        0
+        )
+      (when (and src-level (logtest? (the-as texture-enable-mask-u32 (-> *texture-pool* texture-enable-user))
+                                     (-> tpage-info texture-user)
+                                     )
+                 )
+        (cond
+          ((= (-> tpage-info level-index) 6)
+           (add-level-tpage-dma
+             arg0
+             src-level
+             (the-as tpage-category (-> tpage-info level-texture-page))
+             (-> tpage-info bucket)
+             )
+           )
+          (else
+            (if (not (-> *blit-displays-work* menu-mode))
+                (add-level-tpage-dma
+                  arg0
+                  src-level
+                  (the-as tpage-category (-> tpage-info level-texture-page))
+                  (-> tpage-info bucket)
+                  )
+                )
+            )
+          )
+        )
+      )
+    )
+  (dotimes (v1-16 7)
+    (let ((a0-30 (-> *level* level v1-16)))
+      (when (or (= (-> a0-30 status) 'active) (= (-> a0-30 status) 'reserved))
+        (dotimes (a1-15 18)
+          (set! (-> a0-30 closest-object-array a1-15) 4095996000.0)
+          (set! (-> a0-30 texture-mask a1-15 mask quad) (the-as uint128 0))
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(kmemopen global "texture-dma-buffers")
+
+;; definition for symbol *txt-dma-list*, type dma-buffer
+(define *txt-dma-list* (new 'global 'dma-buffer 4096))
+
+;; failed to figure out what this is:
+(kmemclose)
+
+;; definition for method 13 of type texture-page
+;; WARN: Return type mismatch int vs none.
+(defmethod upload-now! texture-page ((obj texture-page) (arg0 tex-upload-mode))
+  (let ((gp-0 *txt-dma-list*))
+    (let ((v1-0 gp-0))
+      (set! (-> v1-0 base) (-> v1-0 data))
+      (set! (-> v1-0 end) (&-> v1-0 data-buffer (-> v1-0 allocated-length)))
+      )
+    (add-to-dma-buffer obj gp-0 arg0)
+    (let* ((v1-3 gp-0)
+           (a0-1 (the-as dma-packet (-> v1-3 base)))
+           )
+      (set! (-> a0-1 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+      (set! (-> a0-1 vif0) (new 'static 'vif-tag))
+      (set! (-> a0-1 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+      (set! (-> v1-3 base) (the-as pointer (&+ a0-1 16)))
+      )
+    (let* ((v1-4 gp-0)
+           (a0-3 (the-as gs-gif-tag (-> v1-4 base)))
+           )
+      (set! (-> a0-3 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+      (set! (-> a0-3 regs) GIF_REGS_ALL_AD)
+      (set! (-> v1-4 base) (the-as pointer (&+ a0-3 16)))
+      )
+    (let* ((v1-5 gp-0)
+           (a0-5 (-> v1-5 base))
+           )
+      (set! (-> (the-as (pointer int64) a0-5) 0) 1)
+      (set! (-> (the-as (pointer gs-reg64) a0-5) 1) (gs-reg64 texflush))
+      (set! (-> v1-5 base) (&+ a0-5 16))
+      )
+    (let* ((v1-6 gp-0)
+           (a0-7 (the-as object (-> v1-6 base)))
+           )
+      (set! (-> (the-as dma-packet a0-7) dma) (new 'static 'dma-tag :id (dma-tag-id end)))
+      (set! (-> (the-as (pointer int64) a0-7) 1) 0)
+      (set! (-> v1-6 base) (&+ (the-as pointer a0-7) 16))
+      )
+    (dma-buffer-send-chain (the-as dma-bank-source #x1000a000) gp-0)
+    )
+  (dma-sync (the-as pointer #x1000a000) 0 0)
+  (none)
+  )
+
+;; definition for method 12 of type texture-page
+(defmethod add-to-dma-buffer texture-page ((obj texture-page) (arg0 dma-buffer) (arg1 tex-upload-mode))
+  (local-vars (sv-16 int))
+  (let ((v1-0 arg1))
+    (set! sv-16 (cond
+                  ((= v1-0 (tex-upload-mode none))
+                   0
+                   )
+                  ((= v1-0 (tex-upload-mode seg0-1))
+                   (the-as int (+ (-> obj segment 0 size) (-> obj segment 1 size)))
+                   )
+                  ((= v1-0 (tex-upload-mode seg0-1-2))
+                   (the-as int (-> obj size))
+                   )
+                  (else
+                    (the-as int (-> obj segment (the-as int arg1) size))
+                    )
+                  )
+          )
+    )
+  (let* ((v1-7 (max 0 (the-as int arg1)))
+         (a3-4 (* (/ (+ (/ sv-16 64) 63) 64) 32))
+         (t1-0 (shr (-> obj segment v1-7 dest) 6))
+         (a2-10 (-> obj segment v1-7 block-data))
+         )
+    (upload-vram-data arg0 (the-as int t1-0) a2-10 a3-4 128)
+    )
+  sv-16
+  )
+
+;; definition for function texture-relocate
+(defun texture-relocate ((dma-buff dma-buffer) (tex texture) (dest-loc int) (dest-fmt gs-psm) (clut-dst int))
+  (dotimes (v1-0 (the-as int (-> tex num-mips)))
+    (let ((t1-1 (ash (-> tex w) (- v1-0)))
+          (t2-3 (ash (-> tex h) (- v1-0)))
+          )
+      (let* ((t3-2 dma-buff)
+             (t4-0 (the-as object (-> t3-2 base)))
+             )
+        (set! (-> (the-as dma-packet t4-0) dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+        (set! (-> (the-as dma-packet t4-0) vif0) (new 'static 'vif-tag))
+        (set! (-> (the-as dma-packet t4-0) vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+        (set! (-> t3-2 base) (&+ (the-as pointer t4-0) 16))
+        )
+      (let* ((t3-3 dma-buff)
+             (t4-2 (the-as object (-> t3-3 base)))
+             )
+        (set! (-> (the-as gs-gif-tag t4-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+        (set! (-> (the-as gs-gif-tag t4-2) regs) GIF_REGS_ALL_AD)
+        (set! (-> t3-3 base) (&+ (the-as pointer t4-2) 16))
+        )
+      (let* ((t3-4 dma-buff)
+             (t4-4 (-> t3-4 base))
+             )
+        (set! (-> (the-as (pointer gs-bitbltbuf) t4-4) 0) (new 'static 'gs-bitbltbuf
+                                                            :sbp (-> tex dest v1-0)
+                                                            :sbw (-> tex width v1-0)
+                                                            :spsm (the-as int (-> tex psm))
+                                                            :dbp (/ dest-loc 64)
+                                                            :dbw (-> tex width v1-0)
+                                                            :dpsm (the-as int dest-fmt)
+                                                            )
+              )
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 1) (gs-reg64 bitbltbuf))
+        (set! (-> (the-as (pointer gs-trxpos) t4-4) 2) (new 'static 'gs-trxpos))
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 3) (gs-reg64 trxpos))
+        (set! (-> (the-as (pointer gs-trxreg) t4-4) 4) (new 'static 'gs-trxreg :rrw t1-1 :rrh t2-3))
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 5) (gs-reg64 trxreg))
+        (set! (-> (the-as (pointer gs-trxdir) t4-4) 6) (new 'static 'gs-trxdir :xdir #x2))
+        (set! (-> (the-as (pointer gs-reg64) t4-4) 7) (gs-reg64 trxdir))
+        (set! (-> t3-4 base) (&+ t4-4 64))
+        )
+      )
+    (set! (-> tex dest v1-0) (the-as uint (/ dest-loc 64)))
+    )
+  (cond
+    ((< clut-dst 0)
+     )
+    ((= (-> tex psm) (gs-psm mt4))
+     (let* ((v1-7 dma-buff)
+            (a2-2 (the-as object (-> v1-7 base)))
+            )
+       (set! (-> (the-as dma-packet a2-2) dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+       (set! (-> (the-as dma-packet a2-2) vif0) (new 'static 'vif-tag))
+       (set! (-> (the-as dma-packet a2-2) vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+       (set! (-> v1-7 base) (&+ (the-as pointer a2-2) 16))
+       )
+     (let* ((v1-8 dma-buff)
+            (a2-4 (the-as object (-> v1-8 base)))
+            )
+       (set! (-> (the-as gs-gif-tag a2-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+       (set! (-> (the-as gs-gif-tag a2-4) regs) GIF_REGS_ALL_AD)
+       (set! (-> v1-8 base) (&+ (the-as pointer a2-4) 16))
+       )
+     (let* ((v1-9 dma-buff)
+            (a2-6 (-> v1-9 base))
+            )
+       (set! (-> (the-as (pointer gs-bitbltbuf) a2-6) 0) (new 'static 'gs-bitbltbuf
+                                                           :sbw #x1
+                                                           :dbw #x1
+                                                           :dpsm (-> tex clutpsm)
+                                                           :dbp (/ clut-dst 64)
+                                                           :spsm (-> tex clutpsm)
+                                                           :sbp (-> tex clutdest)
+                                                           )
+             )
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 1) (gs-reg64 bitbltbuf))
+       (set! (-> (the-as (pointer gs-trxpos) a2-6) 2) (new 'static 'gs-trxpos))
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 3) (gs-reg64 trxpos))
+       (set! (-> (the-as (pointer gs-trxreg) a2-6) 4) (new 'static 'gs-trxreg :rrw #x8 :rrh #x2))
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 5) (gs-reg64 trxreg))
+       (set! (-> (the-as (pointer gs-trxdir) a2-6) 6) (new 'static 'gs-trxdir :xdir #x2))
+       (set! (-> (the-as (pointer gs-reg64) a2-6) 7) (gs-reg64 trxdir))
+       (set! (-> v1-9 base) (&+ a2-6 64))
+       )
+     (set! (-> tex clutdest) (the-as uint (/ clut-dst 64)))
+     )
+    ((= (-> tex psm) (gs-psm mt8))
+     (let* ((v1-13 dma-buff)
+            (a2-9 (the-as object (-> v1-13 base)))
+            )
+       (set! (-> (the-as dma-packet a2-9) dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt)))
+       (set! (-> (the-as dma-packet a2-9) vif0) (new 'static 'vif-tag))
+       (set! (-> (the-as dma-packet a2-9) vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1))
+       (set! (-> v1-13 base) (&+ (the-as pointer a2-9) 16))
+       )
+     (let* ((v1-14 dma-buff)
+            (a2-11 (the-as object (-> v1-14 base)))
+            )
+       (set! (-> (the-as gs-gif-tag a2-11) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4))
+       (set! (-> (the-as gs-gif-tag a2-11) regs) GIF_REGS_ALL_AD)
+       (set! (-> v1-14 base) (&+ (the-as pointer a2-11) 16))
+       )
+     (let* ((v1-15 dma-buff)
+            (a2-13 (-> v1-15 base))
+            )
+       (set! (-> (the-as (pointer gs-bitbltbuf) a2-13) 0) (new 'static 'gs-bitbltbuf
+                                                            :sbw #x2
+                                                            :dbw #x2
+                                                            :dpsm (-> tex clutpsm)
+                                                            :dbp (/ clut-dst 64)
+                                                            :spsm (-> tex clutpsm)
+                                                            :sbp (-> tex clutdest)
+                                                            )
+             )
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 1) (gs-reg64 bitbltbuf))
+       (set! (-> (the-as (pointer gs-trxpos) a2-13) 2) (new 'static 'gs-trxpos))
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 3) (gs-reg64 trxpos))
+       (set! (-> (the-as (pointer gs-trxreg) a2-13) 4) (new 'static 'gs-trxreg :rrw #x10 :rrh #x10))
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 5) (gs-reg64 trxreg))
+       (set! (-> (the-as (pointer gs-trxdir) a2-13) 6) (new 'static 'gs-trxdir :xdir #x2))
+       (set! (-> (the-as (pointer gs-reg64) a2-13) 7) (gs-reg64 trxdir))
+       (set! (-> v1-15 base) (&+ a2-13 64))
+       )
+     (set! (-> tex clutdest) (the-as uint (/ clut-dst 64)))
+     )
+    )
+  (set! (-> tex psm) dest-fmt)
+  dma-buff
+  )
+
+;; definition for method 11 of type texture-pool
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 16 signed mismatch
+;; WARN: Stack slot offset 16 signed mismatch
+;; WARN: Stack slot offset 16 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 20 signed mismatch
+;; WARN: Stack slot offset 16 signed mismatch
+;; WARN: Stack slot offset 16 signed mismatch
+;; WARN: Stack slot offset 16 signed mismatch
+;; WARN: Return type mismatch int vs none.
+(defmethod setup-font-texture texture-pool ((obj texture-pool))
+  (local-vars (sv-16 int) (sv-20 int))
+  (let ((s3-0 (-> obj font-palette)))
+    (set! sv-16 (-> obj cur))
+    (set! sv-20 (/ s3-0 64))
+    (let ((s5-0
+            (texture-page-login (new 'static 'texture-id :index #x1 :page #xc04) texture-page-default-allocate global)
+            )
+          )
+      (if (and s5-0 (-> s5-0 page))
+          (set! sv-16 (the-as int (-> s5-0 page segment 0 dest)))
+          )
+      (let ((s4-0 *txt-dma-list*))
+        (let ((v1-6 s4-0))
+          (set! (-> v1-6 base) (-> v1-6 data))
+          (set! (-> v1-6 end) (&-> v1-6 data-buffer (-> v1-6 allocated-length)))
+          )
+        (let ((s2-0 (lookup-texture-by-id (new 'static 'texture-id :index #x1 :page #xc04)))
+              (s1-0 #xc2000)
+              (s0-0 36)
+              )
+          (set! (-> s2-0 h) 320)
+          (texture-relocate s4-0 s2-0 s1-0 (the-as gs-psm s0-0) s3-0)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-0-tmpl)) s2-0 s1-0 s0-0 sv-20)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-2-tmpl)) s2-0 s1-0 s0-0 sv-20)
+          )
+        (let ((s3-1 (lookup-texture-by-id (new 'static 'texture-id :page #xc04)))
+              (s2-1 #xc2000)
+              (s1-1 44)
+              )
+          (set! (-> s3-1 h) 320)
+          (texture-relocate s4-0 s3-1 s2-1 (the-as gs-psm s1-1) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-1-tmpl)) s3-1 s2-1 s1-1 sv-20)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* small-font-3-tmpl)) s3-1 s2-1 s1-1 sv-20)
+          )
+        (let ((s3-2 (lookup-texture-by-id (new 'static 'texture-id :index #x4 :page #xc04)))
+              (s2-2 #x90000)
+              (s1-2 36)
+              )
+          (set! (-> s3-2 h) 800)
+          (texture-relocate s4-0 s3-2 s2-2 (the-as gs-psm s1-2) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-0-tmpl)) s3-2 s2-2 s1-2 sv-20)
+          )
+        (let ((s3-3 (lookup-texture-by-id (new 'static 'texture-id :index #x2 :page #xc04)))
+              (s2-3 #x90000)
+              (s1-3 44)
+              )
+          (set! (-> s3-3 h) 800)
+          (texture-relocate s4-0 s3-3 s2-3 (the-as gs-psm s1-3) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-1-tmpl)) s3-3 s2-3 s1-3 sv-20)
+          )
+        (let ((s3-4 (lookup-texture-by-id (new 'static 'texture-id :index #x5 :page #xc04)))
+              (s2-4 #x5e000)
+              (s1-4 36)
+              )
+          (set! (-> s3-4 h) 800)
+          (texture-relocate s4-0 s3-4 s2-4 (the-as gs-psm s1-4) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-2-tmpl)) s3-4 s2-4 s1-4 sv-20)
+          )
+        (let ((s3-5 (lookup-texture-by-id (new 'static 'texture-id :index #x3 :page #xc04)))
+              (s2-5 #x5e000)
+              (s1-5 44)
+              )
+          (set! (-> s3-5 h) 800)
+          (texture-relocate s4-0 s3-5 s2-5 (the-as gs-psm s1-5) -1)
+          (font-set-tex0 (the-as (pointer gs-tex0) (-> *font-work* large-font-3-tmpl)) s3-5 s2-5 s1-5 sv-20)
+          )
+        (let* ((v1-28 s4-0)
+               (a0-26 (the-as dma-packet (-> v1-28 base)))
+               )
+          (set! (-> a0-26 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+          (set! (-> a0-26 vif0) (new 'static 'vif-tag))
+          (set! (-> a0-26 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+          (set! (-> v1-28 base) (the-as pointer (&+ a0-26 16)))
+          )
+        (let* ((v1-29 s4-0)
+               (a0-28 (the-as gs-gif-tag (-> v1-29 base)))
+               )
+          (set! (-> a0-28 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+          (set! (-> a0-28 regs) GIF_REGS_ALL_AD)
+          (set! (-> v1-29 base) (the-as pointer (&+ a0-28 16)))
+          )
+        (let* ((v1-30 s4-0)
+               (a0-30 (-> v1-30 base))
+               )
+          (set! (-> (the-as (pointer int64) a0-30) 0) 1)
+          (set! (-> (the-as (pointer gs-reg64) a0-30) 1) (gs-reg64 texflush))
+          (set! (-> v1-30 base) (&+ a0-30 16))
+          )
+        (let* ((v1-31 s4-0)
+               (a0-32 (the-as object (-> v1-31 base)))
+               )
+          (set! (-> (the-as dma-packet a0-32) dma) (new 'static 'dma-tag :id (dma-tag-id end)))
+          (set! (-> (the-as (pointer int64) a0-32) 1) 0)
+          (set! (-> v1-31 base) (&+ (the-as pointer a0-32) 16))
+          )
+        (dma-buffer-send-chain (the-as dma-bank-source #x10009000) s4-0)
+        )
+      (dma-sync (the-as pointer #x10009000) 0 0)
+      (if (and s5-0 (-> s5-0 page) (= (-> obj cur) (+ sv-16 (-> s5-0 page size))))
+          (set! (-> obj cur) sv-16)
+          (format 0 "ERROR: could not resize texture pool to remove gamefont.~%")
+          )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 5 of type texture-page-dir
+;; WARN: Return type mismatch uint vs int.
+(defmethod asize-of texture-page-dir ((obj texture-page-dir))
+  (the-as int (+ (-> texture-page-dir size) (* 12 (+ (-> obj length) -1))))
+  )
+
+;; definition for method 4 of type texture-page-dir
+(defmethod length texture-page-dir ((obj texture-page-dir))
+  (-> obj length)
+  )
+
+;; definition for method 7 of type texture-page-dir
+;; WARN: Return type mismatch texture-page-dir vs none.
+(defmethod relocate texture-page-dir ((obj texture-page-dir) (arg0 kheap) (arg1 (pointer uint8)))
+  (set! *texture-page-dir* obj)
+  (none)
+  )
+
+;; definition for method 11 of type texture-page
+;; WARN: Return type mismatch texture-page vs none.
+(defmethod relocate-dests! texture-page ((obj texture-page) (new-dest int) (segs int))
+  (let ((new-tbp (shr new-dest 6))
+        (old-tbp (shr (-> obj segment segs dest) 6))
+        )
+    (when (!= new-tbp old-tbp)
+      (dotimes (tex-idx (-> obj length))
+        (when (-> obj data tex-idx)
+          (let* ((tex (-> obj data tex-idx))
+                 (num-mips (-> tex num-mips))
+                 )
+            (if (zero? segs)
+                (set! (-> tex clutdest) (+ (- (-> tex clutdest) old-tbp) new-tbp))
+                )
+            (dotimes (mip-idx (the-as int num-mips))
+              (let ((t4-0 mip-idx)
+                    (t5-0 num-mips)
+                    )
+                (if (= segs (if (>= (the-as uint 2) t5-0)
+                                (+ (- -1 t4-0) t5-0)
+                                (max 0 (- 2 t4-0))
+                                )
+                       )
+                    (set! (-> tex dest mip-idx) (+ (- (-> tex dest mip-idx) old-tbp) new-tbp))
+                    )
+                )
+              )
+            )
+          )
+        )
+      (set! (-> obj segment segs dest) (the-as uint new-dest))
+      )
+    )
+  (none)
+  )
+
+;; definition for method 7 of type texture-page
+(defmethod relocate texture-page ((obj texture-page) (loading-heap kheap) (name (pointer uint8)))
+  (cond
+    ((or (not obj) (not (file-info-correct-version? (-> obj info) (file-kind tpage) 0)))
+     (the-as texture-page #f)
+     )
+    (else
+      (let ((loading-level (-> *level* loading-level)))
+        (when loading-level
+          (set! (-> loading-level loaded-texture-page (-> loading-level loaded-texture-page-count)) obj)
+          (+! (-> loading-level loaded-texture-page-count) 1)
+          (if (and (>= (-> loading-level loaded-texture-page-count) 2) (zero? (-> loading-level load-buffer-mode)))
+              (set! (-> loading-level load-buffer-mode) (load-buffer-mode small-center))
+              )
+          )
+        )
+      (set! (-> obj segment 1 dest) (-> obj segment 0 size))
+      (set! (-> obj segment 2 dest) (+ (-> obj segment 0 size) (-> obj segment 1 size)))
+      (let* ((tpage-id (-> obj id))
+             (dir-entry (-> *texture-page-dir* entries tpage-id))
+             )
+        (set! (-> *texture-relocate-later* memcpy) #f)
+        ((-> *texture-pool* allocate-func) *texture-pool* obj loading-heap (the-as int tpage-id))
+        (cond
+          ((not (-> *texture-relocate-later* memcpy))
+           (set! (-> dir-entry page) obj)
+           (if (not (-> dir-entry link))
+               (set! (-> dir-entry link)
+                     (the-as texture-link (malloc 'loading-level (* (max (-> dir-entry length) (-> obj length)) 4)))
+                     )
+               )
+           )
+          (else
+            (let ((v1-19 *texture-relocate-later*))
+              (set! (-> v1-19 entry) dir-entry)
+              (set! (-> v1-19 page) obj)
+              )
+            )
+          )
+        )
+      obj
+      )
+    )
+  )
+
+;; definition for function relocate-later
+(defun relocate-later ()
+  (let ((gp-0 *texture-relocate-later*))
+    (let ((s5-0 (-> gp-0 entry))
+          (s4-0 (-> gp-0 page))
+          )
+      (ultimate-memcpy (the-as pointer (-> gp-0 dest)) (the-as pointer (-> gp-0 source)) (-> gp-0 move))
+      (set! (-> s5-0 page) s4-0)
+      (if (not (-> s5-0 link))
+          (set! (-> s5-0 link)
+                (the-as texture-link (malloc 'loading-level (* (max (-> s5-0 length) (-> s4-0 length)) 4)))
+                )
+          )
+      )
+    (set! (-> gp-0 memcpy) #f)
+    )
+  #f
+  )
+
+;; definition for function texture-page-login
+(defun texture-page-login ((tex-id texture-id) (alloc-func (function texture-pool texture-page kheap int texture-page)) (heap kheap))
+  (when (and (nonzero? (-> tex-id page)) (< (-> tex-id page) (the-as uint (-> *texture-page-dir* length))))
+    (let ((dir-entry (-> *texture-page-dir* entries (-> tex-id page))))
+      (when (not (-> dir-entry page))
+        (let ((old-alloc-func (-> *texture-pool* allocate-func)))
+          (set! (-> *texture-pool* allocate-func) alloc-func)
+          (let* ((name (make-file-name (file-kind tpage) (the-as string (* (-> tex-id page) 8)) 0 #f))
+                 (loaded-tpage (the-as texture-page (loado name heap)))
+                 )
+            (if loaded-tpage
+                (relocate loaded-tpage heap (charp-basename (-> name data)))
+                )
+            )
+          (set! (-> *texture-pool* allocate-func) old-alloc-func)
+          )
+        )
+      dir-entry
+      )
+    )
+  )
+
+;; definition for function lookup-texture-by-id
+(defun lookup-texture-by-id ((arg0 texture-id))
+  (let ((a0-2 (texture-page-login arg0 texture-page-default-allocate loading-level))
+        (v1-0 (the-as texture-page #f))
+        )
+    (if (and a0-2 (begin (set! v1-0 (-> a0-2 page)) v1-0) (< (-> arg0 index) (the-as uint (-> v1-0 length))))
+        (-> v1-0 data (-> arg0 index))
+        )
+    )
+  )
+
+;; definition for function lookup-texture-by-id-fast
+(defun lookup-texture-by-id-fast ((arg0 texture-id))
+  (let ((a1-2 (if (and (nonzero? (-> arg0 page)) (< (-> arg0 page) (the-as uint (-> *texture-page-dir* length))))
+                  (-> *texture-page-dir* entries (-> arg0 page))
+                  )
+              )
+        (v1-6 (the-as texture-page #f))
+        )
+    (if (and a1-2 (begin (set! v1-6 (-> a1-2 page)) v1-6) (< (-> arg0 index) (the-as uint (-> v1-6 length))))
+        (-> v1-6 data (-> arg0 index))
+        )
+    )
+  )
+
+;; definition for function lookup-texture-by-name
+(defun lookup-texture-by-name ((arg0 string) (arg1 string) (arg2 (pointer texture-page)))
+  (local-vars (sv-16 texture-page-dir))
+  (set! sv-16 *texture-page-dir*)
+  (dotimes (s3-0 (-> sv-16 length))
+    (let ((s2-0 (-> sv-16 entries s3-0 page)))
+      (when (and s2-0 (or (not arg1) (string= (-> s2-0 name) arg1)))
+        (dotimes (s1-0 (-> s2-0 length))
+          (let ((s0-0 (-> s2-0 data s1-0)))
+            (when (and s0-0 (string= (-> s0-0 name) arg0))
+              (if arg2
+                  (set! (-> arg2 0) s2-0)
+                  )
+              (return s0-0)
+              )
+            )
+          )
+        )
+      )
+    )
+  (the-as texture #f)
+  )
+
+;; definition for function lookup-texture-id-by-name
+;; WARN: Return type mismatch int vs texture-id.
+(defun lookup-texture-id-by-name ((arg0 string) (arg1 string))
+  (local-vars (sv-16 texture-page-dir))
+  (set! sv-16 *texture-page-dir*)
+  (dotimes (gp-0 (-> sv-16 length))
+    (let ((s3-0 (-> sv-16 entries gp-0 page)))
+      (when (and s3-0 (or (not arg1) (string= (-> s3-0 name) arg1)))
+        (dotimes (s2-0 (-> s3-0 length))
+          (let ((v1-7 (-> s3-0 data s2-0)))
+            (if (and v1-7 (string= (-> v1-7 name) arg0))
+                (return (new 'static 'texture-id :page gp-0 :index s2-0))
+                )
+            )
+          )
+        )
+      )
+    )
+  (the-as texture-id 0)
+  )
+
+;; definition for function lookup-level-texture-by-name
+(defun lookup-level-texture-by-name ((arg0 string) (arg1 level) (arg2 (pointer texture-page)))
+  (dotimes (s3-0 18)
+    (let ((s2-0 (-> arg1 texture-page s3-0)))
+      (when (and s2-0 (nonzero? s2-0))
+        (dotimes (s1-0 (-> s2-0 length))
+          (let ((s0-0 (-> s2-0 data s1-0)))
+            (when (and s0-0 (string= (-> s0-0 name) arg0))
+              (if arg2
+                  (set! (-> arg2 0) s2-0)
+                  )
+              (return s0-0)
+              )
+            )
+          )
+        )
+      )
+    )
+  (lookup-texture-by-name arg0 (the-as string #f) arg2)
+  )
+
+;; definition for method 17 of type texture-pool
+;; WARN: Return type mismatch int vs none.
+(defmethod unload-page texture-pool ((obj texture-pool) (arg0 texture-page))
+  (local-vars (a0-2 int))
+  (let ((v1-0 *texture-page-dir*))
+    (dotimes (a0-1 (-> v1-0 length))
+      (when (= arg0 (-> v1-0 entries a0-1 page))
+        (set! a0-2 a0-1)
+        (goto cfg-7)
+        )
+      )
+    (set! a0-2 -1)
+    (label cfg-7)
+    (when (>= a0-2 0)
+      (set! (-> v1-0 entries a0-2 page) #f)
+      (set! (-> v1-0 entries a0-2 link) #f)
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for symbol *shader-list*, type pair
+(define *shader-list* '())
+
+;; definition for symbol *edit-shader*, type texture-id
+(define *edit-shader* (new 'static 'texture-id))
+
+;; definition for function link-texture-by-id
+(defun link-texture-by-id ((arg0 texture-id) (arg1 adgif-shader))
+  (when (not (or (zero? (-> arg0 page)) (>= (-> arg0 page) (the-as uint (-> *texture-page-dir* length)))))
+    (let ((s4-0 (-> *texture-page-dir* entries (-> arg0 page))))
+      (if (not (-> s4-0 link))
+          (set! (-> s4-0 link) (the-as texture-link (malloc 'loading-level (* (-> s4-0 length) 4))))
+          )
+      (when (< (-> arg0 index) (the-as uint (-> s4-0 length)))
+        (set! (-> arg1 next shader) (-> s4-0 link next (-> arg0 index) shader))
+        (set! (-> s4-0 link next (-> arg0 index) shader) (shr (the-as int arg1) 4))
+        )
+      s4-0
+      )
+    )
+  )
+
+;; definition for method 9 of type texture-page-dir
+(defmethod unlink-shaders-in-heap texture-page-dir ((obj texture-page-dir) (heap kheap))
+  (local-vars (dist-past-end uint))
+  (let ((mem-start (-> heap base))
+        (mem-end (-> heap top-base))
+        )
+    (dotimes (entry-idx (-> obj length))
+      (let* ((entry (-> obj entries entry-idx))
+             (tex-page (-> entry page))
+             )
+        (when tex-page
+          (let ((link-arr (-> entry link next))
+                (tex-count (min (-> tex-page length) (-> entry length)))
+                )
+            0
+            (when link-arr
+              (dotimes (tex-idx tex-count)
+                (let ((link-slot (&-> link-arr 0))
+                      (shader (the-as adgif-shader (* (-> link-arr 0 shader) 16)))
+                      )
+                  (while (nonzero? (the-as uint shader))
+                    (b!
+                      (< (the-as int (- (the-as uint shader) (the-as uint mem-start))) 0)
+                      cfg-8
+                      :delay (set! dist-past-end (- (the-as uint shader) mem-end))
+                      )
+                    (b! (>= (the-as int dist-past-end) 0) cfg-8 :delay (nop!))
+                    (let ((t4-2 (-> shader next)))
+                      (b! #t cfg-9 :delay (set! (-> link-slot 0) t4-2))
+                      )
+                    (label cfg-8)
+                    (set! link-slot (&-> shader next))
+                    (label cfg-9)
+                    (set! shader (the-as adgif-shader (* (-> shader next shader) 16)))
+                    )
+                  )
+                (set! link-arr (&-> link-arr 1))
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  0
+  )
+
+;; definition for function adgif-shader<-texture!
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function adgif-shader-update!
+;; WARN: Return type mismatch gs-tex1 vs none.
+(defun adgif-shader-update! ((arg0 adgif-shader) (arg1 texture))
+  (let ((s5-0 (the int (/ 256.0 (-> arg1 uv-dist)))))
+    (case (-> arg0 tex1 l)
+      ((1)
+       (set! (-> arg0 tex1 k) (+ (logand (ash s5-0 (- 5 (log2 s5-0))) 31) -350 (* (log2 s5-0) 32)))
+       )
+      (else
+        (set! (-> arg0 tex1 k) (+ (logand (ash s5-0 (- 4 (log2 s5-0))) 15) -175 (* (log2 s5-0) 16)))
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for function adgif-shader<-texture-with-update!
+;; ERROR: function was not converted to expressions. Cannot decompile.
+
+;; definition for function hack-texture
+(defun hack-texture ((arg0 texture))
+  (set! (-> arg0 uv-dist) 1000000.0)
+  (set! (-> arg0 masks data 0 mask w) (the-as int (+ 40960000.0 (-> arg0 masks data 0 dist))))
+  (let ((f0-4 (+ 40960000.0 (-> arg0 masks data 1 dist))))
+    (set! (-> arg0 masks data 1 mask w) (the-as int f0-4))
+    f0-4
+    )
+  )
+
+;; definition for function adgif-shader-login
+(defun adgif-shader-login ((arg0 adgif-shader))
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (set! (-> arg0 texture-id) (level-remap-texture (-> arg0 texture-id)))
+    (when (= (-> arg0 texture-id page) 2797)
+      (nop!)
+      (nop!)
+      0
+      )
+    (link-texture-by-id (-> arg0 texture-id) arg0)
+    (let ((s5-0 (lookup-texture-by-id (-> arg0 texture-id))))
+      (cond
+        (s5-0
+          (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+              (hack-texture s5-0)
+              )
+          (adgif-shader<-texture-with-update! arg0 s5-0)
+          )
+        (else
+          (format
+            0
+            "login<1> could not find texture ~X in obj ~A shader ~X~%"
+            (-> arg0 texture-id)
+            (-> *kernel-context* login-object)
+            arg0
+            )
+          )
+        )
+      s5-0
+      )
+    )
+  )
+
+;; definition for function adgif-shader-login-no-remap
+(defun adgif-shader-login-no-remap ((arg0 adgif-shader))
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (link-texture-by-id (-> arg0 texture-id) arg0)
+    (let ((s5-0 (lookup-texture-by-id (-> arg0 texture-id))))
+      (cond
+        (s5-0
+          (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+              (hack-texture s5-0)
+              )
+          (adgif-shader<-texture-with-update! arg0 s5-0)
+          )
+        (else
+          (format
+            0
+            "login<2> could not find texture ~X in obj ~A shader ~X~%"
+            (-> arg0 texture-id)
+            (-> *kernel-context* login-object)
+            arg0
+            )
+          )
+        )
+      s5-0
+      )
+    )
+  )
+
+;; definition for function adgif-shader-login-fast
+(defun adgif-shader-login-fast ((arg0 adgif-shader))
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (set! (-> arg0 texture-id) (level-remap-texture (-> arg0 texture-id)))
+    (let ((v1-4 (-> arg0 texture-id)))
+      (when (and (nonzero? (-> v1-4 page)) (< (-> v1-4 page) (the-as uint (-> *texture-page-dir* length))))
+        (let ((a0-9 (-> *texture-page-dir* entries (-> v1-4 page))))
+          (when (and (< (-> v1-4 index) (the-as uint (-> a0-9 length))) (-> a0-9 link))
+            (set! (-> arg0 next shader) (-> a0-9 link next (-> v1-4 index) shader))
+            (set! (-> a0-9 link next (-> v1-4 index) shader) (shr (the-as int arg0) 4))
+            )
+          (when (and (-> a0-9 page) (< (-> v1-4 index) (the-as uint (-> a0-9 page length))))
+            (let ((s5-0 (-> a0-9 page data (-> v1-4 index))))
+              (when s5-0
+                (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+                    (hack-texture s5-0)
+                    )
+                (adgif-shader<-texture-with-update! arg0 s5-0)
+                )
+              s5-0
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function adgif-shader-login-no-remap-fast
+(defun adgif-shader-login-no-remap-fast ((arg0 adgif-shader))
+  (when (logtest? (-> arg0 link-test) (link-test-flags needs-log-in))
+    (logclear! (-> arg0 link-test) (link-test-flags needs-log-in bit-9))
+    (let ((v1-4 (-> arg0 texture-id)))
+      (when (and (nonzero? (-> v1-4 page)) (< (-> v1-4 page) (the-as uint (-> *texture-page-dir* length))))
+        (let ((a0-8 (-> *texture-page-dir* entries (-> v1-4 page))))
+          (when (and (< (-> v1-4 index) (the-as uint (-> a0-8 length))) (-> a0-8 link))
+            (set! (-> arg0 next shader) (-> a0-8 link next (-> v1-4 index) shader))
+            (set! (-> a0-8 link next (-> v1-4 index) shader) (shr (the-as int arg0) 4))
+            )
+          (when (and (-> a0-8 page) (< (-> v1-4 index) (the-as uint (-> a0-8 page length))))
+            (let ((s5-0 (-> a0-8 page data (-> v1-4 index))))
+              (when s5-0
+                (if (and *debug-segment* (-> *screen-shot-work* highres-enable))
+                    (hack-texture s5-0)
+                    )
+                (adgif-shader<-texture-with-update! arg0 s5-0)
+                )
+              s5-0
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(when (not *debug-segment*)
+  (set! adgif-shader-login adgif-shader-login-fast)
+  (set! adgif-shader-login-no-remap adgif-shader-login-no-remap-fast)
+  )
+
+;; definition for function adgif-shader<-texture-simple!
+(defun adgif-shader<-texture-simple! ((arg0 adgif-shader) (arg1 texture))
+  (set! (-> arg0 tex1) (new 'static 'gs-tex1 :mmag #x1 :mmin #x1))
+  (set! (-> arg0 tex0 tfx) 0)
+  (if arg1
+      (adgif-shader<-texture! arg0 arg1)
+      )
+  (set! (-> arg0 clamp) (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp)))
+  (set! (-> arg0 alpha) (new 'static 'gs-alpha :b #x1 :d #x1))
+  (set! (-> arg0 prims 1) (gs-reg64 tex0-1))
+  (set! (-> arg0 prims 3) (gs-reg64 tex1-1))
+  (set! (-> arg0 prims 5) (gs-reg64 miptbp1-1))
+  (set! (-> arg0 clamp-reg) (gs-reg64 clamp-1))
+  (set! (-> arg0 prims 9) (gs-reg64 alpha-1))
+  arg0
+  )
+
+;; definition for function set-dirty-mask!
+;; WARN: Return type mismatch int vs none.
+(defun set-dirty-mask! ((arg0 level) (arg1 int) (arg2 int) (arg3 int))
+  (let ((s4-0 (sar (+ arg2 #x3fff) 14))
+        (s5-0 (sar (+ arg3 #x3fff) 14))
+        (gp-0 (-> arg0 texture-dirty-masks arg1))
+        (v1-5 (new 'stack 'texture-mask))
+        )
+    (cond
+      ((< 64 s4-0)
+       (set! (-> v1-5 mask dword 0) (the-as uint -1))
+       (set! (-> v1-5 mask dword 1) (the-as uint (+ (ash 1 (+ s4-0 -64)) -1)))
+       )
+      (else
+        (set! (-> v1-5 mask dword 0) (the-as uint (+ (ash 1 s4-0) -1)))
+        )
+      )
+    (when (nonzero? s5-0)
+      (set! (-> v1-5 mask dword 1)
+            (logior (ash (-> v1-5 mask dword 1) s5-0) (ash (-> v1-5 mask dword 0) (+ s5-0 -64)))
+            )
+      (set! (-> v1-5 mask dword 0) (ash (-> v1-5 mask dword 0) s5-0))
+      )
+    (set! (-> gp-0 mask dword 0) (the-as uint (logior (-> gp-0 mask dword 0) (-> v1-5 mask dword 0))))
+    (set! (-> gp-0 mask dword 1) (the-as uint (logior (-> gp-0 mask dword 1) (-> v1-5 mask dword 1))))
+    )
+  0
+  (none)
+  )
+
+;; definition (debug) for function texture-page-dir-inspect
+;; WARN: Return type mismatch texture-page-dir vs none.
+(defun-debug texture-page-dir-inspect ((arg0 texture-page-dir) (arg1 symbol))
+  (format #t "[~8x] ~A~%" arg0 (-> arg0 type))
+  (let ((v1-0 *texture-pool*))
+    (format
+      #t
+      "~Ttexture pool (~DK used, ~DK free)~%"
+      (/ (- (-> v1-0 cur) (-> v1-0 top)) 256)
+      (/ (- (shl (-> *video-params* display-fbp) 11) (-> v1-0 cur)) 256)
+      )
+    )
+  (dotimes (s4-0 (-> *level* length))
+    (let ((a1-3 (-> *level* level s4-0)))
+      (if (= (-> a1-3 status) 'active)
+          (texture-page-size-check *texture-pool* a1-3 #f)
+          )
+      )
+    )
+  (format #t "~Tlength: ~D~%" (-> arg0 length))
+  (format #t "~Tdata[~D]: @ #x~X~%" (-> arg0 length) (-> arg0 entries))
+  (dotimes (s4-1 (-> arg0 length))
+    (let ((s3-0 (-> arg0 entries s4-1 page))
+          (s2-0 (-> arg0 entries s4-1 link))
+          )
+      (cond
+        (s3-0
+          (format
+            #t
+            "~T  [~3D]   loaded ~S ~A~%"
+            s4-1
+            (if s2-0
+                "  linked"
+                "unlinked"
+                )
+            s3-0
+            )
+          )
+        (else
+          (if (= arg1 'full)
+              (format
+                #t
+                "~T  [~3D] unloaded ~S #<texture-page :length ~D>~%"
+                s4-1
+                (if s2-0
+                    "  linked"
+                    "unlinked"
+                    )
+                (-> arg0 entries s4-1 length)
+                )
+              )
+          )
+        )
+      (when (and (or s3-0 s2-0) arg1)
+        (dotimes (s1-0 (-> arg0 entries s4-1 length))
+          (cond
+            ((not s2-0)
+             (format #t "~T    [~3D]   unlinked" s1-0)
+             )
+            ((zero? (-> s2-0 next s1-0 shader))
+             (format #t "~T    [~3D]   UNUSED  " s1-0)
+             )
+            (else
+              (let ((t9-9 format)
+                    (a0-12 #t)
+                    (a1-10 "~T    [~3D] ~3D links ")
+                    (a2-11 s1-0)
+                    (a3-9 0)
+                    )
+                (let ((v1-40 (the-as object (* (-> s2-0 next s1-0 shader) 16))))
+                  (while (nonzero? (the-as uint v1-40))
+                    (nop!)
+                    (+! a3-9 1)
+                    (set! v1-40 (* (-> (the-as adgif-shader v1-40) next shader) 16))
+                    )
+                  )
+                (t9-9 a0-12 a1-10 a2-11 a3-9)
+                )
+              )
+            )
+          (cond
+            ((not s3-0)
+             (format #t " unloaded~%")
+             )
+            ((not (-> s3-0 data s1-0))
+             (format #t "    empty~%")
+             )
+            (else
+              (format #t " ~A~%" (-> s3-0 data s1-0))
+              )
+            )
+          )
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 3 of type texture-page-dir
+(defmethod inspect texture-page-dir ((obj texture-page-dir))
+  (texture-page-dir-inspect obj #f)
+  obj
+  )
+
+;; definition for symbol *texture-pool*, type texture-pool
+(define *texture-pool* (new 'global 'texture-pool))
+
+
+
+
diff --git a/test/decompiler/reference/jak2/engine/level/level-h_REF.gc b/test/decompiler/reference/jak2/engine/level/level-h_REF.gc
index 8b234e6c21..a4f80bfc39 100644
--- a/test/decompiler/reference/jak2/engine/level/level-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/level/level-h_REF.gc
@@ -664,7 +664,7 @@
    (load-time             float                           :offset-assert 156)
    (load-login-time       float                           :offset-assert 160)
    (draw-level-count      int32                           :offset-assert 164)
-   (draw-level            basic                 7         :offset-assert 168)
+   (draw-level            level                 7         :offset-assert 168)
    (draw-index-map        uint8                 7         :offset-assert 196)
    (load-order            uint64                          :offset-assert 208)
    (pad                   uint8                 30        :offset-assert 216)
diff --git a/test/decompiler/reference/jak2/engine/math/vector-h_REF.gc b/test/decompiler/reference/jak2/engine/math/vector-h_REF.gc
index 7e4f0d236d..0e56d29c7a 100644
--- a/test/decompiler/reference/jak2/engine/math/vector-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/math/vector-h_REF.gc
@@ -387,7 +387,7 @@
 
 ;; definition of type vector4w
 (deftype vector4w (structure)
-  ((data  uint32  4 :offset-assert   0)
+  ((data  int32   4 :offset-assert   0)
    (x     int32     :offset          0)
    (y     int32     :offset          4)
    (z     int32     :offset          8)
diff --git a/test/decompiler/reference/jak2/engine/sound/gsound_REF.gc b/test/decompiler/reference/jak2/engine/sound/gsound_REF.gc
index 988cb420f4..fbb387e310 100644
--- a/test/decompiler/reference/jak2/engine/sound/gsound_REF.gc
+++ b/test/decompiler/reference/jak2/engine/sound/gsound_REF.gc
@@ -883,7 +883,7 @@
              )
            )
        (when v1-2
-         (set! sv-32 (string->sound-name (the-as string (-> (the-as (pointer uint32) (+ #xff37 (the-as int v1-2)))))))
+         (set! sv-32 (string->sound-name (symbol->string v1-2)))
          (set! sv-48 (res-lump-data (the-as res-lump arg0) 'cycle-speed (pointer float)))
          (set! sv-16 *ambient-spec*)
          (set! sv-64 (new 'static 'res-tag))
diff --git a/test/decompiler/reference/jak2/engine/util/profile_REF.gc b/test/decompiler/reference/jak2/engine/util/profile_REF.gc
index c9120d74d7..ac824b63e9 100644
--- a/test/decompiler/reference/jak2/engine/util/profile_REF.gc
+++ b/test/decompiler/reference/jak2/engine/util/profile_REF.gc
@@ -113,43 +113,43 @@
 
 ;; definition for function profile-texture-test
 (defun profile-texture-test ((arg0 bucket-id))
-  (or (= arg0 (bucket-id bucket-4))
-      (= arg0 (bucket-id bucket-7))
-      (= arg0 (bucket-id bucket-18))
-      (= arg0 (bucket-id bucket-29))
-      (= arg0 (bucket-id bucket-40))
-      (= arg0 (bucket-id bucket-51))
-      (= arg0 (bucket-id bucket-62))
-      (= arg0 (bucket-id bucket-73))
-      (= arg0 (bucket-id bucket-82))
-      (= arg0 (bucket-id bucket-91))
-      (= arg0 (bucket-id bucket-100))
-      (= arg0 (bucket-id bucket-109))
-      (= arg0 (bucket-id bucket-118))
-      (= arg0 (bucket-id bucket-127))
-      (= arg0 (bucket-id bucket-137))
-      (= arg0 (bucket-id bucket-147))
-      (= arg0 (bucket-id bucket-157))
-      (= arg0 (bucket-id bucket-167))
-      (= arg0 (bucket-id bucket-177))
-      (= arg0 (bucket-id bucket-187))
-      (= arg0 (bucket-id bucket-196))
-      (= arg0 (bucket-id bucket-200))
-      (= arg0 (bucket-id bucket-204))
-      (= arg0 (bucket-id bucket-208))
-      (= arg0 (bucket-id bucket-212))
-      (= arg0 (bucket-id bucket-216))
-      (= arg0 (bucket-id bucket-220))
-      (= arg0 (bucket-id bucket-252))
-      (= arg0 (bucket-id bucket-261))
-      (= arg0 (bucket-id bucket-270))
-      (= arg0 (bucket-id bucket-279))
-      (= arg0 (bucket-id bucket-288))
-      (= arg0 (bucket-id bucket-297))
-      (= arg0 (bucket-id bucket-306))
-      (= arg0 (bucket-id bucket-312))
-      (= arg0 (bucket-id bucket-316))
-      (= arg0 (bucket-id bucket-319))
+  (or (= arg0 (bucket-id tex-lcom-sky-pre))
+      (= arg0 (bucket-id tex-l0-tfrag))
+      (= arg0 (bucket-id tex-l1-tfrag))
+      (= arg0 (bucket-id tex-l2-tfrag))
+      (= arg0 (bucket-id tex-l3-tfrag))
+      (= arg0 (bucket-id tex-l4-tfrag))
+      (= arg0 (bucket-id tex-l5-tfrag))
+      (= arg0 (bucket-id tex-l0-shrub))
+      (= arg0 (bucket-id tex-l1-shrub))
+      (= arg0 (bucket-id tex-l2-shrub))
+      (= arg0 (bucket-id tex-l3-shrub))
+      (= arg0 (bucket-id tex-l4-shrub))
+      (= arg0 (bucket-id tex-l5-shrub))
+      (= arg0 (bucket-id tex-l0-alpha))
+      (= arg0 (bucket-id tex-l1-alpha))
+      (= arg0 (bucket-id tex-l2-alpha))
+      (= arg0 (bucket-id tex-l3-alpha))
+      (= arg0 (bucket-id tex-l4-alpha))
+      (= arg0 (bucket-id tex-l5-alpha))
+      (= arg0 (bucket-id tex-lcom-tfrag))
+      (= arg0 (bucket-id tex-l0-pris))
+      (= arg0 (bucket-id tex-l1-pris))
+      (= arg0 (bucket-id tex-l2-pris))
+      (= arg0 (bucket-id tex-l3-pris))
+      (= arg0 (bucket-id tex-l4-pris))
+      (= arg0 (bucket-id tex-l5-pris))
+      (= arg0 (bucket-id tex-lcom-pris))
+      (= arg0 (bucket-id tex-l0-water))
+      (= arg0 (bucket-id tex-l1-water))
+      (= arg0 (bucket-id tex-l2-water))
+      (= arg0 (bucket-id tex-l3-water))
+      (= arg0 (bucket-id tex-l4-water))
+      (= arg0 (bucket-id tex-l5-water))
+      (= arg0 (bucket-id tex-lcom-water))
+      (= arg0 (bucket-id tex-all-sprite))
+      (= arg0 (bucket-id tex-all-warp))
+      (= arg0 (bucket-id tex-all-map))
       )
   )
 
@@ -255,86 +255,86 @@
 
 ;; definition for function profile-merc-test
 (defun profile-merc-test ((arg0 bucket-id))
-  (or (= arg0 (bucket-id bucket-14))
-      (= arg0 (bucket-id bucket-25))
-      (= arg0 (bucket-id bucket-36))
-      (= arg0 (bucket-id bucket-47))
-      (= arg0 (bucket-id bucket-58))
-      (= arg0 (bucket-id bucket-69))
-      (= arg0 (bucket-id bucket-79))
-      (= arg0 (bucket-id bucket-88))
-      (= arg0 (bucket-id bucket-97))
-      (= arg0 (bucket-id bucket-106))
-      (= arg0 (bucket-id bucket-115))
-      (= arg0 (bucket-id bucket-124))
-      (= arg0 (bucket-id bucket-131))
-      (= arg0 (bucket-id bucket-141))
-      (= arg0 (bucket-id bucket-151))
-      (= arg0 (bucket-id bucket-161))
-      (= arg0 (bucket-id bucket-171))
-      (= arg0 (bucket-id bucket-181))
-      (= arg0 (bucket-id bucket-188))
-      (= arg0 (bucket-id bucket-192))
-      (= arg0 (bucket-id bucket-197))
-      (= arg0 (bucket-id bucket-201))
-      (= arg0 (bucket-id bucket-205))
-      (= arg0 (bucket-id bucket-209))
-      (= arg0 (bucket-id bucket-213))
-      (= arg0 (bucket-id bucket-217))
-      (= arg0 (bucket-id bucket-221))
-      (= arg0 (bucket-id bucket-225))
-      (= arg0 (bucket-id bucket-229))
-      (= arg0 (bucket-id bucket-233))
-      (= arg0 (bucket-id bucket-237))
-      (= arg0 (bucket-id bucket-241))
-      (= arg0 (bucket-id bucket-245))
-      (= arg0 (bucket-id bucket-249))
-      (= arg0 (bucket-id bucket-253))
-      (= arg0 (bucket-id bucket-262))
-      (= arg0 (bucket-id bucket-271))
-      (= arg0 (bucket-id bucket-280))
-      (= arg0 (bucket-id bucket-289))
-      (= arg0 (bucket-id bucket-298))
-      (= arg0 (bucket-id bucket-307))
+  (or (= arg0 (bucket-id merc-l0-tfrag))
+      (= arg0 (bucket-id merc-l1-tfrag))
+      (= arg0 (bucket-id merc-l2-tfrag))
+      (= arg0 (bucket-id merc-l3-tfrag))
+      (= arg0 (bucket-id merc-l4-tfrag))
+      (= arg0 (bucket-id merc-l5-tfrag))
+      (= arg0 (bucket-id merc-l0-shrub))
+      (= arg0 (bucket-id merc-l1-shrub))
+      (= arg0 (bucket-id merc-l2-shrub))
+      (= arg0 (bucket-id merc-l3-shrub))
+      (= arg0 (bucket-id merc-l4-shrub))
+      (= arg0 (bucket-id merc-l5-shrub))
+      (= arg0 (bucket-id merc-l0-alpha))
+      (= arg0 (bucket-id merc-l1-alpha))
+      (= arg0 (bucket-id merc-l2-alpha))
+      (= arg0 (bucket-id merc-l3-alpha))
+      (= arg0 (bucket-id merc-l4-alpha))
+      (= arg0 (bucket-id merc-l5-alpha))
+      (= arg0 (bucket-id merc-lcom-tfrag))
+      (= arg0 (bucket-id merc-lcom-shrub))
+      (= arg0 (bucket-id merc-l0-pris))
+      (= arg0 (bucket-id merc-l1-pris))
+      (= arg0 (bucket-id merc-l2-pris))
+      (= arg0 (bucket-id merc-l3-pris))
+      (= arg0 (bucket-id merc-l4-pris))
+      (= arg0 (bucket-id merc-l5-pris))
+      (= arg0 (bucket-id merc-lcom-pris))
+      (= arg0 (bucket-id merc-l0-pris2))
+      (= arg0 (bucket-id merc-l1-pris2))
+      (= arg0 (bucket-id merc-l2-pris2))
+      (= arg0 (bucket-id merc-l3-pris2))
+      (= arg0 (bucket-id merc-l4-pris2))
+      (= arg0 (bucket-id merc-l5-pris2))
+      (= arg0 (bucket-id merc-lcom-pris2))
+      (= arg0 (bucket-id merc-l0-water))
+      (= arg0 (bucket-id merc-l1-water))
+      (= arg0 (bucket-id merc-l2-water))
+      (= arg0 (bucket-id merc-l3-water))
+      (= arg0 (bucket-id merc-l4-water))
+      (= arg0 (bucket-id merc-l5-water))
+      (= arg0 (bucket-id merc-lcom-water))
       )
   )
 
 ;; definition for function profile-emerc-test
 (defun profile-emerc-test ((arg0 bucket-id))
-  (or (= arg0 (bucket-id bucket-15))
-      (= arg0 (bucket-id bucket-26))
-      (= arg0 (bucket-id bucket-37))
-      (= arg0 (bucket-id bucket-48))
-      (= arg0 (bucket-id bucket-59))
-      (= arg0 (bucket-id bucket-70))
-      (= arg0 (bucket-id bucket-80))
-      (= arg0 (bucket-id bucket-89))
-      (= arg0 (bucket-id bucket-98))
-      (= arg0 (bucket-id bucket-107))
-      (= arg0 (bucket-id bucket-116))
-      (= arg0 (bucket-id bucket-125))
-      (= arg0 (bucket-id bucket-132))
-      (= arg0 (bucket-id bucket-142))
-      (= arg0 (bucket-id bucket-152))
-      (= arg0 (bucket-id bucket-162))
-      (= arg0 (bucket-id bucket-172))
-      (= arg0 (bucket-id bucket-182))
-      (= arg0 (bucket-id bucket-189))
-      (= arg0 (bucket-id bucket-193))
-      (= arg0 (bucket-id bucket-198))
-      (= arg0 (bucket-id bucket-202))
-      (= arg0 (bucket-id bucket-206))
-      (= arg0 (bucket-id bucket-210))
-      (= arg0 (bucket-id bucket-214))
-      (= arg0 (bucket-id bucket-218))
-      (= arg0 (bucket-id bucket-222))
-      (= arg0 (bucket-id bucket-226))
-      (= arg0 (bucket-id bucket-230))
-      (= arg0 (bucket-id bucket-234))
-      (= arg0 (bucket-id bucket-238))
-      (= arg0 (bucket-id bucket-242))
-      (= arg0 (bucket-id bucket-246))
-      (= arg0 (bucket-id bucket-250))
+  (or (= arg0 (bucket-id emerc-l0-tfrag))
+      (= arg0 (bucket-id emerc-l1-tfrag))
+      (= arg0 (bucket-id emerc-l2-tfrag))
+      (= arg0 (bucket-id emerc-l3-tfrag))
+      (= arg0 (bucket-id emerc-l4-tfrag))
+      (= arg0 (bucket-id emerc-l5-tfrag))
+      (= arg0 (bucket-id emerc-l0-shrub))
+      (= arg0 (bucket-id emerc-l1-shrub))
+      (= arg0 (bucket-id emerc-l2-shrub))
+      (= arg0 (bucket-id emerc-l3-shrub))
+      (= arg0 (bucket-id emerc-l4-shrub))
+      (= arg0 (bucket-id emerc-l5-shrub))
+      (= arg0 (bucket-id emerc-l0-alpha))
+      (= arg0 (bucket-id emerc-l1-alpha))
+      (= arg0 (bucket-id emerc-l2-alpha))
+      (= arg0 (bucket-id emerc-l3-alpha))
+      (= arg0 (bucket-id emerc-l4-alpha))
+      (= arg0 (bucket-id emerc-l5-alpha))
+      (= arg0 (bucket-id emerc-lcom-tfrag))
+      (= arg0 (bucket-id emerc-lcom-shrub))
+      (= arg0 (bucket-id emerc-l0-pris))
+      (= arg0 (bucket-id emerc-l1-pris))
+      (= arg0 (bucket-id emerc-l2-pris))
+      (= arg0 (bucket-id emerc-l3-pris))
+      (= arg0 (bucket-id emerc-l4-pris))
+      (= arg0 (bucket-id emerc-l5-pris))
+      (= arg0 (bucket-id emerc-lcom-pris))
+      (= arg0 (bucket-id emerc-l0-pris2))
+      (= arg0 (bucket-id emerc-l1-pris2))
+      (= arg0 (bucket-id emerc-l2-pris2))
+      (= arg0 (bucket-id emerc-l3-pris2))
+      (= arg0 (bucket-id emerc-l4-pris2))
+      (= arg0 (bucket-id emerc-l5-pris2))
+      (= arg0 (bucket-id emerc-lcom-pris2))
       )
   )
 
@@ -560,25 +560,7 @@
          (a0-3 (the-as object (-> v1-1 base)))
          )
     (set! (-> (the-as gs-gif-tag a0-3) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x9))
-    (set! (-> (the-as gs-gif-tag a0-3) regs) (new 'static 'gif-tag-regs
-                                               :regs0 (gif-reg-id a+d)
-                                               :regs1 (gif-reg-id a+d)
-                                               :regs2 (gif-reg-id a+d)
-                                               :regs3 (gif-reg-id a+d)
-                                               :regs4 (gif-reg-id a+d)
-                                               :regs5 (gif-reg-id a+d)
-                                               :regs6 (gif-reg-id a+d)
-                                               :regs7 (gif-reg-id a+d)
-                                               :regs8 (gif-reg-id a+d)
-                                               :regs9 (gif-reg-id a+d)
-                                               :regs10 (gif-reg-id a+d)
-                                               :regs11 (gif-reg-id a+d)
-                                               :regs12 (gif-reg-id a+d)
-                                               :regs13 (gif-reg-id a+d)
-                                               :regs14 (gif-reg-id a+d)
-                                               :regs15 (gif-reg-id a+d)
-                                               )
-          )
+    (set! (-> (the-as gs-gif-tag a0-3) regs) GIF_REGS_ALL_AD)
     (set! (-> v1-1 base) (&+ (the-as pointer a0-3) 16))
     )
   (let* ((v1-2 arg0)
diff --git a/test/decompiler/test_FormExpressionBuild.cpp b/test/decompiler/test_FormExpressionBuild.cpp
index f87d9618b3..f7f849622e 100644
--- a/test/decompiler/test_FormExpressionBuild.cpp
+++ b/test/decompiler/test_FormExpressionBuild.cpp
@@ -2265,17 +2265,17 @@ TEST_F(FormRegressionTestJak1, ExprPrintName) {
 
   std::string expected =
       "(cond\n"
-      "  ((= arg0 arg1) #t)\n"
+      "  ((= arg0 arg1)\n"
+      "   #t\n"
+      "   )\n"
       "  ((and (= (-> arg0 type) string) (= (-> arg1 type) string))\n"
       "   (string= (the-as string arg0) (the-as string arg1))\n"
       "   )\n"
       "  ((and (= (-> arg0 type) string) (= (-> arg1 type) symbol))\n"
-      "   (string= (the-as string arg0) (the-as string (-> (the-as (pointer uint32) (+ 65336 "
-      "(the-as int arg1))))))\n"
+      "   (string= (the-as string arg0) (symbol->string arg1))\n"
       "   )\n"
       "  ((and (= (-> arg1 type) string) (= (-> arg0 type) symbol))\n"
-      "   (string= (the-as string arg1) (the-as string (-> (the-as (pointer uint32) (+ 65336 "
-      "(the-as int arg0))))))\n"
+      "   (string= (the-as string arg1) (symbol->string arg0))\n"
       "   )\n"
       "  )";
   test_with_expr(func, type, expected, false, "", {},
diff --git a/test/offline/config/jak2/config.jsonc b/test/offline/config/jak2/config.jsonc
index 6d4a78421b..eda19f12dd 100644
--- a/test/offline/config/jak2/config.jsonc
+++ b/test/offline/config/jak2/config.jsonc
@@ -2,7 +2,8 @@
   "dgos": [
   "CGO/KERNEL.CGO",
   "CGO/ENGINE.CGO",
-  "CGO/COMMON.CGO"
+  "CGO/COMMON.CGO",
+  "CGO/GAME.CGO"
   ],
 
   "skip_compile_files": [],
@@ -120,6 +121,8 @@
     "draw-beam", "(method 9 gun-info)",
     // mood
     "update-mood-direction", // power of two case
+    // texture
+    "(method 9 texture-page-dir)", // asm
 
     "i-hopefully-will-never-exist-dont-add-anything-after-me-please"
   ],