jak-project/test/decompiler/reference/engine/math/quaternion_REF.gc

;;-*-Lisp-*-
(in-package goal)

;; definition for method 3 of type quaternion
;; INFO: this function exists in multiple non-identical object files
(defmethod inspect quaternion ((obj quaternion))
  (format #t "[~8x] quaternion~%" obj)
  (format
   #t
   "~T[~F] [~F] [~F] [~F]~%"
   (-> obj x)
   (-> obj y)
   (-> obj z)
   (-> obj w)
   )
  (let
   ((f0-5
     (/
      1.0
      (sqrtf
       (+
        (+ (* (-> obj x) (-> obj x)) (* (-> obj y) (-> obj y)))
        (* (-> obj z) (-> obj z))
        )
       )
      )
     )
    )
   (format
    #t
    "~Taxis: ~F ~F ~F"
    (* f0-5 (-> obj x))
    (* f0-5 (-> obj y))
    (* f0-5 (-> obj z))
    )
   )
  (let ((f0-9 (* 2.0 (acos (-> obj w)))))
   (format #t "~T~Tangle: (deg ~R)~%" f0-9)
   )
  obj
  )

;; definition for function quaternion-axis-angle!
(defun
  quaternion-axis-angle!
  ((quat quaternion) (x float) (y float) (z float) (angle float))
  (let* ((f28-0 (* 0.5 angle))
         (f30-0 (sin f28-0))
         (f0-1 (cos f28-0))
         )
   (set! (-> quat x) (* x f30-0))
   (set! (-> quat y) (* y f30-0))
   (set! (-> quat z) (* z f30-0))
   (set! (-> quat w) f0-1)
   )
  quat
  )

;; definition for function quaternion-vector-angle!
(defun quaternion-vector-angle! ((quat quaternion) (axis vector) (angle float))
  (let* ((f28-0 (* 0.5 angle))
         (f30-0 (sin f28-0))
         (f0-1 (cos f28-0))
         )
   (set! (-> quat x) (* (-> axis x) f30-0))
   (set! (-> quat y) (* (-> axis y) f30-0))
   (set! (-> quat z) (* (-> axis z) f30-0))
   (set! (-> quat w) f0-1)
   )
  quat
  )

;; definition for function vector-angle<-quaternion!
(defun vector-angle<-quaternion! ((arg0 vector) (arg1 quaternion))
  (let* ((f0-0 1.0)
         (f1-0 1.0)
         (f2-0 (-> arg1 w))
         (f30-0 (/ f0-0 (sqrtf (- f1-0 (* f2-0 f2-0)))))
         (f0-3 (* 2.0 (acos-rad (-> arg1 w))))
         )
   (set! (-> arg0 x) (* (-> arg1 x) f30-0))
   (set! (-> arg0 y) (* (-> arg1 y) f30-0))
   (set! (-> arg0 z) (* (-> arg1 z) f30-0))
   (set! (-> arg0 w) f0-3)
   )
  arg0
  )

;; definition for function quaternion-zero!
;; Used lq/sq
(defun quaternion-zero! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  arg0
  )

;; definition for function quaternion-identity!
;; Used lq/sq
(defun quaternion-identity! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 w) 1.0)
  arg0
  )

;; definition for function quaternion-i!
;; Used lq/sq
(defun quaternion-i! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 x) 1.0)
  arg0
  )

;; definition for function quaternion-j!
;; Used lq/sq
(defun quaternion-j! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 y) 1.0)
  arg0
  )

;; definition for function quaternion-k!
;; Used lq/sq
(defun quaternion-k! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 z) 1.0)
  arg0
  )

;; definition for function quaternion-copy!
;; Used lq/sq
(defun quaternion-copy! ((arg0 quaternion) (arg1 quaternion))
  (set! (-> arg0 vec quad) (-> arg1 vec quad))
  arg0
  )

;; definition for function quaternion-set!
(defun
  quaternion-set!
  ((arg0 quaternion) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
  (set! (-> arg0 x) arg1)
  (set! (-> arg0 y) arg2)
  (set! (-> arg0 z) arg3)
  (set! (-> arg0 w) arg4)
  arg0
  )

;; definition for function quaternion+!
(defun quaternion+! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
   (.lvf vf1 (&-> arg1 vec quad))
   (.lvf vf2 (&-> arg2 vec quad))
   (.add.vf vf1 vf1 vf2)
   (.svf (&-> arg0 vec quad) vf1)
   arg0
   )
  )

;; definition for function quaternion-!
(defun quaternion-! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
   (.lvf vf1 (&-> arg1 vec quad))
   (.lvf vf2 (&-> arg2 vec quad))
   (.sub.vf vf1 vf1 vf2)
   (.svf (&-> arg0 vec quad) vf1)
   arg0
   )
  )

;; definition for function quaternion-negate!
;; WARN: Bad vector register dependency: vf2
(defun quaternion-negate! ((arg0 quaternion) (arg1 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
   (.lvf vf1 (&-> arg1 vec quad))
   (.sub.vf vf2 vf2 vf2)
   (.sub.vf vf1 vf2 vf1)
   (.svf (&-> arg0 vec quad) vf1)
   arg0
   )
  )

;; definition for function quaternion-conjugate!
;; WARN: Bad vector register dependency: vf2
(defun quaternion-conjugate! ((arg0 quaternion) (arg1 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
   (.lvf vf1 (&-> arg1 vec quad))
   (.sub.vf vf2 vf2 vf2)
   (.sub.vf vf2 vf2 vf1 :mask #b111)
   (.add.vf vf2 vf2 vf1 :mask #b1000)
   (.svf (&-> arg0 vec quad) vf2)
   arg0
   )
  )

;; definition for function quaternion-float*!
(defun quaternion-float*! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
   (.lvf vf1 (&-> arg1 vec quad))
   (.mov vf2 arg2)
   (.mul.x.vf vf1 vf1 vf2)
   (.svf (&-> arg0 vec quad) vf1)
   arg0
   )
  )

;; definition for function quaternion-float/!
(defun quaternion-float/! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((f0-1 (/ 1.0 arg2)))
   (quaternion-float*! arg0 arg1 f0-1)
   )
  arg0
  )

;; definition for function quaternion-norm2
(defun quaternion-norm2 ((arg0 quaternion))
  (local-vars (v0-0 float))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.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.w.vf vf1 vf0 vf1)
   (.mov v0-0 vf1)
   v0-0
   )
  )

;; definition for function quaternion-norm
(defun quaternion-norm ((arg0 quaternion))
  (local-vars (v1-1 float))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.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.w.vf vf1 vf0 vf1)
   (.mov v1-1 vf1)
   (sqrtf v1-1)
   )
  )

;; definition for function quaternion-normalize!
(defun quaternion-normalize! ((arg0 quaternion))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.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)
   (.isqrt.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
   (.wait.vf)
   (.mul.vf vf2 vf1 Q)
   (.nop.vf)
   (.nop.vf)
   (.svf (&-> arg0 vec quad) vf2)
   arg0
   )
  )

;; definition for function quaternion-inverse!
;; WARN: Bad vector register dependency: vf3
(defun quaternion-inverse! ((arg0 quaternion) (arg1 quaternion))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.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)
   (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
   (.add.vf vf3 vf3 vf1 :mask #b1000)
   (.wait.vf)
   (.mul.vf vf3 vf3 Q)
   (.nop.vf)
   (.nop.vf)
   (.svf (&-> arg0 vec quad) vf3)
   arg0
   )
  )

;; definition for function quaternion-dot
(defun quaternion-dot ((arg0 quaternion) (arg1 quaternion))
  (local-vars (v0-0 float))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.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.w.vf vf1 vf0 vf1)
   (.mov v0-0 vf1)
   v0-0
   )
  )

;; definition for function quaternion*!
(defun quaternion*! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.lvf vf1 (&-> arg1 vec quad))
   (.lvf vf2 (&-> arg2 vec quad))
   (.sub.vf vf4 vf0 vf0 :mask #b1000)
   (.mul.vf vf3 vf1 vf2)
   (.outer.product.vf vf4 vf1 vf2)
   (.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)
   (.add.mul.w.vf vf1 vf4 vf0 acc)
   (.svf (&-> arg0 vec quad) vf1)
   arg0
   )
  )

;; definition for function quaternion-right-mult-matrix!
(defun quaternion-right-mult-matrix! ((arg0 matrix) (arg1 quaternion))
  (let ((f3-0 (-> arg1 x))
        (f2-0 (-> arg1 y))
        (f1-0 (-> arg1 z))
        (f0-0 (-> arg1 w))
        )
   (set! (-> arg0 data 0) f0-0)
   (set! (-> arg0 data 1) f1-0)
   (set! (-> arg0 data 2) (- f2-0))
   (set! (-> arg0 data 3) f3-0)
   (set! (-> arg0 data 4) (- f1-0))
   (set! (-> arg0 data 5) f0-0)
   (set! (-> arg0 data 6) f3-0)
   (set! (-> arg0 data 7) f2-0)
   (set! (-> arg0 data 8) f2-0)
   (set! (-> arg0 data 9) (- f3-0))
   (set! (-> arg0 data 10) f0-0)
   (set! (-> arg0 data 11) f1-0)
   (set! (-> arg0 data 12) (- f3-0))
   (set! (-> arg0 data 13) (- f2-0))
   (set! (-> arg0 data 14) (- f1-0))
   (set! (-> arg0 data 15) f0-0)
   )
  arg0
  )

;; definition for function quaternion-left-mult-matrix!
(defun quaternion-left-mult-matrix! ((arg0 matrix) (arg1 quaternion))
  (let ((f2-0 (-> arg1 x))
        (f1-0 (-> arg1 y))
        (f0-0 (-> arg1 z))
        )
   (let ((f3-0 (-> arg1 w)))
    (set! (-> arg0 data 0) f2-0)
    (set! (-> arg0 data 1) f3-0)
    (set! (-> arg0 data 2) (- f0-0))
    (set! (-> arg0 data 3) f1-0)
    (set! (-> arg0 data 4) f1-0)
    (set! (-> arg0 data 5) f0-0)
    (set! (-> arg0 data 6) f3-0)
    (set! (-> arg0 data 7) (- f3-0))
    (set! (-> arg0 data 8) f0-0)
    (set! (-> arg0 data 9) (- f1-0))
    (set! (-> arg0 data 10) f2-0)
    (set! (-> arg0 data 11) f3-0)
    (set! (-> arg0 data 12) f3-0)
    )
   (set! (-> arg0 data 13) (- f2-0))
   (set! (-> arg0 data 14) (- f1-0))
   (set! (-> arg0 data 15) (- f0-0))
   )
  arg0
  )

;; definition for function quaternion->matrix
(defun quaternion->matrix ((arg0 matrix) (arg1 quaternion))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.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)
   (.outer.product.vf vf2 vf5 vf2)
   (.outer.product.vf vf3 vf5 vf3)
   (.outer.product.vf vf4 vf5 vf4)
   (.add.w.vf vf2 vf2 vf0 :mask #b1)
   (.add.w.vf vf3 vf3 vf0 :mask #b10)
   (.add.w.vf vf4 vf4 vf0 :mask #b100)
   (.svf (&-> arg0 vector 3 quad) vf0)
   (.svf (&-> arg0 vector 0 quad) vf2)
   (.svf (&-> arg0 vector 1 quad) vf3)
   (.svf (&-> arg0 vector 2 quad) vf4)
   arg0
   )
  )

;; definition for function matrix->quaternion
(defun matrix->quaternion ((arg0 quaternion) (arg1 matrix))
  (let ((f0-2 (+ (+ (-> arg1 data 0) (-> arg1 data 5)) (-> arg1 data 10))))
   (cond
    ((< 0.0 f0-2)
     (let ((f0-4 (sqrtf (+ 1.0 f0-2))))
      (set! (-> arg0 w) (* 0.5 f0-4))
      (let ((f0-5 (/ 0.5 f0-4)))
       (set! (-> arg0 x) (* f0-5 (- (-> arg1 data 6) (-> arg1 data 9))))
       (set! (-> arg0 y) (* f0-5 (- (-> arg1 data 8) (-> arg1 data 2))))
       (set! (-> arg0 z) (* f0-5 (- (-> arg1 data 1) (-> arg1 data 4))))
       )
      )
     )
    (else
     (let ((a2-0 0)
           (a3-0 1)
           (v1-1 2)
           )
      (when (< (-> arg1 data 0) (-> arg1 data 5))
       (set! a2-0 1)
       (set! a3-0 2)
       (set! v1-1 0)
       )
      (when
       (<
        (->
         (the-as
          (pointer float)
          (+ (+ (shl a2-0 2) (shl a2-0 4)) (the-as int arg1))
          )
         )
        (-> arg1 data 10)
        )
       (set! a2-0 2)
       (set! a3-0 0)
       (set! v1-1 1)
       )
      (let
       ((f0-12
         (sqrtf
          (+
           (-
            1.0
            (+
             (->
              (the-as
               (pointer float)
               (+ (+ (shl a3-0 2) (shl a3-0 4)) (the-as int arg1))
               )
              )
             (->
              (the-as
               (pointer float)
               (+ (+ (shl v1-1 2) (shl v1-1 4)) (the-as int arg1))
               )
              )
             )
            )
           (->
            (the-as
             (pointer float)
             (+ (+ (shl a2-0 2) (shl a2-0 4)) (the-as int arg1))
             )
            )
           )
          )
         )
        )
       (set!
        (-> (the-as (pointer float) (+ (shl a2-0 2) (the-as int arg0))))
        (* 0.5 f0-12)
        )
       (if (!= f0-12 0.0)
        (set! f0-12 (/ 0.5 f0-12))
        )
       (set!
        (-> arg0 w)
        (*
         (-
          (->
           (the-as
            (pointer float)
            (+ (+ (shl v1-1 2) (shl a3-0 4)) (the-as int arg1))
            )
           )
          (->
           (the-as
            (pointer float)
            (+ (+ (shl a3-0 2) (shl v1-1 4)) (the-as int arg1))
            )
           )
          )
         f0-12
         )
        )
       (set!
        (-> (the-as (pointer float) (+ (shl a3-0 2) (the-as int arg0))))
        (*
         (+
          (->
           (the-as
            (pointer float)
            (+ (+ (shl a3-0 2) (shl a2-0 4)) (the-as int arg1))
            )
           )
          (->
           (the-as
            (pointer float)
            (+ (+ (shl a2-0 2) (shl a3-0 4)) (the-as int arg1))
            )
           )
          )
         f0-12
         )
        )
       (set!
        (-> (the-as (pointer float) (+ (shl v1-1 2) (the-as int arg0))))
        (*
         (+
          (->
           (the-as
            (pointer float)
            (+ (+ (shl v1-1 2) (shl a2-0 4)) (the-as int arg1))
            )
           )
          (->
           (the-as
            (pointer float)
            (+ (+ (shl a2-0 2) (shl v1-1 4)) (the-as int arg1))
            )
           )
          )
         f0-12
         )
        )
       )
      )
     )
    )
   )
  arg0
  )

;; definition for function matrix-with-scale->quaternion
;; WARN: Unsupported inline assembly instruction kind - [mula.s f0, f3]
;; WARN: Unsupported inline assembly instruction kind - [madda.s f1, f4]
;; WARN: Unsupported inline assembly instruction kind - [madd.s f0, f2, f5]
;; WARN: Unsupported inline assembly instruction kind - [mula.s f1, f4]
;; WARN: Unsupported inline assembly instruction kind - [madda.s f2, f5]
;; WARN: Unsupported inline assembly instruction kind - [madd.s f1, f3, f6]
;; WARN: Unsupported inline assembly instruction kind - [mula.s f2, f5]
;; WARN: Unsupported inline assembly instruction kind - [madda.s f3, f6]
;; WARN: Unsupported inline assembly instruction kind - [madd.s f2, f4, f7]
;; Used lq/sq
(defun matrix-with-scale->quaternion ((arg0 quaternion) (arg1 matrix))
  (local-vars (a1-4 float) (f0-1 float) (f1-2 float) (f2-3 float))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         )
   (let ((v1-0 (new 'stack-no-clear 'matrix)))
    (set! (-> v1-0 vector 0 quad) (the-as uint128 0))
    (set! (-> v1-0 vector 1 quad) (the-as uint128 0))
    (set! (-> v1-0 vector 2 quad) (the-as uint128 0))
    (set! (-> v1-0 vector 3 quad) (the-as uint128 0))
    (let* ((a3-0 (-> arg1 data))
           (a2-0 (-> arg1 data))
           (f0-0 (-> a3-0 0))
           (f1-0 (-> a3-0 1))
           (f2-0 (-> a3-0 2))
           (f3-0 (-> a2-0 0))
           (f4-0 (-> a2-0 1))
           (f5-0 (-> a2-0 2))
           )
     (.mula.s f0-0 f3-0)
     (.madda.s f1-0 f4-0)
     (.madd.s f0-1 f2-0 f5-0)
     )
    (let ((f0-2 f0-1))
     (let* ((a3-1 (&-> arg1 data 4))
            (a2-2 (&-> arg1 data 4))
            (f1-1 (-> a3-1 0))
            (f2-1 (-> a3-1 1))
            (f3-1 (-> a3-1 2))
            (f4-1 (-> a2-2 0))
            (f5-1 (-> a2-2 1))
            (f6-0 (-> a2-2 2))
            )
      (.mula.s f1-1 f4-1)
      (.madda.s f2-1 f5-1)
      (.madd.s f1-2 f3-1 f6-0)
      )
     (let ((f1-3 f1-2))
      (let* ((a3-2 (&-> arg1 data 8))
             (a2-4 (&-> arg1 data 8))
             (f2-2 (-> a3-2 0))
             (f3-2 (-> a3-2 1))
             (f4-2 (-> a3-2 2))
             (f5-2 (-> a2-4 0))
             (f6-1 (-> a2-4 1))
             (f7-0 (-> a2-4 2))
             )
       (.mula.s f2-2 f5-2)
       (.madda.s f3-2 f6-1)
       (.madd.s f2-3 f4-2 f7-0)
       )
      (let* ((f2-4 f2-3)
             (f0-4 (/ 1.0 (sqrtf f0-2)))
             (f1-5 (/ 1.0 (sqrtf f1-3)))
             (f2-6 (/ 1.0 (sqrtf f2-4)))
             )
       (.lvf vf1 (&-> arg1 vector 0 quad))
       (.lvf vf2 (&-> arg1 vector 1 quad))
       (.lvf vf3 (&-> arg1 vector 2 quad))
       (.lvf vf4 (&-> arg1 vector 3 quad))
       (let ((a1-1 f0-4))
        (.mov vf5 a1-1)
        )
       (let ((a1-2 f1-5))
        (.mov vf6 a1-2)
        )
       (let ((a1-3 f2-6))
        (.mov vf7 a1-3)
        )
       )
      )
     )
    (.mul.x.vf vf1 vf1 vf5)
    (.mul.x.vf vf2 vf2 vf6)
    (.mul.x.vf vf3 vf3 vf7)
    (.svf (&-> v1-0 vector 0 quad) vf1)
    (.svf (&-> v1-0 vector 1 quad) vf2)
    (.svf (&-> v1-0 vector 2 quad) vf3)
    (.svf (&-> v1-0 vector 3 quad) vf4)
    (.mov a1-4 vf4)
    (matrix->quaternion arg0 v1-0)
    )
   )
  )

;; definition for function quaternion-vector-len
(defun quaternion-vector-len ((arg0 quaternion))
  (let ((f0-0 1.0)
        (f1-0 (-> arg0 w))
        )
   (sqrtf (- f0-0 (* f1-0 f1-0)))
   )
  )

;; definition for function quaternion-log!
(defun quaternion-log! ((arg0 quaternion) (arg1 quaternion))
  (cond
   ((= (-> arg1 w) 0.0)
    (set! (-> arg0 x) (* 1.5707963 (-> arg1 x)))
    (set! (-> arg0 y) (* 1.5707963 (-> arg1 y)))
    (set! (-> arg0 z) (* 1.5707963 (-> arg1 z)))
    )
   (else
    (let* ((f30-0 (quaternion-vector-len arg1))
           (f0-9 (/ (atan2-rad (-> arg1 w) f30-0) f30-0))
           )
     (set! (-> arg0 x) (* (-> arg1 x) f0-9))
     (set! (-> arg0 y) (* (-> arg1 y) f0-9))
     (set! (-> arg0 z) (* (-> arg1 z) f0-9))
     )
    )
   )
  arg0
  )

;; definition for function quaternion-exp!
(defun quaternion-exp! ((arg0 quaternion) (arg1 quaternion))
  (let ((f30-0 (vector-length (the-as vector arg1))))
   (cond
    ((= f30-0 0.0)
     (set! (-> arg0 x) 0.0)
     (set! (-> arg0 y) 0.0)
     (set! (-> arg0 z) 0.0)
     (set! (-> arg0 w) 1.0)
     )
    (else
     (let ((s5-0 (new 'stack-no-clear 'vector)))
      (sincos-rad! (the-as (pointer float) s5-0) f30-0)
      (let ((f0-6 (/ (-> s5-0 x) f30-0)))
       (set! (-> arg0 x) (* (-> arg1 x) f0-6))
       (set! (-> arg0 y) (* (-> arg1 y) f0-6))
       (set! (-> arg0 z) (* (-> arg1 z) f0-6))
       )
      (set! (-> arg0 w) (-> s5-0 y))
      )
     )
    )
   )
  arg0
  )

;; definition for function quaternion-slerp!
(defun
  quaternion-slerp!
  ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float))
  (local-vars (v1-7 float))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         )
   (let ((f0-0 (quaternion-dot arg1 arg2))
         (f30-0 1.0)
         )
    (when (< f0-0 0.0)
     (set! f0-0 (- f0-0))
     (set! f30-0 -1.0)
     )
    (cond
     ((< (- 1.0 f0-0) 0.0001)
      (let ((v1-2 (- 1.0 arg3)))
       (.mov vf1 v1-2)
       )
      (let ((v1-3 (* arg3 f30-0)))
       (.mov vf2 v1-3)
       )
      (.lvf vf3 (&-> arg1 vec quad))
      (.lvf vf4 (&-> arg2 vec quad))
      (.mul.x.vf acc vf3 vf1)
      (.add.mul.x.vf vf3 vf4 vf2 acc)
      (.svf (&-> arg0 vec quad) vf3)
      (quaternion-normalize! arg0)
      )
     (else
      (let* ((f1-4 1.0)
             (f2-1 f0-0)
             (f1-6 (sqrtf (- f1-4 (* f2-1 f2-1))))
             (f0-6 (/ (- f1-6 f0-0) (+ f1-6 f0-0)))
             (f28-0 (/ 1.0 f1-6))
             )
       (let ((f0-7 (atan-series-rad f0-6))
             (s2-0 (new 'stack-no-clear 'vector))
             )
        (set! (-> s2-0 x) (* (- 1.0 arg3) f0-7))
        (set! (-> s2-0 y) (* (* arg3 f0-7) f30-0))
        (vector-sin-rad! s2-0 s2-0)
        (.lvf vf1 (&-> s2-0 quad))
        )
       (let ((v1-6 f28-0))
        (.mov vf2 v1-6)
        )
       )
      (.mul.x.vf vf1 vf1 vf2)
      (.lvf vf3 (&-> arg1 vec quad))
      (.lvf vf4 (&-> arg2 vec quad))
      (.mul.x.vf acc vf3 vf1)
      (.add.mul.y.vf vf3 vf4 vf1 acc)
      (.svf (&-> arg0 vec quad) vf3)
      (.mov v1-7 vf3)
      )
     )
    )
   arg0
   )
  )

;; definition for function quaternion-pseudo-slerp!
(defun
  quaternion-pseudo-slerp!
  ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         )
   (let ((f1-0 (quaternion-dot arg1 arg2))
         (f0-0 1.0)
         )
    (when (< f1-0 0.0)
     (let ((f0-1 (- f1-0)))
      )
     (set! f0-0 -1.0)
     )
    (let ((v1-2 (- 1.0 arg3)))
     (.mov vf1 v1-2)
     )
    (let ((v1-3 (* arg3 f0-0)))
     (.mov vf2 v1-3)
     )
    )
   (.lvf vf3 (&-> arg1 vec quad))
   (.lvf vf4 (&-> arg2 vec quad))
   (.mul.x.vf acc vf3 vf1)
   (.add.mul.x.vf vf3 vf4 vf2 acc)
   (.svf (&-> arg0 vec quad) vf3)
   (quaternion-normalize! arg0)
   arg0
   )
  )

;; definition for function quaternion-zxy!
(defun quaternion-zxy! ((arg0 quaternion) (arg1 vector))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (let ((s4-0 (new 'stack-no-clear 'vector))
         (gp-0 (new 'stack-no-clear 'vector))
         (s5-0 (new 'stack-no-clear 'vector))
         )
    (vector-rad<-vector-deg/2! s4-0 arg1)
    (vector-sincos-rad! gp-0 s5-0 s4-0)
    (.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)
   (.outer.product.vf vf6 vf0 vf0)
   (.outer.product.vf vf5 vf0 vf0)
   (.mul.x.vf vf6 vf0 vf6 :mask #b1000)
   (.mul.x.vf vf5 vf0 vf5 :mask #b1000)
   (.mul.vf acc vf6 vf4)
   (.add.mul.vf vf7 vf5 vf3 acc)
   (.svf (&-> arg0 vec quad) vf7)
   arg0
   )
  )

;; definition for function vector-x-quaternion!
;; Used lq/sq
(defun vector-x-quaternion! ((arg0 vector) (arg1 quaternion))
  (let ((s5-0 (new 'stack-no-clear 'matrix)))
   (set! (-> s5-0 vector 0 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 1 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 2 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 3 quad) (the-as uint128 0))
   (quaternion->matrix s5-0 arg1)
   (set! (-> arg0 quad) (-> (the-as (pointer uint128) (-> s5-0 data)) 0))
   )
  arg0
  )

;; definition for function vector-y-quaternion!
;; Used lq/sq
(defun vector-y-quaternion! ((arg0 vector) (arg1 quaternion))
  (let ((s5-0 (new 'stack-no-clear 'matrix)))
   (set! (-> s5-0 vector 0 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 1 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 2 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 3 quad) (the-as uint128 0))
   (quaternion->matrix s5-0 arg1)
   (set! (-> arg0 quad) (-> (the-as (pointer uint128) (&-> s5-0 data 4)) 0))
   )
  arg0
  )

;; definition for function vector-z-quaternion!
;; Used lq/sq
(defun vector-z-quaternion! ((arg0 vector) (arg1 quaternion))
  (let ((s5-0 (new 'stack-no-clear 'matrix)))
   (set! (-> s5-0 vector 0 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 1 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 2 quad) (the-as uint128 0))
   (set! (-> s5-0 vector 3 quad) (the-as uint128 0))
   (quaternion->matrix s5-0 arg1)
   (set! (-> arg0 quad) (-> (the-as (pointer uint128) (&-> s5-0 data 8)) 0))
   )
  arg0
  )

;; definition for function quaternion-y-angle
(defun quaternion-y-angle ((arg0 quaternion))
  (let ((v1-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0)))
   (atan (-> v1-1 x) (-> v1-1 z))
   )
  )

;; definition for function quaternion-vector-y-angle
(defun quaternion-vector-y-angle ((arg0 quaternion) (arg1 vector))
  (let ((f30-0 (quaternion-y-angle arg0))
        (f0-2 (atan (-> arg1 x) (-> arg1 z)))
        )
   (deg-diff f30-0 f0-2)
   )
  )

;; definition for function quaternion-rotate-local-x!
;; Used lq/sq
(defun
  quaternion-rotate-local-x!
  ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((t9-0 quaternion-vector-angle!)
        (a0-1 (new 'stack-no-clear 'quaternion))
        )
   (set! (-> a0-1 vec quad) (the-as uint128 0))
   (let ((a2-1 (t9-0 a0-1 (new 'static 'vector :x 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 arg1 a2-1))
    )
   )
  )

;; definition for function quaternion-rotate-local-y!
;; Used lq/sq
(defun
  quaternion-rotate-local-y!
  ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((t9-0 quaternion-vector-angle!)
        (a0-1 (new 'stack-no-clear 'quaternion))
        )
   (set! (-> a0-1 vec quad) (the-as uint128 0))
   (let ((a2-1 (t9-0 a0-1 (new 'static 'vector :y 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 arg1 a2-1))
    )
   )
  )

;; definition for function quaternion-rotate-local-z!
;; Used lq/sq
(defun
  quaternion-rotate-local-z!
  ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((t9-0 quaternion-vector-angle!)
        (a0-1 (new 'stack-no-clear 'quaternion))
        )
   (set! (-> a0-1 vec quad) (the-as uint128 0))
   (let ((a2-1 (t9-0 a0-1 (new 'static 'vector :z 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 arg1 a2-1))
    )
   )
  )

;; definition for function quaternion-rotate-y!
;; Used lq/sq
(defun quaternion-rotate-y! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((t9-0 quaternion-vector-angle!)
        (a0-1 (new 'stack-no-clear 'quaternion))
        )
   (set! (-> a0-1 vec quad) (the-as uint128 0))
   (let ((a1-2 (t9-0 a0-1 (new 'static 'vector :y 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 a1-2 arg1))
    )
   )
  )

;; definition for function quaternion-rotate-x!
;; Used lq/sq
(defun quaternion-rotate-x! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((s4-0 quaternion-vector-angle!)
        (s3-0 (new 'stack-no-clear 'quaternion))
        )
   (set! (-> s3-0 vec quad) (the-as uint128 0))
   (let ((t9-0 vector-x-quaternion!)
         (a0-1 (new 'stack-no-clear 'vector))
         )
    (set! (-> a0-1 quad) (the-as uint128 0))
    (let ((a1-3 (s4-0 s3-0 (t9-0 a0-1 arg1) arg2)))
     (quaternion-normalize! (quaternion*! arg0 a1-3 arg1))
     )
    )
   )
  )

;; definition for function quaternion-rotate-z!
;; Used lq/sq
(defun quaternion-rotate-z! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((s4-0 quaternion-vector-angle!)
        (s3-0 (new 'stack-no-clear 'quaternion))
        )
   (set! (-> s3-0 vec quad) (the-as uint128 0))
   (let ((t9-0 vector-z-quaternion!)
         (a0-1 (new 'stack-no-clear 'vector))
         )
    (set! (-> a0-1 quad) (the-as uint128 0))
    (let ((a1-3 (s4-0 s3-0 (t9-0 a0-1 arg1) arg2)))
     (quaternion-normalize! (quaternion*! arg0 a1-3 arg1))
     )
    )
   )
  )

;; definition for function quaternion-delta-y
;; WARN: Unsupported inline assembly instruction kind - [mula.s f0, f3]
;; WARN: Unsupported inline assembly instruction kind - [madda.s f1, f4]
;; WARN: Unsupported inline assembly instruction kind - [madd.s f0, f2, f5]
(defun quaternion-delta-y ((arg0 quaternion) (arg1 quaternion))
  (local-vars (f0-1 float))
  (let ((gp-0 acos))
   (let* ((s5-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0))
          (v1-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) arg1))
          (f0-0 (-> s5-0 x))
          (f1-0 (-> s5-0 y))
          (f2-0 (-> s5-0 z))
          (f3-0 (-> v1-1 x))
          (f4-0 (-> v1-1 y))
          (f5-0 (-> v1-1 z))
          )
    (.mula.s f0-0 f3-0)
    (.madda.s f1-0 f4-0)
    (.madd.s f0-1 f2-0 f5-0)
    )
   (gp-0 f0-1)
   )
  )

;; definition for function quaternion-rotate-y-to-vector!
(defun
  quaternion-rotate-y-to-vector!
  ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float))
  (let ((s5-0 (new 'stack-no-clear 'quaternion)))
   (let ((t9-0 vector-xz-normalize!)
         (a0-1 (new 'stack-no-clear 'vector))
         )
    (set! (-> a0-1 x) (-> arg2 x))
    (set! (-> a0-1 y) 0.0)
    (set! (-> a0-1 z) (-> arg2 z))
    (set! (-> a0-1 w) 1.0)
    (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
       )
      s0-0
      arg3
      )
     )
    )
   (quaternion-normalize! (quaternion*! arg0 s5-0 arg1))
   )
  )

;; definition for function vector-rotate-y!
(defun vector-rotate-y! ((arg0 vector) (arg1 vector) (arg2 float))
  (let
   ((a1-2
     (quaternion-vector-angle!
      (new 'stack-no-clear 'quaternion)
      (new 'static 'vector :y 1.0 :w 1.0)
      arg2
      )
     )
    (s4-0 (new 'stack-no-clear 'matrix))
    )
   (quaternion->matrix s4-0 a1-2)
   (vector-matrix*! arg0 arg1 s4-0)
   )
  )

;; definition for function vector-y-angle
(defun vector-y-angle ((arg0 vector))
  (atan (-> arg0 x) (-> arg0 z))
  )

;; definition for function vector-x-angle
(defun vector-x-angle ((arg0 vector))
  (atan (-> arg0 y) (vector-xz-length arg0))
  )

;; definition for function quaterion<-rotate-y-vector
(defun quaterion<-rotate-y-vector ((arg0 quaternion) (arg1 vector))
  (quaternion-vector-angle!
   arg0
   (new 'static 'vector :y 1.0 :w 1.0)
   (vector-y-angle arg1)
   )
  )

;; definition (debug) for function quaternion-validate
;; INFO: Return type mismatch int vs none.
(defun-debug quaternion-validate ((arg0 quaternion))
  (local-vars (pp process))
  (let ((f0-0 (quaternion-norm arg0)))
   (when (or (< 1.01 f0-0) (< f0-0 0.99))
    (format #t "WARNING: bad quaternion (magnitude ~F) process is " f0-0)
    (if (and pp (type-type? (-> pp type) process-tree))
     (format #t "~A~%" (-> pp name))
     (format #t "#f~%")
     )
    )
   )
  (let ((v0-5 0))
   )
  (none)
  )

;; definition for function quaternion-xz-angle
(defun quaternion-xz-angle ((arg0 quaternion))
  (let ((gp-0 (new 'stack-no-clear 'matrix))
        (s5-0 (new 'stack-no-clear 'vector))
        )
   (quaternion->matrix gp-0 arg0)
   (let ((v1-1 s5-0))
    (set! (-> v1-1 x) 0.0)
    (set! (-> v1-1 y) 0.0)
    (set! (-> v1-1 z) 1.0)
    (set! (-> v1-1 w) 1.0)
    )
   (vector-matrix*! s5-0 s5-0 gp-0)
   (vector-y-angle s5-0)
   )
  )