[decompiler] Update vector ops, reduce casts (#3849)

Update the decompiler to use the new vf macros.

Also, fix a bunch of silly casting issues where accessing inline fields
with an offset of 0 would be better than a cast:

![image](https://github.com/user-attachments/assets/885bbb07-634f-47b8-99f5-5a947941cdde)

---------

Co-authored-by: water111 <awaterford1111445@gmail.com>

test/decompiler/reference/jak1/engine/anim/aligner_REF.gc

@@ -89,13 +89,9 @@
         (set! (-> v1-23 0 vector 2 quad) a2-6)
         (set! (-> v1-23 0 vector 3 quad) a3-3)
         )
-      (vector*! (the-as vector (-> this transform)) (-> s5-1 bone transform vector 3) (-> this process root scale))
-      )
-    (vector-!
-      (the-as vector (-> this delta))
-      (the-as vector (-> this transform))
-      (the-as vector (-> this transform 1))
+      (vector*! (-> this transform 0 trans) (-> s5-1 bone transform vector 3) (-> this process root scale))
       )
+    (vector-! (-> this delta trans) (-> this transform 0 trans) (-> this transform 1 trans))
     (set-vector!
       (-> this align scale)
       (vector-length (the-as vector (-> this matrix)))
@@ -105,9 +101,7 @@
       )
     (vector-! (-> this delta scale) (-> this align scale) (-> this transform 1 scale))
     (let ((a2-8 (matrix-inv-scale! (new 'stack-no-clear 'matrix) (-> this align scale))))
-      (quaternion-normalize!
-        (matrix->quaternion (-> this align quat) (matrix*! a2-8 (the-as matrix (-> this matrix)) a2-8))
-        )
+      (quaternion-normalize! (matrix->quaternion (-> this align quat) (matrix*! a2-8 (-> this matrix 0) a2-8)))
       )
     (let ((a1-24 (quaternion-inverse! (new 'stack-no-clear 'quaternion) (the-as quaternion (-> this transform 1 rot))))
           )

test/decompiler/reference/jak1/engine/anim/joint-mod-h_REF.gc

@@ -807,12 +807,7 @@
   (let ((gp-0 (the-as joint-mod-blend-local (-> arg0 param1))))
     (cond
       ((-> gp-0 enable)
-       (vector-lerp!
-         (the-as vector (-> gp-0 blend-transform))
-         (-> arg1 trans)
-         (the-as vector (-> gp-0 transform))
-         (-> gp-0 blend)
-         )
+       (vector-lerp! (-> gp-0 blend-transform trans) (-> arg1 trans) (-> gp-0 transform trans) (-> gp-0 blend))
        (vector-lerp! (-> gp-0 blend-transform scale) (-> arg1 scale) (-> gp-0 transform scale) (-> gp-0 blend))
        (quaternion-slerp! (-> gp-0 blend-transform quat) (-> arg1 quat) (-> gp-0 transform quat) (-> gp-0 blend))
        (cspace<-parented-transformq-joint! arg0 (-> gp-0 blend-transform))

test/decompiler/reference/jak1/engine/anim/joint_REF.gc

@@ -404,7 +404,7 @@
           (dotimes (s2-0 (-> this length))
             (if (and (-> this data s2-0)
                      (= (-> this data s2-0 type) arg1)
-                     (or (name= arg0 (-> this data s2-0 name)) (string-charp= arg0 (&-> (-> this data s2-0 name) data s3-0)))
+                     (or (name= arg0 (-> this data s2-0 name)) (string-charp= arg0 (&-> this data s2-0 name data s3-0)))
                      )
                 (return (the-as joint (-> this data s2-0)))
                 )
@@ -432,7 +432,7 @@
         (dotimes (s2-0 (-> this length))
           (if (and (-> this data s2-0)
                    (= (-> this data s2-0 type) arg1)
-                   (or (name= arg0 (-> this data s2-0 name)) (string-charp= arg0 (&-> (-> this data s2-0 name) data s3-0)))
+                   (or (name= arg0 (-> this data s2-0 name)) (string-charp= arg0 (&-> this data s2-0 name data s3-0)))
                    )
               (return s2-0)
               )

test/decompiler/reference/jak1/engine/camera/cam-combiner_REF.gc

@@ -229,14 +229,10 @@
                         (let ((s4-1 (new-stack-vector0)))
                           0.0
                           (let ((s3-0 (new-stack-matrix0)))
-                            (vector-!
-                              (the-as vector (-> s1-0 vector))
-                              (the-as vector (-> sv-160 inv-mat))
-                              (the-as vector (-> s5-1 inv-mat))
-                              )
+                            (vector-! (-> s1-0 vector 0) (the-as vector (-> sv-160 inv-mat)) (the-as vector (-> s5-1 inv-mat)))
                             (vector-! (-> s1-0 vector 1) (-> sv-160 inv-mat vector 1) (-> s5-1 inv-mat vector 1))
                             (vector-! (-> s1-0 vector 2) (-> sv-160 inv-mat vector 2) (-> s5-1 inv-mat vector 2))
-                            (let ((f26-0 (vector-length (the-as vector (-> s1-0 vector))))
+                            (let ((f26-0 (vector-length (-> s1-0 vector 0)))
                                   (f28-0 (vector-length (-> s1-0 vector 1)))
                                   (f0-13 (vector-length (-> s1-0 vector 2)))
                                   )
@@ -245,10 +241,10 @@
                                  (vector-cross! s4-1 (-> s1-0 vector 1) (-> s1-0 vector 2))
                                  )
                                 ((and (< f28-0 f26-0) (< f28-0 f0-13))
-                                 (vector-cross! s4-1 (the-as vector (-> s1-0 vector)) (-> s1-0 vector 2))
+                                 (vector-cross! s4-1 (-> s1-0 vector 0) (-> s1-0 vector 2))
                                  )
                                 (else
-                                  (vector-cross! s4-1 (the-as vector (-> s1-0 vector)) (-> s1-0 vector 1))
+                                  (vector-cross! s4-1 (-> s1-0 vector 0) (-> s1-0 vector 1))
                                   )
                                 )
                               )
@@ -259,38 +255,38 @@
                                   )
                               (cond
                                 ((and (< f0-16 f1-2) (< f0-16 f2-2))
-                                 (vector-flatten! (the-as vector (-> s1-0 vector)) (the-as vector (-> sv-160 inv-mat)) s4-1)
+                                 (vector-flatten! (-> s1-0 vector 0) (the-as vector (-> sv-160 inv-mat)) s4-1)
                                  (vector-flatten! (-> s1-0 vector 1) (the-as vector (-> s5-1 inv-mat)) s4-1)
                                  )
                                 ((< f1-2 f2-2)
-                                 (vector-flatten! (the-as vector (-> s1-0 vector)) (-> sv-160 inv-mat vector 1) s4-1)
+                                 (vector-flatten! (-> s1-0 vector 0) (-> sv-160 inv-mat vector 1) s4-1)
                                  (vector-flatten! (-> s1-0 vector 1) (-> s5-1 inv-mat vector 1) s4-1)
                                  )
                                 (else
-                                  (vector-flatten! (the-as vector (-> s1-0 vector)) (-> sv-160 inv-mat vector 2) s4-1)
+                                  (vector-flatten! (-> s1-0 vector 0) (-> sv-160 inv-mat vector 2) s4-1)
                                   (vector-flatten! (-> s1-0 vector 1) (-> s5-1 inv-mat vector 2) s4-1)
                                   )
                                 )
                               )
-                            (vector-normalize! (the-as vector (-> s1-0 vector)) 1.0)
+                            (vector-normalize! (-> s1-0 vector 0) 1.0)
                             (vector-normalize! (-> s1-0 vector 1) 1.0)
-                            (vector-cross! (-> s1-0 vector 2) (the-as vector (-> s1-0 vector)) (-> s1-0 vector 1))
+                            (vector-cross! (-> s1-0 vector 2) (-> s1-0 vector 0) (-> s1-0 vector 1))
                             (if (< (vector-dot (-> s1-0 vector 2) s4-1) 0.0)
                                 (vector-negate! s4-1 s4-1)
                                 )
-                            (let ((f28-1 (acos (vector-dot (the-as vector (-> s1-0 vector)) (-> s1-0 vector 1)))))
+                            (let ((f28-1 (acos (vector-dot (-> s1-0 vector 0) (-> s1-0 vector 1)))))
                               (cond
                                 ((logtest? (-> *camera* master-options) 8)
                                  (logand! (-> *camera* master-options) -25)
                                  (when (and (< 8192.0 f28-1) (logtest? (-> *camera* master-options) 2))
-                                   (vector-! (the-as vector (-> s1-0 vector)) (-> *camera* tpos-curr) s2-0)
+                                   (vector-! (-> s1-0 vector 0) (-> *camera* tpos-curr) s2-0)
                                    (vector-! (-> s1-0 vector 1) s0-0 s2-0)
-                                   (vector-flatten! (the-as vector (-> s1-0 vector)) (the-as vector (-> s1-0 vector)) (-> *camera* local-down))
+                                   (vector-flatten! (-> s1-0 vector 0) (-> s1-0 vector 0) (-> *camera* local-down))
                                    (vector-flatten! (-> s1-0 vector 1) (-> s1-0 vector 1) (-> *camera* local-down))
-                                   (when (and (< 4096.0 (vector-normalize-ret-len! (the-as vector (-> s1-0 vector)) 1.0))
+                                   (when (and (< 4096.0 (vector-normalize-ret-len! (-> s1-0 vector 0) 1.0))
                                               (< 4096.0 (vector-normalize-ret-len! (-> s1-0 vector 1) 1.0))
                                               )
-                                     (vector-cross! (-> s1-0 vector 2) (-> s1-0 vector 1) (the-as vector (-> s1-0 vector)))
+                                     (vector-cross! (-> s1-0 vector 2) (-> s1-0 vector 1) (-> s1-0 vector 0))
                                      (when (< (vector-dot (-> s1-0 vector 2) s4-1) -0.01)
                                        )
                                      )
@@ -309,7 +305,7 @@
                                 (matrix-axis-sin-cos! s3-0 s4-1 (sin f30-1) (cos f30-1))
                                 )
                               )
-                            (matrix*! (-> self inv-camera-rot) (the-as matrix s5-1) s3-0)
+                            (matrix*! (-> self inv-camera-rot) (-> s5-1 inv-mat) s3-0)
                             )
                           )
                         )

test/decompiler/reference/jak1/engine/camera/cam-states-dbg_REF.gc

@@ -71,14 +71,14 @@
               (matrix-axis-angle! s3-0 (-> *camera* local-down) (- (-> s5-0 y)))
               (vector-matrix*! s4-0 s4-0 s3-0)
               )
-            (forward-down->inv-matrix (the-as matrix (-> self tracking)) s4-0 (-> *camera* local-down))
+            (forward-down->inv-matrix (-> self tracking inv-mat) s4-0 (-> *camera* local-down))
             )
           (set! (-> self pivot-rad) (- (-> self pivot-rad) (-> gp-0 z)))
           (if (< (-> self pivot-rad) 4096.0)
               (set! (-> self pivot-rad) 4096.0)
               )
           (set-vector! gp-0 0.0 0.0 (- (-> self pivot-rad)) 1.0)
-          (vector-matrix*! (-> self trans) gp-0 (the-as matrix (-> self tracking)))
+          (vector-matrix*! (-> self trans) gp-0 (-> self tracking inv-mat))
           )
         )
       (suspend)
@@ -394,7 +394,7 @@
         (matrix*! arg0 arg0 (-> s3-0 tm))
         )
       )
-    (matrix-axis-angle! (-> s3-0 tm) (the-as vector (-> arg0 vector)) (- (-> s3-0 rv x)))
+    (matrix-axis-angle! (-> s3-0 tm) (-> arg0 vector 0) (- (-> s3-0 rv x)))
     (matrix*! arg0 arg0 (-> s3-0 tm))
     (matrix-axis-angle! (-> s3-0 tm) (-> arg0 vector 2) (- (-> s3-0 rv z)))
     (matrix*! arg0 arg0 (-> s3-0 tm))
@@ -429,7 +429,7 @@
             (set! a2-0 (the-as vector #f))
             )
         (cam-free-floating-move
-          (the-as matrix (-> self tracking))
+          (-> self tracking inv-mat)
           (-> self trans)
           a2-0
           (the-as int (-> *CAMERA-bank* joypad))
@@ -608,7 +608,7 @@
           (set! (-> gp-0 x) (atan (-> s5-0 y) (vector-xz-length s5-0)))
           )
         (set! (-> gp-0 z) 0.0)
-        (matrix-rotate-zxy! (the-as matrix (-> self tracking)) gp-0)
+        (matrix-rotate-zxy! (-> self tracking inv-mat) gp-0)
         )
       (suspend)
       )

test/decompiler/reference/jak1/engine/camera/cam-states_REF.gc

@@ -29,7 +29,7 @@
           (cam-curve-pos (-> self trans) gp-0 (the-as curve #f) #f)
           (when (!= (-> gp-0 w) 0.0)
             (vector-normalize! gp-0 (the-as float 1.0))
-            (forward-down->inv-matrix (the-as matrix (-> self tracking)) gp-0 (-> *camera* local-down))
+            (forward-down->inv-matrix (-> self tracking inv-mat) gp-0 (-> *camera* local-down))
             )
           )
         )
@@ -56,7 +56,7 @@
        )
       ((-> self cam-entity)
        (cam-slave-get-vector-with-offset (the-as entity-actor (-> self cam-entity)) (-> self trans) 'trans)
-       (cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) (the-as matrix (-> self tracking)))
+       (cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) (-> self tracking inv-mat))
        (set! (-> self fov) (cam-slave-get-fov (-> self cam-entity)))
        (cam-curve-setup (-> self trans))
        ((-> cam-fixed enter))
@@ -207,7 +207,7 @@
                     (cond
                       ((and (< (vector-vector-distance s2-0 gp-0) 40960.0) (< (cos (the-as float 3640.889)) (vector-dot s5-0 s3-0)))
                        (set! (-> self trans quad) (-> s2-0 quad))
-                       (vector-negate! (the-as vector (-> self tracking)) (the-as vector (-> s0-0 vector)))
+                       (vector-negate! (the-as vector (-> self tracking)) (-> s0-0 vector 0))
                        (set! (-> self tracking inv-mat vector 1 quad) (-> s0-0 vector 1 quad))
                        (vector-negate! (-> self tracking inv-mat vector 2) (-> s0-0 vector 2))
                        (set! (-> self fov) (* 2.0 (atan (/ 12.700255 (* 20.3 (-> s1-0 x))) (the-as float 1.0))))
@@ -349,7 +349,7 @@
        (set! (-> self fov) (cam-slave-get-fov (-> self cam-entity)))
        (logior! (-> self options) (cam-slave-get-flags (-> self cam-entity) 'flags))
        (if (logtest? (-> self options) #x8000)
-           (cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) (the-as matrix (-> self tracking)))
+           (cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) (-> self tracking inv-mat))
            (set! (-> self tracking tilt-adjust target)
                  (cam-slave-get-float (-> self cam-entity) 'tiltAdjust (-> *CAMERA-bank* default-tilt-adjust))
                  )
@@ -491,23 +491,23 @@
                 )
               )
             (matrix-axis-angle! s5-0 (-> *camera* local-down) (-> s4-0 y))
-            (matrix*! (the-as matrix (-> self tracking)) (the-as matrix (-> self tracking)) s5-0)
+            (matrix*! (-> self tracking inv-mat) (-> self tracking inv-mat) s5-0)
             (when (not (logtest? (-> self options) 8))
               (if (< (vector-dot (-> self tracking inv-mat vector 1) (-> *camera* local-down)) 0.0)
                   (forward-down->inv-matrix
-                    (the-as matrix (-> self tracking))
+                    (-> self tracking inv-mat)
                     (-> self tracking inv-mat vector 2)
                     (-> *camera* local-down)
                     )
                   (forward-down->inv-matrix
-                    (the-as matrix (-> self tracking))
+                    (-> self tracking inv-mat)
                     (-> self tracking inv-mat vector 2)
                     (vector-negate! (new-stack-vector0) (-> *camera* local-down))
                     )
                   )
               )
             (matrix-axis-angle! s5-0 (the-as vector (-> self tracking)) (- (-> s4-0 x)))
-            (matrix*! (the-as matrix (-> self tracking)) (the-as matrix (-> self tracking)) s5-0)
+            (matrix*! (-> self tracking inv-mat) (-> self tracking inv-mat) s5-0)
             )
           (when (not (logtest? (-> self options) 8))
             (let ((f30-1 (vector-dot (-> *camera* local-down) (-> self tracking inv-mat vector 2))))
@@ -593,7 +593,7 @@
       0
       )
     (set! (-> self fov) 9830.4)
-    (matrix-rotate-y! (the-as matrix (-> self tracking)) (the-as float -32768.0))
+    (matrix-rotate-y! (-> self tracking inv-mat) (the-as float -32768.0))
     )
   :exit (behavior ()
     '()
@@ -696,7 +696,7 @@
          (set! (-> self fov) (cam-slave-get-fov (-> self cam-entity)))
          (logior! (-> self options) (cam-slave-get-flags (-> self cam-entity) 'flags))
          (if (logtest? (-> self options) #x8000)
-             (cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) (the-as matrix (-> self tracking)))
+             (cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) (-> self tracking inv-mat))
              (set! (-> self tracking tilt-adjust target)
                    (cam-slave-get-float (-> self cam-entity) 'tiltAdjust (-> *CAMERA-bank* default-tilt-adjust))
                    )

test/decompiler/reference/jak1/engine/camera/camera_REF.gc

@@ -386,7 +386,7 @@
         (s3-2
           (cond
             (v0-8
-              (vector+! (the-as vector (-> this vec)) (the-as vector (&+ s3-2 0)) (the-as vector v0-8))
+              (vector+! (-> this vec 0) (the-as vector (&+ s3-2 0)) (the-as vector v0-8))
               (vector+! (-> this vec 1) (the-as vector (&+ s3-2 16)) (the-as vector v0-8))
               )
             (else
@@ -411,7 +411,7 @@
       ((logtest? (-> this flags) (cam-index-options SPHERICAL))
        (vector-! s4-1 (-> this vec 1) arg2)
        (set! (-> this vec 1 w) (vector-length s4-1))
-       (vector-! s4-1 (the-as vector (-> this vec)) arg2)
+       (vector-! s4-1 (-> this vec 0) arg2)
        (set! (-> this vec 1 x) (vector-length s4-1))
        (set! (-> this vec 1 w) (- (-> this vec 1 w) (-> this vec 1 x)))
        (set! (-> this vec 0 quad) (-> arg2 quad))
@@ -419,13 +419,13 @@
       ((logtest? (-> this flags) (cam-index-options RADIAL))
        (vector-! s4-1 (-> this vec 1) arg2)
        (set! (-> this vec 1 w) (vector-length s4-1))
-       (vector-! s4-1 (the-as vector (-> this vec)) arg2)
+       (vector-! s4-1 (-> this vec 0) arg2)
        (set! (-> this vec 1 x) (vector-length s4-1))
        (set! (-> this vec 1 w) (- (-> this vec 1 w) (-> this vec 1 x)))
        (set! (-> this vec 0 quad) (-> arg2 quad))
        )
       (else
-        (vector-! (-> this vec 1) (-> this vec 1) (the-as vector (-> this vec)))
+        (vector-! (-> this vec 1) (-> this vec 1) (-> this vec 0))
         (set! (-> this vec 1 w) (vector-normalize-ret-len! (-> this vec 1) 1.0))
         )
       )
@@ -438,7 +438,7 @@
 (defmethod cam-index-method-10 ((this cam-index) (arg0 vector))
   (let ((s5-0 (new-stack-vector0)))
     0.0
-    (vector-! s5-0 arg0 (the-as vector (-> this vec)))
+    (vector-! s5-0 arg0 (-> this vec 0))
     (cond
       ((logtest? (-> this flags) (cam-index-options SPHERICAL))
        (vector-flatten! s5-0 s5-0 (-> *camera* local-down))
@@ -500,8 +500,8 @@
           (set! (-> this summed-len) (- (-> this summed-len) (-> this point arg0 tp-length)))
           (vector-!
             (the-as vector (+ (the-as uint (-> this point 0 direction)) (* 48 arg0)))
-            (the-as vector (-> this point v1-11))
-            (the-as vector (-> this point arg0))
+            (-> this point v1-11 position)
+            (-> this point arg0 position)
             )
           )
         (set! (-> this point arg0 tp-length)
@@ -564,7 +564,7 @@
     (let ((a2-0 (new 'stack-no-clear 'tracking-point)))
       (set! (-> s5-0 cur-pt) (-> this used-point))
       (set! (-> s5-0 partial-pt) (-> this partial-point))
-      (tracking-spline-method-19 this (-> this sample-len) (the-as vector a2-0) s5-0)
+      (tracking-spline-method-19 this (-> this sample-len) (-> a2-0 position) s5-0)
       )
     (if (or (= (-> s5-0 cur-pt) (-> this end-point))
             (= (-> s5-0 cur-pt) (-> this next-to-last-point))
@@ -654,7 +654,7 @@
     (vector-!
       (the-as vector (+ (the-as uint (-> this point 0 direction)) (* 48 s2-0)))
       arg0
-      (the-as vector (-> this point s2-0))
+      (-> this point s2-0 position)
       )
     (set! (-> this point s2-0 tp-length)
           (vector-normalize-ret-len! (the-as vector (+ (the-as uint (-> this point 0 direction)) (* 48 s2-0))) 1.0)
@@ -701,7 +701,7 @@
     (cond
       ((= (-> arg2 cur-pt) (-> this end-point))
        (set! (-> arg2 partial-pt) 0.0)
-       (vector+! arg1 arg1 (the-as vector (-> this point (-> arg2 cur-pt))))
+       (vector+! arg1 arg1 (-> this point (-> arg2 cur-pt) position))
        (return arg1)
        )
       ((begin (set! f0-4 (+ (-> arg2 partial-pt) (/ arg0 (-> this point (-> arg2 cur-pt) tp-length)))) (< f0-4 1.0))
@@ -710,8 +710,8 @@
          (let ((a2-5 (-> this point (-> arg2 cur-pt) next)))
            (vector-lerp!
              (the-as vector s5-0)
-             (the-as vector (-> this point (-> arg2 cur-pt)))
-             (the-as vector (-> this point a2-5))
+             (-> this point (-> arg2 cur-pt) position)
+             (-> this point a2-5 position)
              f0-4
              )
            )
@@ -742,11 +742,7 @@
 ;; INFO: Return type mismatch int vs none.
 (defmethod tracking-spline-method-20 ((this tracking-spline) (arg0 vector) (arg1 int))
   (let ((s3-0 (new 'stack-no-clear 'vector)))
-    (vector-!
-      s3-0
-      (the-as vector (-> this point (-> this used-point)))
-      (the-as vector (-> this point (-> this end-point)))
-      )
+    (vector-! s3-0 (-> this point (-> this used-point) position) (-> this point (-> this end-point) position))
     (let* ((f0-0 (vector-length s3-0))
            (f1-1 (* 0.33333334 (- 1.5 (/ f0-0 METER_LENGTH))))
            )
@@ -794,26 +790,30 @@
                 ((< f26-0 0.0)
                  (if (and *debug-segment* *display-camera-marks*)
                      (camera-line-rel-len
-                       (the-as vector (-> this point s1-0))
+                       (-> this point s1-0 position)
                        s2-0
                        (* -40.96 f26-0)
-                       (the-as vector4w (new 'static 'inline-array qword 1
-                                          (new 'static 'qword :data (new 'static 'array uint32 4 #xff #xff #x0 #x80))
-                                          )
-                               )
+                       (-> (new 'static 'inline-array qword 1
+                             (new 'static 'qword :data (new 'static 'array uint32 4 #xff #xff #x0 #x80))
+                             )
+                           0
+                           vector4w
+                           )
                        )
                      )
                  (vector--float*! arg0 arg0 s2-0 f26-0)
                  )
                 ((and *debug-segment* *display-camera-marks*)
                  (camera-line-rel-len
-                   (the-as vector (-> this point s1-0))
+                   (-> this point s1-0 position)
                    s2-0
                    (* 40.96 f26-0)
-                   (the-as vector4w (new 'static 'inline-array qword 1
-                                      (new 'static 'qword :data (new 'static 'array uint32 4 #x80 #x80 #x0 #x80))
-                                      )
-                           )
+                   (-> (new 'static 'inline-array qword 1
+                         (new 'static 'qword :data (new 'static 'array uint32 4 #x80 #x80 #x0 #x80))
+                         )
+                       0
+                       vector4w
+                       )
                    )
                  )
                 )
@@ -986,7 +986,7 @@
       )
     (else
       (vector-reset! (-> self trans))
-      (matrix-identity! (the-as matrix (-> self tracking)))
+      (matrix-identity! (-> self tracking inv-mat))
       (set! (-> self fov) 11650.845)
       (vector-reset! (-> self velocity))
       )
@@ -1457,7 +1457,7 @@
           (vector-! s3-0 (-> *camera* tpos-curr) arg1)
           (vector-flatten! s3-0 s3-0 (-> arg0 vector 1))
           (vector-normalize! s3-0 1.0)
-          (let ((f28-0 (vector-dot s3-0 (the-as vector (-> arg0 vector)))))
+          (let ((f28-0 (vector-dot s3-0 (-> arg0 vector 0))))
             (set! sv-128 s2-0)
             (set! sv-112 (-> arg0 vector))
             (let ((f0-6 (* 0.8 (tan (/ arg2 2)))))
@@ -1466,26 +1466,26 @@
                 (.mov vf2 v1-6)
                 )
               )
-            (.add.x.vf vf1 vf0 vf0 :mask #b1000)
-            (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+            (.add.x.vf.w vf1 vf0 vf0)
+            (.mul.x.vf.xyz vf1 vf1 vf2)
             (.svf (&-> sv-128 quad) vf1)
             (vector+! s2-0 s2-0 (-> arg0 vector 2))
             (vector-normalize! s2-0 1.0)
-            (let ((f0-8 (vector-dot s2-0 (the-as vector (-> arg0 vector)))))
+            (let ((f0-8 (vector-dot s2-0 (-> arg0 vector 0))))
               (when (< f0-8 (fabs f28-0))
                 (if (< f28-0 0.0)
-                    (vector--float*! s2-0 s2-0 (the-as vector (-> arg0 vector)) (* 2.0 f0-8))
+                    (vector--float*! s2-0 s2-0 (-> arg0 vector 0) (* 2.0 f0-8))
                     )
                 (matrix-from-two-vectors! s5-0 s2-0 s3-0)
                 (vector-matrix*! (-> arg0 vector 2) (-> arg0 vector 2) s5-0)
-                (vector-cross! (the-as vector (-> arg0 vector)) (-> arg0 vector 1) (-> arg0 vector 2))
+                (vector-cross! (-> arg0 vector 0) (-> arg0 vector 1) (-> arg0 vector 2))
                 )
               )
             )
           (vector-! s3-0 (-> *camera* tpos-curr) (-> *camera* pitch-off))
           (vector-! s3-0 s3-0 arg1)
           (vector--float*! s3-0 s3-0 (-> *camera* local-down) (-> *camera* foot-offset))
-          (vector-flatten! s3-0 s3-0 (the-as vector (-> arg0 vector)))
+          (vector-flatten! s3-0 s3-0 (-> arg0 vector 0))
           (vector-normalize! s3-0 1.0)
           (let ((f28-1 (vector-dot s3-0 (-> arg0 vector 1))))
             (set! sv-160 s2-0)
@@ -1496,8 +1496,8 @@
                 (.mov vf2 v1-23)
                 )
               )
-            (.add.x.vf vf1 vf0 vf0 :mask #b1000)
-            (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+            (.add.x.vf.w vf1 vf0 vf0)
+            (.mul.x.vf.xyz vf1 vf1 vf2)
             (.svf (&-> sv-160 quad) vf1)
             (vector+! s2-0 s2-0 (-> arg0 vector 2))
             (vector-normalize! s2-0 1.0)
@@ -1511,7 +1511,7 @@
           (vector-! s3-0 (-> *camera* tpos-curr) (-> *camera* pitch-off))
           (vector-! s3-0 s3-0 arg1)
           (vector--float*! s3-0 s3-0 (-> *camera* local-down) (-> *camera* head-offset))
-          (vector-flatten! s3-0 s3-0 (the-as vector (-> arg0 vector)))
+          (vector-flatten! s3-0 s3-0 (-> arg0 vector 0))
           (vector-normalize! s3-0 1.0)
           (let ((f28-2 (vector-dot s3-0 (-> arg0 vector 1))))
             (let ((s0-1 s2-0))
@@ -1544,13 +1544,13 @@
                            )
                        )
                 )
-            (matrix-axis-angle! s5-0 (the-as vector (-> arg0 vector)) f0-34)
+            (matrix-axis-angle! s5-0 (-> arg0 vector 0) f0-34)
             )
           )
         )
       (vector-matrix*! (-> arg0 vector 2) (-> arg0 vector 2) s5-0)
       )
-    (vector-cross! (-> arg0 vector 1) (-> arg0 vector 2) (the-as vector (-> arg0 vector)))
+    (vector-cross! (-> arg0 vector 1) (-> arg0 vector 2) (-> arg0 vector 0))
     )
   )
 
@@ -1589,11 +1589,11 @@
              (vector-normalize! sv-192 (* f28-0 (-> arg0 point-of-interest-blend value)))
              (let ((v1-3 s1-0))
                (let ((a0-5 s1-0))
-                 (.mov.vf vf6 vf0 :mask #b1000)
+                 (.mov.vf.w vf6 vf0)
                  (.lvf vf4 (&-> a0-5 quad))
                  )
                (.lvf vf5 (&-> sv-192 quad))
-               (.add.vf vf6 vf4 vf5 :mask #b111)
+               (.add.vf.xyz vf6 vf4 vf5)
                (.svf (&-> v1-3 quad) vf6)
                )
              (vector-normalize! s1-0 f28-0)

test/decompiler/reference/jak1/engine/collide/collide-edge-grab_REF.gc

@@ -24,14 +24,14 @@
         (set! (-> gp-0 cshape) v1-0)
         (.lvf vf3 (&-> v1-0 trans quad))
         )
-      (.add.vf vf1 vf1 vf3 :mask #b111)
-      (.add.vf vf2 vf2 vf3 :mask #b111)
+      (.add.vf.xyz vf1 vf1 vf3)
+      (.add.vf.xyz vf2 vf2 vf3)
       (.svf (&-> gp-0 cache-fill-box min quad) vf1)
       (.svf (&-> gp-0 cache-fill-box max quad) vf2)
       (.lvf vf4 (&-> gp-0 local-within-reach-box min quad))
       (.lvf vf5 (&-> gp-0 local-within-reach-box max quad))
-      (.add.vf vf4 vf4 vf3 :mask #b111)
-      (.add.vf vf5 vf5 vf3 :mask #b111)
+      (.add.vf.xyz vf4 vf4 vf3)
+      (.add.vf.xyz vf5 vf5 vf3)
       (.ftoi.vf vf6 vf4)
       (.ftoi.vf vf7 vf5)
       (.svf (&-> gp-0 within-reach-box min quad) vf4)
@@ -163,7 +163,7 @@
     (set! (-> arg1 world-vertex 1 quad) (-> s3-0 vertex-ptr 1 0 quad))
     (set! (-> arg1 hanging-matrix vector 1 quad) (-> *target* control dynam gravity-normal quad))
     (vector-normalize!
-      (vector-! (-> arg1 hanging-matrix vector 2) (-> arg1 world-vertex 1) (the-as vector (-> arg1 world-vertex)))
+      (vector-! (-> arg1 hanging-matrix vector 2) (-> arg1 world-vertex 1) (-> arg1 world-vertex 0))
       1.0
       )
     (vector-normalize!
@@ -271,14 +271,14 @@
           (.outer.product.a.vf acc vf4 vf5)
           (.outer.product.b.vf vf6 vf5 vf4 acc)
           (.mul.vf vf7 vf6 vf6)
-          (.mul.x.vf acc vf0 vf7 :mask #b1000)
-          (.add.mul.y.vf acc vf0 vf7 acc :mask #b1000)
-          (.add.mul.z.vf vf7 vf0 vf7 acc :mask #b1000)
+          (.mul.x.vf.w acc vf0 vf7)
+          (.add.mul.y.vf.w acc vf0 vf7 acc)
+          (.add.mul.z.vf.w vf7 vf0 vf7 acc)
           (.isqrt.vf Q vf0 vf7 :fsf #b11 :ftf #b11)
           (let ((f1-0 0.707))
             (.wait.vf)
             (nop!)
-            (.mul.vf vf6 vf6 Q :mask #b111)
+            (.mul.vf.xyz vf6 vf6 Q)
             (.mov v1-14 vf6)
             (b! (>= (the-as float (gpr->fpr (sar (the-as int v1-14) 32))) f1-0) cfg-17)
             )
@@ -287,7 +287,7 @@
           (label cfg-17)
           (set! (-> this hanging-matrix vector 1 quad) (-> *target* control dynam gravity-normal quad))
           (vector-normalize!
-            (vector-! (-> this hanging-matrix vector 2) (-> this world-vertex 1) (the-as vector (-> this world-vertex)))
+            (vector-! (-> this hanging-matrix vector 2) (-> this world-vertex 1) (-> this world-vertex 0))
             1.0
             )
           (vector-normalize!
@@ -441,19 +441,19 @@
         (.add.vf vf10 vf10 vf1)
         (.sub.vf vf7 vf5 vf10)
         (.mul.vf vf7 vf7 vf7)
-        (.add.z.vf vf7 vf7 vf7 :mask #b1)
+        (.add.z.vf.x vf7 vf7 vf7)
         (.mov v1-4 vf7)
         (b! (< f0-0 v1-4) cfg-4)
         (.sub.vf vf8 vf1 vf5)
         (.mul.vf vf7 vf8 vf8)
-        (.add.z.vf vf7 vf7 vf7 :mask #b1)
+        (.add.z.vf.x vf7 vf7 vf7)
         (.isqrt.vf Q vf0 vf7 :fsf #b11 :ftf #b0)
         (nop!)
         (.wait.vf)
         (nop!)
-        (.mul.vf vf8 vf8 Q :mask #b101)
+        (.mul.vf.xz vf8 vf8 Q)
         (.mul.vf vf9 vf8 vf6)
-        (.add.z.vf vf9 vf9 vf9 :mask #b1)
+        (.add.z.vf.x vf9 vf9 vf9)
         (.mov v1-5 vf9)
         (b! (< v1-5 f1-0) cfg-4)
         )
@@ -463,7 +463,7 @@
     (.mul.vf vf7 vf7 vf7)
     (set! (-> arg0 split) 0)
     (.svf (&-> arg0 outward-pt quad) vf10)
-    (.add.z.vf vf7 vf7 vf7 :mask #b1)
+    (.add.z.vf.x vf7 vf7 vf7)
     (set! (-> arg0 edge) arg1)
     (.mov v1-6 vf7)
     (set! (-> arg0 rating) v1-6)
@@ -509,23 +509,23 @@
       (.sub.vf vf4 vf1 vf2)
       (.sub.vf vf5 vf3 vf2)
       (.mul.vf vf6 vf5 vf5)
-      (.add.z.vf vf6 vf6 vf6 :mask #b1)
+      (.add.z.vf.x vf6 vf6 vf6)
       (.sqrt.vf Q vf6 :ftf #b0)
       (nop!)
       (.wait.vf)
       (nop!)
-      (.add.vf vf6 vf0 Q :mask #b1)
+      (.add.vf.x vf6 vf0 Q)
       (.nop.vf)
       (.mov v1-1 vf6)
       (let ((f1-0 v1-1))
         (.div.vf Q vf0 vf6 :fsf #b11 :ftf #b0)
         (.wait.vf)
         (nop!)
-        (.add.vf vf8 vf0 Q :mask #b1)
+        (.add.vf.x vf8 vf0 Q)
         (.mul.x.vf vf9 vf5 vf8)
         (.mov v1-2 vf8)
         (.mul.vf vf10 vf9 vf4)
-        (.add.z.vf vf10 vf10 vf10 :mask #b1)
+        (.add.z.vf.x vf10 vf10 vf10)
         (let ((f2-0 v1-2))
           (.mov v1-3 vf10)
           (let ((f3-0 v1-3))
@@ -539,8 +539,8 @@
           )
         )
       )
-    (.mul.x.vf vf7 vf5 vf11 :mask #b111)
-    (.add.vf vf7 vf7 vf2 :mask #b111)
+    (.mul.x.vf.xyz vf7 vf5 vf11)
+    (.add.vf.xyz vf7 vf7 vf2)
     (.svf (&-> arg1 quad) vf7)
     (.mov v0-0 vf7)
     v0-0
@@ -553,7 +553,7 @@
   (add-debug-line
     #t
     (bucket-id debug-no-zbuf)
-    (the-as vector (-> this world-vertex))
+    (-> this world-vertex 0)
     (-> this world-vertex 1)
     (new 'static 'rgba :r #xff :a #x60)
     #f
@@ -583,7 +583,7 @@
   (add-debug-outline-triangle
     #t
     (bucket-id debug-no-zbuf)
-    (the-as vector (-> this tri-vertex))
+    (-> this tri-vertex 0)
     (-> this world-vertex 4)
     (-> this world-vertex 5)
     (new 'static 'rgba :r #xff :a #x30)
@@ -708,7 +708,7 @@
     (add-debug-sphere
       #t
       (bucket-id debug-no-zbuf)
-      (the-as vector (-> this attempts s5-1))
+      (-> this attempts s5-1 vector)
       409.6
       (new 'static 'rgba :a #x40)
       )
@@ -726,7 +726,7 @@
       (add-debug-outline-triangle
         #t
         (bucket-id debug-no-zbuf)
-        (the-as vector (-> v1-3 vertex))
+        (-> v1-3 vertex 0)
         (-> v1-3 vertex 1)
         (-> v1-3 vertex 2)
         t1-0

test/decompiler/reference/jak1/engine/collide/collide-func_REF.gc

@@ -25,22 +25,22 @@
     (.mul.vf vf3 vf3 vf3)
     (.mul.vf vf6 vf1 vf1)
     (.mul.vf vf5 vf2 vf1)
-    (.add.y.vf vf4 vf4 vf4 :mask #b1)
+    (.add.y.vf.x vf4 vf4 vf4)
     (let ((result (the-as float 0)))
-      (.add.x.vf vf6 vf6 vf6 :mask #b10)
-      (.sub.x.vf vf6 vf6 vf3 :mask #b100)
-      (.add.z.vf vf4 vf4 vf4 :mask #b1)
-      (.add.x.vf vf5 vf5 vf5 :mask #b10)
+      (.add.x.vf.y vf6 vf6 vf6)
+      (.sub.x.vf.z vf6 vf6 vf3)
+      (.add.z.vf.x vf4 vf4 vf4)
+      (.add.x.vf.y vf5 vf5 vf5)
       (let ((v1-0 (the-as float 0)))
-        (.add.z.vf vf6 vf6 vf6 :mask #b10)
+        (.add.z.vf.y vf6 vf6 vf6)
         (.div.vf Q vf0 vf4 :fsf #b11 :ftf #b0)
-        (.add.z.vf vf5 vf5 vf5 :mask #b10)
+        (.add.z.vf.y vf5 vf5 vf5)
         (.mov a0-1 vf4)
         (.mul.x.vf vf7 vf6 vf4)
         (.mov a1-0 vf6)
         (.mul.vf vf8 vf5 vf5)
         (b! (< (the-as int a1-0) 0) cfg-7 :delay (set! a0-2 a0-1))
-        (.mul.vf vf4 vf0 Q :mask #b1000)
+        (.mul.vf.w vf4 vf0 Q)
         (.sub.vf vf9 vf8 vf7)
         (b! (= a0-2 v1-0) cfg-6 :delay (.mov v1-1 vf5))
         )
@@ -50,11 +50,11 @@
       (.add.x.vf vf6 vf5 vf4)
       (.mov v1-4 vf6)
       (.mul.vf vf6 vf6 vf6)
-      (.mul.vf vf9 vf0 Q :mask #b1000)
+      (.mul.vf.w vf9 vf0 Q)
       (.sub.vf vf6 vf9 vf6)
-      (.add.w.vf vf9 vf5 vf9 :mask #b10)
+      (.add.w.vf.y vf9 vf5 vf9)
       (.mov a0-3 vf6)
-      (.mul.w.vf vf9 vf9 vf4 :mask #b10)
+      (.mul.w.vf.y vf9 vf9 vf4)
       (b! (< (logand (the-as uint v1-4) (the-as uint a0-3)) 0) cfg-6 :delay (.sub.y.vf vf4 vf0 vf9))
       (b! #t cfg-7 :delay (.mov result vf4))
       (label cfg-6)
@@ -86,12 +86,12 @@
          )
     (init-vf0-vector)
     (.lvf vf1 (&-> ray-origin quad))
-    (.mov.vf vf1 vf0 :mask #b10)
+    (.mov.vf.y vf1 vf0)
     (.lvf vf2 (&-> circle-origin quad))
-    (.mov.vf vf2 vf0 :mask #b10)
+    (.mov.vf.y vf2 vf0)
     (.sub.vf vf1 vf1 vf2)
     (.lvf vf2 (&-> ray-dir quad))
-    (.mov.vf vf2 vf0 :mask #b10)
+    (.mov.vf.y vf2 vf0)
     (raw-ray-sphere-intersect radius)
     )
   )
@@ -130,10 +130,10 @@
     (.mov vf14 cyl-len)
     (.mul.vf vf16 vf15 vf13)
     (.mul.vf vf17 vf11 vf13)
-    (.add.x.vf vf16 vf16 vf16 :mask #b10)
-    (.add.x.vf vf17 vf17 vf17 :mask #b10)
-    (.add.z.vf vf16 vf16 vf16 :mask #b10)
-    (.add.z.vf vf17 vf17 vf17 :mask #b10)
+    (.add.x.vf.y vf16 vf16 vf16)
+    (.add.x.vf.y vf17 vf17 vf17)
+    (.add.z.vf.y vf16 vf16 vf16)
+    (.add.z.vf.y vf17 vf17 vf17)
     (.mul.y.vf vf1 vf13 vf16)
     (.add.vf vf18 vf17 vf16)
     (.sub.x.vf vf19 vf16 vf14)
@@ -155,7 +155,7 @@
       (.mul.y.vf vf13 vf13 vf16)
       (.sub.x.vf vf19 vf16 vf14)
       (.mov a0-4 vf16)
-      (b! (< (the-as int a0-4) 0) cfg-6 :delay (.add.vf vf12 vf12 vf13 :mask #b111))
+      (b! (< (the-as int a0-4) 0) cfg-6 :delay (.add.vf.xyz vf12 vf12 vf13))
       (.mov a0-5 vf19)
       (b! (>= (the-as int a0-5) 0) cfg-6 :delay (.svf (&-> arg6 quad) vf12))
       (b! #t cfg-7 :delay (set! v0-1 v1-4))
@@ -197,12 +197,12 @@
     (.mul.vf vf8 vf8 vf4)
     (.mul.vf vf9 vf7 vf4)
     (.mul.vf vf5 vf4 vf4)
-    (.add.y.vf vf8 vf8 vf8 :mask #b1)
-    (.add.y.vf vf9 vf9 vf9 :mask #b1)
-    (.add.y.vf vf5 vf5 vf5 :mask #b1)
-    (.add.z.vf vf8 vf8 vf8 :mask #b1)
-    (.add.z.vf vf9 vf9 vf9 :mask #b1)
-    (.add.z.vf vf5 vf5 vf5 :mask #b1)
+    (.add.y.vf.x vf8 vf8 vf8)
+    (.add.y.vf.x vf9 vf9 vf9)
+    (.add.y.vf.x vf5 vf5 vf5)
+    (.add.z.vf.x vf8 vf8 vf8)
+    (.add.z.vf.x vf9 vf9 vf9)
+    (.add.z.vf.x vf5 vf5 vf5)
     (.mov v1-0 vf9)
     (.mov a2-1 vf8)
     (.isqrt.vf Q vf0 vf5 :fsf #b11 :ftf #b0)
@@ -212,14 +212,14 @@
       (cond
         ((!= f2-0 0.0)
          (let ((f1-1 (/ f1-0 f2-0)))
-           (.mov.vf vf4 vf0 :mask #b1000)
+           (.mov.vf.w vf4 vf0)
            (.wait.vf)
-           (.mul.vf vf4 vf4 Q :mask #b111)
+           (.mul.vf.xyz vf4 vf4 Q)
            (let ((v0-0 f1-1))
              (.mov vf8 v0-0)
              (.svf (&-> arg1 quad) vf4)
              (.mul.x.vf acc vf7 vf8)
-             (.add.mul.w.vf vf7 vf6 vf0 acc :mask #b111)
+             (.add.mul.w.vf.xyz vf7 vf6 vf0 acc)
              (.svf (&-> arg0 quad) vf7)
              (.mov v1-1 vf7)
              v0-0
@@ -278,18 +278,18 @@
     (.mul.vf vf17 vf9 vf9)
     (.outer.product.a.vf acc vf5 vf4)
     (.outer.product.b.vf vf6 vf4 vf5 acc)
-    (.add.y.vf vf17 vf17 vf17 :mask #b1)
+    (.add.y.vf.x vf17 vf17 vf17)
     (.mul.vf vf7 vf6 vf6)
     (.mul.vf vf10 vf10 vf6)
     (.mul.vf vf11 vf9 vf6)
-    (.add.z.vf vf17 vf17 vf17 :mask #b1)
-    (.add.y.vf vf7 vf7 vf7 :mask #b1)
-    (.add.y.vf vf10 vf10 vf10 :mask #b1)
-    (.add.y.vf vf11 vf11 vf11 :mask #b1)
+    (.add.z.vf.x vf17 vf17 vf17)
+    (.add.y.vf.x vf7 vf7 vf7)
+    (.add.y.vf.x vf10 vf10 vf10)
+    (.add.y.vf.x vf11 vf11 vf11)
     (.mov vf18 arg2)
-    (.add.z.vf vf7 vf7 vf7 :mask #b1)
-    (.add.z.vf vf10 vf10 vf10 :mask #b1)
-    (.add.z.vf vf11 vf11 vf11 :mask #b1)
+    (.add.z.vf.x vf7 vf7 vf7)
+    (.add.z.vf.x vf10 vf10 vf10)
+    (.add.z.vf.x vf11 vf11 vf11)
     (.isqrt.vf Q vf0 vf7 :fsf #b11 :ftf #b0)
     (.mov v1-0 vf11)
     (.mov a0-1 vf10)
@@ -297,9 +297,9 @@
            (f3-0 (/ a0-1 f2-0))
            )
       (.sll v1-1 v1-0 1)
-      (.mov.vf vf6 vf0 :mask #b1000)
+      (.mov.vf.w vf6 vf0)
       (b! (zero? v1-1) cfg-5 :delay (.wait.vf))
-      (.mul.vf vf6 vf6 Q :mask #b111)
+      (.mul.vf.xyz vf6 vf6 Q)
       (let ((v0-0 (the-as number f3-0)))
         (.mov vf12 v0-0)
         (.svf (&-> arg5 quad) vf6)
@@ -316,24 +316,24 @@
         (.outer.product.b.vf vf15 vf4 vf19 acc)
         (.outer.product.a.vf acc vf20 vf21)
         (.outer.product.b.vf vf16 vf21 vf20 acc)
-        (.mul.vf vf14 vf14 vf6 :mask #b111)
-        (.mul.vf vf15 vf15 vf6 :mask #b111)
-        (.mul.vf vf16 vf16 vf6 :mask #b111)
-        (.add.x.vf vf14 vf14 vf14 :mask #b10)
-        (.add.x.vf vf15 vf15 vf15 :mask #b10)
-        (.add.x.vf vf16 vf16 vf16 :mask #b10)
-        (.add.z.vf vf14 vf14 vf14 :mask #b10)
-        (.add.z.vf vf15 vf15 vf15 :mask #b10)
-        (.add.z.vf vf16 vf16 vf16 :mask #b10)
+        (.mul.vf.xyz vf14 vf14 vf6)
+        (.mul.vf.xyz vf15 vf15 vf6)
+        (.mul.vf.xyz vf16 vf16 vf6)
+        (.add.x.vf.y vf14 vf14 vf14)
+        (.add.x.vf.y vf15 vf15 vf15)
+        (.add.x.vf.y vf16 vf16 vf16)
+        (.add.z.vf.y vf14 vf14 vf14)
+        (.add.z.vf.y vf15 vf15 vf15)
+        (.add.z.vf.y vf16 vf16 vf16)
         (.mov a0-2 vf14)
         (.mov a1-1 vf15)
         (.mov v1-2 vf16)
         (b! (< (the-as int (logior (logior a0-2 (the-as uint a1-1)) (the-as uint v1-2))) 0) cfg-5 :delay (nop!))
         (b! (zero? (the int arg2)) cfg-6 :delay (nop!))
         (.wait.vf)
-        (.mul.vf vf18 vf18 Q :mask #b1)
-        (.sub.x.vf vf12 vf12 vf18 :mask #b1)
-        (.max.x.vf vf12 vf12 vf0 :mask #b1)
+        (.mul.vf.x vf18 vf18 Q)
+        (.sub.x.vf.x vf12 vf12 vf18)
+        (.max.x.vf.x vf12 vf12 vf0)
         (b! #t cfg-6 :delay (.mov v0-0 vf12))
         (label cfg-5)
         (set! v0-0 -859915232)

test/decompiler/reference/jak1/engine/collide/collide-mesh_REF.gc

@@ -297,11 +297,11 @@
                   (let ((t1-3 (* t1-2 16)))
                     (.max.vf vf9 vf9 vf3)
                     (let ((t2-4 (* t2-3 16)))
-                      (.mul.x.vf acc vf0 vf7 :mask #b1000)
+                      (.mul.x.vf.w acc vf0 vf7)
                       (let ((t3-0 (* t0-5 16)))
-                        (.add.mul.y.vf acc vf0 vf7 acc :mask #b1000)
+                        (.add.mul.y.vf.w acc vf0 vf7 acc)
                         (set! t0-4 (+ t1-3 a2-1))
-                        (.add.mul.z.vf vf7 vf0 vf7 acc :mask #b1000)
+                        (.add.mul.z.vf.w vf7 vf0 vf7 acc)
                         (set! t1-1 (+ t2-4 a2-1))
                         (.isqrt.vf Q vf0 vf7 :fsf #b11 :ftf #b11)
                         (set! t2-2 (+ t3-0 a2-1))
@@ -320,7 +320,7 @@
           (.svf (&-> a1-1 bbox4w min quad) vf8)
           (.wait.vf)
           (.svf (&-> a1-1 bbox4w max quad) vf9)
-          (.mul.vf vf6 vf6 Q :mask #b111)
+          (.mul.vf.xyz vf6 vf6 Q)
           (nop!)
           (nop!)
           (.svf (&-> a1-1 normal quad) vf6)
@@ -405,24 +405,19 @@
         (nop!)
         (b! (nonzero? a1-5) cfg-1 :likely-delay (set! s4-0 (+ s4-0 96)))
         )
-      (closest-pt-in-triangle
-        (the-as vector (-> s5-0 vector))
-        arg1
-        (the-as matrix (-> s4-0 vertex))
-        (-> s4-0 normal)
-        )
+      (closest-pt-in-triangle (-> s5-0 vector 0) arg1 (the-as matrix (-> s4-0 vertex)) (-> s4-0 normal))
       (.lvf vf1 (&-> s5-0 vector 0 quad))
       (.lvf vf2 (&-> arg1 quad))
       (set! v1-0 (-> s5-0 vector 1 quad))
       (set! a0-1 (-> s5-0 vector 2 quad))
       (.sub.vf vf3 vf2 vf1)
-      (.mul.w.vf vf4 vf2 vf2 :mask #b1000)
+      (.mul.w.vf.w vf4 vf2 vf2)
       (.mul.vf vf3 vf3 vf3)
-      (.mul.x.vf acc vf0 vf3 :mask #b1000)
-      (.add.mul.y.vf acc vf0 vf3 acc :mask #b1000)
-      (.add.mul.z.vf vf3 vf0 vf3 acc :mask #b1000)
-      (.sub.w.vf vf3 vf3 vf4 :mask #b1000)
-      (.add.w.vf vf3 vf0 vf3 :mask #b10)
+      (.mul.x.vf.w acc vf0 vf3)
+      (.add.mul.y.vf.w acc vf0 vf3 acc)
+      (.add.mul.z.vf.w vf3 vf0 vf3 acc)
+      (.sub.w.vf.w vf3 vf3 vf4)
+      (.add.w.vf.y vf3 vf0 vf3)
       (.mov a1-7 vf3)
       (b! (>= (the-as int a1-7) 0) cfg-1 :delay (set! s4-0 (+ s4-0 96)))
       )

test/decompiler/reference/jak1/engine/collide/collide-shape-rider_REF.gc

@@ -16,7 +16,7 @@
                (logtest? (-> s5-0 prim-core action) (collide-action rider-plat-sticky))
                (logtest? (-> s4-0 prim-core action) (collide-action rider-target))
                )
-      (let ((f0-4 (- (- (vector-vector-distance (the-as vector (-> s5-0 prim-core)) (the-as vector (-> s4-0 prim-core)))
+      (let ((f0-4 (- (- (vector-vector-distance (-> s5-0 prim-core world-sphere) (-> s4-0 prim-core world-sphere))
                         (-> s5-0 prim-core world-sphere w)
                         )
                      (-> s4-0 prim-core world-sphere w)
@@ -48,7 +48,7 @@
         (when (and (logtest? (-> s1-0 collide-with) s3-0)
                    (logtest? (-> s1-0 prim-core action) (collide-action rider-plat-sticky))
                    )
-          (let ((f0-2 (- (- (vector-vector-distance (the-as vector (-> s1-0 prim-core)) (the-as vector (-> arg0 prim-core)))
+          (let ((f0-2 (- (- (vector-vector-distance (-> s1-0 prim-core world-sphere) (-> arg0 prim-core world-sphere))
                             (-> s1-0 prim-core world-sphere w)
                             )
                          (-> arg0 prim-core world-sphere w)
@@ -79,7 +79,7 @@
            (when (and (logtest? s3-0 (-> s1-0 prim-core collide-as))
                       (logtest? (-> s1-0 prim-core action) (collide-action rider-target))
                       )
-             (let ((f0-2 (- (- (vector-vector-distance (the-as vector (-> this prim-core)) (the-as vector (-> s1-0 prim-core)))
+             (let ((f0-2 (- (- (vector-vector-distance (-> this prim-core world-sphere) (-> s1-0 prim-core world-sphere))
                                (-> this prim-core world-sphere w)
                                )
                             (-> s1-0 prim-core world-sphere w)
@@ -107,7 +107,7 @@
                    (set! (-> this mesh-cache-id) (-> s2-1 id))
                    (populate-cache!
                      s3-1
-                     (the-as collide-mesh-cache-tri (-> this mesh-cache-tris))
+                     (-> this mesh-cache-tris 0)
                      (-> this cshape process node-list data (-> this transform-index) bone transform)
                      )
                    )
@@ -121,9 +121,9 @@
          (let* ((s2-2 (new 'stack-no-clear 'collide-tri-result))
                 (f0-4 (sphere-on-platform-test
                         s3-1
-                        (the-as collide-mesh-cache-tri (-> this mesh-cache-tris))
+                        (-> this mesh-cache-tris 0)
                         s2-2
-                        (the-as vector (-> arg0 prim-core))
+                        (-> arg0 prim-core world-sphere)
                         (-> arg1 best-dist)
                         )
                       )
@@ -440,8 +440,8 @@
                  (.mov at-0 f0-2)
                  )
                (.mov vf2 at-0)
-               (.mov.vf vf1 vf0 :mask #b1000)
-               (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+               (.mov.vf.w vf1 vf0)
+               (.mul.x.vf.xyz vf1 vf1 vf2)
                (.svf (&-> v1-12 quad) vf1)
                )
              (cond

test/decompiler/reference/jak1/engine/collide/collide-touch_REF.gc

@@ -484,17 +484,14 @@
 (defmethod get-middle-of-bsphere-overlap ((this touching-prims-entry) (arg0 vector))
   (let* ((s4-0 (-> this prim1 cprim))
          (s3-0 (-> this prim2 cprim))
-         (gp-1 (vector-!
-                 (new 'stack-no-clear 'vector)
-                 (the-as vector (-> s3-0 prim-core))
-                 (the-as vector (-> s4-0 prim-core))
-                 )
-               )
+         (gp-1
+           (vector-! (new 'stack-no-clear 'vector) (-> s3-0 prim-core world-sphere) (-> s4-0 prim-core world-sphere))
+           )
          )
     (let ((f1-2 (- (- (vector-length gp-1) (-> s3-0 prim-core world-sphere w)) (-> s4-0 prim-core world-sphere w))))
       (vector-normalize! gp-1 (+ (-> s4-0 prim-core world-sphere w) (/ f1-2 2)))
       )
-    (vector+! arg0 gp-1 (the-as vector (-> s4-0 prim-core)))
+    (vector+! arg0 gp-1 (-> s4-0 prim-core world-sphere))
     )
   arg0
   )

test/decompiler/reference/jak1/engine/collide/main-collide_REF.gc

@@ -13,9 +13,9 @@
     (nop!)
     (nop!)
     (.lvf vf1 (&-> arg0 bsphere quad))
-    (.add.w.vf vf2 vf1 vf1 :mask #b111)
+    (.add.w.vf.xyz vf2 vf1 vf1)
     (let ((v1-0 (-> arg1 min quad)))
-      (.sub.w.vf vf1 vf1 vf1 :mask #b111)
+      (.sub.w.vf.xyz vf1 vf1 vf1)
       (let ((a1-1 (-> arg1 max quad)))
         (.ftoi.vf vf4 vf2)
         (nop!)
@@ -114,13 +114,13 @@
     (nop!)
     (vitof12.xyzw vf7 vf7)
     (nop!)
-    (.add.vf vf8 vf8 vf9 :mask #b111)
+    (.add.vf.xyz vf8 vf8 vf9)
     (nop!)
     (nop!)
     (.lvf vf9 (&-> arg0 bsphere quad))
     (vitof12.xyzw vf10 vf10)
     (nop!)
-    (.mul.w.vf vf10 vf10 vf9 :mask #b1)
+    (.mul.w.vf.x vf10 vf10 vf9)
     (nop!)
     (.mul.x.vf acc vf5 vf9)
     (nop!)
@@ -130,9 +130,9 @@
       (let ((a1-1 (-> arg2 max quad)))
         (.add.mul.w.vf vf1 vf8 vf0 acc)
         (nop!)
-        (.add.x.vf vf2 vf1 vf10 :mask #b111)
+        (.add.x.vf.xyz vf2 vf1 vf10)
         (nop!)
-        (.sub.x.vf vf1 vf1 vf10 :mask #b111)
+        (.sub.x.vf.xyz vf1 vf1 vf10)
         (nop!)
         (.ftoi.vf vf4 vf2)
         (nop!)
@@ -181,11 +181,11 @@
     (.mov vf12 v1-2)
     (.itof.vf vf12 vf12)
     (nop!)
-    (.add.vf vf10 vf10 vf12 :mask #b111)
+    (.add.vf.xyz vf10 vf10 vf12)
     (nop!)
-    (.add.vf vf9 vf9 vf10 :mask #b111)
+    (.add.vf.xyz vf9 vf9 vf10)
     (nop!)
-    (.add.w.vf vf11 vf0 vf9 :mask #b1)
+    (.add.w.vf.x vf11 vf0 vf9)
     (nop!)
     (.mov a3-0 vf11)
     (nop!)

test/decompiler/reference/jak1/engine/common-obs/collectables_REF.gc

@@ -331,7 +331,7 @@
           (let ((a0-5 (-> self root root-prim prim-core))
                 (a1-2 (-> (the-as collide-shape v1-3) root-prim prim-core))
                 )
-            (if (< (vector-vector-distance (the-as vector a0-5) (the-as vector a1-2)) (-> *FACT-bank* suck-suck-dist))
+            (if (< (vector-vector-distance (-> a0-5 world-sphere) (-> a1-2 world-sphere)) (-> *FACT-bank* suck-suck-dist))
                 (logior! (-> self flags) (collectable-flags suck))
                 )
             )
@@ -362,9 +362,9 @@
                 (gp-2 (-> v1-6 root-prim prim-core))
                 )
             (if (and arg1 (rand-vu-percent? (the-as float 0.25)))
-                (eco-blue-glow (the-as vector s2-0))
+                (eco-blue-glow (-> s2-0 world-sphere))
                 )
-            (let ((f0-0 (vector-vector-distance (the-as vector s2-0) (the-as vector gp-2))))
+            (let ((f0-0 (vector-vector-distance (-> s2-0 world-sphere) (-> gp-2 world-sphere))))
               (cond
                 ((and arg3 (< f0-0 8192.0))
                  (return #t)
@@ -386,13 +386,13 @@
                  (+! (-> self speed w) (* 163840.0 (seconds-per-frame)))
                  (+! (-> self speed y) (* 291271.12 (seconds-per-frame)))
                  (set! (-> self speed y) (fmin (fmin 291271.12 (-> self speed y)) (-> self speed y)))
-                 (let ((s5-2 (vector-! (new 'stack-no-clear 'vector) (-> self base) (the-as vector gp-2))))
+                 (let ((s5-2 (vector-! (new 'stack-no-clear 'vector) (-> self base) (-> gp-2 world-sphere))))
                    (vector-normalize! s5-2 (fmax 0.0 (- (vector-length s5-2) (* (-> self speed w) (seconds-per-frame)))))
                    (vector-rotate-y! s5-2 s5-2 (* (-> self speed y) (-> self speed z) (seconds-per-frame)))
                    (set! (-> self suck-y-offset)
                          (* 2048.0 (sin (* 873.81335 (the float (mod (- (current-time) (-> self suck-time)) 75)))))
                          )
-                   (vector+! (-> self base) (the-as vector gp-2) s5-2)
+                   (vector+! (-> self base) (-> gp-2 world-sphere) s5-2)
                    )
                  )
                 ((and arg2 (and (< (+ 4096.0 (-> *FACT-bank* suck-bounce-dist)) f0-0)
@@ -402,7 +402,7 @@
                  (go-virtual wait)
                  )
                 (arg1
-                  (add-blue-shake (-> self root trans) (the-as vector s2-0) (the-as vector gp-2))
+                  (add-blue-shake (-> self root trans) (-> s2-0 world-sphere) (-> gp-2 world-sphere))
                   )
                 )
               )
@@ -623,7 +623,7 @@
               )
             )
           )
-        (spawn gp-0 (the-as vector s5-0))
+        (spawn gp-0 (-> s5-0 world-sphere))
         )
       (if (nonzero? (-> self sound))
           (update! (-> self sound))
@@ -689,7 +689,7 @@
             (a1-1 (-> self root root-prim prim-core))
             )
         (if (nonzero? a0-5)
-            (spawn a0-5 (the-as vector a1-1))
+            (spawn a0-5 (-> a1-1 world-sphere))
             )
         )
       (if (nonzero? (-> self sound))
@@ -894,7 +894,7 @@
   (let ((a0-1 (-> this part))
         (a1-0 (-> this root root-prim prim-core))
         )
-    (spawn a0-1 (the-as vector a1-0))
+    (spawn a0-1 (-> a1-0 world-sphere))
     )
   (if (nonzero? (-> this sound))
       (update! (-> this sound))
@@ -1032,7 +1032,7 @@
   (let ((a0-1 (-> this part))
         (a1-0 (-> this root root-prim prim-core))
         )
-    (spawn a0-1 (the-as vector a1-0))
+    (spawn a0-1 (-> a1-0 world-sphere))
     )
   (if (nonzero? (-> this sound))
       (update! (-> this sound))
@@ -1067,7 +1067,7 @@
   (let ((a0-1 (-> this part))
         (a1-0 (-> this root root-prim prim-core))
         )
-    (spawn a0-1 (the-as vector a1-0))
+    (spawn a0-1 (-> a1-0 world-sphere))
     )
   (if (nonzero? (-> this sound))
       (update! (-> this sound))
@@ -1985,7 +1985,7 @@
   :post (behavior ()
     (transform-post)
     (if (-> self state-object)
-        (spawn (-> self part) (the-as vector (-> self root root-prim prim-core)))
+        (spawn (-> self part) (-> self root root-prim prim-core world-sphere))
         )
     )
   )

test/decompiler/reference/jak1/engine/common-obs/crates_REF.gc

@@ -759,7 +759,7 @@
             (when v1-6
               (let* ((gp-2 (-> self root root-prim prim-core))
                      (a1-3 (-> (the-as collide-shape v1-6) root-prim prim-core))
-                     (f30-0 (vector-vector-distance (the-as vector gp-2) (the-as vector a1-3)))
+                     (f30-0 (vector-vector-distance (-> gp-2 world-sphere) (-> a1-3 world-sphere)))
                      )
                 (when (and (< f30-0 (-> *FACT-bank* suck-suck-dist)) (!= (-> self defense) 'steel))
                   (logior! (-> self fact options) (fact-options can-collect))

test/decompiler/reference/jak1/engine/common-obs/generic-obs_REF.gc

@@ -1301,7 +1301,7 @@
                 )
             (.lvf vf16 (&-> v1-36 origin quad))
             (.lvf vf17 (&-> v1-36 bounds quad))
-            (.mul.x.vf vf16 vf16 vf0 :mask #b1000)
+            (.mul.x.vf.w vf16 vf16 vf0)
             (.add.vf vf16 vf16 vf17)
             (.svf (&-> a0-18 quad) vf16)
             )
@@ -2365,7 +2365,7 @@
       ((and (nonzero? s4-0) (type-type? (-> s4-0 type) collide-shape))
        (vector+!
          arg1
-         (the-as vector (-> (the-as collide-shape s4-0) root-prim prim-core))
+         (-> (the-as collide-shape s4-0) root-prim prim-core world-sphere)
          (rand-vu-sphere-point! arg1 (-> (the-as collide-shape s4-0) root-prim prim-core world-sphere w))
          )
        )
@@ -2408,14 +2408,14 @@
         ((< (-> v1-0 w) 0.0)
          (.lvf vf1 (&-> a0-1 conerot quad))
          (.lvf vf2 (&-> v1-0 vec quad))
-         (.sub.vf vf1 vf0 vf2 :mask #b111)
+         (.sub.vf.xyz vf1 vf0 vf2)
          (.svf (&-> a0-1 conerot quad) vf1)
          (.mov a0-2 vf1)
          )
         (else
           (.lvf vf1 (&-> a0-1 conerot quad))
           (.lvf vf2 (&-> v1-0 vec quad))
-          (.add.vf vf1 vf0 vf2 :mask #b111)
+          (.add.vf.xyz vf1 vf0 vf2)
           (.svf (&-> a0-1 conerot quad) vf1)
           (.mov a0-3 vf1)
           )

test/decompiler/reference/jak1/engine/common-obs/nav-enemy_REF.gc

@@ -95,7 +95,7 @@
     (if *target*
         (look-at-enemy!
           (-> *target* neck)
-          (the-as vector (-> this collide-info root-prim prim-core))
+          (-> this collide-info root-prim prim-core world-sphere)
           (if (logtest? (-> this nav-enemy-flags) (nav-enemy-flags navenmf2))
               'attacking
               )

test/decompiler/reference/jak1/engine/common-obs/plat-eco_REF.gc

@@ -139,7 +139,7 @@
             (when v1-6
               (let* ((s5-0 (-> self root root-prim prim-core))
                      (a1-3 (-> (the-as collide-shape v1-6) root-prim prim-core))
-                     (f30-0 (vector-vector-distance (the-as vector s5-0) (the-as vector a1-3)))
+                     (f30-0 (vector-vector-distance (-> s5-0 world-sphere) (-> a1-3 world-sphere)))
                      )
                 (when (rand-vu-percent? 0.5)
                   (let ((gp-2 (new 'stack-no-clear 'vector)))

test/decompiler/reference/jak1/engine/common-obs/process-taskable_REF.gc

@@ -153,9 +153,7 @@
 ;; INFO: Return type mismatch int vs none.
 (defmethod process-taskable-method-46 ((this process-taskable))
   (when (nonzero? (-> this sound-flava))
-    (let ((s5-1
-            (vector-! (new 'stack-no-clear 'vector) (target-pos 0) (the-as vector (-> this root root-prim prim-core)))
-            )
+    (let ((s5-1 (vector-! (new 'stack-no-clear 'vector) (target-pos 0) (-> this root root-prim prim-core world-sphere)))
           )
       (set! (-> s5-1 y) (* 4.0 (-> s5-1 y)))
       (cond
@@ -173,9 +171,7 @@
       )
     )
   (when (-> this music)
-    (let ((s5-3
-            (vector-! (new 'stack-no-clear 'vector) (target-pos 0) (the-as vector (-> this root root-prim prim-core)))
-            )
+    (let ((s5-3 (vector-! (new 'stack-no-clear 'vector) (target-pos 0) (-> this root root-prim prim-core world-sphere)))
           )
       (set! (-> s5-3 y) (* 4.0 (-> s5-3 y)))
       (cond
@@ -724,7 +720,7 @@
   (if *target*
       (or (not *target*) (< 245760.0 (vector-vector-distance (-> this root trans) (-> *target* control trans))))
       (< 60397978000.0
-         (vector-vector-distance-squared (the-as vector (-> this root root-prim prim-core)) (camera-pos))
+         (vector-vector-distance-squared (-> this root root-prim prim-core world-sphere) (camera-pos))
          )
       )
   )
@@ -907,7 +903,7 @@
                         )
                    )
               (< (-> (target-pos 0) y) (+ 8192.0 (-> self root root-prim prim-core world-sphere y)))
-              (< (vector-vector-distance (target-pos 0) (the-as vector (-> self root root-prim prim-core))) 32768.0)
+              (< (vector-vector-distance (target-pos 0) (-> self root root-prim prim-core world-sphere)) 32768.0)
               (= (-> *level* loading-level) (-> *level* level-default))
               (not (movie?))
               (not (level-hint-displayed?))
@@ -1223,11 +1219,7 @@
               )
             (when #t
               (set! (-> *camera-other-trans* quad) (-> s5-0 quad))
-              (vector-normalize-copy!
-                (the-as vector (-> *camera-other-matrix* vector))
-                (the-as vector (-> s4-0 vector))
-                -1.0
-                )
+              (vector-normalize-copy! (-> *camera-other-matrix* vector 0) (-> s4-0 vector 0) -1.0)
               (set! (-> *camera-other-matrix* vector 0 w) 0.0)
               (vector-normalize-copy! (-> *camera-other-matrix* vector 1) (-> s4-0 vector 1) 1.0)
               (set! (-> *camera-other-matrix* vector 1 w) 0.0)

test/decompiler/reference/jak1/engine/common-obs/ropebridge_REF.gc

@@ -745,7 +745,7 @@
 ;; WARN: Function (method 22 ropebridge) has a return type of none, but the expression builder found a return statement.
 (defmethod set-vel-from-rider ((this ropebridge) (arg0 uint) (arg1 vector) (arg2 int))
   (loop
-    (let ((f0-0 (vector-vector-distance arg1 (the-as vector (-> this spring-point (the-as int arg0))))))
+    (let ((f0-0 (vector-vector-distance arg1 (-> this spring-point (the-as int arg0) local-pos))))
       (if (< (-> this tuning max-influence-dist) f0-0)
           (return #f)
           )
@@ -790,20 +790,20 @@
     (let ((v1-1 (-> this tuning gravity)))
       (.mov vf9 v1-1)
       )
-    (.add.x.vf vf9 vf0 vf9 :mask #b10)
-    (.mov.vf vf9 vf0 :mask #b1101)
+    (.add.x.vf.y vf9 vf0 vf9)
+    (.mov.vf.xzw vf9 vf0)
     0
     (let ((v1-4 (-> this tuning friction)))
       (.mov vf12 v1-4)
       )
-    (.add.x.vf vf12 vf0 vf12 :mask #b10)
-    (.add.x.vf vf12 vf0 vf12 :mask #b100)
+    (.add.x.vf.y vf12 vf0 vf12)
+    (.add.x.vf.z vf12 vf0 vf12)
     0
     (let ((v1-7 (/ 1.0 (-> this tuning spring-mass))))
       (.mov vf14 v1-7)
       )
-    (.add.x.vf vf14 vf0 vf14 :mask #b10)
-    (.add.x.vf vf14 vf0 vf14 :mask #b100)
+    (.add.x.vf.y vf14 vf0 vf14)
+    (.add.x.vf.z vf14 vf0 vf14)
     0
     (let ((v1-11 (+ (-> this tuning num-spring-points) -2)))
       (let* ((a2-0 (-> this spring-point))
@@ -813,11 +813,11 @@
         (label cfg-1)
         (.lvf vf1 (&-> a1-1 extra-force quad))
         (.lvf vf3 (&-> a1-1 local-pos quad))
-        (.add.vf vf1 vf1 vf9 :mask #b111)
+        (.add.vf.xyz vf1 vf1 vf9)
         (.sub.vf vf5 vf2 vf3)
-        (.mul.vf vf7 vf5 vf5 :mask #b111)
-        (.add.y.vf vf7 vf7 vf7 :mask #b1)
-        (.add.z.vf vf7 vf7 vf7 :mask #b1)
+        (.mul.vf.xyz vf7 vf5 vf5)
+        (.add.y.vf.x vf7 vf7 vf7)
+        (.add.z.vf.x vf7 vf7 vf7)
         (.mov a2-1 vf7)
         (let ((f0-5 (- a2-1 (-> this tuning desired-spring-len))))
           (when (< 0.0 f0-5)
@@ -827,17 +827,17 @@
             (let ((a2-5 (* f0-5 (-> this tuning spring-coefficient))))
               (.mov vf10 a2-5)
               )
-            (.mul.x.vf vf10 vf5 vf10 :mask #b111)
-            (.add.vf vf1 vf1 vf10 :mask #b111)
+            (.mul.x.vf.xyz vf10 vf5 vf10)
+            (.add.vf.xyz vf1 vf1 vf10)
             0
             )
           )
         (let ((a2-8 (&+ a1-1 48)))
           (.lvf vf4 (&-> a2-8 local-pos quad))
           (.sub.vf vf6 vf4 vf3)
-          (.mul.vf vf8 vf6 vf6 :mask #b111)
-          (.add.y.vf vf8 vf8 vf8 :mask #b1)
-          (.add.z.vf vf8 vf8 vf8 :mask #b1)
+          (.mul.vf.xyz vf8 vf6 vf6)
+          (.add.y.vf.x vf8 vf8 vf8)
+          (.add.z.vf.x vf8 vf8 vf8)
           (.mov a3-0 vf8)
           (let ((f0-8 (- a3-0 (-> this tuning desired-spring-len))))
             (when (< 0.0 f0-8)
@@ -847,15 +847,15 @@
               (let ((a3-4 (* f0-8 (-> this tuning spring-coefficient))))
                 (.mov vf10 a3-4)
                 )
-              (.mul.x.vf vf10 vf6 vf10 :mask #b111)
-              (.add.vf vf1 vf1 vf10 :mask #b111)
+              (.mul.x.vf.xyz vf10 vf6 vf10)
+              (.add.vf.xyz vf1 vf1 vf10)
               0
               )
             )
-          (.mul.vf vf15 vf1 vf14 :mask #b111)
+          (.mul.vf.xyz vf15 vf1 vf14)
           (.lvf vf11 (&-> a1-1 vel quad))
-          (.add.vf vf11 vf11 vf15 :mask #b111)
-          (.mul.vf vf11 vf11 vf12 :mask #b111)
+          (.add.vf.xyz vf11 vf11 vf15)
+          (.mul.vf.xyz vf11 vf11 vf12)
           (.svf (&-> a1-1 vel quad) vf11)
           (set! a1-1 a2-8)
           )
@@ -868,16 +868,16 @@
     (let ((v1-13 (seconds-per-frame)))
       (.mov vf13 v1-13)
       )
-    (.add.x.vf vf13 vf0 vf13 :mask #b10)
-    (.add.x.vf vf13 vf0 vf13 :mask #b100)
+    (.add.x.vf.y vf13 vf0 vf13)
+    (.add.x.vf.z vf13 vf0 vf13)
     0
     (let ((v1-17 (+ (-> this tuning num-spring-points) -2)))
       (let ((a0-1 (the-as object (&-> this stack 320))))
         (label cfg-7)
         (.lvf vf11 (&-> (the-as (inline-array vector) a0-1) 1 quad))
         (.lvf vf3 (&-> (the-as (inline-array vector) a0-1) 0 quad))
-        (.mul.vf vf11 vf11 vf13 :mask #b111)
-        (.add.vf vf3 vf3 vf11 :mask #b111)
+        (.mul.vf.xyz vf11 vf11 vf13)
+        (.add.vf.xyz vf3 vf3 vf11)
         (.svf (&-> (the-as (inline-array vector) a0-1) 0 quad) vf3)
         (set! a0-1 (-> (the-as (inline-array vector) a0-1) 3))
         )
@@ -939,11 +939,11 @@
             (let ((v1-3 (the-as ropebridge-spring-point (-> this spring-point))))
               (.mov vf2 a1-2)
               (.add.x.vf vf2 vf0 vf2)
-              (.mov.vf vf2 vf0 :mask #b1011)
+              (.mov.vf.xyw vf2 vf0)
               (countdown (a0-5 (-> this tuning num-spring-points))
                 (.svf (&-> v1-3 local-pos quad) vf1)
                 (.svf (&-> v1-3 vel quad) vf0)
-                (.add.vf vf1 vf1 vf2 :mask #b111)
+                (.add.vf.xyz vf1 vf1 vf2)
                 (&+! v1-3 48)
                 )
               )
@@ -970,7 +970,7 @@
     (while (< s4-0 (-> arg0 tuning num-springs))
       (set! s3-0 (&+ (the-as ropebridge-spring-point s3-0) 48))
       (let ((v1-4 (new 'stack-no-clear 'vector)))
-        (vector-! v1-4 (-> (the-as ropebridge-spring-point s3-0) local-pos) (the-as vector (-> s5-1 0)))
+        (vector-! v1-4 (-> (the-as ropebridge-spring-point s3-0) local-pos) (-> s5-1 0 local-pos))
         (let ((f0-8 (- (atan (-> v1-4 y) (-> v1-4 z))))
               (s2-0 (-> arg0 node-list data (+ s4-0 4) bone transform))
               )

test/decompiler/reference/jak1/engine/common-obs/water_REF.gc

@@ -37,7 +37,7 @@
 ;; definition for function birth-func-ocean-height
 ;; INFO: Return type mismatch int vs none.
 (defun birth-func-ocean-height ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 matrix))
-  (set! (-> arg2 vector 0 y) (+ (ocean-get-height (the-as vector (-> arg2 vector))) (-> arg1 user-float)))
+  (set! (-> arg2 vector 0 y) (+ (ocean-get-height (-> arg2 vector 0)) (-> arg1 user-float)))
   0
   (none)
   )
@@ -682,7 +682,7 @@
          )
         ((begin
            (set! (-> this top 1 quad) (-> this top 0 quad))
-           (vector<-cspace! (the-as vector (-> this top)) (-> this process node-list data (-> this joint-index)))
+           (vector<-cspace! (-> this top 0) (-> this process node-list data (-> this joint-index)))
            (+! (-> this top 0 y) (-> this top-y-offset))
            (set! (-> this bottom 1 quad) (-> this bottom 0 quad))
            (set! (-> this bottom 0 quad) (-> this process root trans quad))
@@ -695,9 +695,7 @@
                                   )
                         )
                    )
-              (set! (-> this real-ocean-offset)
-                    (- (ocean-get-height (the-as vector (-> this bottom))) (-> this base-height))
-                    )
+              (set! (-> this real-ocean-offset) (- (ocean-get-height (-> this bottom 0)) (-> this base-height)))
               (if (not (logtest? (-> this flags) (water-flags wt09)))
                   (set! (-> this ocean-offset) (-> this real-ocean-offset))
                   (set! (-> this ocean-offset) (lerp (-> this ocean-offset) (-> this real-ocean-offset) 0.2))
@@ -705,7 +703,7 @@
               )
              ((logtest? (water-flags wt20) (-> this flags))
               (let* ((a0-26 (-> this volume process 0))
-                     (f30-0 (ripple-find-height (the-as process-drawable a0-26) 0 (the-as vector (-> this bottom))))
+                     (f30-0 (ripple-find-height (the-as process-drawable a0-26) 0 (-> this bottom 0)))
                      )
                 (set! (-> this real-ocean-offset) (- f30-0 (-> this base-height)))
                 (if (not (logtest? (-> this flags) (water-flags wt09)))

test/decompiler/reference/jak1/engine/debug/debug_REF.gc

@@ -30,10 +30,10 @@
     (.add.mul.z.vf vf5 vf3 vf5 acc)
     (.div.vf Q vf9 vf5 :fsf #b0 :ftf #b11)
     (.wait.vf)
-    (.mul.vf vf5 vf5 Q :mask #b111)
+    (.mul.vf.xyz vf5 vf5 Q)
     (.add.vf vf5 vf5 vf8)
-    (.max.x.vf vf5 vf5 vf0 :mask #b1000)
-    (.min.x.vf vf5 vf5 vf6 :mask #b1000)
+    (.max.x.vf.w vf5 vf5 vf0)
+    (.min.x.vf.w vf5 vf5 vf6)
     (vftoi4.xyzw vf5 vf5)
     (.svf (&-> arg1 quad) vf5)
     arg1
@@ -391,7 +391,7 @@
     (set! (-> arg2 w) 1.0)
     (set! (-> arg3 w) 1.0)
     (set! (-> arg4 w) 1.0)
-    (when (and (transform-point-qword! (the-as vector4w (-> s5-0 vector)) arg2)
+    (when (and (transform-point-qword! (-> s5-0 vector 0) arg2)
                (transform-point-qword! (-> s5-0 vector 1) arg3)
                (transform-point-qword! (-> s5-0 vector 2) arg4)
                )
@@ -985,7 +985,7 @@
     arg0
     arg1
     (-> arg2 vector 3)
-    (the-as vector (-> arg2 vector))
+    (-> arg2 vector 0)
     (meters 2)
     (new 'static 'rgba :r #xff :a #x80)
     )
@@ -1010,14 +1010,7 @@
 
 ;; definition (debug) for function add-debug-rot-matrix
 (defun-debug add-debug-rot-matrix ((arg0 symbol) (arg1 bucket-id) (arg2 matrix) (arg3 vector))
-  (add-debug-vector
-    arg0
-    arg1
-    arg3
-    (the-as vector (-> arg2 vector))
-    (meters 2)
-    (new 'static 'rgba :r #xff :a #x80)
-    )
+  (add-debug-vector arg0 arg1 arg3 (-> arg2 vector 0) (meters 2) (new 'static 'rgba :r #xff :a #x80))
   (add-debug-vector arg0 arg1 arg3 (-> arg2 vector 1) (meters 2) (new 'static 'rgba :g #xff :a #x80))
   (add-debug-vector arg0 arg1 arg3 (-> arg2 vector 2) (meters 2) (new 'static 'rgba :b #xff :a #x80))
   arg2
@@ -1336,7 +1329,6 @@
   )
 
 ;; definition for method 3 of type debug-vertex-stats
-;; INFO: this function exists in multiple non-identical object files
 (defmethod inspect ((this debug-vertex-stats))
   (format #t "[~8x] ~A~%" this (-> this type))
   (format #t "~Tlength: ~D~%" (-> this length))

test/decompiler/reference/jak1/engine/debug/part-tester_REF.gc

@@ -64,7 +64,7 @@
           (when (!= gp-1 (-> self old-group))
             (when (nonzero? (-> self part))
               (kill-and-free-particles (-> self part))
-              (set! (-> self heap-cur) (&-> (-> self part) type))
+              (set! (-> self heap-cur) (&-> self part type))
               )
             (set! (-> self part) (create-launch-control gp-1 self))
             )

test/decompiler/reference/jak1/engine/draw/drawable_REF.gc

@@ -587,7 +587,7 @@
             )
         (.lvf vf16 (&-> arg1 origin quad))
         (.lvf vf17 (&-> arg1 bounds quad))
-        (.mul.x.vf vf16 vf16 vf0 :mask #b1000)
+        (.mul.x.vf.w vf16 vf16 vf0)
         (.add.vf vf16 vf16 vf17)
         (.svf (&-> s4-0 quad) vf16)
         (.lvf vf28 (&-> arg1 color-mult quad))
@@ -604,7 +604,7 @@
                  (set-vector! a1-1 0.612 0.5 -0.612 0.0)
                  (set-vector! s1-0 -0.696 0.174 0.696 0.0)
                  (vector-matrix*! (the-as vector (-> tod title-light-group)) a1-1 s0-0)
-                 (vector-matrix*! (the-as vector (-> tod title-light-group dir1)) s1-0 s0-0)
+                 (vector-matrix*! (-> tod title-light-group dir1 direction) s1-0 s0-0)
                  )
                (set-vector! (-> *time-of-day-context* current-shadow) 0.612 -0.5 -0.612 1.0)
                )
@@ -718,7 +718,7 @@
               )
             )
           (if *display-lights*
-              (add-debug-lights #t (bucket-id debug) (the-as (inline-array light) (-> tod light-group)) (-> arg1 origin))
+              (add-debug-lights #t (bucket-id debug) (-> tod light-group 0 lights) (-> arg1 origin))
               )
           (let ((at-0 *math-camera*))
             (.lvf vf16 (&-> at-0 plane 0 quad))
@@ -739,15 +739,15 @@
             (.mul.w.vf acc vf27 vf0)
             (.add.mul.x.vf acc vf24 vf15 acc)
             (.add.mul.y.vf acc vf25 vf15 acc)
-            (.add.mul.z.vf vf15 vf26 vf15 acc :mask #b111)
+            (.add.mul.z.vf.xyz vf15 vf26 vf15 acc)
             (.mul.vf vf28 vf15 vf15)
             (.max.w.vf vf29 vf0 vf0)
             (.add.y.vf acc vf28 vf28)
-            (.add.mul.z.vf vf28 vf29 vf28 acc :mask #b1)
+            (.add.mul.z.vf.x vf28 vf29 vf28 acc)
             (.sqrt.vf Q vf28 :ftf #b0)
-            (.sub.w.vf vf28 vf0 vf15 :mask #b1000)
+            (.sub.w.vf.w vf28 vf0 vf15)
             (.wait.vf)
-            (.add.vf vf15 vf28 Q :mask #b1000)
+            (.add.vf.w vf15 vf28 Q)
             (.svf (&-> v1-42 quad) vf15)
             (when (< 0.0 (+ (-> v1-42 z) (-> arg1 bounds w)))
               (let ((lod-to-use 0))

test/decompiler/reference/jak1/engine/draw/process-drawable_REF.gc

@@ -47,10 +47,10 @@
     (.lvf vf2 (&-> (-> arg1 bone) transform vector 3 quad))
     (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
     (.wait.vf)
-    (.mul.vf vf2 vf2 Q :mask #b111)
+    (.mul.vf.xyz vf2 vf2 Q)
     (.nop.vf)
     (.nop.vf)
-    (.mov.vf vf2 vf0 :mask #b1000)
+    (.mov.vf.w vf2 vf0)
     (.svf (&-> arg0 quad) vf2)
     arg0
     )
@@ -167,7 +167,7 @@
           (set! gp-0 (the-as cspace-array #f))
           (goto cfg-16)
           )
-        (let ((v1-10 ((method-of-type cspace reset-and-assign-geo!) (the-as cspace (-> gp-0 data)) #f)))
+        (let ((v1-10 ((method-of-type cspace reset-and-assign-geo!) (-> gp-0 data 0) #f)))
           (set! (-> v1-10 bone) (the-as bone (-> s4-1 bones)))
           (let ((a0-6 (-> gp-0 data)))
             (set! (-> a0-6 0 param0) cspace<-transformq!)
@@ -288,7 +288,7 @@
      )
     ((zero? (-> this skel))
      (matrix<-transformq+trans!
-       (the-as matrix (-> this draw skeleton bones 3))
+       (-> this draw skeleton bones 3 transform)
        (the-as transformq (-> this root trans))
        (-> this draw skeleton bones 0 transform vector 3)
        )
@@ -299,7 +299,7 @@
         (let ((s4-0 (+ s5-0 2)))
           (+ s4-0 1)
           ((-> this skel generate-frame-function)
-           (the-as (inline-array vector) (-> (the-as terrain-context #x70000000) work foreground joint-work mtx-acc))
+           (-> (the-as terrain-context #x70000000) work foreground joint-work mtx-acc 0 vector)
            s4-0
            this
            )

test/decompiler/reference/jak1/engine/entity/ambient_REF.gc

@@ -1035,7 +1035,7 @@
              (let ((v1-28 ((method-of-type res-lump lookup-tag-idx) this 'effect-param 'exact 0.0)))
                (set! (-> this ambient-data user-float 1) (the-as float (if (< (the-as int v1-28) 0)
                                                                            (the-as (pointer res-tag) #f)
-                                                                           (&-> (-> this tag) (-> v1-28 lo))
+                                                                           (&-> this tag (-> v1-28 lo))
                                                                            )
                                                                  )
                      )

test/decompiler/reference/jak1/engine/entity/entity_REF.gc

@@ -1166,7 +1166,7 @@
                 (add-debug-box
                   #t
                   (bucket-id debug)
-                  (the-as vector (-> s3-4 data s2-4))
+                  (-> s3-4 data s2-4 min)
                   (the-as vector (+ (the-as uint (-> s3-4 data 0 max)) (* s2-4 32)))
                   (if (zero? (-> s4-4 index))
                       (new 'static 'rgba :g #x80 :b #x80 :a #x80)

test/decompiler/reference/jak1/engine/entity/res_REF.gc

@@ -57,8 +57,8 @@
     (set! (-> this allocated-length) data-count)
     (set! (-> this data-size) data-size)
     (set! (-> this length) 0)
-    (set! (-> this data-base) (&-> (-> this tag) data-count))
-    (set! (-> this data-top) (&-> (-> this tag) data-count))
+    (set! (-> this data-base) (&-> this tag data-count))
+    (set! (-> this data-top) (&-> this tag data-count))
     this
     )
   )
@@ -75,7 +75,6 @@
   )
 
 ;; definition for method 3 of type res-lump
-;; INFO: this function exists in multiple non-identical object files
 ;; INFO: Used lq/sq
 (defmethod inspect ((this res-lump))
   (format #t "[~8x] ~A~%" this (-> this type))
@@ -179,7 +178,7 @@
         (goto cfg-73)
         )
       (let ((interp-tag-idx tag-idx)
-            (tag-ptr (&-> (-> this tag) tag-idx))
+            (tag-ptr (&-> this tag tag-idx))
             )
         (while (not (or (>= interp-tag-idx (-> this length))
                         (< type-chars (-> (the-as (pointer uint64) (-> (symbol->string (-> tag-ptr 0 name)) data)) 0))

test/decompiler/reference/jak1/engine/game/effect-control_REF.gc

@@ -149,13 +149,13 @@
               (set! (-> this res) (-> s5-0 extra))
               (let ((v1-6 (-> (lookup-tag-idx (-> s5-0 extra) 'effect-name 'base -1000000000.0) lo)))
                 (set! (-> this name) (if (>= (the-as int v1-6) 0)
-                                         (&-> (-> s5-0 extra tag) v1-6)
+                                         (&-> s5-0 extra tag v1-6)
                                          (the-as (pointer res-tag) #f)
                                          )
                       )
                 )
               (if (and (-> this name) (= (-> this name 0 key-frame) -1000000000.0))
-                  (set! (-> this name) (&-> (-> this name) 1))
+                  (set! (-> this name) (&-> this name 1))
                   )
               (effect-control-method-14 this f30-0 f30-0 f30-0)
               )

test/decompiler/reference/jak1/engine/game/game-save_REF.gc

@@ -424,7 +424,7 @@
       (set! (-> s2-0 elt-count) (+ (length arg1) 1))
       (set! (-> s2-0 elt-size) (the-as uint 1))
       )
-    (copy-charp<-charp (the-as (pointer uint8) (-> (the-as (inline-array game-save-tag) s3-2) 1)) (-> arg1 data))
+    (copy-charp<-charp (-> (the-as (inline-array game-save-tag) s3-2) 1 user-uint8) (-> arg1 data))
     (let ((v1-37 (&+
                    (the-as pointer s3-2)
                    (+ (logand -16 (+ (-> (the-as (inline-array game-save-tag) s3-2) 0 elt-count) 15)) 16)
@@ -461,10 +461,7 @@
                   (set! (-> s2-1 elt-count) (+ ((method-of-type string length) s3-3) 1))
                   (set! (-> s2-1 elt-size) (the-as uint 1))
                   )
-                (copy-charp<-charp
-                  (the-as (pointer uint8) (the-as game-save-tag (&+ (the-as game-save-tag s4-1) 16)))
-                  (-> s3-3 data)
-                  )
+                (copy-charp<-charp (-> (the-as game-save-tag (&+ (the-as game-save-tag s4-1) 16)) user-uint8) (-> s3-3 data))
                 )
               (let ((v1-50 (&+ (the-as pointer s4-1) (+ (logand -16 (+ (-> (the-as game-save-tag s4-1) elt-count) 15)) 16))))
                 (let ((a0-24 (the-as game-save-tag (&+ v1-50 0))))
@@ -1593,7 +1590,7 @@ auto-save-post
       0
       (label cfg-7)
       (set! (-> self result)
-            (mc-save (-> self card) (-> self which) (&-> (-> self save) type) (the-as int (-> self save info-int32)))
+            (mc-save (-> self card) (-> self which) (&-> self save type) (the-as int (-> self save info-int32)))
             )
       (when (!= (-> self result) (mc-status-code ok))
         (suspend)

test/decompiler/reference/jak1/engine/game/projectiles_REF.gc

@@ -74,11 +74,11 @@
                      )
                 (when (the-as collide-shape-moving s4-1)
                   (let* ((s3-1 (-> s4-1 root-prim prim-core))
-                         (f30-0 (- (vector-vector-distance (-> gp-0 point) (the-as vector s3-1)) (-> s3-1 world-sphere w)))
+                         (f30-0 (- (vector-vector-distance (-> gp-0 point) (-> s3-1 world-sphere)) (-> s3-1 world-sphere w)))
                          )
                     (when (nonzero? (-> s4-1 root-prim prim-core collide-as))
                       (let ((s4-2 0)
-                            (v1-8 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (the-as vector s3-1) (-> gp-0 point)) 1.0))
+                            (v1-8 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> s3-1 world-sphere) (-> gp-0 point)) 1.0))
                             )
                         (if (logtest? (process-mask enemy) (-> s5-0 mask))
                             (set! s4-2 (logior s4-2 1))
@@ -133,7 +133,7 @@
      (send-event (-> arg0 process) 'die)
      )
     )
-  (vector-! sv-64 (the-as vector (-> arg1 best-from-prim prim-core)) (-> arg1 best-tri intersect))
+  (vector-! sv-64 (-> arg1 best-from-prim prim-core world-sphere) (-> arg1 best-tri intersect))
   (set! (-> sv-64 w) 1.0)
   (vector-normalize! sv-64 1.0)
   (set! (-> arg0 coverage) (vector-dot sv-64 (-> arg1 best-tri normal)))
@@ -625,7 +625,7 @@
 ;; definition for method 24 of type projectile
 ;; INFO: Return type mismatch int vs none.
 (defmethod projectile-method-24 ((this projectile))
-  (spawn (-> this part) (the-as vector (-> this root root-prim prim-core)))
+  (spawn (-> this part) (-> this root root-prim prim-core world-sphere))
   0
   (none)
   )
@@ -1038,11 +1038,11 @@
            (set! (-> *part-id-table* 353 init-specs 16 random-rangef) (the-as float 0))
            0
            )
-         (spawn (-> this part) (the-as vector (-> this root root-prim prim-core)))
+         (spawn (-> this part) (-> this root root-prim prim-core world-sphere))
          )
        )
       (else
-        (spawn (-> this part) (the-as vector (-> this root root-prim prim-core)))
+        (spawn (-> this part) (-> this root root-prim prim-core world-sphere))
         )
       )
     (let ((s5-0 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
@@ -1281,7 +1281,7 @@
 ;; INFO: Return type mismatch int vs none.
 (defmethod projectile-method-24 ((this projectile-blue))
   (if (rand-vu-percent? 0.75)
-      (eco-blue-glow (the-as vector (-> this root root-prim prim-core)))
+      (eco-blue-glow (-> this root root-prim prim-core world-sphere))
       )
   0
   (none)

test/decompiler/reference/jak1/engine/geometry/bounding-box_REF.gc

@@ -39,8 +39,8 @@
     (.add.vf vf5 vf4 vf3)
     (.min.vf vf1 vf4 vf5)
     (.max.vf vf2 vf4 vf5)
-    (.mov.vf vf1 vf0 :mask #b1000)
-    (.mov.vf vf2 vf0 :mask #b1000)
+    (.mov.vf.w vf1 vf0)
+    (.mov.vf.w vf2 vf0)
     (.svf (&-> this min quad) vf1)
     (.svf (&-> this max quad) vf2)
     0
@@ -102,10 +102,10 @@
     (.add.vf vf6 vf5 vf4)
     (.min.vf vf2 vf5 vf6)
     (.max.vf vf3 vf5 vf6)
-    (.add.x.vf vf3 vf3 vf1 :mask #b111)
-    (.sub.x.vf vf2 vf2 vf1 :mask #b111)
-    (.mov.vf vf2 vf0 :mask #b1000)
-    (.mov.vf vf3 vf0 :mask #b1000)
+    (.add.x.vf.xyz vf3 vf3 vf1)
+    (.sub.x.vf.xyz vf2 vf2 vf1)
+    (.mov.vf.w vf2 vf0)
+    (.mov.vf.w vf3 vf0)
     (.svf (&-> this min quad) vf2)
     (.svf (&-> this max quad) vf3)
     0
@@ -121,10 +121,10 @@
          )
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 quad))
-    (.sub.w.vf vf2 vf1 vf1 :mask #b111)
-    (.add.w.vf vf3 vf1 vf1 :mask #b111)
-    (.mov.vf vf2 vf0 :mask #b1000)
-    (.mov.vf vf3 vf0 :mask #b1000)
+    (.sub.w.vf.xyz vf2 vf1 vf1)
+    (.add.w.vf.xyz vf3 vf1 vf1)
+    (.mov.vf.w vf2 vf0)
+    (.mov.vf.w vf3 vf0)
     (.svf (&-> this min quad) vf2)
     (.svf (&-> this max quad) vf3)
     0

test/decompiler/reference/jak1/engine/geometry/cylinder_REF.gc

@@ -97,8 +97,8 @@
         (let ((v1-5 (-> s3-0 vector 3)))
           (.lvf vf4 (&-> (-> this origin) quad))
           (.lvf vf5 (&-> sv-896 vector 0 quad))
-          (.mov.vf vf6 vf0 :mask #b1000)
-          (.sub.vf vf6 vf4 vf5 :mask #b111)
+          (.mov.vf.w vf6 vf0)
+          (.sub.vf.xyz vf6 vf4 vf5)
           (.svf (&-> v1-5 quad) vf6)
           )
         (set! sv-912 0)
@@ -264,8 +264,8 @@
         (let ((v1-5 (-> s3-0 vector 3)))
           (.lvf vf4 (&-> (-> this origin) quad))
           (.lvf vf5 (&-> sv-448 quad))
-          (.mov.vf vf6 vf0 :mask #b1000)
-          (.sub.vf vf6 vf4 vf5 :mask #b111)
+          (.mov.vf.w vf6 vf0)
+          (.sub.vf.xyz vf6 vf4 vf5)
           (.svf (&-> v1-5 quad) vf6)
           )
         (set! sv-464 0)

test/decompiler/reference/jak1/engine/geometry/geometry_REF.gc

@@ -12,7 +12,7 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> src quad))
     (.lvf vf2 (&-> plane-normal quad))
-    (.mov.vf vf3 vf0 :mask #b1000)
+    (.mov.vf.w vf3 vf0)
     (.outer.product.a.vf acc vf1 vf2)
     (.outer.product.b.vf vf3 vf2 vf1 acc)
     (.outer.product.a.vf acc vf2 vf3)
@@ -33,13 +33,13 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> src quad))
     (.lvf vf2 (&-> plane-normal quad))
-    (.mov.vf vf3 vf0 :mask #b1000)
+    (.mov.vf.w vf3 vf0)
     (.outer.product.a.vf acc vf1 vf2)
     (.outer.product.b.vf vf3 vf2 vf1 acc)
     (.outer.product.a.vf acc vf2 vf3)
     (.outer.product.b.vf vf3 vf3 vf2 acc)
-    (.add.vf acc vf3 vf3 :mask #b111)
-    (.sub.mul.w.vf vf3 vf1 vf0 acc :mask #b111)
+    (.add.vf.xyz acc vf3 vf3)
+    (.sub.mul.w.vf.xyz vf3 vf1 vf0 acc)
     (.svf (&-> dst quad) vf3)
     dst
     )
@@ -56,12 +56,12 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> src quad))
     (.lvf vf2 (&-> plane-normal quad))
-    (.mov.vf vf3 vf0 :mask #b1000)
+    (.mov.vf.w vf3 vf0)
     (.outer.product.a.vf acc vf1 vf2)
     (.outer.product.b.vf vf3 vf2 vf1 acc)
     (.outer.product.a.vf acc vf2 vf3)
     (.outer.product.b.vf vf3 vf3 vf2 acc)
-    (.add.vf vf3 vf3 vf2 :mask #b111)
+    (.add.vf.xyz vf3 vf3 vf2)
     (.svf (&-> dst quad) vf3)
     dst
     )
@@ -78,7 +78,7 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> src quad))
     (.lvf vf2 (&-> plane-normal quad))
-    (.mov.vf vf3 vf0 :mask #b1000)
+    (.mov.vf.w vf3 vf0)
     (.outer.product.a.vf acc vf1 vf2)
     (.outer.product.b.vf vf3 vf2 vf1 acc)
     (.outer.product.a.vf acc vf2 vf3)
@@ -99,7 +99,7 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> src quad))
     (.lvf vf2 (&-> plane-normal quad))
-    (.mov.vf vf3 vf0 :mask #b1000)
+    (.mov.vf.w vf3 vf0)
     (.outer.product.a.vf acc vf1 vf2)
     (.outer.product.b.vf vf3 vf2 vf1 acc)
     (.outer.product.a.vf acc vf2 vf3)
@@ -137,12 +137,12 @@
     (.sub.vf vf1 vf4 vf3)
     (.sub.vf vf6 vf5 vf3)
     (.mul.vf vf2 vf1 vf1)
-    (.mul.x.vf acc vf0 vf2 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000)
-    (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000)
+    (.mul.x.vf.w acc vf0 vf2)
+    (.add.mul.y.vf.w acc vf0 vf2 acc)
+    (.add.mul.z.vf.w vf2 vf0 vf2 acc)
     (.sqrt.vf Q vf2 :ftf #b11)
     (.wait.vf)
-    (.add.vf vf2 vf0 Q :mask #b1)
+    (.add.vf.x vf2 vf0 Q)
     (.nop.vf)
     (.nop.vf)
     (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b0)
@@ -152,8 +152,8 @@
       (.mul.vf vf1 vf1 Q)
       (.mul.vf vf7 vf1 vf6)
       (let ((f1-0 0.0))
-        (.add.y.vf vf7 vf7 vf7 :mask #b1)
-        (.add.z.vf vf7 vf7 vf7 :mask #b1)
+        (.add.y.vf.x vf7 vf7 vf7)
+        (.add.z.vf.x vf7 vf7 vf7)
         (.mov v1-1 vf7)
         (let ((f0-0 v1-1))
           (b! (< f0-0 f1-0) cfg-4 :likely-delay (set! f0-0 f1-0))
@@ -166,18 +166,18 @@
         )
       )
     (.mul.x.vf vf1 vf1 vf7)
-    (b! (= arg3 #f) cfg-6 :delay (.mov.vf vf8 vf0 :mask #b1000))
-    (.add.vf vf8 vf3 vf1 :mask #b111)
+    (b! (= arg3 #f) cfg-6 :delay (.mov.vf.w vf8 vf0))
+    (.add.vf.xyz vf8 vf3 vf1)
     (.svf (&-> arg3 quad) vf8)
     (label cfg-6)
     (.sub.vf vf2 vf6 vf1)
     (.mul.vf vf2 vf2 vf2)
-    (.mul.x.vf acc vf0 vf2 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000)
-    (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000)
+    (.mul.x.vf.w acc vf0 vf2)
+    (.add.mul.y.vf.w acc vf0 vf2 acc)
+    (.add.mul.z.vf.w vf2 vf0 vf2 acc)
     (.sqrt.vf Q vf2 :ftf #b11)
     (.wait.vf)
-    (.add.vf vf2 vf0 Q :mask #b1)
+    (.add.vf.x vf2 vf0 Q)
     (.nop.vf)
     (.mov v0-0 vf2)
     v0-0
@@ -226,27 +226,27 @@
     (.lvf vf1 (&-> arg2 vec quad))
     (.lvf vf6 (&-> arg1 quad))
     (.add.vf vf5 vf1 vf1)
-    (.add.w.vf vf2 vf0 vf1 :mask #b1)
-    (.add.z.vf vf2 vf0 vf1 :mask #b10)
-    (.sub.y.vf vf2 vf0 vf1 :mask #b100)
-    (.sub.w.vf vf2 vf0 vf0 :mask #b1000)
-    (.sub.z.vf vf3 vf0 vf1 :mask #b1)
-    (.add.w.vf vf3 vf0 vf1 :mask #b10)
-    (.add.x.vf vf3 vf0 vf1 :mask #b100)
-    (.sub.w.vf vf3 vf0 vf0 :mask #b1000)
-    (.add.y.vf vf4 vf0 vf1 :mask #b1)
-    (.sub.x.vf vf4 vf0 vf1 :mask #b10)
-    (.add.w.vf vf4 vf0 vf1 :mask #b100)
-    (.sub.w.vf vf4 vf0 vf0 :mask #b1000)
+    (.add.w.vf.x vf2 vf0 vf1)
+    (.add.z.vf.y vf2 vf0 vf1)
+    (.sub.y.vf.z vf2 vf0 vf1)
+    (.sub.w.vf.w vf2 vf0 vf0)
+    (.sub.z.vf.x vf3 vf0 vf1)
+    (.add.w.vf.y vf3 vf0 vf1)
+    (.add.x.vf.z vf3 vf0 vf1)
+    (.sub.w.vf.w vf3 vf0 vf0)
+    (.add.y.vf.x vf4 vf0 vf1)
+    (.sub.x.vf.y vf4 vf0 vf1)
+    (.add.w.vf.z vf4 vf0 vf1)
+    (.sub.w.vf.w vf4 vf0 vf0)
     (.outer.product.a.vf acc vf5 vf2)
     (.outer.product.b.vf vf2 vf2 vf5 acc)
     (.outer.product.a.vf acc vf5 vf3)
     (.outer.product.b.vf vf3 vf3 vf5 acc)
     (.outer.product.a.vf acc vf5 vf4)
     (.outer.product.b.vf vf4 vf4 vf5 acc)
-    (.add.w.vf vf2 vf2 vf0 :mask #b1)
-    (.add.w.vf vf3 vf3 vf0 :mask #b10)
-    (.add.w.vf vf4 vf4 vf0 :mask #b100)
+    (.add.w.vf.x vf2 vf2 vf0)
+    (.add.w.vf.y vf3 vf3 vf0)
+    (.add.w.vf.z vf4 vf4 vf0)
     (.mul.w.vf acc vf0 vf6)
     (.add.mul.x.vf acc vf2 vf6 acc)
     (.add.mul.y.vf acc vf3 vf6 acc)
@@ -260,9 +260,9 @@
 ;; INFO: Used lq/sq
 (defun forward-down->inv-matrix ((arg0 matrix) (arg1 vector) (arg2 vector))
   (vector-normalize-copy! (-> arg0 vector 2) arg1 1.0)
-  (vector-cross! (the-as vector (-> arg0 vector)) (-> arg0 vector 2) arg2)
-  (vector-normalize! (the-as vector (-> arg0 vector)) 1.0)
-  (vector-cross! (-> arg0 vector 1) arg1 (the-as vector (-> arg0 vector)))
+  (vector-cross! (-> arg0 vector 0) (-> arg0 vector 2) arg2)
+  (vector-normalize! (-> arg0 vector 0) 1.0)
+  (vector-cross! (-> arg0 vector 1) arg1 (-> arg0 vector 0))
   (vector-normalize! (-> arg0 vector 1) 1.0)
   (set! (-> arg0 vector 3 quad) (the-as uint128 0))
   (set! (-> arg0 vector 0 w) 0.0)
@@ -277,9 +277,9 @@
 (defun forward-down-nopitch->inv-matrix ((arg0 matrix) (arg1 vector) (arg2 vector))
   (vector-normalize-copy! (-> arg0 vector 1) arg2 1.0)
   (vector-negate! (-> arg0 vector 1) (-> arg0 vector 1))
-  (vector-cross! (the-as vector (-> arg0 vector)) (-> arg0 vector 1) arg1)
-  (vector-normalize! (the-as vector (-> arg0 vector)) 1.0)
-  (vector-cross! (-> arg0 vector 2) (the-as vector (-> arg0 vector)) (-> arg0 vector 1))
+  (vector-cross! (-> arg0 vector 0) (-> arg0 vector 1) arg1)
+  (vector-normalize! (-> arg0 vector 0) 1.0)
+  (vector-cross! (-> arg0 vector 2) (-> arg0 vector 0) (-> arg0 vector 1))
   (vector-normalize! (-> arg0 vector 2) 1.0)
   (set! (-> arg0 vector 3 quad) (the-as uint128 0))
   (set! (-> arg0 vector 0 w) 0.0)
@@ -599,12 +599,12 @@
     (.outer.product.a.vf acc vf2 vf1)
     (.outer.product.b.vf vf4 vf1 vf2 acc)
     (.mul.vf vf5 vf4 vf4)
-    (.add.y.vf vf5 vf5 vf5 :mask #b1)
-    (.add.z.vf vf5 vf5 vf5 :mask #b1)
+    (.add.y.vf.x vf5 vf5 vf5)
+    (.add.z.vf.x vf5 vf5 vf5)
     (.isqrt.vf Q vf0 vf5 :fsf #b11 :ftf #b0)
-    (.mov.vf vf4 vf0 :mask #b1000)
+    (.mov.vf.w vf4 vf0)
     (.wait.vf)
-    (.mul.vf vf4 vf4 Q :mask #b111)
+    (.mul.vf.xyz vf4 vf4 Q)
     (.nop.vf)
     (.nop.vf)
     (.svf (&-> arg0 quad) vf4)
@@ -625,7 +625,7 @@
     (.lvf vf1 (&-> arg1 quad))
     (.lvf vf2 (&-> arg2 quad))
     (.lvf vf3 (&-> arg3 quad))
-    (.add.x.vf vf4 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf4 vf0 vf0)
     (.sub.vf vf2 vf2 vf1)
     (.sub.vf vf3 vf3 vf1)
     (.outer.product.a.vf acc vf2 vf3)
@@ -684,13 +684,13 @@
     (.outer.product.a.vf acc vf9 vf10)
     (.outer.product.b.vf vf16 vf10 vf9 acc)
     (.mul.vf vf12 vf15 vf1)
-    (.add.x.vf vf11 vf11 vf11 :mask #b10)
+    (.add.x.vf.y vf11 vf11 vf11)
     (.mul.vf vf13 vf16 vf1)
-    (.add.x.vf vf12 vf12 vf12 :mask #b10)
-    (.add.x.vf vf13 vf13 vf13 :mask #b10)
-    (.add.z.vf vf11 vf11 vf11 :mask #b10)
-    (.add.z.vf vf12 vf12 vf12 :mask #b10)
-    (.add.z.vf vf13 vf13 vf13 :mask #b10)
+    (.add.x.vf.y vf12 vf12 vf12)
+    (.add.x.vf.y vf13 vf13 vf13)
+    (.add.z.vf.y vf11 vf11 vf11)
+    (.add.z.vf.y vf12 vf12 vf12)
+    (.add.z.vf.y vf13 vf13 vf13)
     (.mov v1-0 vf11)
     (.mov a1-1 vf12)
     (.mov a0-1 vf13)
@@ -704,17 +704,17 @@
       (b! (nonzero? v1-3) cfg-3 :delay (set! v1-4 (+ v1-3 -1)))
       )
     (.sub.vf vf17 vf5 vf2)
-    (.mov.vf vf18 vf0 :mask #b1000)
+    (.mov.vf.w vf18 vf0)
     (.outer.product.a.vf acc vf17 vf1)
     (.outer.product.b.vf vf18 vf1 vf17 acc)
     (.outer.product.a.vf acc vf1 vf18)
     (.outer.product.b.vf vf18 vf18 vf1 acc)
-    (.add.vf vf18 vf18 vf2 :mask #b111)
+    (.add.vf.xyz vf18 vf18 vf2)
     (b! #t cfg-24 :delay (.svf (&-> arg0 quad) vf18))
     (nop!)
     (label cfg-3)
     (b! (nonzero? v1-4) cfg-6 :delay (set! v1-5 (+ v1-4 -1)))
-    (vector-segment-distance-point! arg1 (the-as vector (-> arg2 vector)) (-> arg2 vector 1) arg0)
+    (vector-segment-distance-point! arg1 (-> arg2 vector 0) (-> arg2 vector 1) arg0)
     (goto cfg-24)
     (label cfg-6)
     (b! (nonzero? v1-5) cfg-9 :delay (set! v1-6 (+ v1-5 -1)))
@@ -722,7 +722,7 @@
     (goto cfg-24)
     (label cfg-9)
     (b! (nonzero? v1-6) cfg-14 :delay (set! v1-7 (+ v1-6 -1)))
-    (let ((f30-0 (vector-segment-distance-point! arg1 (-> arg2 vector 1) (the-as vector (-> arg2 vector)) arg0))
+    (let ((f30-0 (vector-segment-distance-point! arg1 (-> arg2 vector 1) (-> arg2 vector 0) arg0))
           (s3-0 (new 'stack-no-clear 'vector))
           )
       (if (< (vector-segment-distance-point! arg1 (-> arg2 vector 1) (-> arg2 vector 2) s3-0) f30-0)
@@ -732,20 +732,20 @@
     (goto cfg-24)
     (label cfg-14)
     (b! (nonzero? v1-7) cfg-17 :delay (set! v1-10 (+ v1-7 -1)))
-    (vector-segment-distance-point! arg1 (-> arg2 vector 2) (the-as vector (-> arg2 vector)) arg0)
+    (vector-segment-distance-point! arg1 (-> arg2 vector 2) (-> arg2 vector 0) arg0)
     (goto cfg-24)
     (label cfg-17)
     (b! (nonzero? v1-10) cfg-22 :delay (nop!))
-    (let ((f30-1 (vector-segment-distance-point! arg1 (the-as vector (-> arg2 vector)) (-> arg2 vector 1) arg0))
+    (let ((f30-1 (vector-segment-distance-point! arg1 (-> arg2 vector 0) (-> arg2 vector 1) arg0))
           (s3-1 (new 'stack-no-clear 'vector))
           )
-      (if (< (vector-segment-distance-point! arg1 (the-as vector (-> arg2 vector)) (-> arg2 vector 2) s3-1) f30-1)
+      (if (< (vector-segment-distance-point! arg1 (-> arg2 vector 0) (-> arg2 vector 2) s3-1) f30-1)
           (set! (-> arg0 quad) (-> s3-1 quad))
           )
       )
     (goto cfg-24)
     (label cfg-22)
-    (let ((f30-2 (vector-segment-distance-point! arg1 (-> arg2 vector 2) (the-as vector (-> arg2 vector)) arg0))
+    (let ((f30-2 (vector-segment-distance-point! arg1 (-> arg2 vector 2) (-> arg2 vector 0) arg0))
           (s3-2 (new 'stack-no-clear 'vector))
           )
       (if (< (vector-segment-distance-point! arg1 (-> arg2 vector 2) (-> arg2 vector 1) s3-2) f30-2)
@@ -795,13 +795,13 @@
     (.mul.vf vf3 vf3 vf1)
     (.nop.vf)
     (.mul.vf vf4 vf4 vf1)
-    (.add.x.vf vf2 vf2 vf2 :mask #b10)
-    (.add.x.vf vf3 vf3 vf3 :mask #b10)
-    (.add.x.vf vf4 vf4 vf4 :mask #b10)
+    (.add.x.vf.y vf2 vf2 vf2)
+    (.add.x.vf.y vf3 vf3 vf3)
+    (.add.x.vf.y vf4 vf4 vf4)
     (.nop.vf)
-    (.add.z.vf vf2 vf2 vf2 :mask #b10)
-    (.add.z.vf vf3 vf3 vf3 :mask #b10)
-    (.add.z.vf vf4 vf4 vf4 :mask #b10)
+    (.add.z.vf.y vf2 vf2 vf2)
+    (.add.z.vf.y vf3 vf3 vf3)
+    (.add.z.vf.y vf4 vf4 vf4)
     (.nop.vf)
     (.mov a0-1 vf2)
     (.mov a1-1 vf3)
@@ -888,11 +888,11 @@
       (.sub.vf vf5 vf4 vf3)
       (.mul.x.vf vf1 vf1 vf2)
       (.mul.x.vf vf5 vf5 vf2)
-      (.mul.vf vf5 vf5 vf5 :mask #b101)
-      (.add.z.vf vf5 vf5 vf5 :mask #b1)
+      (.mul.vf.xz vf5 vf5 vf5)
+      (.add.z.vf.x vf5 vf5 vf5)
       (.sqrt.vf Q vf5 :ftf #b0)
       (.wait.vf)
-      (.mul.vf vf1 vf0 Q :mask #b1000)
+      (.mul.vf.w vf1 vf0 Q)
       (.nop.vf)
       (.nop.vf)
       (.svf (&-> a1-2 quad) vf1)
@@ -1113,7 +1113,7 @@
       (.lvf vf6 (&-> s4-0 quad))
       )
     (.sll v1-8 v1-7 4)
-    (.add.x.vf vf1 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf1 vf0 vf0)
     (let ((v1-9 (+ v1-8 (the-as int arg2))))
       (nop!)
       (nop!)
@@ -1127,11 +1127,11 @@
       )
     (.mul.x.vf acc vf2 vf6)
     (nop!)
-    (.add.mul.y.vf acc vf3 vf6 acc :mask #b111)
+    (.add.mul.y.vf.xyz acc vf3 vf6 acc)
     (nop!)
-    (.add.mul.z.vf acc vf4 vf6 acc :mask #b111)
+    (.add.mul.z.vf.xyz acc vf4 vf6 acc)
     (nop!)
-    (.add.mul.w.vf vf1 vf5 vf6 acc :mask #b111)
+    (.add.mul.w.vf.xyz vf1 vf5 vf6 acc)
     (nop!)
     (nop!)
     (nop!)

test/decompiler/reference/jak1/engine/gfx/eye_REF.gc

@@ -890,8 +890,8 @@
              (convert-eye-data s0-0 (-> s4-0 eye-anim-data data (* s2-1 2) dword))
              (vector4-lerp!
                (the-as vector (+ (the-as uint (-> *eye-control-array* data 0 left)) (* 96 (-> s5-0 eye-slot))))
-               (the-as vector (-> s1-0 data))
-               (the-as vector (-> s0-0 data))
+               (-> s1-0 data 0)
+               (-> s0-0 data 0)
                f30-0
                )
              (vector4-lerp!
@@ -904,8 +904,8 @@
              (convert-eye-data s0-0 (-> s4-0 eye-anim-data data (+ (* s2-1 2) 1) dword))
              (vector4-lerp!
                (the-as vector (+ (the-as uint (-> *eye-control-array* data 0 right)) (* 96 (-> s5-0 eye-slot))))
-               (the-as vector (-> s1-0 data))
-               (the-as vector (-> s0-0 data))
+               (-> s1-0 data 0)
+               (-> s0-0 data 0)
                f30-0
                )
              (vector4-lerp!

test/decompiler/reference/jak1/engine/gfx/math-camera_REF.gc

@@ -341,10 +341,10 @@
     (.div.vf Q vf0 vf31 :fsf #b11 :ftf #b11)
     (.wait.vf)
     (.cfc2.i v1-7 Clipping)
-    (.mul.vf vf28 vf28 Q :mask #b111)
+    (.mul.vf.xyz vf28 vf28 Q)
     (.mul.vf vf23 vf23 Q)
     (.add.vf vf28 vf28 vf30)
-    (.max.x.vf vf28 vf28 vf0 :mask #b1000)
+    (.max.x.vf.w vf28 vf28 vf0)
     (.svf (&-> arg0 quad) vf28)
     (not (logtest? v1-7 63))
     )
@@ -387,10 +387,10 @@
     (.div.vf Q vf0 vf31 :fsf #b11 :ftf #b11)
     (.wait.vf)
     (.cfc2.i v1-7 Clipping)
-    (.mul.vf vf28 vf28 Q :mask #b111)
+    (.mul.vf.xyz vf28 vf28 Q)
     (.mul.vf vf23 vf23 Q)
     (.add.vf vf28 vf28 vf30)
-    (.max.x.vf vf28 vf28 vf0 :mask #b1000)
+    (.max.x.vf.w vf28 vf28 vf0)
     (vftoi4.xyzw vf28 vf28)
     (.svf (&-> arg0 quad) vf28)
     (not (logtest? v1-7 63))
@@ -434,10 +434,10 @@
     (.div.vf Q vf0 vf31 :fsf #b11 :ftf #b11)
     (.wait.vf)
     (.cfc2.i v1-7 Clipping)
-    (.mul.vf vf28 vf28 Q :mask #b111)
+    (.mul.vf.xyz vf28 vf28 Q)
     (.mul.vf vf23 vf23 Q)
     (.add.vf vf28 vf28 vf30)
-    (.max.x.vf vf28 vf28 vf0 :mask #b1000)
+    (.max.x.vf.w vf28 vf28 vf0)
     (.svf (&-> arg0 quad) vf28)
     (not (logtest? v1-7 63))
     (.mov v0-0 vf23)

test/decompiler/reference/jak1/engine/gfx/merc/merc_REF.gc

@@ -76,6 +76,7 @@
   )
 
 ;; definition for method 3 of type merc-fragment-control
+;; INFO: this function exists in multiple non-identical object files
 (defmethod inspect ((this merc-fragment-control))
   (format #t "[~8x] ~A~%" this 'merc-fragment-control)
   (format #t "~Tunsigned-four-count: ~D~%" (-> this unsigned-four-count))
@@ -123,6 +124,7 @@
   )
 
 ;; definition for method 3 of type merc-ctrl
+;; INFO: this function exists in multiple non-identical object files
 (defmethod inspect ((this merc-ctrl))
   (format #t "[~8x] ~A~%" this (-> this type))
   (format #t "~Tname: ~A~%" (-> this name))
@@ -385,7 +387,7 @@
 ;; definition for function merc-vu1-initialize-chain
 ;; INFO: Used lq/sq
 (defun merc-vu1-initialize-chain ((arg0 dma-gif-packet))
-  (let ((gp-0 (the-as object (merc-vu1-add-vu-function (the-as dma-packet arg0) merc-vu1-block 1))))
+  (let ((gp-0 (the-as object (merc-vu1-add-vu-function (-> arg0 dma-vif) merc-vu1-block 1))))
     (set! (-> (the-as dma-gif-packet gp-0) dma-vif dma) (new 'static 'dma-tag :qwc #xa :id (dma-tag-id cnt)))
     (set! (-> (the-as dma-gif-packet gp-0) dma-vif vif0) (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)))
     (set! (-> (the-as dma-gif-packet gp-0) dma-vif vif1) (new 'static 'vif-tag :cmd (vif-cmd stmod)))

test/decompiler/reference/jak1/engine/gfx/mood/mood-tables_REF.gc

@@ -22,8 +22,8 @@
       )
     (set-vector! (-> arg0 dir1 color) 0.8 0.775 0.7 1.0)
     (set! (-> arg0 dir1 levels x) arg3)
-    (vector-matrix*! (the-as vector (-> arg0 dir0)) (the-as vector (-> arg0 dir0)) s4-0)
-    (vector-matrix*! (the-as vector (-> arg0 dir1)) (the-as vector (-> arg0 dir1)) s4-0)
+    (vector-matrix*! (-> arg0 dir0 direction) (-> arg0 dir0 direction) s4-0)
+    (vector-matrix*! (-> arg0 dir1 direction) (-> arg0 dir1 direction) s4-0)
     )
   (let ((v1-4 (-> arg0 dir2)))
     (set! (-> v1-4 direction x) 0.0)
@@ -302,12 +302,12 @@
       (set! (-> s5-0 x) (* 2.0 (-> s5-0 x)))
       (set! (-> s5-0 y) (* 2.0 (-> s5-0 y)))
       (set! (-> s5-0 z) (* 2.0 (-> s5-0 z)))
-      (vector+float*! (the-as vector s4-0) (-> arg2 amb-color) (-> arg2 lgt-color) (-> arg2 direction y))
-      (vector*! (the-as vector s4-0) (the-as vector s4-0) (-> *ocean-map-village2* far-color))
+      (vector+float*! (-> s4-0 fog-color) (-> arg2 amb-color) (-> arg2 lgt-color) (-> arg2 direction y))
+      (vector*! (-> s4-0 fog-color) (-> s4-0 fog-color) (-> *ocean-map-village2* far-color))
       (set! (-> s4-0 fog-color x) (* 2.0 (-> s4-0 fog-color x)))
       (set! (-> s4-0 fog-color y) (* 2.0 (-> s4-0 fog-color y)))
       (set! (-> s4-0 fog-color z) (* 2.0 (-> s4-0 fog-color z)))
-      (vector4-lerp! s5-0 s5-0 (the-as vector s4-0) 0.5)
+      (vector4-lerp! s5-0 s5-0 (-> s4-0 fog-color) 0.5)
       )
     (let ((f0-15 (* 0.003921569 (- 255.0 (-> arg0 fog-dists w)))))
       (vector4-lerp! s5-0 s5-0 (-> arg0 fog-color) f0-15)
@@ -652,7 +652,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *village1-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *village1-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *village1-mood-lights-table* data 1))
@@ -848,7 +848,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *snow-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *snow-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *snow-mood-lights-table* data 1))
@@ -860,10 +860,7 @@
 (update-mood-shadow-direction (-> *snow-mood-lights-table* data 3))
 
 ;; failed to figure out what this is:
-(update-mood-erase-color
-  (the-as mood-fog (-> *snow-mood-fog-table* data))
-  (the-as mood-lights (-> *snow-mood-lights-table* data))
-  )
+(update-mood-erase-color (-> *snow-mood-fog-table* data 0) (-> *snow-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-erase-color (-> *snow-mood-fog-table* data 2) (-> *snow-mood-lights-table* data 1))
@@ -877,7 +874,7 @@
 ;; failed to figure out what this is:
 (update-mood-erase-color2
   (-> *snow-mood-fog-table* data 1)
-  (the-as mood-lights (-> *snow-mood-lights-table* data))
+  (-> *snow-mood-lights-table* data 0)
   (-> *snow-mood-lights-table* data 1)
   )
 
@@ -899,14 +896,14 @@
 (update-mood-erase-color2
   (-> *snow-mood-fog-table* data 7)
   (-> *snow-mood-lights-table* data 3)
-  (the-as mood-lights (-> *snow-mood-lights-table* data))
+  (-> *snow-mood-lights-table* data 0)
   )
 
 ;; failed to figure out what this is:
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 0 erase-color)
   (-> *snow-mood-fog-table* data 0 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data))
+  (-> *snow-mood-fog-table* data 0 fog-color)
   0.41
   )
 
@@ -914,7 +911,7 @@
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 1 erase-color)
   (-> *snow-mood-fog-table* data 1 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data 1))
+  (-> *snow-mood-fog-table* data 1 fog-color)
   0.41
   )
 
@@ -922,7 +919,7 @@
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 2 erase-color)
   (-> *snow-mood-fog-table* data 2 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data 2))
+  (-> *snow-mood-fog-table* data 2 fog-color)
   0.41
   )
 
@@ -930,7 +927,7 @@
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 3 erase-color)
   (-> *snow-mood-fog-table* data 3 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data 3))
+  (-> *snow-mood-fog-table* data 3 fog-color)
   0.41
   )
 
@@ -938,7 +935,7 @@
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 4 erase-color)
   (-> *snow-mood-fog-table* data 4 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data 4))
+  (-> *snow-mood-fog-table* data 4 fog-color)
   0.41
   )
 
@@ -946,7 +943,7 @@
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 5 erase-color)
   (-> *snow-mood-fog-table* data 5 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data 5))
+  (-> *snow-mood-fog-table* data 5 fog-color)
   0.41
   )
 
@@ -954,7 +951,7 @@
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 6 erase-color)
   (-> *snow-mood-fog-table* data 6 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data 6))
+  (-> *snow-mood-fog-table* data 6 fog-color)
   0.41
   )
 
@@ -962,7 +959,7 @@
 (vector4-lerp!
   (-> *snow-mood-fog-table* data 7 erase-color)
   (-> *snow-mood-fog-table* data 7 erase-color)
-  (the-as vector (-> *snow-mood-fog-table* data 7))
+  (-> *snow-mood-fog-table* data 7 fog-color)
   0.41
   )
 
@@ -1273,7 +1270,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *misty-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *misty-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *misty-mood-lights-table* data 1))
@@ -1404,7 +1401,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *village2-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *village2-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *village2-mood-lights-table* data 1))
@@ -1536,7 +1533,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *swamp-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *swamp-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *swamp-mood-lights-table* data 1))
@@ -1632,7 +1629,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *sunken-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *sunken-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *sunken-mood-lights-table* data 1))
@@ -1745,7 +1742,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *rolling-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *rolling-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *rolling-mood-lights-table* data 1))
@@ -1882,7 +1879,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *firecanyon-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *firecanyon-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *firecanyon-mood-lights-table* data 1))
@@ -2031,7 +2028,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *ogre-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *ogre-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *ogre-mood-lights-table* data 1))
@@ -2100,7 +2097,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *ogre2-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *ogre2-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-shadow-direction (-> *ogre2-mood-lights-table* data 1))
@@ -2158,7 +2155,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *ogre3-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *ogre3-mood-lights-table* data 0))
 
 ;; definition for symbol *village3-mood-fog-table*, type mood-fog-table
 (define *village3-mood-fog-table*
@@ -2322,7 +2319,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-shadow-direction (the-as mood-lights (-> *lavatube-mood-lights-table* data)))
+(update-mood-shadow-direction (-> *lavatube-mood-lights-table* data 0))
 
 ;; definition for symbol *lavatube-mood-sun-table*, type mood-sun-table
 (define *lavatube-mood-sun-table*
@@ -2429,10 +2426,7 @@
   )
 
 ;; failed to figure out what this is:
-(update-mood-erase-color
-  (the-as mood-fog (-> *finalboss-mood-fog-table* data))
-  (the-as mood-lights (-> *village1-mood-lights-table* data))
-  )
+(update-mood-erase-color (-> *finalboss-mood-fog-table* data 0) (-> *village1-mood-lights-table* data 0))
 
 ;; failed to figure out what this is:
 (update-mood-erase-color (-> *finalboss-mood-fog-table* data 1) (-> *village1-mood-lights-table* data 1))
@@ -2464,7 +2458,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 0 erase-color)
   (-> *finalboss-mood-fog-table* data 0 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data))
+  (-> *finalboss-mood-fog-table* data 0 fog-color)
   0.41
   )
 
@@ -2472,7 +2466,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 1 erase-color)
   (-> *finalboss-mood-fog-table* data 1 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data 1))
+  (-> *finalboss-mood-fog-table* data 1 fog-color)
   0.41
   )
 
@@ -2480,7 +2474,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 2 erase-color)
   (-> *finalboss-mood-fog-table* data 2 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data 2))
+  (-> *finalboss-mood-fog-table* data 2 fog-color)
   0.41
   )
 
@@ -2488,7 +2482,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 3 erase-color)
   (-> *finalboss-mood-fog-table* data 3 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data 3))
+  (-> *finalboss-mood-fog-table* data 3 fog-color)
   1.0
   )
 
@@ -2496,7 +2490,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 4 erase-color)
   (-> *finalboss-mood-fog-table* data 4 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data 4))
+  (-> *finalboss-mood-fog-table* data 4 fog-color)
   0.41
   )
 
@@ -2504,7 +2498,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 5 erase-color)
   (-> *finalboss-mood-fog-table* data 5 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data 5))
+  (-> *finalboss-mood-fog-table* data 5 fog-color)
   0.41
   )
 
@@ -2512,7 +2506,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 6 erase-color)
   (-> *finalboss-mood-fog-table* data 6 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data 6))
+  (-> *finalboss-mood-fog-table* data 6 fog-color)
   0.41
   )
 
@@ -2520,7 +2514,7 @@
 (vector4-lerp!
   (-> *finalboss-mood-fog-table* data 7 erase-color)
   (-> *finalboss-mood-fog-table* data 7 erase-color)
-  (the-as vector (-> *finalboss-mood-fog-table* data 7))
+  (-> *finalboss-mood-fog-table* data 7 fog-color)
   0.41
   )
 

test/decompiler/reference/jak1/engine/gfx/mood/mood_REF.gc

@@ -69,21 +69,21 @@
     (.lvf vf1 (&-> arg0 times 0 quad))
     (nop!)
     (.lvf vf2 (&-> arg0 times 1 quad))
-    (.mul.w.vf vf1 vf1 vf1 :mask #b111)
+    (.mul.w.vf.xyz vf1 vf1 vf1)
     (.lvf vf3 (&-> arg0 times 2 quad))
-    (.mul.w.vf vf2 vf2 vf2 :mask #b111)
+    (.mul.w.vf.xyz vf2 vf2 vf2)
     (.lvf vf4 (&-> arg0 times 3 quad))
-    (.mul.w.vf vf3 vf3 vf3 :mask #b111)
+    (.mul.w.vf.xyz vf3 vf3 vf3)
     (.lvf vf5 (&-> arg0 times 4 quad))
-    (.mul.w.vf vf4 vf4 vf4 :mask #b111)
+    (.mul.w.vf.xyz vf4 vf4 vf4)
     (.lvf vf6 (&-> arg0 times 5 quad))
-    (.mul.w.vf vf5 vf5 vf5 :mask #b111)
+    (.mul.w.vf.xyz vf5 vf5 vf5)
     (.lvf vf7 (&-> arg0 times 6 quad))
-    (.mul.w.vf vf6 vf6 vf6 :mask #b111)
+    (.mul.w.vf.xyz vf6 vf6 vf6)
     (.lvf vf8 (&-> arg0 times 7 quad))
-    (.mul.w.vf vf7 vf7 vf7 :mask #b111)
+    (.mul.w.vf.xyz vf7 vf7 vf7)
     (nop!)
-    (.mul.w.vf vf8 vf8 vf8 :mask #b111)
+    (.mul.w.vf.xyz vf8 vf8 vf8)
     (nop!)
     (vftoi12.xyzw vf1 vf1)
     (nop!)
@@ -270,9 +270,9 @@
         (set! (-> arg0 sky-times s5-0) (- 1.0 f30-0))
         (set! (-> arg0 sky-times s4-0) f30-0)
         (vector4-lerp!
-          (the-as vector (-> arg0 current-sun))
-          (the-as vector (-> arg0 mood-sun-table data s5-0))
-          (the-as vector (-> arg0 mood-sun-table data s4-0))
+          (-> arg0 current-sun sun-color)
+          (-> arg0 mood-sun-table data s5-0 sun-color)
+          (-> arg0 mood-sun-table data s4-0 sun-color)
           f30-0
           )
         (vector4-lerp!
@@ -384,9 +384,9 @@
      )
     (else
       (vector4-lerp!
-        (the-as vector (-> arg0 current-fog))
-        (the-as vector (-> arg1 current-fog))
-        (the-as vector (-> arg2 current-fog))
+        (-> arg0 current-fog fog-color)
+        (-> arg1 current-fog fog-color)
+        (-> arg2 current-fog fog-color)
         arg3
         )
       (vector4-lerp!
@@ -403,9 +403,9 @@
         )
       (vector4-lerp! (-> arg0 current-prt-color) (-> arg1 current-prt-color) (-> arg2 current-prt-color) arg3)
       (vector4-lerp!
-        (the-as vector (-> arg0 current-sun))
-        (the-as vector (-> arg1 current-sun))
-        (the-as vector (-> arg2 current-sun))
+        (-> arg0 current-sun sun-color)
+        (-> arg1 current-sun sun-color)
+        (-> arg2 current-sun sun-color)
         arg3
         )
       (vector4-lerp!
@@ -1163,7 +1163,7 @@
   (let ((f30-0 (fmax 0.0 (-> *math-camera* camera-rot vector 1 z))))
     (let ((a2-4 (new 'stack-no-clear 'vector)))
       (set-vector! a2-4 0.0 32.0 48.0 128.0)
-      (vector4-lerp! (the-as vector (-> arg0 current-fog)) (the-as vector (-> arg0 current-fog)) a2-4 (/ f30-0 2))
+      (vector4-lerp! (-> arg0 current-fog fog-color) (-> arg0 current-fog fog-color) a2-4 (/ f30-0 2))
       )
     (let ((f0-7 (-> arg0 current-fog fog-dists w))
           (f1-1 255.0)
@@ -1974,7 +1974,7 @@
             (while (>= s1-0 s2-0)
               (let ((f28-0 (-> *palette-fade-controls* control s2-0 fade)))
                 (set! (-> arg0 times s2-0 w) f28-0)
-                (vector-! s3-0 (the-as vector (-> *palette-fade-controls* control s2-0)) (-> *target* control trans))
+                (vector-! s3-0 (-> *palette-fade-controls* control s2-0 trans) (-> *target* control trans))
                 (let* ((f3-0 (vector-length s3-0))
                        (f28-1 (* f28-0 (fmax 0.0 (fmin 1.0 (- 1.0 (/ f3-0 (meters 20)))))))
                        )
@@ -2327,27 +2327,27 @@
           f30-3
           )
         (vector-lerp!
-          (the-as vector (-> arg0 mood-lights-table data))
+          (-> arg0 mood-lights-table data 0 direction)
           s5-1
-          (the-as vector (-> arg0 mood-lights-table data))
+          (-> arg0 mood-lights-table data 0 direction)
           f30-3
           )
         (vector-lerp!
-          (the-as vector (-> arg0 mood-lights-table data 1))
+          (-> arg0 mood-lights-table data 1 direction)
           s5-1
-          (the-as vector (-> arg0 mood-lights-table data 1))
+          (-> arg0 mood-lights-table data 1 direction)
           f30-3
           )
         (vector-lerp!
-          (the-as vector (-> arg0 mood-lights-table data 2))
+          (-> arg0 mood-lights-table data 2 direction)
           s5-1
-          (the-as vector (-> arg0 mood-lights-table data 2))
+          (-> arg0 mood-lights-table data 2 direction)
           f30-3
           )
         (vector-lerp!
-          (the-as vector (-> arg0 mood-lights-table data 3))
+          (-> arg0 mood-lights-table data 3 direction)
           s5-1
-          (the-as vector (-> arg0 mood-lights-table data 3))
+          (-> arg0 mood-lights-table data 3 direction)
           f30-3
           )
         )
@@ -2487,20 +2487,10 @@
                    (vector4-lerp! (the-as vector (-> s5-2 0)) (the-as vector (-> s4-2 0)) (the-as vector (-> s5-2 0)) f30-1)
                    (vector4-lerp! (-> s5-2 0 dir0 color) (-> s4-2 0 dir0 color) (-> s5-2 0 dir0 color) f30-1)
                    (vector4-lerp! (-> s5-2 0 dir0 levels) (-> s4-2 0 dir0 levels) (-> s5-2 0 dir0 levels) f30-1)
-                   (vector4-lerp!
-                     (the-as vector (-> s5-2 0 dir1))
-                     (the-as vector (-> s4-2 0 dir1))
-                     (the-as vector (-> s5-2 0 dir1))
-                     f30-1
-                     )
+                   (vector4-lerp! (-> s5-2 0 dir1 direction) (-> s4-2 0 dir1 direction) (-> s5-2 0 dir1 direction) f30-1)
                    (vector4-lerp! (-> s5-2 0 dir1 color) (-> s4-2 0 dir1 color) (-> s5-2 0 dir1 color) f30-1)
                    (vector4-lerp! (-> s5-2 0 dir1 levels) (-> s4-2 0 dir1 levels) (-> s5-2 0 dir1 levels) f30-1)
-                   (vector4-lerp!
-                     (the-as vector (-> s5-2 0 ambi))
-                     (the-as vector (-> s4-2 0 ambi))
-                     (the-as vector (-> s5-2 0 ambi))
-                     f30-1
-                     )
+                   (vector4-lerp! (-> s5-2 0 ambi direction) (-> s4-2 0 ambi direction) (-> s5-2 0 ambi direction) f30-1)
                    (vector4-lerp! (-> s5-2 0 ambi color) (-> s4-2 0 ambi color) (-> s5-2 0 ambi color) f30-1)
                    (vector4-lerp! (-> s5-2 0 ambi levels) (-> s4-2 0 ambi levels) (-> s5-2 0 ambi levels) f30-1)
                    (vector4-lerp! (-> arg0 current-shadow) (-> *ogre2-mood* current-shadow) (-> arg0 current-shadow) f30-1)
@@ -2542,35 +2532,20 @@
                       (vector4-lerp! (the-as vector (-> s5-3 0)) (the-as vector (-> s4-3 0)) (the-as vector (-> s5-3 0)) f30-3)
                       (vector4-lerp! (-> s5-3 0 dir0 color) (-> s4-3 0 dir0 color) (-> s5-3 0 dir0 color) f30-3)
                       (vector4-lerp! (-> s5-3 0 dir0 levels) (-> s4-3 0 dir0 levels) (-> s5-3 0 dir0 levels) f30-3)
-                      (vector4-lerp!
-                        (the-as vector (-> s5-3 0 dir1))
-                        (the-as vector (-> s4-3 0 dir1))
-                        (the-as vector (-> s5-3 0 dir1))
-                        f30-3
-                        )
+                      (vector4-lerp! (-> s5-3 0 dir1 direction) (-> s4-3 0 dir1 direction) (-> s5-3 0 dir1 direction) f30-3)
                       (vector4-lerp! (-> s5-3 0 dir1 color) (-> s4-3 0 dir1 color) (-> s5-3 0 dir1 color) f30-3)
                       (vector4-lerp! (-> s5-3 0 dir1 levels) (-> s4-3 0 dir1 levels) (-> s5-3 0 dir1 levels) f30-3)
-                      (vector4-lerp!
-                        (the-as vector (-> s5-3 0 dir2))
-                        (the-as vector (-> s4-3 0 dir2))
-                        (the-as vector (-> s5-3 0 dir1))
-                        f30-3
-                        )
+                      (vector4-lerp! (-> s5-3 0 dir2 direction) (-> s4-3 0 dir2 direction) (-> s5-3 0 dir1 direction) f30-3)
                       (vector4-lerp! (-> s5-3 0 dir2 color) (-> s4-3 0 dir2 color) (-> s5-3 0 dir1 color) f30-3)
                       (vector4-lerp! (-> s5-3 0 dir2 levels) (-> s4-3 0 dir2 levels) (-> s5-3 0 dir1 levels) f30-3)
-                      (vector4-lerp!
-                        (the-as vector (-> s5-3 0 ambi))
-                        (the-as vector (-> s4-3 0 ambi))
-                        (the-as vector (-> s5-3 0 ambi))
-                        f30-3
-                        )
+                      (vector4-lerp! (-> s5-3 0 ambi direction) (-> s4-3 0 ambi direction) (-> s5-3 0 ambi direction) f30-3)
                       (vector4-lerp! (-> s5-3 0 ambi color) (-> s4-3 0 ambi color) (-> s5-3 0 ambi color) f30-3)
                       (vector4-lerp! (-> s5-3 0 ambi levels) (-> s4-3 0 ambi levels) (-> s5-3 0 ambi levels) f30-3)
                       (vector4-lerp! (-> arg0 current-shadow) (-> *ogre3-mood* current-shadow) (-> arg0 current-shadow) f30-3)
                       (vector4-lerp!
-                        (the-as vector (-> arg0 current-fog))
-                        (the-as vector (-> *ogre3-mood* current-fog))
-                        (the-as vector (-> arg0 current-fog))
+                        (-> arg0 current-fog fog-color)
+                        (-> *ogre3-mood* current-fog fog-color)
+                        (-> arg0 current-fog fog-color)
                         f30-3
                         )
                       (vector4-lerp!

test/decompiler/reference/jak1/engine/gfx/mood/time-of-day_REF.gc

@@ -406,9 +406,9 @@
               f30-0
               )
             (vector4-lerp!
-              (the-as vector (-> arg0 current-sun))
-              (the-as vector (-> arg0 moods 0 current-sun))
-              (the-as vector (-> arg0 moods 1 current-sun))
+              (-> arg0 current-sun sun-color)
+              (-> arg0 moods 0 current-sun sun-color)
+              (-> arg0 moods 1 current-sun sun-color)
               f30-0
               )
             (vector4-lerp!

test/decompiler/reference/jak1/engine/gfx/mood/weather-part_REF.gc

@@ -534,7 +534,7 @@
   (let ((s5-0 (the int (-> arg1 user-float))))
     (let* ((a1-1 (math-camera-pos))
            (a2-1 (-> *sky-parms* upload-data sun (/ s5-0 4)))
-           (v1-3 (vector+float*! (new 'stack-no-clear 'vector) a1-1 (the-as vector a2-1) 4096.0))
+           (v1-3 (vector+float*! (new 'stack-no-clear 'vector) a1-1 (-> a2-1 pos) 4096.0))
            )
       (set! (-> arg2 vector 0 x) (-> v1-3 x))
       (set! (-> arg2 vector 0 y) (-> v1-3 y))

test/decompiler/reference/jak1/engine/gfx/ocean/ocean-mid_REF.gc

@@ -424,8 +424,8 @@
         )
       (.sub.vf vf1 vf3 vf2)
       (.mul.vf vf1 vf1 vf1)
-      (.add.y.vf vf1 vf1 vf1 :mask #b1)
-      (.add.z.vf vf1 vf1 vf1 :mask #b1)
+      (.add.y.vf.x vf1 vf1 vf1)
+      (.add.z.vf.x vf1 vf1 vf1)
       (.mov a3-2 vf1)
       (when (< a3-2 309237600000.0)
         (logior! (-> (the-as (pointer uint8) (+ arg2 (the-as int arg0)))) (ash 1 arg1))
@@ -440,8 +440,8 @@
         )
       (.sub.vf vf1 vf3 vf2)
       (.mul.vf vf1 vf1 vf1)
-      (.add.y.vf vf1 vf1 vf1 :mask #b1)
-      (.add.z.vf vf1 vf1 vf1 :mask #b1)
+      (.add.y.vf.x vf1 vf1 vf1)
+      (.add.z.vf.x vf1 vf1 vf1)
       (.mov a3-6 vf1)
       (when (< a3-6 309237600000.0)
         (logior! (-> (the-as (pointer uint8) (+ arg2 (the-as int arg0)))) (ash 1 arg1))
@@ -456,8 +456,8 @@
         )
       (.sub.vf vf1 vf3 vf2)
       (.mul.vf vf1 vf1 vf1)
-      (.add.y.vf vf1 vf1 vf1 :mask #b1)
-      (.add.z.vf vf1 vf1 vf1 :mask #b1)
+      (.add.y.vf.x vf1 vf1 vf1)
+      (.add.z.vf.x vf1 vf1 vf1)
       (.mov a3-10 vf1)
       (when (< a3-10 309237600000.0)
         (logior! (-> (the-as (pointer uint8) (+ arg2 (the-as int arg0)))) (ash 1 arg1))
@@ -469,8 +469,8 @@
       )
     (.sub.vf vf1 vf3 vf2)
     (.mul.vf vf1 vf1 vf1)
-    (.add.y.vf vf1 vf1 vf1 :mask #b1)
-    (.add.z.vf vf1 vf1 vf1 :mask #b1)
+    (.add.y.vf.x vf1 vf1 vf1)
+    (.add.z.vf.x vf1 vf1 vf1)
     (.mov v1-10 vf1)
     (when (< v1-10 309237600000.0)
       (logior! (-> (the-as (pointer uint8) (+ arg2 (the-as int arg0)))) (ash 1 arg1))

test/decompiler/reference/jak1/engine/gfx/ocean/ocean-transition_REF.gc

@@ -433,8 +433,8 @@
         )
       (.sub.vf vf1 vf3 vf2)
       (.mul.vf vf1 vf1 vf1)
-      (.add.y.vf vf1 vf1 vf1 :mask #b1)
-      (.add.z.vf vf1 vf1 vf1 :mask #b1)
+      (.add.y.vf.x vf1 vf1 vf1)
+      (.add.z.vf.x vf1 vf1 vf1)
       (.mov a3-2 vf1)
       (when (< a3-2 19327350000.0)
         (logior! (-> arg0 mask arg2) (ash 1 arg1))
@@ -449,8 +449,8 @@
         )
       (.sub.vf vf1 vf3 vf2)
       (.mul.vf vf1 vf1 vf1)
-      (.add.y.vf vf1 vf1 vf1 :mask #b1)
-      (.add.z.vf vf1 vf1 vf1 :mask #b1)
+      (.add.y.vf.x vf1 vf1 vf1)
+      (.add.z.vf.x vf1 vf1 vf1)
       (.mov a3-6 vf1)
       (when (< a3-6 19327350000.0)
         (logior! (-> arg0 mask arg2) (ash 1 arg1))
@@ -465,8 +465,8 @@
         )
       (.sub.vf vf1 vf3 vf2)
       (.mul.vf vf1 vf1 vf1)
-      (.add.y.vf vf1 vf1 vf1 :mask #b1)
-      (.add.z.vf vf1 vf1 vf1 :mask #b1)
+      (.add.y.vf.x vf1 vf1 vf1)
+      (.add.z.vf.x vf1 vf1 vf1)
       (.mov a3-10 vf1)
       (when (< a3-10 19327350000.0)
         (logior! (-> arg0 mask arg2) (ash 1 arg1))
@@ -478,8 +478,8 @@
       )
     (.sub.vf vf1 vf3 vf2)
     (.mul.vf vf1 vf1 vf1)
-    (.add.y.vf vf1 vf1 vf1 :mask #b1)
-    (.add.z.vf vf1 vf1 vf1 :mask #b1)
+    (.add.y.vf.x vf1 vf1 vf1)
+    (.add.z.vf.x vf1 vf1 vf1)
     (.mov v1-10 vf1)
     (when (< v1-10 19327350000.0)
       (logior! (-> arg0 mask arg2) (ash 1 arg1))

test/decompiler/reference/jak1/engine/gfx/shadow/shadow_REF.gc

@@ -90,14 +90,14 @@
               ((< (-> s0-0 w) 0.0)
                (.lvf vf1 (&-> v1-9 vel-sxvel quad))
                (.lvf vf2 (&-> s0-0 quad))
-               (.sub.vf vf1 vf0 vf2 :mask #b111)
+               (.sub.vf.xyz vf1 vf0 vf2)
                (.svf (&-> v1-9 vel-sxvel quad) vf1)
                (.mov v1-10 vf1)
                )
               (else
                 (.lvf vf1 (&-> v1-9 vel-sxvel quad))
                 (.lvf vf2 (&-> s0-0 quad))
-                (.add.vf vf1 vf0 vf2 :mask #b111)
+                (.add.vf.xyz vf1 vf0 vf2)
                 (.svf (&-> v1-9 vel-sxvel quad) vf1)
                 (.mov v1-11 vf1)
                 )

test/decompiler/reference/jak1/engine/gfx/sky/sky-tng_REF.gc

@@ -566,12 +566,7 @@
         (set! (-> s5-0 (+ v1-24 4) col quad) (-> arg2 quad))
         )
       (dotimes (s3-1 4)
-        (vector4-lerp!
-          (the-as vector (-> s5-0 (+ s3-1 8)))
-          (the-as vector (-> s5-0 s3-1))
-          (the-as vector (-> s5-0 (+ s3-1 4)))
-          f30-0
-          )
+        (vector4-lerp! (-> s5-0 (+ s3-1 8) pos) (-> s5-0 s3-1 pos) (-> s5-0 (+ s3-1 4) pos) f30-0)
         (vector4-lerp! (-> s5-0 (+ s3-1 8) stq) (-> s5-0 s3-1 stq) (-> s5-0 (+ s3-1 4) stq) f30-0)
         (set! (-> s5-0 (+ s3-1 8) col quad) (-> arg2 quad))
         )

test/decompiler/reference/jak1/engine/gfx/sprite/sparticle/sparticle-launcher_REF.gc

@@ -34,7 +34,6 @@
   )
 
 ;; definition for method 3 of type sparticle-launcher
-;; INFO: this function exists in multiple non-identical object files
 ;; INFO: Return type mismatch int vs sparticle-launcher.
 (defmethod inspect ((this sparticle-launcher))
   (format #t "~X: sparticle-launcher~%" this)
@@ -460,7 +459,7 @@
           (s3-0 (new 'stack-no-clear 'vector))
           )
       (sp-init-fields!
-        (the-as (pointer float) (-> s5-0 launchrot))
+        (&-> s5-0 launchrot x)
         arg2
         (sp-field-id launch-fields-start)
         (sp-field-id launch-fields-end)
@@ -515,14 +514,14 @@
         ((< (-> s5-0 w) 0.0)
          (.lvf vf1 (&-> arg0 conerot quad))
          (.lvf vf2 (&-> s5-0 vec quad))
-         (.sub.vf vf1 vf0 vf2 :mask #b111)
+         (.sub.vf.xyz vf1 vf0 vf2)
          (.svf (&-> arg0 conerot quad) vf1)
          (.mov v1-1 vf1)
          )
         (else
           (.lvf vf1 (&-> arg0 conerot quad))
           (.lvf vf2 (&-> s5-0 vec quad))
-          (.add.vf vf1 vf0 vf2 :mask #b111)
+          (.add.vf.xyz vf1 vf0 vf2)
           (.svf (&-> arg0 conerot quad) vf1)
           (.mov v1-2 vf1)
           )
@@ -624,8 +623,8 @@
       (set! (-> s5-0 rot) (the float (sar (shl (the int (-> s5-0 rot)) 48) 48)))
       (.lvf vf4 (&-> s5-0 color quad))
       (.lvf vf5 (&-> s5-0 x-y-z-sx quad))
-      (.min.x.vf vf4 vf4 vf31 :mask #b111)
-      (.add.vf vf5 vf5 vf30 :mask #b111)
+      (.min.x.vf.xyz vf4 vf4 vf31)
+      (.add.vf.xyz vf5 vf5 vf30)
       (.svf (&-> s5-0 color quad) vf4)
       (.svf (&-> s5-0 x-y-z-sx quad) vf5)
       (when (not *death-adgif*)
@@ -651,8 +650,8 @@
       (.lvf vf4 (&-> (-> *time-of-day-context* current-prt-color) quad))
       (.lvf vf5 (&-> s5-0 color quad))
       (.lvf vf6 (&-> gp-0 fade quad))
-      (.mul.vf vf5 vf5 vf4 :mask #b111)
-      (.mul.vf vf6 vf6 vf4 :mask #b111)
+      (.mul.vf.xyz vf5 vf5 vf4)
+      (.mul.vf.xyz vf6 vf6 vf4)
       (.svf (&-> s5-0 color quad) vf5)
       (.svf (&-> gp-0 fade quad) vf6)
       (.mov v1-25 vf6)
@@ -664,7 +663,7 @@
         (.lvf vf3 (&-> s5-0 color quad))
         (.svf (&-> v1-26 x-y-z-sx quad) vf1)
         (.svf (&-> v1-26 flag-rot-sy quad) vf2)
-        (.sub.w.vf vf3 vf0 vf0 :mask #b1000)
+        (.sub.w.vf.w vf3 vf0 vf0)
         (.svf (&-> v1-26 color quad) vf3)
         )
       (.mov v1-27 vf3)
@@ -719,7 +718,7 @@
          (set! (-> arg2 fade y) 99999.0)
          (set! (-> arg2 fade z) 99999.0)
          (let ((a1-2 (sp-init-fields!
-                       (the-as (pointer float) (-> arg3 x-y-z-sx))
+                       (&-> arg3 x-y-z-sx x)
                        (the-as (inline-array sp-field-init-spec) a1-1)
                        (sp-field-id sprite-fields-start)
                        (sp-field-id sprite-fields-end)
@@ -764,7 +763,7 @@
        )
       (else
         (let ((a1-3 (sp-init-fields!
-                      (the-as (pointer float) (-> arg3 x-y-z-sx))
+                      (&-> arg3 x-y-z-sx x)
                       (the-as (inline-array sp-field-init-spec) a1-1)
                       (sp-field-id sprite-fields-start)
                       (sp-field-id sprite-fields-end)
@@ -840,14 +839,14 @@
           ((< (-> s3-0 w) 0.0)
            (.lvf vf1 (&-> arg3 qx-qy-qz-sy quad))
            (.lvf vf2 (&-> s3-0 vec quad))
-           (.sub.vf vf1 vf0 vf2 :mask #b111)
+           (.sub.vf.xyz vf1 vf0 vf2)
            (.svf (&-> arg3 qx-qy-qz-sy quad) vf1)
            (.mov v1-9 vf1)
            )
           (else
             (.lvf vf1 (&-> arg3 qx-qy-qz-sy quad))
             (.lvf vf2 (&-> s3-0 vec quad))
-            (.add.vf vf1 vf0 vf2 :mask #b111)
+            (.add.vf.xyz vf1 vf0 vf2)
             (.svf (&-> arg3 qx-qy-qz-sy quad) vf1)
             (.mov v1-10 vf1)
             )
@@ -1190,14 +1189,14 @@
             ((< (-> s4-0 w) 0.0)
              (.lvf vf1 (&-> v1-3 qx-qy-qz-sy quad))
              (.lvf vf2 (&-> s4-0 quad))
-             (.sub.vf vf1 vf0 vf2 :mask #b111)
+             (.sub.vf.xyz vf1 vf0 vf2)
              (.svf (&-> v1-3 qx-qy-qz-sy quad) vf1)
              (.mov v1-4 vf1)
              )
             (else
               (.lvf vf1 (&-> v1-3 qx-qy-qz-sy quad))
               (.lvf vf2 (&-> s4-0 quad))
-              (.add.vf vf1 vf0 vf2 :mask #b111)
+              (.add.vf.xyz vf1 vf0 vf2)
               (.svf (&-> v1-3 qx-qy-qz-sy quad) vf1)
               (.mov v1-5 vf1)
               )
@@ -1257,14 +1256,14 @@
             ((< (-> s4-0 w) 0.0)
              (.lvf vf1 (&-> v1-14 qx-qy-qz-sy quad))
              (.lvf vf2 (&-> s4-0 quad))
-             (.sub.vf vf1 vf0 vf2 :mask #b111)
+             (.sub.vf.xyz vf1 vf0 vf2)
              (.svf (&-> v1-14 qx-qy-qz-sy quad) vf1)
              (.mov v1-15 vf1)
              )
             (else
               (.lvf vf1 (&-> v1-14 qx-qy-qz-sy quad))
               (.lvf vf2 (&-> s4-0 quad))
-              (.add.vf vf1 vf0 vf2 :mask #b111)
+              (.add.vf.xyz vf1 vf0 vf2)
               (.svf (&-> v1-14 qx-qy-qz-sy quad) vf1)
               (.mov v1-16 vf1)
               )

test/decompiler/reference/jak1/engine/gfx/sprite/sparticle/sparticle_REF.gc

@@ -537,9 +537,9 @@
   (let ((gp-0 (-> arg1 rotvel3d))
         (s5-0 (new 'stack-no-clear 'quaternion))
         )
-    (vector-angle<-quaternion! (the-as vector s5-0) gp-0)
+    (vector-angle<-quaternion! (-> s5-0 vec) gp-0)
     (set! (-> s5-0 w) (* 12516.455 (-> s5-0 w)))
-    (quaternion-vector-angle! gp-0 (the-as vector s5-0) (-> s5-0 w))
+    (quaternion-vector-angle! gp-0 (-> s5-0 vec) (-> s5-0 w))
     )
   0
   (none)
@@ -551,9 +551,9 @@
   (let ((gp-0 (-> arg1 rotvel3d))
         (s5-0 (new 'stack-no-clear 'quaternion))
         )
-    (vector-angle<-quaternion! (the-as vector s5-0) gp-0)
+    (vector-angle<-quaternion! (-> s5-0 vec) gp-0)
     (set! (-> s5-0 w) (* 8691.982 (-> s5-0 w)))
-    (quaternion-vector-angle! gp-0 (the-as vector s5-0) (-> s5-0 w))
+    (quaternion-vector-angle! gp-0 (-> s5-0 vec) (-> s5-0 w))
     )
   0
   (none)

test/decompiler/reference/jak1/engine/gfx/sprite/sprite-distort_REF.gc

@@ -235,11 +235,11 @@
             (TODO.VCLIP vf10 vf10)
             (b! (zero? (-> sv-16 flag)) cfg-21 :delay (nop!))
             (.wait.vf)
-            (.mul.vf vf1 vf1 Q :mask #b111)
-            (.mul.vf vf2 vf2 Q :mask #b111)
+            (.mul.vf.xyz vf1 vf1 Q)
+            (.mul.vf.xyz vf2 vf2 Q)
             (.cfc2.i v1-25 Clipping)
             (b! (logtest? v1-25 63) cfg-21 :delay (.add.vf vf1 vf1 vf9))
-            (.max.x.vf vf1 vf1 vf0 :mask #b1000)
+            (.max.x.vf.w vf1 vf1 vf0)
             (.svf (&-> (the-as vector a0-1) quad) vf1)
             (.svf (&-> (the-as vector sv-48) quad) vf2)
             (set! (-> (the-as vector a0-1) w) 255.0)

test/decompiler/reference/jak1/engine/gfx/sprite/sprite_REF.gc

@@ -449,14 +449,14 @@
       ((< (-> arg1 w) 0.0)
        (.lvf vf1 (&-> arg0 qx-qy-qz-sy quad))
        (.lvf vf2 (&-> arg1 vec quad))
-       (.sub.vf vf1 vf0 vf2 :mask #b111)
+       (.sub.vf.xyz vf1 vf0 vf2)
        (.svf (&-> arg0 qx-qy-qz-sy quad) vf1)
        (.mov v1-0 vf1)
        )
       (else
         (.lvf vf1 (&-> arg0 qx-qy-qz-sy quad))
         (.lvf vf2 (&-> arg1 vec quad))
-        (.add.vf vf1 vf0 vf2 :mask #b111)
+        (.add.vf.xyz vf1 vf0 vf2)
         (.svf (&-> arg0 qx-qy-qz-sy quad) vf1)
         (.mov v1-1 vf1)
         )

test/decompiler/reference/jak1/engine/gfx/texture/texture_REF.gc

@@ -723,7 +723,7 @@
 ;; INFO: Return type mismatch int vs none.
 (defmethod allocate-defaults! ((this texture-pool))
   (allocate-segment! this (-> this segment-common) #x1c000)
-  (allocate-segment! this (the-as texture-pool-segment (-> this segment)) #x62000)
+  (allocate-segment! this (-> this segment 0) #x62000)
   (set! *sky-base-vram-word* (allocate-vram-words! this #x7000))
   (set! *sky-base-block* (/ *sky-base-vram-word* 64))
   (set! *sky-base-page* (sar *sky-base-vram-word* 11))
@@ -1116,7 +1116,7 @@
       )
     )
   (upload-now! page 2)
-  (update-vram-pages pool (the-as texture-pool-segment (-> pool segment)) page 2)
+  (update-vram-pages pool (-> pool segment 0) page 2)
   (let ((page-seg-2-size (logand -4096 (+ (-> page segment 2 size) 4095))))
     (cond
       ((< (the-as uint #x24000) page-seg-2-size)
@@ -1156,7 +1156,7 @@
         )
       )
     (upload-now! page 2)
-    (update-vram-pages pool (the-as texture-pool-segment (-> pool segment)) page 2)
+    (update-vram-pages pool (-> pool segment 0) page 2)
     (cond
       ((< (the-as uint #x24000) seg2-size)
        (set! (-> page segment 2 size) (+ -147456 seg2-size))
@@ -1390,13 +1390,8 @@
       (when tfrag-page
         (set! (-> level upload-size 0) 0)
         (if (< distance 81920.0)
-            (+! (-> level upload-size 0) (upload-vram-pages
-                                           this
-                                           (the-as texture-pool-segment (-> this segment))
-                                           tfrag-page
-                                           2
-                                           (the-as bucket-id tfrag-bucket)
-                                           )
+            (+! (-> level upload-size 0)
+                (upload-vram-pages this (-> this segment 0) tfrag-page 2 (the-as bucket-id tfrag-bucket))
                 )
             )
         (cond

test/decompiler/reference/jak1/engine/gfx/tie/tie-methods_REF.gc

@@ -232,7 +232,6 @@
 ;; ERROR: function was not converted to expressions. Cannot decompile.
 
 ;; definition for method 9 of type drawable-tree-instance-tie
-;; INFO: this function exists in multiple non-identical object files
 (defmethod login ((this drawable-tree-instance-tie))
   (if (nonzero? (-> this prototypes prototype-array-tie))
       (login (-> this prototypes prototype-array-tie))
@@ -299,9 +298,7 @@
           (set! sv-16 (-> (the-as drawable-inline-array-node v1-16) length))
           (when (nonzero? sv-16)
             (let* ((v1-21 (logand (the-as int *gsf-buffer*) 8191))
-                   (v1-23
-                     (logand (the-as int (&- (logand (the-as int (&-> (-> s4-1 data) -512)) 8191) (the-as uint v1-21))) 8191)
-                     )
+                   (v1-23 (logand (the-as int (&- (logand (the-as int (&-> s4-1 data -512)) 8191) (the-as uint v1-21))) 8191))
                    )
               (set! *instance-tie-work-copy* (the-as instance-tie-work (+ (the-as int *gsf-buffer*) v1-23)))
               )

test/decompiler/reference/jak1/engine/level/bsp-h_REF.gc

@@ -109,7 +109,7 @@
   (format #t "~Tdrawable-trees: ~A~%" (-> this drawable-trees))
   (format #t "~Tpat: #x~X~%" (-> this pat))
   (format #t "~Tpat-length: ~D~%" (-> this pat-length))
-  (inspect-bsp-tree this (the-as bsp-node (-> this nodes)))
+  (inspect-bsp-tree this (-> this nodes 0))
   this
   )
 

test/decompiler/reference/jak1/engine/level/bsp_REF.gc

@@ -129,7 +129,7 @@
         )
       )
     )
-  (mem-usage-bsp-tree this (the-as bsp-node (-> this nodes)) mem-use flags)
+  (mem-usage-bsp-tree this (-> this nodes 0) mem-use flags)
   this
   )
 
@@ -408,10 +408,10 @@
       (label cfg-1)
       (b! (< (the-as int next-node) 0) cfg-4 :delay (set! real-node next-node))
       (.lvf vf2 (&-> real-node plane quad))
-      (.mul.vf vf2 vf2 vf1 :mask #b111)
-      (.add.x.vf vf2 vf2 vf2 :mask #b10)
-      (.add.z.vf vf2 vf2 vf2 :mask #b10)
-      (.sub.w.vf vf2 vf2 vf2 :mask #b10)
+      (.mul.vf.xyz vf2 vf2 vf1)
+      (.add.x.vf.y vf2 vf2 vf2)
+      (.add.z.vf.y vf2 vf2 vf2)
+      (.sub.w.vf.y vf2 vf2 vf2)
       (.mov v1-1 vf2)
       (let ((a2-0 (-> real-node front-flags)))
         (b! (>= (the-as int v1-1) 0) cfg-1 :delay (set! next-node (the-as bsp-node (-> real-node front))))

test/decompiler/reference/jak1/engine/level/load-boundary_REF.gc

@@ -1282,7 +1282,7 @@
           (a3-0 (-> arg0 data (-> arg0 data s5-0 v2)))
           (s4-0 (new 'stack-no-clear 'vector))
           )
-      (normal-of-plane s4-0 (the-as vector a1-0) (the-as vector a2-0) (the-as vector a3-0))
+      (normal-of-plane s4-0 (-> a1-0 v) (-> a2-0 v) (-> a3-0 v))
       (if (or (!= (-> s4-0 x) 0.0) (!= (-> s4-0 z) 0.0))
           (format 0 "ERROR in the load-boundary code : tell Eddie!!!~%")
           )

test/decompiler/reference/jak1/engine/load/loader_REF.gc

@@ -565,7 +565,7 @@
         )
     (cond
       (s4-4
-        (mem-copy! (&-> (-> this last-preload-stream) type) (&-> s4-4 type) 44)
+        (mem-copy! (&-> this last-preload-stream type) (&-> s4-4 type) 44)
         (str-play-queue (-> s4-4 name))
         )
       (else
@@ -684,11 +684,11 @@
          (let ((v1-5 s5-0))
            (cond
              ((zero? v1-5)
-              (mem-copy! (&+ (the-as pointer (-> this rec)) -4) (&-> (-> this rec 1) type) 44)
-              (mem-copy! (&-> (-> this rec 1) type) (&-> (-> this rec 2) type) 44)
+              (mem-copy! (&+ (the-as pointer (-> this rec)) -4) (&-> this rec 1 type) 44)
+              (mem-copy! (&-> this rec 1 type) (&-> this rec 2 type) 44)
               )
              ((= v1-5 1)
-              (mem-copy! (&-> (-> this rec 1) type) (&-> (-> this rec 2) type) 44)
+              (mem-copy! (&-> this rec 1 type) (&-> this rec 2 type) 44)
               )
              )
            )
@@ -743,8 +743,8 @@
      (if (>= arg3 (-> this rec 0 priority))
          (return (the-as int #f))
          )
-     (mem-copy! (&-> (-> this rec) 0 type) (&-> (-> this rec 1) type) 44)
-     (mem-copy! (&-> (-> this rec 1) type) (&-> (-> this rec 2) type) 44)
+     (mem-copy! (&-> this rec 0 type) (&-> this rec 1 type) 44)
+     (mem-copy! (&-> this rec 1 type) (&-> this rec 2 type) 44)
      (set! (-> this rec 2 name) #f)
      (set! (-> this rec 2 owner) (the-as handle #f))
      )
@@ -752,7 +752,7 @@
      (if (>= arg3 (-> this rec 1 priority))
          (return (the-as int #f))
          )
-     (mem-copy! (&-> (-> this rec 1) type) (&-> (-> this rec 2) type) 44)
+     (mem-copy! (&-> this rec 1 type) (&-> this rec 2 type) 44)
      (set! (-> this rec 2 name) #f)
      (set! (-> this rec 2 owner) (the-as handle #f))
      )
@@ -766,15 +766,15 @@
     )
   (cond
     ((< arg3 (-> this rec 0 priority))
-     (mem-copy! (&-> (-> this rec 2) type) (&-> (-> this rec 1) type) 44)
-     (mem-copy! (&-> (-> this rec 1) type) (&-> (-> this rec) 0 type) 44)
+     (mem-copy! (&-> this rec 2 type) (&-> this rec 1 type) 44)
+     (mem-copy! (&-> this rec 1 type) (&-> this rec 0 type) 44)
      (set! (-> this rec 0 name) arg0)
      (set! (-> this rec 0 parts) arg1)
      (set! (-> this rec 0 priority) arg3)
      (set! (-> this rec 0 owner) (process->handle arg2))
      )
     ((< arg3 (-> this rec 1 priority))
-     (mem-copy! (&-> (-> this rec 2) type) (&-> (-> this rec 1) type) 44)
+     (mem-copy! (&-> this rec 2 type) (&-> this rec 1 type) 44)
      (set! (-> this rec 1 name) arg0)
      (set! (-> this rec 1 parts) arg1)
      (set! (-> this rec 1 priority) arg3)

test/decompiler/reference/jak1/engine/math/math_REF.gc

@@ -131,7 +131,7 @@
     (init-vf0-vector)
     (TODO.VRGET vf1)
     (.sqrt.vf Q vf1 :ftf #b0)
-    (.add.vf vf2 vf0 Q :mask #b1)
+    (.add.vf.x vf2 vf0 Q)
     (TODO.VRXOR vf2)
     (TODO.VRNEXT vf1)
     (.sub.w.vf vf1 vf1 vf0)

test/decompiler/reference/jak1/engine/math/matrix_REF.gc

@@ -2,7 +2,6 @@
 (in-package goal)
 
 ;; definition for method 3 of type matrix
-;; INFO: this function exists in multiple non-identical object files
 (defmethod inspect ((this matrix))
   (format #t "[~8x] matrix~%" this)
   (format
@@ -41,7 +40,6 @@
   )
 
 ;; definition for method 3 of type matrix3
-;; INFO: this function exists in multiple non-identical object files
 (defmethod inspect ((this matrix3))
   (format #t "[~8x] matrix3~%" this)
   (format #t "~T[~F] [~F] [~F]~%" (-> this data 0) (-> this data 1) (-> this data 2))
@@ -286,15 +284,15 @@
     (.lvf vf1 (&-> dst vector 0 quad))
     (.lvf vf2 (&-> dst vector 1 quad))
     (.lvf vf3 (&-> dst vector 2 quad))
-    (.sub.vf vf1 vf1 vf1 :mask #b1000)
-    (.sub.vf vf2 vf2 vf2 :mask #b1000)
-    (.sub.vf vf3 vf3 vf3 :mask #b1000)
+    (.sub.vf.w vf1 vf1 vf1)
+    (.sub.vf.w vf2 vf2 vf2)
+    (.sub.vf.w vf3 vf3 vf3)
     (.lvf vf8 (&-> src vector 3 quad))
     (.mul.x.vf acc vf1 vf8)
     (.add.mul.y.vf acc vf2 vf8 acc)
     (.add.mul.z.vf vf4 vf3 vf8 acc)
     (.sub.vf vf4 vf0 vf4)
-    (.mov.vf vf4 vf0 :mask #b1000)
+    (.mov.vf.w vf4 vf0)
     (.svf (&-> dst vector 0 quad) vf1)
     (.svf (&-> dst vector 1 quad) vf2)
     (.svf (&-> dst vector 2 quad) vf3)
@@ -369,87 +367,87 @@
     (nop!)
     (.mul.z.vf vf15 vf25 vf24)
     (nop!)
-    (.mul.z.vf vf26 vf7 vf25 :mask #b10)
+    (.mul.z.vf.y vf26 vf7 vf25)
     (nop!)
-    (.mul.z.vf vf27 vf11 vf24 :mask #b1)
+    (.mul.z.vf.x vf27 vf11 vf24)
     (nop!)
-    (.mul.y.vf vf28 vf9 vf25 :mask #b1)
+    (.mul.y.vf.x vf28 vf9 vf25)
     (nop!)
-    (.mul.z.vf vf29 vf14 vf23 :mask #b1)
+    (.mul.z.vf.x vf29 vf14 vf23)
     (nop!)
-    (.mul.z.vf vf30 vf8 vf25 :mask #b1)
+    (.mul.z.vf.x vf30 vf8 vf25)
     (nop!)
-    (.mul.y.vf vf31 vf7 vf25 :mask #b100)
+    (.mul.y.vf.z vf31 vf7 vf25)
     (nop!)
-    (.add.y.vf vf16 vf27 vf26 :mask #b1)
+    (.add.y.vf.x vf16 vf27 vf26)
     (nop!)
     (.sub.vf vf1 vf0 vf1)
     (nop!)
-    (.add.x.vf vf17 vf29 vf30 :mask #b1)
+    (.add.x.vf.x vf17 vf29 vf30)
     (nop!)
-    (.sub.z.vf vf18 vf28 vf31 :mask #b1)
+    (.sub.z.vf.x vf18 vf28 vf31)
     (nop!)
-    (.sub.y.vf vf23 vf14 vf15 :mask #b100)
+    (.sub.y.vf.z vf23 vf14 vf15)
     (nop!)
-    (.sub.z.vf vf26 vf15 vf13 :mask #b1)
+    (.sub.z.vf.x vf26 vf15 vf13)
     (nop!)
-    (.sub.x.vf vf29 vf13 vf14 :mask #b10)
+    (.sub.x.vf.y vf29 vf13 vf14)
     (nop!)
-    (.sub.vf vf19 vf16 vf17 :mask #b1)
+    (.sub.vf.x vf19 vf16 vf17)
     (nop!)
-    (.sub.z.vf vf24 vf12 vf11 :mask #b10)
+    (.sub.z.vf.y vf24 vf12 vf11)
     (nop!)
-    (.sub.x.vf vf27 vf10 vf12 :mask #b100)
+    (.sub.x.vf.z vf27 vf10 vf12)
     (nop!)
-    (.sub.y.vf vf30 vf11 vf10 :mask #b1)
+    (.sub.y.vf.x vf30 vf11 vf10)
     (nop!)
-    (.add.vf vf20 vf19 vf18 :mask #b1)
+    (.add.vf.x vf20 vf19 vf18)
     (nop!)
-    (.sub.y.vf vf25 vf8 vf9 :mask #b100)
+    (.sub.y.vf.z vf25 vf8 vf9)
     (nop!)
-    (.sub.z.vf vf28 vf9 vf7 :mask #b1)
+    (.sub.z.vf.x vf28 vf9 vf7)
     (nop!)
-    (.sub.x.vf vf31 vf7 vf8 :mask #b10)
+    (.sub.x.vf.y vf31 vf7 vf8)
     (nop!)
     (.div.vf Q vf0 vf20 :fsf #b11 :ftf #b0)
     (nop!)
-    (.sub.w.vf vf3 vf3 vf3 :mask #b1000)
+    (.sub.w.vf.w vf3 vf3 vf3)
     (nop!)
-    (.sub.w.vf vf4 vf4 vf4 :mask #b1000)
+    (.sub.w.vf.w vf4 vf4 vf4)
     (nop!)
-    (.sub.w.vf vf5 vf5 vf5 :mask #b1000)
+    (.sub.w.vf.w vf5 vf5 vf5)
     (nop!)
-    (.mov.vf vf6 vf0 :mask #b1000)
+    (.mov.vf.w vf6 vf0)
     (nop!)
     (.wait.vf)
     (nop!)
-    (.add.vf vf2 vf0 Q :mask #b1)
+    (.add.vf.x vf2 vf0 Q)
     (nop!)
-    (.add.x.vf vf2 vf0 vf2 :mask #b111)
+    (.add.x.vf.xyz vf2 vf0 vf2)
     (nop!)
-    (.mul.z.vf vf3 vf2 vf23 :mask #b1)
+    (.mul.z.vf.x vf3 vf2 vf23)
     (nop!)
-    (.mul.x.vf vf4 vf2 vf26 :mask #b1)
+    (.mul.x.vf.x vf4 vf2 vf26)
     (nop!)
-    (.mul.y.vf vf5 vf2 vf29 :mask #b1)
+    (.mul.y.vf.x vf5 vf2 vf29)
     (nop!)
-    (.mul.y.vf vf3 vf2 vf24 :mask #b10)
+    (.mul.y.vf.y vf3 vf2 vf24)
     (nop!)
-    (.mul.z.vf vf4 vf2 vf27 :mask #b10)
+    (.mul.z.vf.y vf4 vf2 vf27)
     (nop!)
-    (.mul.x.vf vf5 vf2 vf30 :mask #b10)
+    (.mul.x.vf.y vf5 vf2 vf30)
     (nop!)
-    (.mul.z.vf vf3 vf2 vf25 :mask #b100)
+    (.mul.z.vf.z vf3 vf2 vf25)
     (nop!)
-    (.mul.x.vf vf4 vf2 vf28 :mask #b100)
+    (.mul.x.vf.z vf4 vf2 vf28)
     (nop!)
-    (.mul.y.vf vf5 vf2 vf31 :mask #b100)
+    (.mul.y.vf.z vf5 vf2 vf31)
     (nop!)
     (.mul.x.vf acc vf3 vf1)
     (.svf (&-> dst vector 0 quad) vf3)
     (.add.mul.y.vf acc vf4 vf1 acc)
     (.svf (&-> dst vector 1 quad) vf4)
-    (.add.mul.z.vf vf6 vf5 vf1 acc :mask #b111)
+    (.add.mul.z.vf.xyz vf6 vf5 vf1 acc)
     (.svf (&-> dst vector 2 quad) vf5)
     (nop!)
     (.svf (&-> dst vector 3 quad) vf6)
@@ -825,9 +823,9 @@
     (.lvf vf10 (&-> arg0 vector 0 quad))
     (.outer.product.a.vf acc vf11 vf12)
     (.outer.product.b.vf vf13 vf12 vf11 acc)
-    (.mul.vf vf13 vf13 vf10 :mask #b111)
-    (.add.y.vf vf13 vf13 vf13 :mask #b1)
-    (.add.z.vf vf13 vf13 vf13 :mask #b1)
+    (.mul.vf.xyz vf13 vf13 vf10)
+    (.add.y.vf.x vf13 vf13 vf13)
+    (.add.z.vf.x vf13 vf13 vf13)
     (.mov v0-0 vf13)
     v0-0
     )
@@ -922,15 +920,15 @@
     (.outer.product.b.vf vf13 vf12 vf11 acc)
     (.outer.product.a.vf acc vf12 vf10)
     (.outer.product.b.vf vf14 vf10 vf12 acc)
-    (.mul.vf vf1 vf10 vf13 :mask #b111)
+    (.mul.vf.xyz vf1 vf10 vf13)
     (.outer.product.a.vf acc vf10 vf11)
     (.outer.product.b.vf vf15 vf11 vf10 acc)
     (.nop.vf)
-    (.add.y.vf vf1 vf1 vf1 :mask #b1)
+    (.add.y.vf.x vf1 vf1 vf1)
     (.nop.vf)
     (.nop.vf)
     (.nop.vf)
-    (.add.z.vf vf1 vf1 vf1 :mask #b1)
+    (.add.z.vf.x vf1 vf1 vf1)
     (.nop.vf)
     (.nop.vf)
     (.nop.vf)

test/decompiler/reference/jak1/engine/math/quaternion_REF.gc

@@ -162,8 +162,8 @@
          )
     (.lvf vf1 (&-> arg1 vec quad))
     (.sub.vf vf2 vf2 vf2)
-    (.sub.vf vf2 vf2 vf1 :mask #b111)
-    (.add.vf vf2 vf2 vf1 :mask #b1000)
+    (.sub.vf.xyz vf2 vf2 vf1)
+    (.add.vf.w vf2 vf2 vf1)
     (.svf (&-> arg0 vec quad) vf2)
     arg0
     )
@@ -200,9 +200,9 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 vec quad))
     (.mul.vf vf1 vf1 vf1)
-    (.add.z.vf acc vf1 vf1 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000)
-    (.add.mul.x.vf vf1 vf0 vf1 acc :mask #b1000)
+    (.add.z.vf.w acc vf1 vf1)
+    (.add.mul.y.vf.w acc vf0 vf1 acc)
+    (.add.mul.x.vf.w vf1 vf0 vf1 acc)
     (.add.w.vf vf1 vf0 vf1)
     (.mov v0-0 vf1)
     v0-0
@@ -219,9 +219,9 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 vec quad))
     (.mul.vf vf1 vf1 vf1)
-    (.add.z.vf acc vf1 vf1 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000)
-    (.add.mul.x.vf vf1 vf0 vf1 acc :mask #b1000)
+    (.add.z.vf.w acc vf1 vf1)
+    (.add.mul.y.vf.w acc vf0 vf1 acc)
+    (.add.mul.x.vf.w vf1 vf0 vf1 acc)
     (.add.w.vf vf1 vf0 vf1)
     (.mov v1-1 vf1)
     (sqrtf v1-1)
@@ -239,9 +239,9 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 vec quad))
     (.mul.vf vf2 vf1 vf1)
-    (.add.z.vf acc vf2 vf2 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000)
-    (.add.mul.x.vf vf2 vf0 vf2 acc :mask #b1000)
+    (.add.z.vf.w acc vf2 vf2)
+    (.add.mul.y.vf.w acc vf0 vf2 acc)
+    (.add.mul.x.vf.w vf2 vf0 vf2 acc)
     (.isqrt.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
     (.wait.vf)
     (.mul.vf vf2 vf1 Q)
@@ -266,12 +266,12 @@
     (.lvf vf1 (&-> arg1 vec quad))
     (.mul.vf vf2 vf1 vf1)
     (.sub.vf vf3 vf3 vf3)
-    (.add.z.vf acc vf2 vf2 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000)
-    (.add.mul.x.vf vf2 vf0 vf2 acc :mask #b1000)
-    (.sub.vf vf3 vf3 vf1 :mask #b111)
+    (.add.z.vf.w acc vf2 vf2)
+    (.add.mul.y.vf.w acc vf0 vf2 acc)
+    (.add.mul.x.vf.w vf2 vf0 vf2 acc)
+    (.sub.vf.xyz vf3 vf3 vf1)
     (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
-    (.add.vf vf3 vf3 vf1 :mask #b1000)
+    (.add.vf.w vf3 vf3 vf1)
     (.wait.vf)
     (.mul.vf vf3 vf3 Q)
     (.nop.vf)
@@ -293,9 +293,9 @@
     (.lvf vf1 (&-> arg0 vec quad))
     (.lvf vf2 (&-> arg1 vec quad))
     (.mul.vf vf1 vf1 vf2)
-    (.add.z.vf acc vf1 vf1 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000)
-    (.add.mul.x.vf vf1 vf0 vf1 acc :mask #b1000)
+    (.add.z.vf.w acc vf1 vf1)
+    (.add.mul.y.vf.w acc vf0 vf1 acc)
+    (.add.mul.x.vf.w vf1 vf0 vf1 acc)
     (.add.w.vf vf1 vf0 vf1)
     (.mov v0-0 vf1)
     v0-0
@@ -314,16 +314,16 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> arg1 vec quad))
     (.lvf vf2 (&-> arg2 vec quad))
-    (.sub.vf vf4 vf0 vf0 :mask #b1000)
+    (.sub.vf.w vf4 vf0 vf0)
     (.mul.vf vf3 vf1 vf2)
     (.outer.product.a.vf acc vf1 vf2)
     (.outer.product.b.vf vf4 vf2 vf1 acc)
     (.mul.w.vf acc vf1 vf2)
     (.add.mul.w.vf acc vf2 vf1 acc)
-    (.sub.mul.w.vf acc vf0 vf3 acc :mask #b1000)
-    (.sub.mul.z.vf acc vf0 vf3 acc :mask #b1000)
-    (.sub.mul.y.vf acc vf0 vf3 acc :mask #b1000)
-    (.sub.mul.x.vf acc vf0 vf3 acc :mask #b1000)
+    (.sub.mul.w.vf.w acc vf0 vf3 acc)
+    (.sub.mul.z.vf.w acc vf0 vf3 acc)
+    (.sub.mul.y.vf.w acc vf0 vf3 acc)
+    (.sub.mul.x.vf.w acc vf0 vf3 acc)
     (.add.mul.w.vf vf1 vf4 vf0 acc)
     (.svf (&-> arg0 vec quad) vf1)
     arg0
@@ -398,27 +398,27 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> arg1 vec quad))
     (.add.vf vf5 vf1 vf1)
-    (.add.w.vf vf2 vf0 vf1 :mask #b1)
-    (.add.z.vf vf2 vf0 vf1 :mask #b10)
-    (.sub.y.vf vf2 vf0 vf1 :mask #b100)
-    (.sub.w.vf vf2 vf0 vf0 :mask #b1000)
-    (.sub.z.vf vf3 vf0 vf1 :mask #b1)
-    (.add.w.vf vf3 vf0 vf1 :mask #b10)
-    (.add.x.vf vf3 vf0 vf1 :mask #b100)
-    (.sub.w.vf vf3 vf0 vf0 :mask #b1000)
-    (.add.y.vf vf4 vf0 vf1 :mask #b1)
-    (.sub.x.vf vf4 vf0 vf1 :mask #b10)
-    (.add.w.vf vf4 vf0 vf1 :mask #b100)
-    (.sub.w.vf vf4 vf0 vf0 :mask #b1000)
+    (.add.w.vf.x vf2 vf0 vf1)
+    (.add.z.vf.y vf2 vf0 vf1)
+    (.sub.y.vf.z vf2 vf0 vf1)
+    (.sub.w.vf.w vf2 vf0 vf0)
+    (.sub.z.vf.x vf3 vf0 vf1)
+    (.add.w.vf.y vf3 vf0 vf1)
+    (.add.x.vf.z vf3 vf0 vf1)
+    (.sub.w.vf.w vf3 vf0 vf0)
+    (.add.y.vf.x vf4 vf0 vf1)
+    (.sub.x.vf.y vf4 vf0 vf1)
+    (.add.w.vf.z vf4 vf0 vf1)
+    (.sub.w.vf.w vf4 vf0 vf0)
     (.outer.product.a.vf acc vf5 vf2)
     (.outer.product.b.vf vf2 vf2 vf5 acc)
     (.outer.product.a.vf acc vf5 vf3)
     (.outer.product.b.vf vf3 vf3 vf5 acc)
     (.outer.product.a.vf acc vf5 vf4)
     (.outer.product.b.vf vf4 vf4 vf5 acc)
-    (.add.w.vf vf2 vf2 vf0 :mask #b1)
-    (.add.w.vf vf3 vf3 vf0 :mask #b10)
-    (.add.w.vf vf4 vf4 vf0 :mask #b100)
+    (.add.w.vf.x vf2 vf2 vf0)
+    (.add.w.vf.y vf3 vf3 vf0)
+    (.add.w.vf.z vf4 vf4 vf0)
     (.svf (&-> arg0 vector 3 quad) vf0)
     (.svf (&-> arg0 vector 0 quad) vf2)
     (.svf (&-> arg0 vector 1 quad) vf3)
@@ -514,7 +514,7 @@
          (vf7 :class vf)
          )
     (let ((v1-0 (new-stack-matrix0)))
-      (let* ((f0-1 (vector-dot (the-as vector (-> arg1 vector)) (the-as vector (-> arg1 vector))))
+      (let* ((f0-1 (vector-dot (-> arg1 vector 0) (-> arg1 vector 0)))
              (f1-1 (vector-dot (-> arg1 vector 1) (-> arg1 vector 1)))
              (f2-1 (vector-dot (-> arg1 vector 2) (-> arg1 vector 2)))
              (f0-3 (/ 1.0 (sqrtf f0-1)))
@@ -580,7 +580,7 @@
 
 ;; definition for function quaternion-exp!
 (defun quaternion-exp! ((arg0 quaternion) (arg1 quaternion))
-  (let ((f30-0 (vector-length (the-as vector arg1))))
+  (let ((f30-0 (vector-length (-> arg1 vec))))
     (cond
       ((= f30-0 0.0)
        (set! (-> arg0 x) 0.0)
@@ -590,7 +590,7 @@
        )
       (else
         (let ((s5-0 (new 'stack-no-clear 'vector)))
-          (sincos-rad! (the-as (pointer float) s5-0) f30-0)
+          (sincos-rad! (&-> s5-0 x) f30-0)
           (let ((f0-6 (/ (-> s5-0 x) f30-0)))
             (set! (-> arg0 x) (* (-> arg1 x) f0-6))
             (set! (-> arg0 y) (* (-> arg1 y) f0-6))
@@ -722,17 +722,17 @@
       (.lvf vf1 (&-> gp-0 quad))
       (.lvf vf2 (&-> s5-0 quad))
       )
-    (.mul.x.vf vf4 vf0 vf1 :mask #b1000)
-    (.add.vf vf4 vf0 vf2 :mask #b111)
-    (.sub.vf vf4 vf0 vf4 :mask #b110)
-    (.add.vf vf3 vf0 vf1 :mask #b111)
-    (.mul.x.vf vf3 vf0 vf2 :mask #b1000)
+    (.mul.x.vf.w vf4 vf0 vf1)
+    (.add.vf.xyz vf4 vf0 vf2)
+    (.sub.vf.yz vf4 vf0 vf4)
+    (.add.vf.xyz vf3 vf0 vf1)
+    (.mul.x.vf.w vf3 vf0 vf2)
     (.outer.product.a.vf acc vf1 vf1)
     (.outer.product.b.vf vf6 vf0 vf0 acc)
     (.outer.product.a.vf acc vf2 vf2)
     (.outer.product.b.vf vf5 vf0 vf0 acc)
-    (.mul.x.vf vf6 vf0 vf6 :mask #b1000)
-    (.mul.x.vf vf5 vf0 vf5 :mask #b1000)
+    (.mul.x.vf.w vf6 vf0 vf6)
+    (.mul.x.vf.w vf5 vf0 vf5)
     (.mul.vf acc vf6 vf4)
     (.add.mul.vf vf7 vf5 vf3 acc)
     (.svf (&-> arg0 vec quad) vf7)
@@ -858,7 +858,7 @@
       (let ((s0-0 (t9-0 a0-1 1.0)))
         (quaternion-from-two-vectors-max-angle!
           s5-0
-          (vector-z-quaternion! (the-as vector (new 'stack-no-clear 'quaternion)) arg1)
+          (vector-z-quaternion! (-> (new 'stack-no-clear 'quaternion) vec) arg1)
           s0-0
           arg3
           )

test/decompiler/reference/jak1/engine/math/transformq_REF.gc

@@ -125,7 +125,7 @@
          )
     (let ((dir-z (-> rot-mat vector 2)))
       (vector-normalize! (vector-flatten! (-> rot-mat vector 1) grav dir-z) 1.0)
-      (vector-cross! (the-as vector (-> rot-mat vector)) (-> rot-mat vector 1) dir-z)
+      (vector-cross! (-> rot-mat vector 0) (-> rot-mat vector 1) dir-z)
       )
     (let ((a1-5 (matrix-rotate-z! (new 'stack-no-clear 'matrix) arg0)))
       (matrix*! rot-mat a1-5 rot-mat)
@@ -233,7 +233,7 @@
         (.lvf vf3 (&-> arg0 vector 0 quad))
         (.lvf vf4 (&-> arg0 vector 1 quad))
         (.lvf vf5 (&-> arg0 vector 2 quad))
-        (.mov.vf vf2 vf0 :mask #b1000)
+        (.mov.vf.w vf2 vf0)
         (.mul.x.vf vf3 vf3 vf1)
         (.mul.y.vf vf4 vf4 vf1)
         (.mul.z.vf vf5 vf5 vf1)
@@ -294,14 +294,14 @@
     (.lvf vf3 (&-> arg0 vector 0 quad))
     (.lvf vf4 (&-> arg0 vector 1 quad))
     (.lvf vf5 (&-> arg0 vector 2 quad))
-    (.mov.vf vf2 vf0 :mask #b1000)
+    (.mov.vf.w vf2 vf0)
     (.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)
+    (.add.mul.w.vf.xyz vf2 vf2 vf0 acc)
     (.svf (&-> arg0 vector 3 quad) vf2)
     (.svf (&-> arg0 vector 0 quad) vf3)
     (.svf (&-> arg0 vector 1 quad) vf4)
@@ -328,11 +328,11 @@
     (.lvf vf3 (&-> arg0 vector 0 quad))
     (.lvf vf4 (&-> arg0 vector 1 quad))
     (.lvf vf5 (&-> arg0 vector 2 quad))
-    (.mov.vf vf2 vf0 :mask #b1000)
+    (.mov.vf.w vf2 vf0)
     (.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)
+    (.add.vf.xyz vf2 vf2 vf6)
     (.svf (&-> arg0 vector 3 quad) vf2)
     (.svf (&-> arg0 vector 0 quad) vf3)
     (.svf (&-> arg0 vector 1 quad) vf4)
@@ -360,7 +360,7 @@
       (set! (-> v1-0 z) (/ 1.0 (-> arg2 z)))
       (.lvf vf1 (&-> arg1 scale quad))
       (.lvf vf2 (&-> arg1 trans quad))
-      (.mov.vf vf2 vf0 :mask #b1000)
+      (.mov.vf.w vf2 vf0)
       (.lvf vf4 (&-> arg0 vector 0 quad))
       (.lvf vf5 (&-> arg0 vector 1 quad))
       (.lvf vf6 (&-> arg0 vector 2 quad))

test/decompiler/reference/jak1/engine/math/vector-h_REF.gc

@@ -696,8 +696,8 @@
     (.lvf vf1 (&-> arg0 quad))
     (.lvf vf2 (&-> arg1 quad))
     (.mul.vf vf1 vf1 vf2)
-    (.add.y.vf vf1 vf1 vf1 :mask #b1)
-    (.add.z.vf vf1 vf1 vf1 :mask #b1)
+    (.add.y.vf.x vf1 vf1 vf1)
+    (.add.z.vf.x vf1 vf1 vf1)
     (.mov v0-0 vf1)
     v0-0
     )
@@ -721,11 +721,11 @@
     (.lvf vf1 (&-> arg0 quad))
     (.lvf vf2 (&-> arg1 quad))
     (.mul.vf vf1 vf1 vf2)
-    (.add.w.vf vf3 vf0 vf0 :mask #b1)
-    (.mul.x.vf acc vf3 vf1 :mask #b1)
-    (.add.mul.y.vf acc vf3 vf1 acc :mask #b1)
-    (.add.mul.z.vf acc vf3 vf1 acc :mask #b1)
-    (.add.mul.w.vf vf1 vf3 vf1 acc :mask #b1)
+    (.add.w.vf.x vf3 vf0 vf0)
+    (.mul.x.vf.x acc vf3 vf1)
+    (.add.mul.y.vf.x acc vf3 vf1 acc)
+    (.add.mul.z.vf.x acc vf3 vf1 acc)
+    (.add.mul.w.vf.x vf1 vf3 vf1 acc)
     (.mov v0-0 vf1)
     v0-0
     )

test/decompiler/reference/jak1/engine/math/vector_REF.gc

@@ -16,8 +16,8 @@
     (init-vf0-vector)
     (.mov vf6 arg2)
     (.lvf vf4 (&-> arg1 quad))
-    (.add.x.vf vf5 vf0 vf0 :mask #b1000)
-    (.add.x.vf vf5 vf4 vf6 :mask #b111)
+    (.add.x.vf.w vf5 vf0 vf0)
+    (.add.x.vf.xyz vf5 vf4 vf6)
     (.svf (&-> arg0 quad) vf5)
     arg0
     )
@@ -41,9 +41,9 @@
     (.mov vf7 arg3)
     (.lvf vf5 (&-> arg2 quad))
     (.lvf vf4 (&-> arg1 quad))
-    (.add.x.vf vf6 vf0 vf0 :mask #b1000)
-    (.mul.x.vf acc vf5 vf7 :mask #b111)
-    (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+    (.add.x.vf.w vf6 vf0 vf0)
+    (.mul.x.vf.xyz acc vf5 vf7)
+    (.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
     (.svf (&-> arg0 quad) vf6)
     arg0
     )
@@ -62,9 +62,9 @@
     (.mov vf7 arg3)
     (.lvf vf5 (&-> arg2 quad))
     (.lvf vf4 (&-> arg1 quad))
-    (.add.x.vf vf6 vf0 vf0 :mask #b1000)
-    (.mul.w.vf acc vf4 vf0 :mask #b111)
-    (.sub.mul.x.vf vf6 vf5 vf7 acc :mask #b111)
+    (.add.x.vf.w vf6 vf0 vf0)
+    (.mul.w.vf.xyz acc vf4 vf0)
+    (.sub.mul.x.vf.xyz vf6 vf5 vf7 acc)
     (.svf (&-> arg0 quad) vf6)
     arg0
     )
@@ -82,19 +82,19 @@
     (init-vf0-vector)
     (.lvf vf5 (&-> arg2 quad))
     (.div.vf Q vf0 vf5 :fsf #b11 :ftf #b1)
-    (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf6 vf0 vf0)
     (.lvf vf4 (&-> arg1 quad))
     (let ((v1-0 (/ (-> arg1 x) (-> arg2 x))))
       (.wait.vf)
-      (.mul.vf vf6 vf4 Q :mask #b10)
+      (.mul.vf.y vf6 vf4 Q)
       (.nop.vf)
       (.nop.vf)
       (.div.vf Q vf0 vf5 :fsf #b11 :ftf #b10)
       (.mov vf7 v1-0)
       )
-    (.add.x.vf vf6 vf0 vf7 :mask #b1)
+    (.add.x.vf.x vf6 vf0 vf7)
     (.wait.vf)
-    (.mul.vf vf6 vf4 Q :mask #b100)
+    (.mul.vf.z vf6 vf4 Q)
     (.nop.vf)
     (.nop.vf)
     (.svf (&-> arg0 quad) vf6)
@@ -111,8 +111,8 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> arg1 quad))
     (.mov vf2 arg2)
-    (.add.x.vf vf1 vf0 vf0 :mask #b1000)
-    (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+    (.add.x.vf.w vf1 vf0 vf0)
+    (.mul.x.vf.xyz vf1 vf1 vf2)
     (.svf (&-> arg0 quad) vf1)
     arg0
     )
@@ -133,9 +133,9 @@
       (.lvf vf2 (&-> arg2 quad))
       (.mov vf3 v1-0)
       )
-    (.add.x.vf vf4 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf4 vf0 vf0)
     (.mul.x.vf acc vf1 vf3)
-    (.add.mul.x.vf vf4 vf2 vf3 acc :mask #b111)
+    (.add.mul.x.vf.xyz vf4 vf2 vf3 acc)
     (.svf (&-> arg0 quad) vf4)
     arg0
     )
@@ -154,9 +154,9 @@
     (.lvf vf2 (&-> arg2 quad))
     (.lvf vf1 (&-> arg1 quad))
     (.mov vf3 arg3)
-    (.add.x.vf vf4 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf4 vf0 vf0)
     (.mul.x.vf acc vf2 vf3)
-    (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111)
+    (.add.mul.w.vf.xyz vf4 vf1 vf0 acc)
     (.svf (&-> arg0 quad) vf4)
     arg0
     )
@@ -175,9 +175,9 @@
     (.lvf vf2 (&-> arg2 quad))
     (.lvf vf1 (&-> arg1 quad))
     (.mov vf3 arg3)
-    (.add.x.vf vf4 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf4 vf0 vf0)
     (.mul.w.vf acc vf1 vf0)
-    (.sub.mul.x.vf vf4 vf2 vf3 acc :mask #b111)
+    (.sub.mul.x.vf.xyz vf4 vf2 vf3 acc)
     (.svf (&-> arg0 quad) vf4)
     arg0
     )
@@ -195,9 +195,9 @@
     (.mov vf3 arg2)
     (.div.vf Q vf0 vf3 :fsf #b11 :ftf #b0)
     (.lvf vf1 (&-> arg1 quad))
-    (.add.x.vf vf4 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf4 vf0 vf0)
     (.wait.vf)
-    (.mul.vf vf4 vf1 Q :mask #b111)
+    (.mul.vf.xyz vf4 vf1 Q)
     (.nop.vf)
     (.nop.vf)
     (.svf (&-> arg0 quad) vf4)
@@ -213,8 +213,8 @@
          )
     (init-vf0-vector)
     (.lvf vf1 (&-> arg1 quad))
-    (.sub.vf vf4 vf0 vf1 :mask #b111)
-    (.add.x.vf vf4 vf0 vf0 :mask #b1000)
+    (.sub.vf.xyz vf4 vf0 vf1)
+    (.add.x.vf.w vf4 vf0 vf0)
     (.svf (&-> arg0 quad) vf4)
     arg0
     )
@@ -227,7 +227,7 @@
          )
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 quad))
-    (.sub.vf vf1 vf0 vf1 :mask #b111)
+    (.sub.vf.xyz vf1 vf0 vf1)
     (.svf (&-> arg0 quad) vf1)
     arg0
     )
@@ -250,10 +250,10 @@
     (.lvf vf2 (&-> arg1 quad))
     (.sub.vf vf1 vf2 vf1)
     (.abs.vf vf1 vf1)
-    (.mul.x.vf acc vf0 vf1 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000)
-    (.add.mul.z.vf vf3 vf0 vf1 acc :mask #b1000)
-    (.add.w.vf vf3 vf0 vf3 :mask #b1)
+    (.mul.x.vf.w acc vf0 vf1)
+    (.add.mul.y.vf.w acc vf0 vf1 acc)
+    (.add.mul.z.vf.w vf3 vf0 vf1 acc)
+    (.add.w.vf.x vf3 vf0 vf3)
     (.mov v0-0 vf3)
     v0-0
     )
@@ -272,12 +272,12 @@
     (.mov vf4 arg2)
     (.lvf vf1 (&-> arg1 quad))
     (.lvf vf2 (&-> arg0 quad))
-    (.add.x.vf vf1 vf0 vf0 :mask #b1000)
-    (.sub.x.vf vf5 vf0 vf4 :mask #b1)
-    (.sub.vf vf3 vf1 vf2 :mask #b111)
-    (.min.x.vf vf3 vf3 vf4 :mask #b111)
-    (.max.x.vf vf3 vf3 vf5 :mask #b111)
-    (.add.vf vf1 vf2 vf3 :mask #b111)
+    (.add.x.vf.w vf1 vf0 vf0)
+    (.sub.x.vf.x vf5 vf0 vf4)
+    (.sub.vf.xyz vf3 vf1 vf2)
+    (.min.x.vf.xyz vf3 vf3 vf4)
+    (.max.x.vf.xyz vf3 vf3 vf5)
+    (.add.vf.xyz vf1 vf2 vf3)
     (.svf (&-> arg0 quad) vf1)
     arg0
     )
@@ -470,8 +470,8 @@
       (.mov at-0 f0-0)
       )
     (.mov vf2 at-0)
-    (.mov.vf vf1 vf0 :mask #b1000)
-    (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+    (.mov.vf.w vf1 vf0)
+    (.mul.x.vf.xyz vf1 vf1 vf2)
     (.svf (&-> arg0 quad) vf1)
     arg0
     )
@@ -490,8 +490,8 @@
       (.mov at-0 f0-0)
       )
     (.mov vf2 at-0)
-    (.mov.vf vf1 vf0 :mask #b1000)
-    (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+    (.mov.vf.w vf1 vf0)
+    (.mul.x.vf.xyz vf1 vf1 vf2)
     (.svf (&-> arg0 quad) vf1)
     arg0
     )
@@ -512,11 +512,11 @@
          )
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 quad))
-    (.add.w.vf vf2 vf0 vf0 :mask #b1)
+    (.add.w.vf.x vf2 vf0 vf0)
     (.mul.vf vf1 vf1 vf1)
-    (.mul.x.vf acc vf2 vf1 :mask #b1)
-    (.add.mul.y.vf acc vf2 vf1 acc :mask #b1)
-    (.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1)
+    (.mul.x.vf.x acc vf2 vf1)
+    (.add.mul.y.vf.x acc vf2 vf1 acc)
+    (.add.mul.z.vf.x vf1 vf2 vf1 acc)
     (.mov v0-0 vf1)
     v0-0
     )
@@ -547,13 +547,13 @@
     (.lvf vf3 (&-> arg1 quad))
     (.sub.vf vf1 vf3 vf2)
     (.mul.vf vf1 vf1 vf1)
-    (.mul.x.vf acc vf0 vf1 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000)
-    (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1000)
+    (.mul.x.vf.w acc vf0 vf1)
+    (.add.mul.y.vf.w acc vf0 vf1 acc)
+    (.add.mul.z.vf.w vf1 vf0 vf1 acc)
     (.sqrt.vf Q vf1 :ftf #b11)
-    (.add.w.vf vf1 vf0 vf0 :mask #b1)
+    (.add.w.vf.x vf1 vf0 vf0)
     (.wait.vf)
-    (.mul.vf vf1 vf1 Q :mask #b1)
+    (.mul.vf.x vf1 vf1 Q)
     (.nop.vf)
     (.nop.vf)
     (.mov v0-0 vf1)
@@ -572,8 +572,8 @@
     (.lvf vf3 (&-> arg1 quad))
     (.sub.vf vf1 vf3 vf2)
     (.mul.vf vf1 vf1 vf1)
-    (.add.y.vf vf1 vf1 vf1 :mask #b1)
-    (.add.z.vf vf1 vf1 vf1 :mask #b1)
+    (.add.y.vf.x vf1 vf1 vf1)
+    (.add.z.vf.x vf1 vf1 vf1)
     (.mov v0-0 vf1)
     v0-0
     )
@@ -594,12 +594,12 @@
     (.lvf vf3 (&-> arg1 quad))
     (.sub.vf vf1 vf3 vf2)
     (.mul.vf vf1 vf1 vf1)
-    (.mul.x.vf acc vf0 vf1 :mask #b1000)
-    (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1000)
+    (.mul.x.vf.w acc vf0 vf1)
+    (.add.mul.z.vf.w vf1 vf0 vf1 acc)
     (.sqrt.vf Q vf1 :ftf #b11)
-    (.add.w.vf vf1 vf0 vf0 :mask #b1)
+    (.add.w.vf.x vf1 vf0 vf0)
     (.wait.vf)
-    (.mul.vf vf1 vf1 Q :mask #b1)
+    (.mul.vf.x vf1 vf1 Q)
     (.nop.vf)
     (.nop.vf)
     (.mov v0-0 vf1)
@@ -618,7 +618,7 @@
     (.lvf vf3 (&-> arg1 quad))
     (.sub.vf vf1 vf3 vf2)
     (.mul.vf vf1 vf1 vf1)
-    (.add.z.vf vf1 vf1 vf1 :mask #b1)
+    (.add.z.vf.x vf1 vf1 vf1)
     (.mov v0-0 vf1)
     v0-0
     )
@@ -635,16 +635,16 @@
          )
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 quad))
-    (.mul.vf vf2 vf1 vf1 :mask #b111)
+    (.mul.vf.xyz vf2 vf1 vf1)
     (let ((v1-0 arg1))
       (.mov vf3 v1-0)
       )
-    (.mul.x.vf acc vf0 vf2 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000)
-    (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000)
+    (.mul.x.vf.w acc vf0 vf2)
+    (.add.mul.y.vf.w acc vf0 vf2 acc)
+    (.add.mul.z.vf.w vf2 vf0 vf2 acc)
     (.isqrt.vf Q vf3 vf2 :fsf #b0 :ftf #b11)
     (.wait.vf)
-    (.mul.vf vf1 vf1 Q :mask #b111)
+    (.mul.vf.xyz vf1 vf1 Q)
     (.nop.vf)
     (.nop.vf)
     (.nop.vf)
@@ -665,19 +665,19 @@
          )
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 quad))
-    (.mul.vf vf2 vf1 vf1 :mask #b111)
+    (.mul.vf.xyz vf2 vf1 vf1)
     (let ((v1-0 arg1))
       (.mov vf3 v1-0)
       )
-    (.mul.x.vf acc vf0 vf2 :mask #b1000)
-    (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000)
-    (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000)
+    (.mul.x.vf.w acc vf0 vf2)
+    (.add.mul.y.vf.w acc vf0 vf2 acc)
+    (.add.mul.z.vf.w vf2 vf0 vf2 acc)
     (.isqrt.vf Q vf3 vf2 :fsf #b0 :ftf #b11)
-    (.add.w.vf vf2 vf0 vf2 :mask #b1)
+    (.add.w.vf.x vf2 vf0 vf2)
     (.mov v1-1 vf2)
     (let ((v0-0 (sqrtf v1-1)))
       (.wait.vf)
-      (.mul.vf vf1 vf1 Q :mask #b111)
+      (.mul.vf.xyz vf1 vf1 Q)
       (.nop.vf)
       (.nop.vf)
       (.nop.vf)
@@ -838,10 +838,10 @@
     (.lvf vf1 (&-> a quad))
     (.lvf vf2 (&-> b quad))
     (.mov vf4 alpha)
-    (.add.x.vf vf3 vf0 vf0 :mask #b1000)
+    (.add.x.vf.w vf3 vf0 vf0)
     (.sub.vf vf2 vf2 vf1)
     (.mul.x.vf vf2 vf2 vf4)
-    (.add.vf vf3 vf1 vf2 :mask #b111)
+    (.add.vf.xyz vf3 vf1 vf2)
     (.svf (&-> out quad) vf3)
     out
     )
@@ -873,10 +873,10 @@
               (.mov vf4 a1-1)
               )
             )
-          (.add.x.vf vf3 vf0 vf0 :mask #b1000)
+          (.add.x.vf.w vf3 vf0 vf0)
           (.sub.vf vf2 vf2 vf1)
           (.mul.x.vf vf2 vf2 vf4)
-          (.add.vf vf3 vf1 vf2 :mask #b111)
+          (.add.vf.xyz vf3 vf1 vf2)
           (.svf (&-> v1-2 quad) vf3)
           )
         )
@@ -1084,13 +1084,13 @@
     (init-vf0-vector)
     (.lvf vf1 (&-> arg0 quad))
     (.lvf vf2 (&-> arg1 quad))
-    (.sub.vf vf3 vf1 vf2 :mask #b111)
-    (.mul.vf vf3 vf3 vf3 :mask #b111)
-    (.add.w.vf vf4 vf1 vf2 :mask #b1000)
-    (.mul.w.vf vf4 vf4 vf4 :mask #b1000)
-    (.add.y.vf vf3 vf3 vf3 :mask #b1)
-    (.add.z.vf vf3 vf3 vf3 :mask #b1)
-    (.add.w.vf vf4 vf0 vf4 :mask #b1)
+    (.sub.vf.xyz vf3 vf1 vf2)
+    (.mul.vf.xyz vf3 vf3 vf3)
+    (.add.w.vf.w vf4 vf1 vf2)
+    (.mul.w.vf.w vf4 vf4 vf4)
+    (.add.y.vf.x vf3 vf3 vf3)
+    (.add.z.vf.x vf3 vf3 vf3)
+    (.add.w.vf.x vf4 vf0 vf4)
     (.mov a0-1 vf4)
     (.mov v1-0 vf3)
     (>= a0-1 v1-0)

test/decompiler/reference/jak1/engine/nav/navigate_REF.gc

@@ -331,11 +331,11 @@
          )
     (.lvf vf1 (&-> arg1 quad))
     (.lvf vf2 (&-> arg2 quad))
-    (.sub.vf vf1 vf1 vf1 :mask #b1010)
+    (.sub.vf.yw vf1 vf1 vf1)
     (.lvf vf3 (&-> arg3 quad))
-    (.sub.vf vf2 vf2 vf2 :mask #b1010)
+    (.sub.vf.yw vf2 vf2 vf2)
     (.lvf vf12 (&-> arg0 quad))
-    (.sub.vf vf3 vf3 vf3 :mask #b1010)
+    (.sub.vf.yw vf3 vf3 vf3)
     (.sub.vf vf4 vf2 vf1)
     (.sub.vf vf9 vf1 vf12)
     (.sub.vf vf5 vf3 vf2)
@@ -448,11 +448,11 @@
             (when (>= arg3 f0-3)
               (.lvf vf1 (&-> v1-5 quad))
               (.lvf vf2 (&-> a1-5 quad))
-              (.sub.vf vf1 vf1 vf1 :mask #b1010)
+              (.sub.vf.yw vf1 vf1 vf1)
               (.lvf vf3 (&-> a0-2 quad))
-              (.sub.vf vf2 vf2 vf2 :mask #b1010)
+              (.sub.vf.yw vf2 vf2 vf2)
               (.lvf vf12 (&-> arg2 quad))
-              (.sub.vf vf3 vf3 vf3 :mask #b1010)
+              (.sub.vf.yw vf3 vf3 vf3)
               (.sub.vf vf4 vf2 vf1)
               (.sub.vf vf9 vf1 vf12)
               (.sub.vf vf5 vf3 vf2)
@@ -846,19 +846,19 @@
                       )
                     )
                   )
-                (.min.vf vf1 vf3 vf4 :mask #b111)
+                (.min.vf.xyz vf1 vf3 vf4)
                 (.lvf vf6 (&-> arg0 quad))
-                (.add.y.vf vf7 vf3 vf4 :mask #b10)
+                (.add.y.vf.y vf7 vf3 vf4)
                 (.svf (&-> s2-0 0 quad) vf3)
-                (.max.vf vf2 vf3 vf4 :mask #b111)
+                (.max.vf.xyz vf2 vf3 vf4)
                 (.svf (&-> s2-0 1 quad) vf4)
-                (.min.vf vf1 vf1 vf5 :mask #b111)
+                (.min.vf.xyz vf1 vf1 vf5)
                 (.svf (&-> s2-0 2 quad) vf5)
-                (.max.vf vf2 vf2 vf5 :mask #b111)
-                (.mul.x.vf vf7 vf7 vf7 :mask #b10)
+                (.max.vf.xyz vf2 vf2 vf5)
+                (.mul.x.vf.y vf7 vf7 vf7)
                 (.svf (&-> s2-0 3 quad) vf1)
                 (.svf (&-> s2-0 4 quad) vf2)
-                (.sub.y.vf vf7 vf6 vf7 :mask #b10)
+                (.sub.y.vf.y vf7 vf6 vf7)
                 (.mov v1-10 vf7)
                 (let ((v1-11 (the-as number (sar (the-as int v1-10) 32))))
                   (when (and (>= arg2 (fabs (the-as float v1-11)))
@@ -1648,7 +1648,7 @@
     (set! (-> s4-0 vector 0 quad) (-> this vertex (-> arg0 vertex 0) quad))
     (set! (-> s4-0 vector 1 quad) (-> this vertex (-> arg0 vertex 1) quad))
     (set! (-> s4-0 vector 2 quad) (-> this vertex (-> arg0 vertex 2) quad))
-    (normal-of-plane s3-0 (the-as vector (-> s4-0 vector)) (-> s4-0 vector 1) (-> s4-0 vector 2))
+    (normal-of-plane s3-0 (-> s4-0 vector 0) (-> s4-0 vector 1) (-> s4-0 vector 2))
     (closest-pt-in-triangle arg1 arg2 s4-0 s3-0)
     )
   (none)
@@ -1929,7 +1929,7 @@
           (add-debug-sphere
             #t
             (bucket-id debug-no-zbuf)
-            (the-as vector (-> this shape root-prim prim-core))
+            (-> this shape root-prim prim-core world-sphere)
             (-> this shape nav-radius)
             (new 'static 'rgba :g #xff :b #xff :a #x20)
             )
@@ -2456,9 +2456,9 @@
             (f1-0 (-> sv-208 w))
             )
         (when (< f0-10 (* f1-0 f1-0))
-          (vector-! (the-as vector (-> gp-0 temp-dir)) arg1 (the-as vector sv-208))
+          (vector-! (-> gp-0 temp-dir 0) arg1 (the-as vector sv-208))
           (set! (-> gp-0 temp-dir 0 y) 0.0)
-          (if (< 0.0 (vector-dot (the-as vector (-> gp-0 temp-dir)) (-> gp-0 in-dir)))
+          (if (< 0.0 (vector-dot (-> gp-0 temp-dir 0) (-> gp-0 in-dir)))
               (+! (-> gp-0 initial-ignore-mask) (ash 1 s0-0))
               )
           (set! (-> gp-0 inside-dist) (- (-> sv-208 w) (sqrtf (-> gp-0 dist2))))
@@ -2486,7 +2486,7 @@
       )
     (+! (-> gp-0 initial-ignore-mask) (ash 1 (-> gp-0 i-first-sphere)))
     (let ((a1-9 (-> this sphere (-> gp-0 i-first-sphere))))
-      (circle-tangent-directions arg1 a1-9 (the-as vector (-> gp-0 temp-dir)) (-> gp-0 temp-dir 1))
+      (circle-tangent-directions arg1 a1-9 (-> gp-0 temp-dir 0) (-> gp-0 temp-dir 1))
       )
     (dotimes (v1-31 2)
       (let ((a0-28 (vector-dot (-> gp-0 right-dir) (-> gp-0 temp-dir v1-31))))
@@ -2508,12 +2508,7 @@
       (b! #t cfg-31 :delay (nop!))
       (label cfg-22)
       (+! (-> gp-0 ignore-mask) (ash 1 v1-38))
-      (circle-tangent-directions
-        arg1
-        (-> this sphere v1-38)
-        (the-as vector (-> gp-0 temp-dir))
-        (-> gp-0 temp-dir 1)
-        )
+      (circle-tangent-directions arg1 (-> this sphere v1-38) (-> gp-0 temp-dir 0) (-> gp-0 temp-dir 1))
       (set! (-> gp-0 dir-update) #f)
       (dotimes (v1-40 2)
         (let ((f0-23 (-> gp-0 sign))
@@ -2560,18 +2555,18 @@
           )
         (vector-normalize! (-> gp-0 away-dir) 1.0)
         (let ((f30-2 (/ (-> gp-0 inside-sphere-dist) (-> s2-1 w))))
-          (vector-lerp! (the-as vector (-> gp-0 best-dir)) (the-as vector (-> gp-0 best-dir)) (-> gp-0 away-dir) f30-2)
+          (vector-lerp! (-> gp-0 best-dir 0) (-> gp-0 best-dir 0) (-> gp-0 away-dir) f30-2)
           (vector-lerp! (-> gp-0 best-dir 1) (-> gp-0 best-dir 1) (-> gp-0 away-dir) f30-2)
           )
         )
-      (vector-normalize! (the-as vector (-> gp-0 best-dir)) 1.0)
+      (vector-normalize! (-> gp-0 best-dir 0) 1.0)
       (vector-normalize! (-> gp-0 best-dir 1) 1.0)
       )
-    (let ((f30-3 (vector-dot (-> gp-0 in-dir) (the-as vector (-> gp-0 best-dir))))
+    (let ((f30-3 (vector-dot (-> gp-0 in-dir) (-> gp-0 best-dir 0)))
           (f28-0 (vector-dot (-> gp-0 in-dir) (-> gp-0 best-dir 1)))
           )
       (when (< (fmax f30-3 f28-0) (cos 1820.4445))
-        (set! f30-3 (vector-dot arg3 (the-as vector (-> gp-0 best-dir))))
+        (set! f30-3 (vector-dot arg3 (-> gp-0 best-dir 0)))
         (set! f28-0 (vector-dot arg3 (-> gp-0 best-dir 1)))
         )
       (vector-float*!

test/decompiler/reference/jak1/engine/ps2/rpc-h_REF.gc

@@ -36,7 +36,7 @@
     (set! (-> v0-0 elt-count) arg1)
     (set! (-> v0-0 elt-used) (the-as uint 0))
     (set! (-> v0-0 busy) #f)
-    (set! (-> v0-0 base) (logand -64 (&-> (-> v0-0 data) 63)))
+    (set! (-> v0-0 base) (logand -64 (&-> v0-0 data 63)))
     v0-0
     )
   )

test/decompiler/reference/jak1/engine/target/collide-reaction-target_REF.gc

@@ -288,7 +288,7 @@
       (move-by-vector! arg0 (vector-normalize-copy! (new-stack-vector0) sv-84 3.0))
       )
   (set! (-> arg0 poly-normal quad) (-> arg1 best-tri normal quad))
-  (collide-shape-moving-angle-set! arg0 sv-84 (the-as vector (-> sv-88 vector)))
+  (collide-shape-moving-angle-set! arg0 sv-84 (-> sv-88 vector 0))
   (if (< (-> arg0 poly-angle) -0.2)
       (set! sv-96 (logior sv-96 16))
       )
@@ -319,10 +319,10 @@
       (let ((f30-0 (- 1.0 (-> arg0 surf impact-fric))))
         (when (< f30-0 1.0)
           (let ((s3-1 (new-stack-vector0))
-                (f28-0 (vector-dot (-> arg0 dynam gravity-normal) (the-as vector (-> sv-88 vector))))
+                (f28-0 (vector-dot (-> arg0 dynam gravity-normal) (-> sv-88 vector 0)))
                 )
             0.0
-            (vector-! s3-1 (the-as vector (-> sv-88 vector)) (vector-float*! s3-1 (-> arg0 dynam gravity-normal) f28-0))
+            (vector-! s3-1 (-> sv-88 vector 0) (vector-float*! s3-1 (-> arg0 dynam gravity-normal) f28-0))
             (let* ((f0-20 (vector-length s3-1))
                    (f1-9 f0-20)
                    )
@@ -330,8 +330,8 @@
                   (set! f28-0 (* f28-0 f30-0))
                   )
               (vector+!
-                (the-as vector (-> sv-88 vector))
-                (vector-float*! (the-as vector (-> sv-88 vector)) (-> arg0 dynam gravity-normal) f28-0)
+                (-> sv-88 vector 0)
+                (vector-float*! (-> sv-88 vector 0) (-> arg0 dynam gravity-normal) f28-0)
                 (vector-float*! s3-1 s3-1 (/ f0-20 f1-9))
                 )
               )
@@ -368,10 +368,10 @@
         (#f
           (sound-play "cursor-options")
           (set! sv-104 (logior sv-104 8192))
-          (vector-reflect-flat-above! arg2 (the-as vector (-> sv-88 vector)) sv-84)
+          (vector-reflect-flat-above! arg2 (-> sv-88 vector 0) sv-84)
           )
         (else
-          (vector-reflect-flat! arg2 (the-as vector (-> sv-88 vector)) sv-84)
+          (vector-reflect-flat! arg2 (-> sv-88 vector 0) sv-84)
           )
         )
       (cond
@@ -393,7 +393,7 @@
           (set! sv-104 (logand -65 sv-104))
           (let ((s3-4 (vector-cross! (new 'stack-no-clear 'vector) (-> arg0 poly-normal) (-> arg0 ground-poly-normal))))
             (vector-normalize! s3-4 1.0)
-            (vector-float*! arg2 s3-4 (vector-dot (the-as vector (-> sv-88 vector)) s3-4))
+            (vector-float*! arg2 s3-4 (vector-dot (-> sv-88 vector 0) s3-4))
             )
           (vector+! arg2 arg2 (-> arg0 poly-normal))
           )
@@ -405,7 +405,7 @@
       (if (= (-> arg1 best-from-prim prim-id) 6)
           (set! (-> arg0 local-normal quad) (-> sv-84 quad))
           )
-      (vector-reflect-flat! arg2 (the-as vector (-> sv-88 vector)) sv-84)
+      (vector-reflect-flat! arg2 (-> sv-88 vector 0) sv-84)
       (vector+! arg2 arg2 sv-84)
       (set! (-> arg0 ground-touch-point w) 0.0)
       (when (not (or (logtest? sv-104 15) (nonzero? (-> arg0 poly-pat event))))

test/decompiler/reference/jak1/engine/target/logic-target_REF.gc

@@ -783,7 +783,7 @@
                               (-> self control dynam gravity-normal)
                               (vector-!
                                 (new 'stack-no-clear 'vector)
-                                (the-as vector (-> self control unknown-sphere-array00 1 prim-core))
+                                (-> self control unknown-sphere-array00 1 prim-core world-sphere)
                                 (-> self control unknown-vector70)
                                 )
                               )
@@ -1264,7 +1264,7 @@
         )
     (set! (-> self control ground-pat) (the-as pat-surface (-> s5-0 edge-tri-pat)))
     (vector-normalize!
-      (vector-! (-> self control unknown-vector100) (the-as vector (-> s5-0 world-vertex)) (-> s5-0 world-vertex 1))
+      (vector-! (-> self control unknown-vector100) (-> s5-0 world-vertex 0) (-> s5-0 world-vertex 1))
       1.0
       )
     (let ((gp-1 (vector-cross!
@@ -1322,7 +1322,7 @@
         (debug-draw gp-0)
         )
     (vector-normalize!
-      (vector-! (-> self control unknown-vector100) (the-as vector (-> gp-0 world-vertex)) (-> gp-0 world-vertex 1))
+      (vector-! (-> self control unknown-vector100) (-> gp-0 world-vertex 0) (-> gp-0 world-vertex 1))
       1.0
       )
     (vector-cross!
@@ -1445,45 +1445,36 @@
               (< (fabs (- (-> gp-0 y) (-> self control trans y))) 8192.0)
               )
             )
-       (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> gp-0 quad))
+       (set! (-> (&-> self control unknown-qword00) 0) (-> gp-0 quad))
        )
       (else
         (let ((v1-11 (-> self water flags)))
           (cond
             ((and (logtest? v1-11 (water-flags wt09)) (logtest? v1-11 (water-flags wt11 wt12)))
-             (vector<-cspace!
-               (the-as vector (&-> (-> self control) unknown-qword00))
-               (the-as cspace (-> self node-list data))
-               )
+             (vector<-cspace! (the-as vector (&-> self control unknown-qword00)) (-> self node-list data 0))
              (if (not (and (logtest? (-> self water flags) (water-flags wt12))
                            (not (logtest? (-> self water flags) (water-flags wt04)))
                            )
                       )
                  (set! (-> self control unknown-float30) (- (-> self water base-height) (-> self water swim-height)))
                  )
-             (&-> (-> self control) unknown-qword00)
+             (&-> self control unknown-qword00)
              )
             ((and (logtest? (-> self water flags) (water-flags wt09)) (logtest? (water-flags wt18) (-> self water flags)))
-             (vector<-cspace!
-               (the-as vector (&-> (-> self control) unknown-qword00))
-               (the-as cspace (-> self node-list data))
-               )
+             (vector<-cspace! (the-as vector (&-> self control unknown-qword00)) (-> self node-list data 0))
              (set! (-> self control unknown-float30) (-> self water base-height))
              )
             ((logtest? (-> self control root-prim prim-core action) (collide-action racer))
-             (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> self control trans quad))
+             (set! (-> (&-> self control unknown-qword00) 0) (-> self control trans quad))
              )
             ((logtest? (-> self control root-prim prim-core action) (collide-action tube))
-             (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> self control shadow-pos quad))
+             (set! (-> (&-> self control unknown-qword00) 0) (-> self control shadow-pos quad))
              )
             ((logtest? (-> self draw status) (draw-status hidden no-anim))
-             (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> self control trans quad))
+             (set! (-> (&-> self control unknown-qword00) 0) (-> self control trans quad))
              )
             (else
-              (vector<-cspace!
-                (the-as vector (&-> (-> self control) unknown-qword00))
-                (the-as cspace (-> self node-list data))
-                )
+              (vector<-cspace! (the-as vector (&-> self control unknown-qword00)) (-> self node-list data 0))
               )
             )
           )
@@ -1952,7 +1943,7 @@
     (quaternion-identity! (-> self control unknown-quaternion00))
     (quaternion-identity! (-> self control dir-targ))
     (set! (-> self control transv quad) (the-as uint128 0))
-    (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> self control trans quad))
+    (set! (-> (&-> self control unknown-qword00) 0) (-> self control trans quad))
     )
   (target-exit)
   (target-timed-invulnerable-off self)
@@ -2050,7 +2041,7 @@
   (backup-collide-with-as (-> self control))
   (set! (-> self game) *game-info*)
   (move-to-point! (-> self control) (-> arg0 trans))
-  (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> arg0 trans quad))
+  (set! (-> (&-> self control unknown-qword00) 0) (-> arg0 trans quad))
   (set! (-> self control unknown-cpad-info00) (-> *cpad-list* cpads 0))
   (set! (-> self control unknown-surface01) (new 'process 'surface))
   (set! (-> self control unknown-surface01 name) 'current)

test/decompiler/reference/jak1/engine/target/sidekick_REF.gc

@@ -43,8 +43,8 @@
       (.lvf vf5 (&-> s5-0 vector 2 quad))
       (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
       (.wait.vf)
-      (.mul.vf vf2 vf2 Q :mask #b111)
-      (.mov.vf vf2 vf0 :mask #b1000)
+      (.mul.vf.xyz vf2 vf2 Q)
+      (.mov.vf.w vf2 vf0)
       (.mul.x.vf vf3 vf3 vf1)
       (.mul.y.vf vf4 vf4 vf1)
       (.mul.z.vf vf5 vf5 vf1)

test/decompiler/reference/jak1/engine/target/target-death_REF.gc

@@ -78,7 +78,7 @@
     (quaternion-copy! (-> self control unknown-quaternion00) (-> arg0 quat))
     (move-to-point! (-> self control) (-> arg0 trans))
     (rot->dir-targ! (-> self control))
-    (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> self control trans quad))
+    (set! (-> (&-> self control unknown-qword00) 0) (-> self control trans quad))
     (cond
       ((not (string= (-> arg0 name) "default"))
        (set! *external-cam-mode* #f)
@@ -885,7 +885,7 @@
                     )
                   (move-to-point! (-> self control) s4-1)
                   )
-                (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> self control trans quad))
+                (set! (-> (&-> self control unknown-qword00) 0) (-> self control trans quad))
                 (send-event *camera* 'teleport)
                 (go target-stance)
                 )
@@ -988,7 +988,7 @@
     (compute-alignment! (-> self align))
     (let ((s5-0 (new 'stack-no-clear 'vector)))
       (when (not (logtest? (-> self align flags) (align-flags disabled)))
-        (vector-matrix*! s5-0 (the-as vector (-> self align delta)) (-> self control unknown-matrix01))
+        (vector-matrix*! s5-0 (-> self align delta trans) (-> self control unknown-matrix01))
         (vector-float*! (-> self control transv) s5-0 (-> *display* frames-per-second))
         )
       )

test/decompiler/reference/jak1/engine/target/target-handler_REF.gc

@@ -739,7 +739,7 @@
        )
      )
     (('launch)
-     (mem-copy! (&-> (-> self control) unknown-pointer00) (the-as pointer arg3) 72)
+     (mem-copy! (&-> self control unknown-pointer00) (the-as pointer arg3) 72)
      #t
      )
     (('powerup)
@@ -911,7 +911,7 @@
               (vector-normalize!
                 (vector-!
                   s4-0
-                  (the-as vector (-> self control unknown-sphere-array00 0 prim-core))
+                  (-> self control unknown-sphere-array00 0 prim-core world-sphere)
                   (-> self control unknown-vector72)
                   )
                 (the-as float 1.0)

test/decompiler/reference/jak1/engine/target/target-part_REF.gc

@@ -63,14 +63,14 @@
               ((< (-> s4-1 w) 0.0)
                (.lvf vf1 (&-> arg2 conerot quad))
                (.lvf vf2 (&-> s4-1 vec quad))
-               (.sub.vf vf1 vf0 vf2 :mask #b111)
+               (.sub.vf.xyz vf1 vf0 vf2)
                (.svf (&-> arg2 conerot quad) vf1)
                (.mov v1-11 vf1)
                )
               (else
                 (.lvf vf1 (&-> arg2 conerot quad))
                 (.lvf vf2 (&-> s4-1 vec quad))
-                (.add.vf vf1 vf0 vf2 :mask #b111)
+                (.add.vf.xyz vf1 vf0 vf2)
                 (.svf (&-> arg2 conerot quad) vf1)
                 (.mov v1-12 vf1)
                 )
@@ -112,14 +112,14 @@
           ((< (-> s5-0 w) 0.0)
            (.lvf vf1 (&-> arg2 conerot quad))
            (.lvf vf2 (&-> s5-0 vec quad))
-           (.sub.vf vf1 vf0 vf2 :mask #b111)
+           (.sub.vf.xyz vf1 vf0 vf2)
            (.svf (&-> arg2 conerot quad) vf1)
            (.mov v1-10 vf1)
            )
           (else
             (.lvf vf1 (&-> arg2 conerot quad))
             (.lvf vf2 (&-> s5-0 vec quad))
-            (.add.vf vf1 vf0 vf2 :mask #b111)
+            (.add.vf.xyz vf1 vf0 vf2)
             (.svf (&-> arg2 conerot quad) vf1)
             (.mov v1-11 vf1)
             )
@@ -156,14 +156,14 @@
             ((< (-> s5-0 w) 0.0)
              (.lvf vf1 (&-> arg2 conerot quad))
              (.lvf vf2 (&-> s5-0 vec quad))
-             (.sub.vf vf1 vf0 vf2 :mask #b111)
+             (.sub.vf.xyz vf1 vf0 vf2)
              (.svf (&-> arg2 conerot quad) vf1)
              (.mov v1-4 vf1)
              )
             (else
               (.lvf vf1 (&-> arg2 conerot quad))
               (.lvf vf2 (&-> s5-0 vec quad))
-              (.add.vf vf1 vf0 vf2 :mask #b111)
+              (.add.vf.xyz vf1 vf0 vf2)
               (.svf (&-> arg2 conerot quad) vf1)
               (.mov v1-5 vf1)
               )

test/decompiler/reference/jak1/engine/target/target-util_REF.gc

@@ -1277,7 +1277,7 @@
          )
         ((logtest? (state-flags falling-into-pool-of-bad) (-> gp-0 state-flags))
          (let ((s5-0 (the-as object (new 'static 'vector))))
-           (set! (-> (the-as vector s5-0) quad) (-> (&-> (-> gp-0 control) unknown-qword00) 0))
+           (set! (-> (the-as vector s5-0) quad) (-> (&-> gp-0 control unknown-qword00) 0))
            (set! (-> (the-as vector s5-0) y) (fmax (-> (the-as vector s5-0) y) (-> gp-0 alt-cam-pos y)))
            (add-debug-sphere
              *display-camera-marks*
@@ -1293,11 +1293,11 @@
           (add-debug-sphere
             *display-camera-marks*
             (bucket-id debug-no-zbuf)
-            (the-as vector (&-> (-> gp-0 control) unknown-qword00))
+            (the-as vector (&-> gp-0 control unknown-qword00))
             819.2
             (new 'static 'rgba :r #xff :a #x80)
             )
-          (&-> (-> gp-0 control) unknown-qword00)
+          (&-> gp-0 control unknown-qword00)
           )
         )
       )

test/decompiler/reference/jak1/engine/target/target2_REF.gc

@@ -548,11 +548,11 @@
                     )
                 (set! sv-48 s5-1)
                 (let ((v0-3 (camera-pos)))
-                  (.mov.vf vf6 vf0 :mask #b1000)
+                  (.mov.vf.w vf6 vf0)
                   (.lvf vf4 (&-> v0-3 quad))
                   )
                 (.lvf vf5 (&-> s5-1 quad))
-                (.add.vf vf6 vf4 vf5 :mask #b111)
+                (.add.vf.xyz vf6 vf4 vf5)
                 (.svf (&-> sv-48 quad) vf6)
                 (let ((t1-0 (if (>= (-> self fact eco-level) (-> *FACT-bank* eco-level-max))
                                 56
@@ -699,11 +699,11 @@
                     )
                 (set! sv-48 s5-1)
                 (let ((v0-4 (camera-pos)))
-                  (.mov.vf vf6 vf0 :mask #b1000)
+                  (.mov.vf.w vf6 vf0)
                   (.lvf vf4 (&-> v0-4 quad))
                   )
                 (.lvf vf5 (&-> s5-1 quad))
-                (.add.vf vf6 vf4 vf5 :mask #b111)
+                (.add.vf.xyz vf6 vf4 vf5)
                 (.svf (&-> sv-48 quad) vf6)
                 (let ((t1-0 (if (>= (-> self fact eco-level) (-> *FACT-bank* eco-level-max))
                                 120
@@ -1255,7 +1255,7 @@
         (target-compute-edge-rider)
         (compute-alignment! (-> self align))
         (when (not (logtest? (-> self align flags) (align-flags disabled)))
-          (vector-matrix*! s4-0 (the-as vector (-> self align delta)) (-> self control unknown-matrix01))
+          (vector-matrix*! s4-0 (-> self align delta trans) (-> self control unknown-matrix01))
           (move-by-vector! (-> self control) s4-0)
           )
         (suspend)
@@ -1284,7 +1284,7 @@
       (until (ja-done? 0)
         (compute-alignment! (-> self align))
         (when (not (logtest? (-> self align flags) (align-flags disabled)))
-          (vector-matrix*! gp-0 (the-as vector (-> self align delta)) (-> self control unknown-matrix01))
+          (vector-matrix*! gp-0 (-> self align delta trans) (-> self control unknown-matrix01))
           (move-by-vector! (-> self control) gp-0)
           )
         (suspend)
@@ -2751,7 +2751,7 @@
     (send-event (ppointer->process (-> self sidekick)) 'matrix 'normal)
     (send-event (ppointer->process (-> self sidekick)) 'shadow #t)
     (let ((gp-0 (joint-node eichar-lod0-jg main))
-          (a1-2 (&-> (-> self control) unknown-qword00))
+          (a1-2 (&-> self control unknown-qword00))
           )
       (cond
         ((not (-> self control unknown-spoolanim00))

test/decompiler/reference/jak1/engine/ui/text_REF.gc

@@ -239,22 +239,10 @@
         )
       )
     (set-vector! s5-0 128 128 128 128)
-    (add-debug-line2d
-      #t
-      (bucket-id debug-no-zbuf)
-      (the-as vector (-> gp-0 vector))
-      (-> gp-0 vector 1)
-      (the-as vector s5-0)
-      )
+    (add-debug-line2d #t (bucket-id debug-no-zbuf) (-> gp-0 vector 0) (-> gp-0 vector 1) (the-as vector s5-0))
     (add-debug-line2d #t (bucket-id debug-no-zbuf) (-> gp-0 vector 1) (-> gp-0 vector 2) (the-as vector s5-0))
     (add-debug-line2d #t (bucket-id debug-no-zbuf) (-> gp-0 vector 2) (-> gp-0 vector 3) (the-as vector s5-0))
-    (add-debug-line2d
-      #t
-      (bucket-id debug-no-zbuf)
-      (-> gp-0 vector 3)
-      (the-as vector (-> gp-0 vector))
-      (the-as vector s5-0)
-      )
+    (add-debug-line2d #t (bucket-id debug-no-zbuf) (-> gp-0 vector 3) (-> gp-0 vector 0) (the-as vector s5-0))
     )
   0
   (none)

test/decompiler/reference/jak1/kernel/gkernel_REF.gc

@@ -550,7 +550,6 @@
   )
 
 ;; definition for method 3 of type dead-pool-heap
-;; INFO: this function exists in multiple non-identical object files
 (defmethod inspect ((this dead-pool-heap))
   (format #t "[~8x] ~A~%" this (-> this type))
   (format #t "~Tname: ~A~%" (-> this name))
@@ -846,7 +845,7 @@
           (set! (-> s4-0 prev) a1-3)
           (set! (-> this alive-list prev) s4-0)
           (set! (-> s4-0 process)
-                (relocate (-> s4-0 process) (&- (gap-location this a1-3) (the-as uint (&-> (-> s4-0 process) type))))
+                (relocate (-> s4-0 process) (&- (gap-location this a1-3) (the-as uint (&-> s4-0 process type))))
                 )
           )
         )

test/decompiler/reference/jak1/levels/beach/lurkercrab_REF.gc

@@ -473,7 +473,7 @@ nav-enemy-default-event-handler
     (let ((a0-0 (-> self part))
           (a1-0 (-> self collide-info root-prim prim-core))
           )
-      (spawn a0-0 (the-as vector a1-0))
+      (spawn a0-0 (-> a1-0 world-sphere))
       )
     (nav-enemy-travel-post)
     )

test/decompiler/reference/jak1/levels/beach/pelican_REF.gc

@@ -586,7 +586,7 @@
   :post (behavior ()
     (when *target*
       (if *target*
-          (look-at-enemy! (-> *target* neck) (the-as vector (-> self root root-prim prim-core)) 'nothing self)
+          (look-at-enemy! (-> *target* neck) (-> self root root-prim prim-core world-sphere) 'nothing self)
           )
       (if (nonzero? (-> self neck))
           (set-target! (-> self neck) (target-pos 5))

test/decompiler/reference/jak1/levels/beach/seagull_REF.gc

@@ -594,8 +594,8 @@
           (.mov at-0 f0-0)
           )
         (.mov vf2 at-0)
-        (.mov.vf vf1 vf0 :mask #b1000)
-        (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+        (.mov.vf.w vf1 vf0)
+        (.mul.x.vf.xyz vf1 vf1 vf2)
         (.svf (&-> a2-0 quad) vf1)
         )
       (vector+! a1-1 a0-2 v1-0)

test/decompiler/reference/jak1/levels/citadel/citadel-part_REF.gc

@@ -617,14 +617,14 @@
           ((< (-> s5-0 w) 0.0)
            (.lvf vf1 (&-> arg2 vector 1 quad))
            (.lvf vf2 (&-> s5-0 quad))
-           (.sub.vf vf1 vf0 vf2 :mask #b111)
+           (.sub.vf.xyz vf1 vf0 vf2)
            (.svf (&-> arg2 vector 1 quad) vf1)
            (.mov v1-5 vf1)
            )
           (else
             (.lvf vf1 (&-> arg2 vector 1 quad))
             (.lvf vf2 (&-> s5-0 quad))
-            (.add.vf vf1 vf0 vf2 :mask #b111)
+            (.add.vf.xyz vf1 vf0 vf2)
             (.svf (&-> arg2 vector 1 quad) vf1)
             (.mov v1-6 vf1)
             )

test/decompiler/reference/jak1/levels/common/blocking-plane_REF.gc

@@ -67,14 +67,12 @@
       (vector+! (-> self root trans) s5-0 gp-0)
       (vector-float*! (-> self root trans) (-> self root trans) 0.5)
       (+! (-> self root trans y) 61440.0)
-      (vector-! (the-as vector (-> s4-2 vector)) gp-0 s5-0)
-      (set! (-> self root scale x)
-            (* 0.00024414062 (vector-normalize-ret-len! (the-as vector (-> s4-2 vector)) 1.0))
-            )
+      (vector-! (-> s4-2 vector 0) gp-0 s5-0)
+      (set! (-> self root scale x) (* 0.00024414062 (vector-normalize-ret-len! (-> s4-2 vector 0) 1.0)))
       (set! (-> self root scale y) 30.0)
       (set! (-> self root scale z) 0.0)
       (set! (-> s4-2 vector 1 quad) (-> (new 'static 'vector :y 1.0 :w 1.0) quad))
-      (vector-cross! (-> s4-2 vector 2) (the-as vector (-> s4-2 vector)) (-> s4-2 vector 1))
+      (vector-cross! (-> s4-2 vector 2) (-> s4-2 vector 0) (-> s4-2 vector 1))
       (vector-normalize! (-> s4-2 vector 2) 1.0)
       (matrix->quaternion (-> self root quat) s4-2)
       )

test/decompiler/reference/jak1/levels/finalboss/final-door_REF.gc

@@ -278,7 +278,7 @@
           (eval-position! gp-1 f0-2 (-> self root trans))
           )
         (transform-post)
-        (spawn (-> self part) (the-as vector (-> self root root-prim prim-core)))
+        (spawn (-> self part) (-> self root root-prim prim-core world-sphere))
         (suspend)
         (if (nonzero? (-> self skel))
             (ja :num! (loop! 0.5))

test/decompiler/reference/jak1/levels/finalboss/robotboss-weapon_REF.gc

@@ -32,7 +32,7 @@
         (s5-0 (new 'stack-no-clear 'vector))
         (f30-0 (+ (-> this radius-secondary) (-> arg0 world-sphere w)))
         )
-    (vector-! gp-0 (the-as vector arg0) (-> this origin))
+    (vector-! gp-0 (-> arg0 world-sphere) (-> this origin))
     (vector-flatten! s5-0 gp-0 (-> this axis))
     (vector-normalize! s5-0 (-> this radius-primary))
     (vector-! arg1 gp-0 s5-0)

test/decompiler/reference/jak1/levels/finalboss/robotboss_REF.gc

@@ -63,11 +63,7 @@
             (vector<-cspace! s4-1 (joint-node robotboss-basic-lod0-jg camera))
             (set! (-> *camera-other-trans* quad) (-> s4-1 quad))
             )
-          (vector-normalize-copy!
-            (the-as vector (-> *camera-other-matrix* vector))
-            (the-as vector (-> s5-1 vector))
-            (the-as float -1.0)
-            )
+          (vector-normalize-copy! (-> *camera-other-matrix* vector 0) (-> s5-1 vector 0) (the-as float -1.0))
           (set! (-> *camera-other-matrix* vector 0 w) 0.0)
           (vector-normalize-copy! (-> *camera-other-matrix* vector 1) (-> s5-1 vector 1) (the-as float 1.0))
           (set! (-> *camera-other-matrix* vector 1 w) 0.0)
@@ -295,7 +291,7 @@
       (set! (-> gp-0 x) 0.0)
       (vector-matrix*! gp-0 gp-0 s4-0)
       (vector+! (-> self root trans) gp-0 (-> self entity extra trans))
-      (vector-negate! (the-as vector (-> s4-0 vector)) (the-as vector (-> s4-0 vector)))
+      (vector-negate! (-> s4-0 vector 0) (-> s4-0 vector 0))
       (vector-negate! (-> s4-0 vector 2) (-> s4-0 vector 2))
       (matrix->quaternion (-> self root quat) s4-0)
       )
@@ -1360,19 +1356,14 @@
         (set! (-> s1-0 dest w) 1.0)
         )
       (dotimes (s1-1 s3-0)
-        (vector-! s4-0 (the-as vector (-> arg0 info s3-0)) (the-as vector (-> arg0 info s1-1)))
+        (vector-! s4-0 (-> arg0 info s3-0 dest) (-> arg0 info s1-1 dest))
         (let ((f0-13 (vector-length-squared s4-0)))
           (if (< f0-13 1073741800.0)
-              (vector+float*!
-                (the-as vector (-> arg0 info s3-0))
-                (the-as vector (-> arg0 info s1-1))
-                s4-0
-                (/ 32768.0 (sqrtf f0-13))
-                )
+              (vector+float*! (-> arg0 info s3-0 dest) (-> arg0 info s1-1 dest) s4-0 (/ 32768.0 (sqrtf f0-13)))
               )
           )
         )
-      (vector+! s5-0 s5-0 (the-as vector (-> arg0 info s3-0)))
+      (vector+! s5-0 s5-0 (-> arg0 info s3-0 dest))
       (let* ((f30-2 60.0)
              (v1-27 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
              (v1-28 (the-as number (logior #x3f800000 v1-27)))
@@ -1391,7 +1382,7 @@
     (vector-float*! s5-0 s5-0 0.16666667)
     (vector-! s5-0 (-> self entity extra trans) s5-0)
     (dotimes (v1-53 6)
-      (vector+! (the-as vector (-> arg0 info v1-53)) (the-as vector (-> arg0 info v1-53)) s5-0)
+      (vector+! (-> arg0 info v1-53 dest) (-> arg0 info v1-53 dest) s5-0)
       (+! (-> arg0 info v1-53 dest y) 2048.0)
       )
     )
@@ -1686,7 +1677,7 @@
               )
           (robotboss-yellow-eco-on)
           (robotboss-redshot-fill-array gp-1)
-          (robotboss-redshot (the-as redshot-launch-info (-> gp-1 info)) #t)
+          (robotboss-redshot (-> gp-1 info 0) #t)
           (let* ((v1-127 (+ s5-0 (the int (* f30-1 (the float (-> self dda red-shots-rnd))))))
                  (s5-1 (+ (min 6 v1-127) -1))
                  )

test/decompiler/reference/jak1/levels/flut_common/target-flut_REF.gc

@@ -775,11 +775,10 @@
                 (-> self control)
                 (the-as uint 6)
                 )
-               (< 0.0
-                  (vector-dot
-                    (-> self control dynam gravity-normal)
-                    (vector-! (new 'stack-no-clear 'vector) (the-as vector (-> self control trans-old)) (-> self control trans))
-                    )
+               (< 0.0 (vector-dot
+                        (-> self control dynam gravity-normal)
+                        (vector-! (new 'stack-no-clear 'vector) (-> self control trans-old 0) (-> self control trans))
+                        )
                   )
                )
       (send-event proc 'bonk (-> block param 0) (-> self control ground-impact-vel))
@@ -1408,11 +1407,10 @@
               (-> self control)
               (the-as uint 6)
               )
-             (< 0.0
-                (vector-dot
-                  (-> self control dynam gravity-normal)
-                  (vector-! (new 'stack-no-clear 'vector) (the-as vector (-> self control trans-old)) (-> self control trans))
-                  )
+             (< 0.0 (vector-dot
+                      (-> self control dynam gravity-normal)
+                      (vector-! (new 'stack-no-clear 'vector) (-> self control trans-old 0) (-> self control trans))
+                      )
                 )
              )
         (send-event proc 'bonk (-> block param 0) (-> self control ground-impact-vel))
@@ -1660,7 +1658,7 @@
                     )
                   (move-to-point! (-> self control) s4-1)
                   )
-                (set! (-> (&-> (-> self control) unknown-qword00) 0) (-> self control trans quad))
+                (set! (-> (&-> self control unknown-qword00) 0) (-> self control trans quad))
                 (send-event *camera* 'teleport)
                 (go target-flut-stance)
                 )
@@ -1803,7 +1801,7 @@
           (compute-alignment! (-> self align))
           (let ((gp-5 (new 'stack-no-clear 'vector)))
             (when (not (logtest? (-> self align flags) (align-flags disabled)))
-              (vector-matrix*! gp-5 (the-as vector (-> self align delta)) (-> self control unknown-matrix01))
+              (vector-matrix*! gp-5 (-> self align delta trans) (-> self control unknown-matrix01))
               (vector-float*! (-> self control transv) gp-5 (-> *display* frames-per-second))
               )
             )
@@ -1830,7 +1828,7 @@
   :exit (-> target-flut-start exit)
   :code (behavior ((arg0 handle))
     (set! (-> self control transv quad) (the-as uint128 0))
-    (set! (-> self alt-cam-pos quad) (-> (&-> (-> self control) unknown-qword00) 0))
+    (set! (-> self alt-cam-pos quad) (-> (&-> self control unknown-qword00) 0))
     (logior! (-> self state-flags) (state-flags use-alt-cam-pos))
     (set-time! (-> self state-time))
     (let ((gp-0 (new 'stack-no-clear 'vector)))

test/decompiler/reference/jak1/levels/jungle/fisher_REF.gc

@@ -1571,7 +1571,7 @@
   (set! (-> self paddle) (fmax 0.0 (fmin 1.0 (-> self paddle))))
   (vector-lerp!
     (-> self paddle-pos)
-    (the-as vector (-> self paddle-end))
+    (-> self paddle-end 0)
     (the-as vector (&-> self stack 288))
     (-> self paddle)
     )
@@ -2017,7 +2017,7 @@
         )
     (+! (-> s5-0 y) 2457.6)
     (vector-normalize! (vector-rotate-y! s4-0 s4-0 16384.0) (-> *FISHER-bank* width))
-    (vector-! (the-as vector (-> this paddle-end)) s5-0 s4-0)
+    (vector-! (-> this paddle-end 0) s5-0 s4-0)
     (vector+! (the-as vector (&-> this stack 288)) s5-0 s4-0)
     )
   (set! (-> this music) 'fishgame)

test/decompiler/reference/jak1/levels/jungle/jungle-mirrors_REF.gc

@@ -696,7 +696,7 @@
       (let ((v1-2 (-> self change-event-from)))
         (set! (-> self trans quad) (-> (the-as periscope (-> v1-2 0)) reflector-trans quad))
         (matrix-rotate-yx!
-          (the-as matrix (-> self tracking))
+          (-> self tracking inv-mat)
           (-> (the-as periscope (-> v1-2 0)) turn)
           (-> (the-as periscope (-> v1-2 0)) tilt)
           )
@@ -783,7 +783,7 @@
             )
           (+! f30-0 (* (-> s5-0 y) (-> *display* time-adjust-ratio)))
           (set! f28-0 (fmax -12743.111 (fmin 12743.111 (+ f28-0 (* (-> s5-0 x) (-> *display* time-adjust-ratio))))))
-          (matrix-rotate-yx! (the-as matrix (-> self tracking)) f30-0 f28-0)
+          (matrix-rotate-yx! (-> self tracking inv-mat) f30-0 f28-0)
           )
         (suspend)
         )

test/decompiler/reference/jak1/levels/jungle/jungle-obs_REF.gc

@@ -61,7 +61,7 @@
             (else
               (transform-post)
               (if *target*
-                  (look-at-enemy! (-> *target* neck) (the-as vector (-> self root root-prim prim-core)) #f self)
+                  (look-at-enemy! (-> *target* neck) (-> self root root-prim prim-core world-sphere) #f self)
                   )
               )
             )

test/decompiler/reference/jak1/levels/jungle/junglesnake_REF.gc

@@ -251,8 +251,8 @@ junglesnake-default-event-handler
           (vector-normalize-copy! (-> s3-1 vector 1) a1-7 1.0)
           )
         (set! (-> s3-1 vector 1 w) 0.0)
-        (vector-normalize! (vector-cross! (-> s3-1 vector 2) (the-as vector (-> s3-1 vector)) (-> s3-1 vector 1)) 1.0)
-        (vector-normalize! (vector-cross! (the-as vector (-> s3-1 vector)) (-> s3-1 vector 1) (-> s3-1 vector 2)) 1.0)
+        (vector-normalize! (vector-cross! (-> s3-1 vector 2) (-> s3-1 vector 0) (-> s3-1 vector 1)) 1.0)
+        (vector-normalize! (vector-cross! (-> s3-1 vector 0) (-> s3-1 vector 1) (-> s3-1 vector 2)) 1.0)
         )
       )
     (cond
@@ -391,7 +391,7 @@ junglesnake-default-event-handler
       (if *target*
           (look-at-enemy!
             (-> *target* neck)
-            (the-as vector (-> (the-as collide-shape-prim-group (-> self root root-prim)) prims 0 prim-core))
+            (-> (the-as collide-shape-prim-group (-> self root root-prim)) prims 0 prim-core world-sphere)
             'attacking
             self
             )
@@ -441,7 +441,7 @@ junglesnake-default-event-handler
       (if *target*
           (look-at-enemy!
             (-> *target* neck)
-            (the-as vector (-> (the-as collide-shape-prim-group (-> self root root-prim)) prims 0 prim-core))
+            (-> (the-as collide-shape-prim-group (-> self root root-prim)) prims 0 prim-core world-sphere)
             'attacking
             self
             )
@@ -486,7 +486,7 @@ junglesnake-default-event-handler
       (if *target*
           (look-at-enemy!
             (-> *target* neck)
-            (the-as vector (-> (the-as collide-shape-prim-group (-> self root root-prim)) prims 0 prim-core))
+            (-> (the-as collide-shape-prim-group (-> self root root-prim)) prims 0 prim-core world-sphere)
             'attacking
             self
             )

test/decompiler/reference/jak1/levels/jungleb/plant-boss_REF.gc

@@ -261,8 +261,8 @@
 (defbehavior plant-boss-post plant-boss ()
   (when *target*
     (let ((gp-0 (-> *target* control root-prim prim-core)))
-      (set-target! (-> self neck) (the-as vector gp-0))
-      (set-target! (-> self body) (the-as vector gp-0))
+      (set-target! (-> self neck) (-> gp-0 world-sphere))
+      (set-target! (-> self body) (-> gp-0 world-sphere))
       )
     )
   (transform-post)

test/decompiler/reference/jak1/levels/lavatube/lavatube-energy_REF.gc

@@ -405,7 +405,7 @@
         )
     (vector-! gp-0 (target-pos 0) (-> self root trans))
     (quaternion->matrix s5-0 (-> self root quat))
-    (vector-dot gp-0 (the-as vector (-> s5-0 vector)))
+    (vector-dot gp-0 (-> s5-0 vector 0))
     )
   )
 

test/decompiler/reference/jak1/levels/lavatube/lavatube-obs_REF.gc

@@ -525,11 +525,11 @@
           (set! (-> self leak s5-1 first-frame) #f)
           (let ((s4-1 (new 'stack-no-clear 'matrix)))
             (matrix-transpose! s4-1 gp-0)
-            (vector-matrix*! (the-as vector (-> self leak s5-1)) (the-as vector (-> self leak s5-1)) s4-1)
+            (vector-matrix*! (-> self leak s5-1 offset) (-> self leak s5-1 offset) s4-1)
             )
           )
         (let ((s4-2 (new 'stack-no-clear 'vector)))
-          (vector-matrix*! s4-2 (the-as vector (-> self leak s5-1)) gp-0)
+          (vector-matrix*! s4-2 (-> self leak s5-1 offset) gp-0)
           (vector+! s4-2 s4-2 (-> self root trans))
           (spawn (-> self part) s4-2)
           )

test/decompiler/reference/jak1/levels/maincave/driller-lurker_REF.gc

@@ -473,12 +473,7 @@
       (when (and arg1 *target*)
         (set-target! (-> this neck) (target-pos 5))
         (if *target*
-            (look-at-enemy!
-              (-> *target* neck)
-              (the-as vector (-> this root-overeride root-prim prim-core))
-              'attacking
-              this
-              )
+            (look-at-enemy! (-> *target* neck) (-> this root-overeride root-prim prim-core world-sphere) 'attacking this)
             )
         )
       (let ((f30-3 (-> this drill-speed)))

test/decompiler/reference/jak1/levels/maincave/maincave-obs_REF.gc

@@ -510,7 +510,7 @@
       (cond
         ((< gp-0 a0-1)
          (when (sphere-in-view-frustum? (the-as sphere (-> self root root-prim prim-core)))
-           (launch-particles (-> *part-id-table* 704) (the-as vector (-> self launch-pos)))
+           (launch-particles (-> *part-id-table* 704) (-> self launch-pos 0))
            (launch-particles (-> *part-id-table* 705) (the-as vector (&-> self stack 112)))
            )
          (when (-> self should-play-sound?)
@@ -626,8 +626,8 @@
         (set! (-> v1-53 0 z) 0.0)
         (set! (-> v1-53 0 w) 1.0)
         )
-      (vector-rotate-around-y! (the-as vector s4-1) (the-as vector s4-1) f30-0)
-      (vector+! (the-as vector s4-1) (the-as vector s4-1) (-> this root trans))
+      (vector-rotate-around-y! (-> s4-1 0) (-> s4-1 0) f30-0)
+      (vector+! (-> s4-1 0) (-> s4-1 0) (-> this root trans))
       )
     (let ((s4-2 (the-as object (&-> this stack 112))))
       (set-vector! (the-as vector s4-2) -6144.0 0.0 0.0 1.0)

test/decompiler/reference/jak1/levels/maincave/mother-spider-proj_REF.gc

@@ -237,7 +237,7 @@
 ;; definition for method 24 of type mother-spider-proj
 (defmethod projectile-method-24 ((this mother-spider-proj))
   (with-pp
-    (spawn (-> this part) (the-as vector (-> this root root-prim prim-core)))
+    (spawn (-> this part) (-> this root root-prim prim-core world-sphere))
     (let ((s5-0 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
       (set! (-> s5-0 command) (sound-command set-param))
       (set! (-> s5-0 id) (-> this sound-id))

test/decompiler/reference/jak1/levels/maincave/mother-spider_REF.gc

@@ -94,8 +94,8 @@
             (.mov at-0 f0-2)
             )
           (.mov vf2 at-0)
-          (.mov.vf vf1 vf0 :mask #b1000)
-          (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+          (.mov.vf.w vf1 vf0)
+          (.mul.x.vf.xyz vf1 vf1 vf2)
           (.svf (&-> v1-1 quad) vf1)
           )
         (when (>= (fill-and-probe-using-line-sphere
@@ -625,7 +625,7 @@
           (case (-> this mode)
             ((1 2)
              (if *target*
-                 (look-at-enemy! (-> *target* neck) (the-as vector (-> this root root-prim prim-core)) 'attacking this)
+                 (look-at-enemy! (-> *target* neck) (-> this root root-prim prim-core world-sphere) 'attacking this)
                  )
              )
             )
@@ -714,8 +714,8 @@
                    (.mov at-0 f0-7)
                    )
                  (.mov vf2 at-0)
-                 (.mov.vf vf1 vf0 :mask #b1000)
-                 (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+                 (.mov.vf.w vf1 vf0)
+                 (.mul.x.vf.xyz vf1 vf1 vf2)
                  (.svf (&-> v1-20 quad) vf1)
                  )
                (when (>= (fill-and-probe-using-line-sphere
@@ -1609,7 +1609,7 @@
         (set! (-> arg0 vector 0 y) (-> arg0 vector 2 x))
         )
       )
-    (vector-cross! (-> arg0 vector 1) (the-as vector (-> arg0 vector)) (-> arg0 vector 2))
+    (vector-cross! (-> arg0 vector 1) (-> arg0 vector 0) (-> arg0 vector 2))
     (vector-normalize! (-> arg0 vector 1) 1.0)
     (set! (-> arg0 vector 0 w) 0.0)
     (set! (-> arg0 vector 1 w) 0.0)

test/decompiler/reference/jak1/levels/misty/mistycannon_REF.gc

@@ -877,10 +877,10 @@
                   (t2-0 (new 'stack-no-clear 'collide-tri-result))
                   )
              0.0
-             (vector-! a2-1 (the-as vector v1-5) (the-as vector a1-2))
+             (vector-! a2-1 (-> v1-5 world-sphere) (-> a1-2 world-sphere))
              (when (< (fill-and-probe-using-line-sphere
                         *collide-cache*
-                        (the-as vector a1-2)
+                        (-> a1-2 world-sphere)
                         a2-1
                         40.96
                         (collide-kind background)
@@ -1638,7 +1638,7 @@
               (a0-1 (-> self tracking))
               (v1-2 (-> (the-as mistycannon (-> v1-0 0)) rotate))
               )
-          (t9-0 (the-as matrix a0-1) (the float (sar (shl (the int (+ (-> v1-2 min) (-> v1-2 value))) 48) 48)) 3640.889)
+          (t9-0 (-> a0-1 inv-mat) (the float (sar (shl (the int (+ (-> v1-2 min) (-> v1-2 value))) 48) 48)) 3640.889)
           )
         )
       (suspend)

test/decompiler/reference/jak1/levels/misty/muse_REF.gc

@@ -67,15 +67,15 @@
 ;; definition for function analyze-point-on-path-segment
 ;; INFO: Used lq/sq
 (defun analyze-point-on-path-segment ((arg0 point-on-path-segment-info))
-  (vector-! (-> arg0 dir) (-> arg0 segment 1) (the-as vector (-> arg0 segment)))
+  (vector-! (-> arg0 dir) (-> arg0 segment 1) (-> arg0 segment 0))
   (vector-normalize! (-> arg0 dir) 1.0)
-  (set! (-> arg0 segment-length) (vector-vector-distance (the-as vector (-> arg0 segment)) (-> arg0 segment 1)))
+  (set! (-> arg0 segment-length) (vector-vector-distance (-> arg0 segment 0) (-> arg0 segment 1)))
   (let ((s5-0 (new 'stack-no-clear 'vector)))
-    (vector-! s5-0 (the-as vector (-> arg0 segment)) (-> arg0 point))
+    (vector-! s5-0 (-> arg0 segment 0) (-> arg0 point))
     (vector+*! s5-0 s5-0 (-> arg0 dir) (- (vector-dot s5-0 (-> arg0 dir))))
     (vector+! (-> arg0 nearest-point) (-> arg0 point) s5-0)
     (set! (-> arg0 distance-to-segment) (vector-length s5-0))
-    (vector-! s5-0 (-> arg0 point) (the-as vector (-> arg0 segment)))
+    (vector-! s5-0 (-> arg0 point) (-> arg0 segment 0))
     (set! (-> arg0 parametric-index) (/ (vector-dot (-> arg0 dir) s5-0) (-> arg0 segment-length)))
     )
   (cond
@@ -116,7 +116,7 @@
       (dotimes (s3-0 s5-0)
         (let ((f22-0 (the float s3-0)))
           (let ((f20-0 (the float (+ s3-0 1))))
-            (eval-path-curve-div! (-> self path) (the-as vector (-> gp-0 segment)) f22-0 'interp)
+            (eval-path-curve-div! (-> self path) (-> gp-0 segment 0) f22-0 'interp)
             (eval-path-curve-div! (-> self path) (-> gp-0 segment 1) f20-0 'interp)
             )
           (set! (-> gp-0 point quad) (-> s4-0 quad))

test/decompiler/reference/jak1/levels/misty/quicksandlurker_REF.gc

@@ -349,7 +349,7 @@
     (while (not (time-elapsed? (-> self state-time) (seconds 4)))
       (fill-cache-integrate-and-collide! (-> self root) (-> self root transv) (-> self root root-prim collide-with))
       (if (or (logtest? (-> self root status) (cshape-moving-flags twall))
-              (< (vector-vector-distance (-> self root trans) (the-as vector (-> self root trans-old))) 40.96)
+              (< (vector-vector-distance (-> self root trans) (-> self root trans-old 0)) 40.96)
               )
           (go quicksandlurker-missile-impact)
           )

test/decompiler/reference/jak1/levels/ogre/ogreboss_REF.gc

@@ -670,7 +670,7 @@
                 :frame-num 0.0
                 )
     (until (ja-done? 0)
-      (when (< 81920.0 (vector-vector-distance (the-as vector (-> self root root-prim prim-core)) (target-pos 0)))
+      (when (< 81920.0 (vector-vector-distance (-> self root root-prim prim-core world-sphere) (target-pos 0)))
         (ja-channel-push! 1 (seconds 0.1))
         (go ogreboss-super-boulder-roll)
         )
@@ -908,7 +908,7 @@
     (vector+*! (-> self root trans) (-> self src-pos) (-> self side-dir) (-> self side-pos))
     (transform-post)
     (find-ground-and-draw-shadow
-      (the-as vector (-> self root root-prim prim-core))
+      (-> self root root-prim prim-core world-sphere)
       (the-as vector #f)
       (the-as float 49152.0)
       (collide-kind background)

test/decompiler/reference/jak1/levels/racer_common/racer-states_REF.gc

@@ -1042,7 +1042,7 @@
   :exit (-> target-racing-start exit)
   :code (behavior ((arg0 handle))
     (set! (-> self control transv quad) (the-as uint128 0))
-    (set! (-> self alt-cam-pos quad) (-> (&-> (-> self control) unknown-qword00) 0))
+    (set! (-> self alt-cam-pos quad) (-> (&-> self control unknown-qword00) 0))
     (logior! (-> self state-flags) (state-flags use-alt-cam-pos))
     (set-time! (-> self state-time))
     (let ((gp-0 (new 'stack-no-clear 'vector)))

test/decompiler/reference/jak1/levels/racer_common/target-racer_REF.gc

@@ -1336,7 +1336,7 @@
             (seek! (-> self control unknown-float81) 0.0 (* 2.0 (seconds-per-frame)))
             (seek! (-> self racer mult-rotx) 1.0 (* 16.0 (seconds-per-frame)))
             (let ((f0-77 (vector-dot (-> self control dynam gravity-normal) (-> self control transv))))
-              (vector-! (new 'stack-no-clear 'vector) (-> self control trans) (the-as vector (-> self control trans-old)))
+              (vector-! (new 'stack-no-clear 'vector) (-> self control trans) (-> self control trans-old 0))
               (let* ((v1-128 (-> self racer bounce))
                      (f1-36 (cond
                               ((= v1-128 1)

test/decompiler/reference/jak1/levels/rolling/rolling-lightning-mole_REF.gc

@@ -355,7 +355,7 @@
     (quaternion->matrix s5-0 (-> self collide-info quat))
     (set! (-> self run-blend-interp) (acos (vector-dot (-> s5-0 vector 2) (-> gp-0 vector 2))))
     (set! (-> self run-blend-interp) (/ (-> self run-blend-interp) (-> self flee-info blend_interp_angle)))
-    (if (< (vector-dot (-> s5-0 vector 2) (the-as vector (-> gp-0 vector))) 0.0)
+    (if (< (vector-dot (-> s5-0 vector 2) (-> gp-0 vector 0)) 0.0)
         (set! (-> self run-blend-interp) (- (-> self run-blend-interp)))
         )
     )