diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc
index 7e274a5cd0..b473fe7151 100644
--- a/decompiler/config/all-types.gc
+++ b/decompiler/config/all-types.gc
@@ -1406,28 +1406,35 @@
   :size-assert         #x8c
   :flag-assert         #x1c0000008c
   (:methods
-    (dummy-9 () none 9)
-    (dummy-10 () none 10)
-    (dummy-11 () none 11)
-    (dummy-12 () none 12)
-    (dummy-13 () none 13)
-    (dummy-14 () none 14)
-    (dummy-15 () none 15)
-    (dummy-16 () none 16)
-    (dummy-17 () none 17)
-    (dummy-18 () none 18)
-    (dummy-19 () none 19)
-    (dummy-20 () none 20)
-    (dummy-21 () none 21)
+    (TODO-RENAME-9 (_type_ vector float int) quaternion 9)
+    (TODO-RENAME-10 (_type_ vector) quaternion 10)
+    (TODO-RENAME-11 (_type_ vector float int) quaternion 11)
+    (TODO-RENAME-12 (_type_ vector) quaternion 12)
+    (TODO-RENAME-13 (_type_ float float int) quaternion 13)
+    (TODO-RENAME-14 (_type_ float) quaternion 14)
+    (TODO-RENAME-15 (_type_ float) quaternion 15)
+    (TODO-RENAME-VECTOR-DOT-16 (_type_ float) quaternion 16)
+    (TODO-RENAME-17 (_type_ quaternion float float) quaternion 17)
+    (set-quaternion!-18 (_type_ quaternion) quaternion 18)
+    (TODO-RENAME-19 (_type_ vector) quaternion 19)
+    (TODO-RENAME-20 (_type_ vector) quaternion 20)
+    (rot->dir-targ!-21 (_type_) quaternion 21)
     (y-angle (_type_) float 22)
     (global-y-angle-to-point (_type_ vector) float 23)
     (relative-y-angle-to-point (_type_ vector) float 24)
-    (dummy-25 () none 25)
+    (TODO-VECTOR-MATH-ISSUES-25 (_type_) float 25)
     (dummy-26 () none 26)
     (get-quaternion (_type_) quaternion 27)
     )
   )
 
+(define-extern matrix<-transformq+trans! (function matrix transformq vector matrix))
+(define-extern matrix<-transformq+world-trans! (function matrix transformq vector matrix))
+(define-extern matrix<-no-trans-transformq! (function matrix transformq matrix))
+(define-extern transformq-copy! (function transformq transformq transformq))
+(define-extern matrix<-parented-transformq! (function matrix transformq quaternion matrix))
+(define-extern matrix<-transformq! (function matrix transformq matrix))
+
 ;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;; BOUNDING-BOX     ;;;;;;;;;;;;;;;;;;;;;;
@@ -9900,6 +9907,7 @@
   :flag-assert         #x38000000b8
   (:methods
     (new (symbol type process int) _type_)
+    (dummy-26 () none 26)
     (dummy-28 () none 28)
     (dummy-29 () none 29)
     (dummy-30 () none 30)
@@ -9963,6 +9971,35 @@
   :size-assert         #x1bc
   :flag-assert         #x41000001bc
   (:methods
+    (dummy-26 () none 26)
+    (dummy-28 () none 28)
+    (dummy-29 () none 29)
+    (dummy-30 () none 30)
+    (dummy-31 () none 31)
+    (dummy-32 () none 32)
+    (dummy-33 () none 33)
+    (dummy-34 () none 34)
+    (dummy-35 () none 35)
+    (dummy-36 () none 36)
+    (dummy-37 () none 37)
+    (dummy-38 () none 38)
+    (dummy-39 () none 39)
+    (dummy-40 () none 40)
+    (dummy-41 () none 41)
+    (dummy-42 () none 42)
+    (dummy-43 () none 43)
+    (dummy-44 () none 44)
+    (dummy-45 () none 45)
+    (dummy-46 () none 46)
+    (dummy-47 () none 47)
+    (dummy-48 () none 48)
+    (dummy-49 () none 49)
+    (dummy-50 () none 50)
+    (dummy-51 () none 51)
+    (dummy-52 () none 52)
+    (dummy-53 () none 53)
+    (dummy-54 () none 54)
+    (dummy-55 () none 55)
     (dummy-56 () none 56)
     (dummy-57 () none 57)
     (dummy-58 () none 58)
@@ -33928,12 +33965,7 @@
 (define-extern activate-progress function)
 (define-extern camera-pos function)
 ;;(define-extern ambient-volume object) ;; unknown type
-(define-extern matrix<-transformq+trans! function)
-(define-extern matrix<-transformq+world-trans! function)
-(define-extern matrix<-no-trans-transformq! function)
-(define-extern transformq-copy! function)
-(define-extern matrix<-parented-transformq! function)
-(define-extern matrix<-transformq! function)
+
 (define-extern moving-sphere-triangle-intersect function)
 (define-extern ray-circle-intersect function)
 (define-extern moving-sphere-moving-sphere-intersect function)
diff --git a/decompiler/config/jak1_ntsc_black_label/label_types.jsonc b/decompiler/config/jak1_ntsc_black_label/label_types.jsonc
index ff65cab51d..76eba74bb9 100644
--- a/decompiler/config/jak1_ntsc_black_label/label_types.jsonc
+++ b/decompiler/config/jak1_ntsc_black_label/label_types.jsonc
@@ -283,6 +283,12 @@
     ["L9", "float", true]
   ],
 
+  "transformq": [
+    ["L39", "vector", true],
+    ["L40", "vector", true],
+    ["L47", "float", true]
+  ],
+
   "mood-tables": [
     ["L12", "mood-sun-table", true],
     ["L13", "mood-lights-table", true],
diff --git a/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc b/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc
index bc1cad1f1f..6b2d6aa361 100644
--- a/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc
+++ b/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc
@@ -176,6 +176,56 @@
 
   "make-light-kit": [[16, "matrix"]],
 
+  "matrix<-parented-transformq!": [[16, "quaternion"]],
+
+  "(method 20 trsqv)": [[16, "vector"]],
+
+  "(method 19 trsqv)": [[16, "vector"]],
+
+  "(method 17 trsqv)": [
+    [16, "quaternion"],
+    [32, "vector"],
+    [48, "vector"],
+    [64, "vector"],
+    [80, "vector"]
+  ],
+
+  "(method 25 trsqv)": [
+    [16, "vector"],
+    [32, "vector"],
+    [48, "vector"],
+    [64, "quaternion"]
+  ],
+
+  "(method 16 trsqv)": [
+    [16, "matrix"],
+    [80, "matrix"]
+  ],
+
+  "(method 14 trsqv)": [
+    [16, "vector"]
+  ],
+
+  "(method 13 trsqv)": [
+    [16, "vector"]
+  ],
+
+  "(method 12 trsqv)": [
+    [16, "vector"],
+    [32, "vector"]
+  ],
+
+  "(method 11 trsqv)": [
+    [16, "vector"]
+  ],
+
+  "(method 10 trsqv)": [
+    [16, "vector"],
+    [32, "vector"]
+  ],
+  
+  "make-light-kit": [[16, "matrix"]],
+
   "(method 23 trsqv)": [[16, "vector"]],
   "(method 24 trsqv)": [[16, "vector"]],
 
diff --git a/goal_src/engine/geometry/geometry.gc b/goal_src/engine/geometry/geometry.gc
index 4135dac2a0..199b07ea96 100644
--- a/goal_src/engine/geometry/geometry.gc
+++ b/goal_src/engine/geometry/geometry.gc
@@ -6,4 +6,8 @@
 ;; dgos: GAME, ENGINE
 
 ;; TODO - temporary for lights.gc
-(define-extern vector-deg-slerp (function vector vector vector float vector))
\ No newline at end of file
+(define-extern vector-deg-slerp (function vector vector vector float vector))
+;; TODO - temporary for transformq.gc
+(define-extern forward-up-nopitch->quaternion (function quaternion vector vector quaternion))
+(define-extern forward-up->quaternion (function quaternion vector vector quaternion))
+(define-extern vector-flatten! (function vector vector vector vector))
diff --git a/goal_src/engine/math/transformq-h.gc b/goal_src/engine/math/transformq-h.gc
index 349b677b5e..5db838a7d8 100644
--- a/goal_src/engine/math/transformq-h.gc
+++ b/goal_src/engine/math/transformq-h.gc
@@ -26,40 +26,41 @@
   )
 
 ;; Representing a translate/rotate/scale with a quaternion and a velocity.
+;; definition of type trsqv
 (deftype trsqv (trsq)
-  ((pause-adjust-distance float              :offset 4) ;; todo meters
-   (nav-radius            float              :offset 8) ;; todo meters
-   (transv                vector     :inline :offset-assert 64)
-   (rotv                  vector     :inline :offset-assert 80)
-   (scalev                vector     :inline :offset-assert 96)
-   (dir-targ              quaternion :inline :offset-assert 112)
-   (angle-change-time     uint64             :offset-assert 128)
-   (old-y-angle-diff      float              :offset-assert 136)
+  ((pause-adjust-distance float      :offset   4)
+   (nav-radius            float      :offset   8)
+   (transv                vector     :inline     :offset-assert 64)
+   (rotv                  vector     :inline     :offset-assert 80)
+   (scalev                vector     :inline     :offset-assert 96)
+   (dir-targ              quaternion :inline     :offset-assert 112)
+   (angle-change-time     uint64                 :offset-assert 128)
+   (old-y-angle-diff      float                  :offset-assert 136)
    )
   :method-count-assert 28
   :size-assert         #x8c
   :flag-assert         #x1c0000008c
   (:methods
-   (dummy-9 () none 9)
-   (dummy-10 () none 10)
-   (dummy-11 () none 11)
-   (dummy-12 () none 12)
-   (dummy-13 () none 13)
-   (dummy-14 () none 14)
-   (dummy-15 () none 15)
-   (dummy-16 () none 16)
-   (dummy-17 () none 17)
-   (dummy-18 () none 18)
-   (dummy-19 () none 19)
-   (dummy-20 () none 20)
-   (dummy-21 () none 21)
-   (y-angle (_type_) float 22)
-   (global-y-angle-to-point (_type_ vector) float 23)
-   (relative-y-angle-to-point (_type_ vector) float 24)
-   (dummy-25 () none 25)
-   (dummy-26 () none 26)
-   (get-quaternion (_type_) quaternion 27)
-   )
+    (TODO-RENAME-9 (_type_ vector float int) quaternion 9)
+    (TODO-RENAME-10 (_type_ vector) quaternion 10)
+    (TODO-RENAME-11 (_type_ vector float int) quaternion 11)
+    (TODO-RENAME-12 (_type_ vector) quaternion 12)
+    (TODO-RENAME-13 (_type_ float float int) quaternion 13)
+    (TODO-RENAME-14 (_type_ float) quaternion 14)
+    (TODO-RENAME-15 (_type_ float) quaternion 15)
+    (TODO-RENAME-VECTOR-DOT-16 (_type_ float) quaternion 16)
+    (TODO-RENAME-17 (_type_ quaternion float float) quaternion 17)
+    (set-quaternion!-18 (_type_ quaternion) quaternion 18)
+    (TODO-RENAME-19 (_type_ vector) quaternion 19)
+    (TODO-RENAME-20 (_type_ vector) quaternion 20)
+    (rot->dir-targ!-21 (_type_) quaternion 21)
+    (y-angle (_type_) float 22)
+    (global-y-angle-to-point (_type_ vector) float 23)
+    (relative-y-angle-to-point (_type_ vector) float 24)
+    (TODO-VECTOR-MATH-ISSUES-25 (_type_) float 25)
+    (dummy-26 () none 26)
+    (get-quaternion (_type_) quaternion 27)
+    )
   )
 
 (defmethod global-y-angle-to-point trsqv ((obj trsqv) (arg0 vector))
diff --git a/goal_src/engine/math/transformq.gc b/goal_src/engine/math/transformq.gc
index d9a5ba0c54..6c575e988d 100644
--- a/goal_src/engine/math/transformq.gc
+++ b/goal_src/engine/math/transformq.gc
@@ -5,3 +5,544 @@
 ;; name in dgo: transformq
 ;; dgos: GAME, ENGINE
 
+;; definition for method 2 of type transformq
+(defmethod print transformq ((obj transformq))
+  (format #t "#<transformq @ #x~X~%" obj)
+  (format
+   #t
+   "~T~Ttrans:~F ~F ~F ~F ~%"
+   (-> obj trans x)
+   (-> obj trans y)
+   (-> obj trans z)
+   (-> obj trans w)
+   )
+  (format
+   #t
+   "~T~Tquat:  ~F ~F ~F ~F ~%"
+   (-> obj rot x)
+   (-> obj rot y)
+   (-> obj rot z)
+   (-> obj rot w)
+   )
+  (format
+   #t
+   "~T~Tscale:~F ~F ~F ~F>"
+   (-> obj scale x)
+   (-> obj scale y)
+   (-> obj scale z)
+   (-> obj scale w)
+   )
+  obj
+  )
+
+;; definition for method 27 of type trsqv
+;; INFO: Return type mismatch vector vs quaternion.
+(defmethod get-quaternion trsqv ((obj trsqv))
+  (the-as quaternion (-> obj rot))
+  )
+
+;; definition for method 18 of type trsqv
+(defmethod set-quaternion!-18 trsqv ((obj trsqv) (arg0 quaternion))
+  (quaternion-copy! (get-quaternion obj) arg0)
+  )
+
+;; definition for method 21 of type trsqv
+(defmethod rot->dir-targ!-21 trsqv ((obj trsqv))
+  (quaternion-copy! (-> obj dir-targ) (get-quaternion obj))
+  )
+
+;; definition for method 22 of type trsqv
+(defmethod y-angle trsqv ((obj trsqv))
+  (quaternion-y-angle (get-quaternion obj))
+  )
+
+;; definition for method 9 of type trsqv
+(defmethod TODO-RENAME-9 trsqv ((obj trsqv) (arg0 vector) (arg1 float) (arg2 int))
+  (let*
+   ((f0-0
+     (deg-diff
+      (quaternion-y-angle (the-as quaternion (-> obj rot)))
+      (vector-y-angle arg0)
+      )
+     )
+    (f1-2
+     (fmin
+      (* arg1 (-> *display* seconds-per-frame))
+      (/ (* 5.0 (fabs f0-0)) (the float arg2))
+      )
+     )
+    (f30-0 (fmax (fmin f0-0 f1-2) (- f1-2)))
+    )
+   (let ((f0-2 (-> obj old-y-angle-diff)))
+    (set! f30-0 (cond
+                 ((or
+                   (= f0-2 0.0)
+                   (and (< 0.0 f30-0) (< 0.0 f0-2))
+                   (or
+                    (and (< f30-0 0.0) (< f0-2 0.0))
+                    (>=
+                     (the-as
+                      int
+                      (-
+                       (-> *display* base-frame-counter)
+                       (-> obj angle-change-time)
+                       )
+                      )
+                     60
+                     )
+                    )
+                   )
+                  (set!
+                   (-> obj angle-change-time)
+                   (-> *display* base-frame-counter)
+                   )
+                  f30-0
+                  )
+                 (else
+                  (* 0.000000001 f30-0)
+                  )
+                 )
+     )
+    )
+   (set! (-> obj old-y-angle-diff) f30-0)
+   (let ((a1-2 (get-quaternion obj)))
+    (quaternion-rotate-y! a1-2 a1-2 f30-0)
+    )
+   )
+  )
+
+;; definition for method 10 of type trsqv
+(defmethod TODO-RENAME-10 trsqv ((obj trsqv) (arg0 vector))
+  (let ((s3-0 (get-quaternion obj)))
+   (forward-up-nopitch->quaternion
+    s3-0
+    (vector-normalize-copy! (new 'stack-no-clear 'vector) arg0 1.0)
+    (vector-y-quaternion! (new 'stack-no-clear 'vector) s3-0)
+    )
+   )
+  )
+
+;; definition for method 11 of type trsqv
+(defmethod TODO-RENAME-11 trsqv ((obj trsqv) (arg0 vector) (arg1 float) (arg2 int))
+  (rlet ((vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (let* ((v1-0 obj)
+          (t9-0 (method-of-object v1-0 TODO-RENAME-9))
+          (t0-1 (new 'stack-no-clear 'vector))
+          )
+    (let ((a0-1 (-> obj trans)))
+     (.lvf vf4 (&-> arg0 quad))
+     (.lvf vf5 (&-> a0-1 quad))
+     )
+    (.mov.vf vf6 vf0 :mask #b1000)
+    (.sub.vf vf6 vf4 vf5 :mask #b111)
+    (.svf (&-> t0-1 quad) vf6)
+    (t9-0 v1-0 t0-1 arg1 arg2)
+    )
+   )
+  )
+
+;; definition for method 12 of type trsqv
+(defmethod TODO-RENAME-12 trsqv ((obj trsqv) (arg0 vector))
+  (rlet ((vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (let* ((s3-0 (get-quaternion obj))
+          (gp-0 forward-up-nopitch->quaternion)
+          (s5-0 s3-0)
+          (t9-1 vector-normalize!)
+          (a0-2 (new 'stack-no-clear 'vector))
+          )
+    (let ((v1-1 (-> obj trans)))
+     (.lvf vf4 (&-> arg0 quad))
+     (.lvf vf5 (&-> v1-1 quad))
+     )
+    (.mov.vf vf6 vf0 :mask #b1000)
+    (.sub.vf vf6 vf4 vf5 :mask #b111)
+    (.svf (&-> a0-2 quad) vf6)
+    (gp-0
+     s5-0
+     (t9-1 a0-2 1.0)
+     (vector-y-quaternion! (new 'stack-no-clear 'vector) s3-0)
+     )
+    )
+   )
+  )
+
+;; definition for method 13 of type trsqv
+(defmethod
+  TODO-RENAME-13
+  trsqv
+  ((obj trsqv) (arg0 float) (arg1 float) (arg2 int))
+  (let ((s3-0 (method-of-object obj TODO-RENAME-9))
+        (s2-0 (new 'stack-no-clear 'vector))
+        )
+   (set! (-> s2-0 x) (sin arg0))
+   (set! (-> s2-0 y) 0.0)
+   (set! (-> s2-0 z) (cos arg0))
+   (set! (-> s2-0 w) 1.0)
+   (s3-0 obj s2-0 arg1 arg2)
+   )
+  )
+
+;; definition for method 14 of type trsqv
+(defmethod TODO-RENAME-14 trsqv ((obj trsqv) (arg0 float))
+  (let ((s5-0 (method-of-object obj TODO-RENAME-19))
+        (s4-0 (new 'stack-no-clear 'vector))
+        )
+   (set! (-> s4-0 x) (sin arg0))
+   (set! (-> s4-0 y) 0.0)
+   (set! (-> s4-0 z) (cos arg0))
+   (set! (-> s4-0 w) 1.0)
+   (s5-0 obj s4-0)
+   )
+  )
+
+;; definition for method 15 of type trsqv
+(defmethod TODO-RENAME-15 trsqv ((obj trsqv) (arg0 float))
+  (TODO-RENAME-VECTOR-DOT-16 obj arg0)
+  )
+
+;; definition for method 16 of type trsqv
+(defmethod TODO-RENAME-VECTOR-DOT-16 trsqv ((obj trsqv) (arg0 float))
+  (rlet ((acc :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         (vf3 :class vf)
+         )
+   (let* ((s5-0 (get-quaternion obj))
+          (s1-0 (-> *standard-dynamics* gravity-normal))
+          (s3-0 (quaternion->matrix (new 'stack-no-clear 'matrix) s5-0))
+          )
+    (let ((s4-0 (&-> s3-0 data 8)))
+     (vector-normalize!
+      (vector-flatten!
+       (the-as vector (&-> s3-0 data 4))
+       s1-0
+       (the-as vector s4-0)
+       )
+      1.0
+      )
+     (let ((a0-4 (-> s3-0 data)))
+      (let ((v1-3 (&-> s3-0 data 4)))
+       (.lvf vf1 v1-3)
+       )
+      (.lvf vf2 s4-0)
+      (.outer.product.vf vf3 vf1 vf2)
+      (.svf (the-as (pointer uint128) (&-> a0-4 0)) vf3)
+      )
+     )
+    (let ((a1-5 (matrix-rotate-z! (new 'stack-no-clear 'matrix) arg0)))
+     (matrix*! s3-0 a1-5 s3-0)
+     )
+    (matrix->quaternion s5-0 s3-0)
+    )
+   )
+  )
+
+;; definition for method 25 of type trsqv
+;; WARN: Unsupported inline assembly instruction kind - [mula.s f0, f3]
+;; WARN: Unsupported inline assembly instruction kind - [madda.s f1, f4]
+;; WARN: Unsupported inline assembly instruction kind - [madd.s f0, f2, f5]
+;; WARN: Unsupported inline assembly instruction kind - [mula.s f1, f4]
+;; WARN: Unsupported inline assembly instruction kind - [madda.s f2, f5]
+;; WARN: Unsupported inline assembly instruction kind - [madd.s f1, f3, f6]
+(defmethod TODO-VECTOR-MATH-ISSUES-25 trsqv ((obj trsqv))
+  (local-vars (f0-1 float) (f1-2 float))
+  (rlet ((acc :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         (vf3 :class vf)
+         )
+   (let* ((s5-0 (get-quaternion obj))
+          (gp-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) s5-0))
+          (s5-1 (vector-y-quaternion! (new 'stack-no-clear 'vector) s5-0))
+          (a1-2 (-> *standard-dynamics* gravity-normal))
+          (v1-2
+           (vector-normalize!
+            (vector-flatten! (new 'stack-no-clear 'vector) a1-2 gp-0)
+            1.0
+            )
+           )
+          )
+    (let ((f0-2 (vector-dot v1-2 s5-1)))
+     (let ((a0-7 (new 'stack-no-clear 'quaternion)))
+      (.lvf vf1 (&-> v1-2 quad))
+      (.lvf vf2 (&-> s5-1 quad))
+      (.outer.product.vf vf3 vf1 vf2)
+      (.svf (&-> a0-7 vec quad) vf3)
+      (let ((f1-2 (vector-dot a0-7 gp-0)))
+       (if (< f1-2 0.0)
+        (- (acos f0-2))
+        (acos f0-2)
+        )
+       )
+      )
+     )
+    )
+   )
+  )
+
+;; definition for method 17 of type trsqv
+;; Used lq/sq
+(defmethod
+  TODO-RENAME-17
+  trsqv
+  ((obj trsqv) (arg0 quaternion) (arg1 float) (arg2 float))
+  (local-vars (sv-96 vector))
+  (let ((gp-0 (get-quaternion obj)))
+   (let ((s5-0 (new 'stack-no-clear 'quaternion)))
+    (when (< 0.0 arg2)
+     (let ((s1-0 quaternion-from-two-vectors-max-angle!)
+           (s0-0 s5-0)
+           )
+      (set! sv-96 (vector-y-quaternion! (new 'stack-no-clear 'vector) gp-0))
+      (let ((a2-1 (vector-y-quaternion! (new 'stack-no-clear 'vector) arg0))
+            (a3-1 (* arg2 (-> *display* seconds-per-frame)))
+            )
+       (s1-0 s0-0 sv-96 a2-1 a3-1)
+       )
+      )
+     (quaternion-normalize! (quaternion*! gp-0 s5-0 gp-0))
+     )
+    (let ((v0-6 (when (< 0.0 arg1)
+                 (quaternion-from-two-vectors-max-angle!
+                  s5-0
+                  (vector-z-quaternion! (new 'stack-no-clear 'vector) gp-0)
+                  (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0)
+                  (* arg1 (-> *display* seconds-per-frame))
+                  )
+                 (quaternion-normalize! (quaternion*! gp-0 s5-0 gp-0))
+                 )
+           )
+          )
+     )
+    )
+   gp-0
+   )
+  )
+
+;; definition for method 19 of type trsqv
+(defmethod TODO-RENAME-19 trsqv ((obj trsqv) (arg0 vector))
+  (forward-up->quaternion
+   (get-quaternion obj)
+   (vector-normalize-copy! (new 'stack-no-clear 'vector) arg0 1.0)
+   (new 'static 'vector :y 1.0 :w 1.0)
+   )
+  )
+
+;; definition for method 20 of type trsqv
+(defmethod TODO-RENAME-20 trsqv ((obj trsqv) (arg0 vector))
+  (rlet ((vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (let ((gp-0 forward-up->quaternion)
+         (s3-0 (get-quaternion obj))
+         (t9-1 vector-normalize!)
+         (a0-2 (new 'stack-no-clear 'vector))
+         )
+    (let ((v1-1 (-> obj trans)))
+     (.lvf vf4 (&-> arg0 quad))
+     (.lvf vf5 (&-> v1-1 quad))
+     )
+    (.mov.vf vf6 vf0 :mask #b1000)
+    (.sub.vf vf6 vf4 vf5 :mask #b111)
+    (.svf (&-> a0-2 quad) vf6)
+    (gp-0 s3-0 (t9-1 a0-2 1.0) (new 'static 'vector :y 1.0 :w 1.0))
+    )
+   )
+  )
+
+;; definition for function transformq-copy!
+;; Used lq/sq
+(defun transformq-copy! ((arg0 transformq) (arg1 transformq))
+  (set! (-> arg0 trans quad) (-> arg1 trans quad))
+  (set! (-> arg0 rot quad) (-> arg1 rot quad))
+  (set! (-> arg0 scale quad) (-> arg1 scale quad))
+  arg0
+  )
+
+;; definition for function matrix<-transformq!
+;; Used lq/sq
+(defun matrix<-transformq! ((arg0 matrix) (arg1 transformq))
+  (local-vars (v1-1 float))
+  (rlet ((vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         (vf3 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
+   (cond
+    (#f
+     (set! (-> arg0 vector 3 quad) (-> arg1 trans quad))
+     )
+    (else
+     (.lvf vf1 (&-> arg1 scale quad))
+     (.lvf vf2 (&-> arg1 trans quad))
+     (.lvf vf3 (&-> arg0 vector 0 quad))
+     (.lvf vf4 (&-> arg0 vector 1 quad))
+     (.lvf vf5 (&-> arg0 vector 2 quad))
+     (.mov.vf vf2 vf0 :mask #b1000)
+     (.mul.x.vf vf3 vf3 vf1)
+     (.mul.y.vf vf4 vf4 vf1)
+     (.mul.z.vf vf5 vf5 vf1)
+     (.svf (&-> arg0 vector 3 quad) vf2)
+     (.svf (&-> arg0 vector 0 quad) vf3)
+     (.svf (&-> arg0 vector 1 quad) vf4)
+     (.svf (&-> arg0 vector 2 quad) vf5)
+     (.mov v1-1 vf5)
+     )
+    )
+   arg0
+   )
+  )
+
+;; definition for function matrix<-no-trans-transformq!
+(defun matrix<-no-trans-transformq! ((arg0 matrix) (arg1 transformq))
+  (rlet ((vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         (vf3 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
+   (.lvf vf1 (&-> arg1 scale quad))
+   (.lvf vf3 (&-> arg0 vector 0 quad))
+   (.lvf vf4 (&-> arg0 vector 1 quad))
+   (.lvf vf5 (&-> arg0 vector 2 quad))
+   (.mov.vf vf2 vf0)
+   (.mul.x.vf vf3 vf3 vf1)
+   (.mul.y.vf vf4 vf4 vf1)
+   (.mul.z.vf vf5 vf5 vf1)
+   (.svf (&-> arg0 vector 3 quad) vf2)
+   (.svf (&-> arg0 vector 0 quad) vf3)
+   (.svf (&-> arg0 vector 1 quad) vf4)
+   (.svf (&-> arg0 vector 2 quad) vf5)
+   arg0
+   )
+  )
+
+;; definition for function matrix<-transformq+trans!
+(defun matrix<-transformq+trans! ((arg0 matrix) (arg1 transformq) (arg2 vector))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         (vf3 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
+   (.lvf vf1 (&-> arg1 scale quad))
+   (.lvf vf2 (&-> arg1 trans quad))
+   (.lvf vf6 (&-> arg2 quad))
+   (.lvf vf3 (&-> arg0 vector 0 quad))
+   (.lvf vf4 (&-> arg0 vector 1 quad))
+   (.lvf vf5 (&-> arg0 vector 2 quad))
+   (.mov.vf vf2 vf0 :mask #b1000)
+   (.mul.x.vf vf3 vf3 vf1)
+   (.mul.y.vf vf4 vf4 vf1)
+   (.mul.z.vf vf5 vf5 vf1)
+   (.mul.x.vf acc vf3 vf6)
+   (.add.mul.y.vf acc vf4 vf6 acc)
+   (.add.mul.z.vf acc vf5 vf6 acc)
+   (.add.mul.w.vf vf2 vf2 vf0 acc :mask #b111)
+   (.svf (&-> arg0 vector 3 quad) vf2)
+   (.svf (&-> arg0 vector 0 quad) vf3)
+   (.svf (&-> arg0 vector 1 quad) vf4)
+   (.svf (&-> arg0 vector 2 quad) vf5)
+   arg0
+   )
+  )
+
+;; definition for function matrix<-transformq+world-trans!
+(defun
+  matrix<-transformq+world-trans!
+  ((arg0 matrix) (arg1 transformq) (arg2 vector))
+  (rlet ((vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         (vf3 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
+   (.lvf vf1 (&-> arg1 scale quad))
+   (.lvf vf2 (&-> arg1 trans quad))
+   (.lvf vf6 (&-> arg2 quad))
+   (.lvf vf3 (&-> arg0 vector 0 quad))
+   (.lvf vf4 (&-> arg0 vector 1 quad))
+   (.lvf vf5 (&-> arg0 vector 2 quad))
+   (.mov.vf vf2 vf0 :mask #b1000)
+   (.mul.x.vf vf3 vf3 vf1)
+   (.mul.y.vf vf4 vf4 vf1)
+   (.mul.z.vf vf5 vf5 vf1)
+   (.add.vf vf2 vf2 vf6 :mask #b111)
+   (.svf (&-> arg0 vector 3 quad) vf2)
+   (.svf (&-> arg0 vector 0 quad) vf3)
+   (.svf (&-> arg0 vector 1 quad) vf4)
+   (.svf (&-> arg0 vector 2 quad) vf5)
+   arg0
+   )
+  )
+
+;; definition for function matrix<-parented-transformq!
+(defun
+  matrix<-parented-transformq!
+  ((arg0 matrix) (arg1 transformq) (arg2 quaternion))
+  (local-vars (v1-1 float))
+  (rlet ((vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         (vf3 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
+   (let ((v1-0 (new 'stack-no-clear 'quaternion)))
+    (set! (-> v1-0 x) (/ 1.0 (-> arg2 x)))
+    (set! (-> v1-0 y) (/ 1.0 (-> arg2 y)))
+    (set! (-> v1-0 z) (/ 1.0 (-> arg2 z)))
+    (.lvf vf1 (&-> arg1 scale quad))
+    (.lvf vf2 (&-> arg1 trans quad))
+    (.mov.vf vf2 vf0 :mask #b1000)
+    (.lvf vf4 (&-> arg0 vector 0 quad))
+    (.lvf vf5 (&-> arg0 vector 1 quad))
+    (.lvf vf6 (&-> arg0 vector 2 quad))
+    (.mul.x.vf vf4 vf4 vf1)
+    (.mul.y.vf vf5 vf5 vf1)
+    (.mul.z.vf vf6 vf6 vf1)
+    (.lvf vf3 (&-> v1-0 vec quad))
+    )
+   (.mul.vf vf4 vf4 vf3)
+   (.mul.vf vf5 vf5 vf3)
+   (.mul.vf vf6 vf6 vf3)
+   (.svf (&-> arg0 vector 3 quad) vf2)
+   (.svf (&-> arg0 vector 0 quad) vf4)
+   (.svf (&-> arg0 vector 1 quad) vf5)
+   (.svf (&-> arg0 vector 2 quad) vf6)
+   (.mov v1-1 vf6)
+   arg0
+   )
+  )
diff --git a/test/decompiler/reference/engine/math/transformq-h_REF.gc b/test/decompiler/reference/engine/math/transformq-h_REF.gc
index c003c7ca3a..be9aab9b07 100644
--- a/test/decompiler/reference/engine/math/transformq-h_REF.gc
+++ b/test/decompiler/reference/engine/math/transformq-h_REF.gc
@@ -54,23 +54,23 @@
   :size-assert         #x8c
   :flag-assert         #x1c0000008c
   (:methods
-    (dummy-9 () none 9)
-    (dummy-10 () none 10)
-    (dummy-11 () none 11)
-    (dummy-12 () none 12)
-    (dummy-13 () none 13)
-    (dummy-14 () none 14)
-    (dummy-15 () none 15)
-    (dummy-16 () none 16)
-    (dummy-17 () none 17)
-    (dummy-18 () none 18)
-    (dummy-19 () none 19)
-    (dummy-20 () none 20)
-    (dummy-21 () none 21)
+    (TODO-RENAME-9 (_type_ vector float int) quaternion 9)
+    (TODO-RENAME-10 (_type_ vector) quaternion 10)
+    (TODO-RENAME-11 (_type_ vector float int) quaternion 11)
+    (TODO-RENAME-12 (_type_ vector) quaternion 12)
+    (TODO-RENAME-13 (_type_ float float int) quaternion 13)
+    (TODO-RENAME-14 (_type_ float) quaternion 14)
+    (TODO-RENAME-15 (_type_ float) quaternion 15)
+    (TODO-RENAME-VECTOR-DOT-16 (_type_ float) quaternion 16)
+    (TODO-RENAME-17 (_type_ quaternion float float) quaternion 17)
+    (set-quaternion!-18 (_type_ quaternion) quaternion 18)
+    (TODO-RENAME-19 (_type_ vector) quaternion 19)
+    (TODO-RENAME-20 (_type_ vector) quaternion 20)
+    (rot->dir-targ!-21 (_type_) quaternion 21)
     (y-angle (_type_) float 22)
     (global-y-angle-to-point (_type_ vector) float 23)
     (relative-y-angle-to-point (_type_ vector) float 24)
-    (dummy-25 () none 25)
+    (TODO-VECTOR-MATH-ISSUES-25 (_type_) float 25)
     (dummy-26 () none 26)
     (get-quaternion (_type_) quaternion 27)
     )