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

;; definition for method 3 of type matrix
;; INFO: this function exists in multiple non-identical object files
(defmethod inspect matrix ((obj matrix))
  (format #t "[~8x] matrix~%" obj)
  (format
    #t
    "~T[~F] [~F] [~F] [~F]~%"
    (-> obj vector 0 x)
    (-> obj vector 0 y)
    (-> obj vector 0 z)
    (-> obj vector 0 w)
    )
  (format
    #t
    "~T[~F] [~F] [~F] [~F]~%"
    (-> obj vector 1 x)
    (-> obj vector 1 y)
    (-> obj vector 1 z)
    (-> obj vector 1 w)
    )
  (format
    #t
    "~T[~F] [~F] [~F] [~F]~%"
    (-> obj vector 2 x)
    (-> obj vector 2 y)
    (-> obj vector 2 z)
    (-> obj vector 2 w)
    )
  (format
    #t
    "~T[~F] [~F] [~F] [~F]~%"
    (-> obj vector 3 x)
    (-> obj vector 3 y)
    (-> obj vector 3 z)
    (-> obj vector 3 w)
    )
  obj
  )

;; definition for method 3 of type matrix3
;; INFO: this function exists in multiple non-identical object files
(defmethod inspect matrix3 ((obj matrix3))
  (format #t "[~8x] matrix3~%" obj)
  (format #t "~T[~F] [~F] [~F]~%" (-> obj data 0) (-> obj data 1) (-> obj data 2))
  (format #t "~T[~F] [~F] [~F]~%" (-> obj data 4) (-> obj data 5) (-> obj data 6))
  (format #t "~T[~F] [~F] [~F]~%" (-> obj data 8) (-> obj data 9) (-> obj data 10))
  obj
  )

;; definition for function matrix-identity!
;; Used lq/sq
(defun matrix-identity! ((arg0 matrix))
  (set! (-> arg0 vector 0 quad) (the-as uint128 0))
  (set! (-> arg0 vector 1 quad) (the-as uint128 0))
  (set! (-> arg0 vector 2 quad) (the-as uint128 0))
  (set! (-> arg0 vector 3 quad) (the-as uint128 0))
  (let ((f0-0 1.0))
    (set! (-> arg0 vector 3 w) f0-0)
    (set! (-> arg0 vector 2 z) f0-0)
    (set! (-> arg0 vector 1 y) f0-0)
    (set! (-> arg0 vector 0 x) f0-0)
    )
  arg0
  )

;; definition for symbol *identity-matrix*, type matrix
(define *identity-matrix* (new 'global 'matrix))

;; failed to figure out what this is:
(matrix-identity! *identity-matrix*)

;; definition for function matrix+!
(defun matrix+! ((dst matrix) (src1 matrix) (src2 matrix))
  (dotimes (i 16)
    (set! (-> dst data i) (+ (-> src1 data i) (-> src2 data i)))
    )
  dst
  )

;; definition for function matrix-!
(defun matrix-! ((dst matrix) (src1 matrix) (src2 matrix))
  (dotimes (i 16)
    (set! (-> dst data i) (- (-> src1 data i) (-> src2 data i)))
    )
  dst
  )

;; definition for function matrix*!
(defun matrix*! ((dst matrix) (src1 matrix) (src2 matrix))
  (rlet ((acc :class vf)
         (vf10 :class vf)
         (vf11 :class vf)
         (vf12 :class vf)
         (vf13 :class vf)
         (vf14 :class vf)
         (vf15 :class vf)
         (vf16 :class vf)
         (vf17 :class vf)
         (vf18 :class vf)
         (vf19 :class vf)
         (vf20 :class vf)
         (vf21 :class vf)
         )
    (.lvf vf10 (&-> src1 vector 0 quad))
    (.lvf vf14 (&-> src2 vector 0 quad))
    (.lvf vf15 (&-> src2 vector 1 quad))
    (.lvf vf16 (&-> src2 vector 2 quad))
    (.lvf vf17 (&-> src2 vector 3 quad))
    (.lvf vf11 (&-> src1 vector 1 quad))
    (.lvf vf12 (&-> src1 vector 2 quad))
    (.lvf vf13 (&-> src1 vector 3 quad))
    (.mul.x.vf acc vf14 vf10)
    (.add.mul.y.vf acc vf15 vf10 acc)
    (.add.mul.z.vf acc vf16 vf10 acc)
    (.add.mul.w.vf vf18 vf17 vf10 acc)
    (.mul.x.vf acc vf14 vf11)
    (.add.mul.y.vf acc vf15 vf11 acc)
    (.add.mul.z.vf acc vf16 vf11 acc)
    (.add.mul.w.vf vf19 vf17 vf11 acc)
    (.mul.x.vf acc vf14 vf12)
    (.add.mul.y.vf acc vf15 vf12 acc)
    (.add.mul.z.vf acc vf16 vf12 acc)
    (.add.mul.w.vf vf20 vf17 vf12 acc)
    (.mul.x.vf acc vf14 vf13)
    (.add.mul.y.vf acc vf15 vf13 acc)
    (.add.mul.z.vf acc vf16 vf13 acc)
    (.add.mul.w.vf vf21 vf17 vf13 acc)
    (.svf (&-> dst vector 0 quad) vf18)
    (.svf (&-> dst vector 1 quad) vf19)
    (.svf (&-> dst vector 2 quad) vf20)
    (.svf (&-> dst vector 3 quad) vf21)
    dst
    )
  )

;; definition for function matrixp*!
;; Used lq/sq
(defun matrixp*! ((dst matrix) (src1 matrix) (src2 matrix))
  (let ((temp-mat (new-stack-matrix0)))
    (matrix*! temp-mat src1 src2)
    (set! (-> dst vector 0 quad) (-> temp-mat vector 0 quad))
    (set! (-> dst vector 1 quad) (-> temp-mat vector 1 quad))
    (set! (-> dst vector 2 quad) (-> temp-mat vector 2 quad))
    (set! (-> dst vector 3 quad) (-> temp-mat vector 3 quad))
    )
  dst
  )

;; definition for function vector-matrix*!
(defun vector-matrix*! ((dst vector) (vec vector) (mat matrix))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         )
    (.lvf vf1 (&-> mat vector 0 quad))
    (.lvf vf2 (&-> mat vector 1 quad))
    (.lvf vf3 (&-> mat vector 2 quad))
    (.lvf vf4 (&-> mat vector 3 quad))
    (.lvf vf5 (&-> vec quad))
    (.mul.x.vf acc vf1 vf5)
    (.add.mul.y.vf acc vf2 vf5 acc)
    (.add.mul.z.vf acc vf3 vf5 acc)
    (.add.mul.w.vf vf5 vf4 vf5 acc)
    (.svf (&-> dst quad) vf5)
    dst
    )
  )

;; definition for function vector-rotate*!
(defun vector-rotate*! ((dst vector) (vec vector) (mat matrix))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         )
    (nop!)
    (nop!)
    (.lvf vf5 (&-> vec quad))
    (nop!)
    (.lvf vf1 (&-> mat vector 0 quad))
    (nop!)
    (.lvf vf2 (&-> mat vector 1 quad))
    (.mul.x.vf acc vf1 vf5)
    (.lvf vf3 (&-> mat vector 2 quad))
    (.add.mul.y.vf acc vf2 vf5 acc)
    (.lvf vf4 (&-> mat vector 3 quad))
    (.add.mul.z.vf vf5 vf3 vf5 acc)
    (nop!)
    (nop!)
    (.svf (&-> dst quad) vf5)
    dst
    )
  )

;; definition for function vector3s-matrix*!
;; Used lq/sq
(defun vector3s-matrix*! ((dst vector3s) (vec vector3s) (mat matrix))
  (let ((temp-vec3 (new-stack-vector0)))
    (set-vector! temp-vec3 (-> vec x) (-> vec y) (-> vec z) 1.0)
    (vector-matrix*! temp-vec3 temp-vec3 mat)
    (set! (-> dst x) (-> temp-vec3 x))
    (set! (-> dst y) (-> temp-vec3 y))
    (set! (-> dst z) (-> temp-vec3 z))
    )
  dst
  )

;; definition for function vector3s-rotate*!
;; Used lq/sq
(defun vector3s-rotate*! ((dst vector3s) (vec vector3s) (mat matrix))
  (let ((temp-vec3 (new-stack-vector0)))
    (set-vector! temp-vec3 (-> vec x) (-> vec y) (-> vec z) 1.0)
    (vector-rotate*! temp-vec3 temp-vec3 mat)
    (set! (-> dst x) (-> temp-vec3 x))
    (set! (-> dst y) (-> temp-vec3 y))
    (set! (-> dst z) (-> temp-vec3 z))
    )
  dst
  )

;; definition for function matrix-transpose!
;; WARN: Function may read a register that is not set: f31
;; Used lq/sq
(defun matrix-transpose! ((dst matrix) (src matrix))
  (local-vars
    (r0-0 int)
    (r0-1 int)
    (r0-2 int)
    (r0-3 int)
    (v1-0 uint128)
    (v1-1 uint128)
    (v1-2 uint128)
    (a1-1 uint128)
    (a2-1 uint128)
    (a3-1 uint128)
    (a3-2 uint128)
    (t0-1 uint128)
    (f31-0 none)
    )
  (nop!)
  (nop!)
  (let ((t0-0 (-> src vector 0 quad)))
    (nop!)
    (let ((t1-0 (-> src vector 1 quad)))
      (nop!)
      (let ((a2-0 (-> src vector 2 quad)))
        (.pextlw v1-0 t1-0 t0-0)
        (let ((a3-0 (-> src vector 3 quad)))
          (.pextuw a1-1 t1-0 t0-0)
          (.mov r0-0 f31-0)
          (.pextlw t0-1 a3-0 a2-0)
          (.mov r0-1 f31-0)
          (.pextuw a2-1 a3-0 a2-0)
          )
        )
      )
    )
  (.mov r0-2 f31-0)
  (.pcpyld a3-1 t0-1 v1-0)
  (.mov r0-3 f31-0)
  (.pcpyud v1-1 v1-0 t0-1)
  (set! (-> dst vector 0 quad) a3-1)
  (.pcpyld a3-2 a2-1 a1-1)
  (set! (-> dst vector 1 quad) v1-1)
  (.pcpyud v1-2 a1-1 a2-1)
  (set! (-> dst vector 2 quad) a3-2)
  (nop!)
  (set! (-> dst vector 3 quad) v1-2)
  dst
  )

;; definition for function matrix-inverse-of-rot-trans!
(defun matrix-inverse-of-rot-trans! ((dst matrix) (src matrix))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf8 :class vf)
         )
    (init-vf0-vector)
    (matrix-transpose! dst src)
    (.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)
    (.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)
    (.svf (&-> dst vector 0 quad) vf1)
    (.svf (&-> dst vector 1 quad) vf2)
    (.svf (&-> dst vector 2 quad) vf3)
    (.svf (&-> dst vector 3 quad) vf4)
    dst
    )
  )

;; definition for function matrix-4x4-inverse!
;; WARN: Bad vector register dependency: vf3
;; WARN: Bad vector register dependency: vf4
;; WARN: Bad vector register dependency: vf5
(defun matrix-4x4-inverse! ((dst matrix) (src matrix))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf10 :class vf)
         (vf11 :class vf)
         (vf12 :class vf)
         (vf13 :class vf)
         (vf14 :class vf)
         (vf15 :class vf)
         (vf16 :class vf)
         (vf17 :class vf)
         (vf18 :class vf)
         (vf19 :class vf)
         (vf2 :class vf)
         (vf20 :class vf)
         (vf23 :class vf)
         (vf24 :class vf)
         (vf25 :class vf)
         (vf26 :class vf)
         (vf27 :class vf)
         (vf28 :class vf)
         (vf29 :class vf)
         (vf3 :class vf)
         (vf30 :class vf)
         (vf31 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         (vf8 :class vf)
         (vf9 :class vf)
         )
    (init-vf0-vector)
    (nop!)
    (nop!)
    (.lvf vf23 (&-> src vector 0 quad))
    (nop!)
    (.lvf vf24 (&-> src vector 1 quad))
    (nop!)
    (.lvf vf25 (&-> src vector 2 quad))
    (nop!)
    (.lvf vf1 (&-> src vector 3 quad))
    (.mul.x.vf vf7 vf24 vf23)
    (nop!)
    (.mul.y.vf vf8 vf24 vf23)
    (nop!)
    (.mul.z.vf vf9 vf24 vf23)
    (nop!)
    (.mul.x.vf vf10 vf25 vf23)
    (nop!)
    (.mul.y.vf vf11 vf25 vf23)
    (nop!)
    (.mul.z.vf vf12 vf25 vf23)
    (nop!)
    (.mul.x.vf vf13 vf25 vf24)
    (nop!)
    (.mul.y.vf vf14 vf25 vf24)
    (nop!)
    (.mul.z.vf vf15 vf25 vf24)
    (nop!)
    (.mul.z.vf vf26 vf7 vf25 :mask #b10)
    (nop!)
    (.mul.z.vf vf27 vf11 vf24 :mask #b1)
    (nop!)
    (.mul.y.vf vf28 vf9 vf25 :mask #b1)
    (nop!)
    (.mul.z.vf vf29 vf14 vf23 :mask #b1)
    (nop!)
    (.mul.z.vf vf30 vf8 vf25 :mask #b1)
    (nop!)
    (.mul.y.vf vf31 vf7 vf25 :mask #b100)
    (nop!)
    (.add.y.vf vf16 vf27 vf26 :mask #b1)
    (nop!)
    (.sub.vf vf1 vf0 vf1)
    (nop!)
    (.add.x.vf vf17 vf29 vf30 :mask #b1)
    (nop!)
    (.sub.z.vf vf18 vf28 vf31 :mask #b1)
    (nop!)
    (.sub.y.vf vf23 vf14 vf15 :mask #b100)
    (nop!)
    (.sub.z.vf vf26 vf15 vf13 :mask #b1)
    (nop!)
    (.sub.x.vf vf29 vf13 vf14 :mask #b10)
    (nop!)
    (.sub.vf vf19 vf16 vf17 :mask #b1)
    (nop!)
    (.sub.z.vf vf24 vf12 vf11 :mask #b10)
    (nop!)
    (.sub.x.vf vf27 vf10 vf12 :mask #b100)
    (nop!)
    (.sub.y.vf vf30 vf11 vf10 :mask #b1)
    (nop!)
    (.add.vf vf20 vf19 vf18 :mask #b1)
    (nop!)
    (.sub.y.vf vf25 vf8 vf9 :mask #b100)
    (nop!)
    (.sub.z.vf vf28 vf9 vf7 :mask #b1)
    (nop!)
    (.sub.x.vf vf31 vf7 vf8 :mask #b10)
    (nop!)
    (.div.vf Q vf0 vf20 :fsf #b11 :ftf #b0)
    (nop!)
    (.sub.w.vf vf3 vf3 vf3 :mask #b1000)
    (nop!)
    (.sub.w.vf vf4 vf4 vf4 :mask #b1000)
    (nop!)
    (.sub.w.vf vf5 vf5 vf5 :mask #b1000)
    (nop!)
    (.mov.vf vf6 vf0 :mask #b1000)
    (nop!)
    (.wait.vf)
    (nop!)
    (.add.vf vf2 vf0 Q :mask #b1)
    (nop!)
    (.add.x.vf vf2 vf0 vf2 :mask #b111)
    (nop!)
    (.mul.z.vf vf3 vf2 vf23 :mask #b1)
    (nop!)
    (.mul.x.vf vf4 vf2 vf26 :mask #b1)
    (nop!)
    (.mul.y.vf vf5 vf2 vf29 :mask #b1)
    (nop!)
    (.mul.y.vf vf3 vf2 vf24 :mask #b10)
    (nop!)
    (.mul.z.vf vf4 vf2 vf27 :mask #b10)
    (nop!)
    (.mul.x.vf vf5 vf2 vf30 :mask #b10)
    (nop!)
    (.mul.z.vf vf3 vf2 vf25 :mask #b100)
    (nop!)
    (.mul.x.vf vf4 vf2 vf28 :mask #b100)
    (nop!)
    (.mul.y.vf vf5 vf2 vf31 :mask #b100)
    (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)
    (.svf (&-> dst vector 2 quad) vf5)
    (nop!)
    (.svf (&-> dst vector 3 quad) vf6)
    dst
    )
  )

;; definition for function matrix-translate!
(defun matrix-translate! ((dst matrix) (trans vector))
  (matrix-identity! dst)
  (set! (-> dst vector 3 x) (-> trans x))
  (set! (-> dst vector 3 y) (-> trans y))
  (set! (-> dst vector 3 z) (-> trans z))
  dst
  )

;; definition for function matrix-translate+!
;; Used lq/sq
(defun matrix-translate+! ((dst matrix) (src matrix) (trans vector))
  (set! (-> dst vector 3 x) (+ (-> src vector 3 x) (-> trans x)))
  (set! (-> dst vector 3 y) (+ (-> src vector 3 y) (-> trans y)))
  (set! (-> dst vector 3 z) (+ (-> src vector 3 z) (-> trans z)))
  (when (!= dst src)
    (set! (-> dst vector 0 quad) (-> src vector 0 quad))
    (set! (-> dst vector 1 quad) (-> src vector 1 quad))
    (set! (-> dst vector 2 quad) (-> src vector 2 quad))
    )
  dst
  )

;; definition for function matrix-scale!
;; Used lq/sq
(defun matrix-scale! ((dst matrix) (scale vector))
  (set! (-> dst vector 0 quad) (the-as uint128 0))
  (set! (-> dst vector 1 quad) (the-as uint128 0))
  (set! (-> dst vector 2 quad) (the-as uint128 0))
  (set! (-> dst vector 3 quad) (the-as uint128 0))
  (set! (-> dst vector 0 x) (-> scale x))
  (set! (-> dst vector 1 y) (-> scale y))
  (set! (-> dst vector 2 z) (-> scale z))
  (set! (-> dst vector 3 w) 1.0)
  dst
  )

;; definition for function scale-matrix!
(defun scale-matrix! ((dst matrix) (scale vector) (src matrix))
  (rlet ((vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         (vf8 :class vf)
         )
    (.lvf vf4 (&-> scale quad))
    (.lvf vf5 (&-> src vector 0 quad))
    (.lvf vf6 (&-> src vector 1 quad))
    (.lvf vf7 (&-> src vector 2 quad))
    (.lvf vf8 (&-> src vector 3 quad))
    (.mul.x.vf vf5 vf5 vf4)
    (.mul.y.vf vf6 vf6 vf4)
    (.mul.z.vf vf7 vf7 vf4)
    (.mul.w.vf vf8 vf8 vf4)
    (.svf (&-> dst vector 0 quad) vf5)
    (.svf (&-> dst vector 1 quad) vf6)
    (.svf (&-> dst vector 2 quad) vf7)
    (.svf (&-> dst vector 3 quad) vf8)
    dst
    )
  )

;; definition for function matrix-inv-scale!
;; Used lq/sq
(defun matrix-inv-scale! ((dst matrix) (scale vector))
  (set! (-> dst vector 0 quad) (the-as uint128 0))
  (set! (-> dst vector 1 quad) (the-as uint128 0))
  (set! (-> dst vector 2 quad) (the-as uint128 0))
  (set! (-> dst vector 3 quad) (the-as uint128 0))
  (set! (-> dst vector 0 x) (/ 1.0 (-> scale x)))
  (set! (-> dst vector 1 y) (/ 1.0 (-> scale y)))
  (set! (-> dst vector 2 z) (/ 1.0 (-> scale z)))
  (set! (-> dst vector 3 w) 1.0)
  dst
  )

;; definition for function column-scale-matrix!
(defun column-scale-matrix! ((dst matrix) (scale vector) (src matrix))
  (rlet ((vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         (vf8 :class vf)
         )
    (.lvf vf4 (&-> scale quad))
    (.lvf vf5 (&-> src vector 0 quad))
    (.lvf vf6 (&-> src vector 1 quad))
    (.lvf vf7 (&-> src vector 2 quad))
    (.lvf vf8 (&-> src vector 3 quad))
    (.mul.vf vf5 vf5 vf4)
    (.mul.vf vf6 vf6 vf4)
    (.mul.vf vf7 vf7 vf4)
    (.mul.vf vf8 vf8 vf4)
    (.svf (&-> dst vector 0 quad) vf5)
    (.svf (&-> dst vector 1 quad) vf6)
    (.svf (&-> dst vector 2 quad) vf7)
    (.svf (&-> dst vector 3 quad) vf8)
    dst
    )
  )

;; definition for function matrix-rotate-x!
;; Used lq/sq
(defun matrix-rotate-x! ((dst matrix) (rot-deg float))
  (let ((rot-sin (sin rot-deg))
        (rot-cos (cos rot-deg))
        )
    (set! (-> dst vector 0 quad) (the-as uint128 0))
    (set! (-> dst vector 1 quad) (the-as uint128 0))
    (set! (-> dst vector 2 quad) (the-as uint128 0))
    (set! (-> dst vector 3 quad) (the-as uint128 0))
    (set! (-> dst vector 0 x) 1.0)
    (set! (-> dst vector 1 y) rot-cos)
    (set! (-> dst vector 1 z) rot-sin)
    (set! (-> dst vector 2 y) (- rot-sin))
    (set! (-> dst vector 2 z) rot-cos)
    )
  (set! (-> dst vector 3 w) 1.0)
  dst
  )

;; definition for function matrix-rotate-y!
;; Used lq/sq
(defun matrix-rotate-y! ((dst matrix) (rot-deg float))
  (let ((rot-sin (sin rot-deg))
        (rot-cos (cos rot-deg))
        )
    (set! (-> dst vector 0 quad) (the-as uint128 0))
    (set! (-> dst vector 1 quad) (the-as uint128 0))
    (set! (-> dst vector 2 quad) (the-as uint128 0))
    (set! (-> dst vector 3 quad) (the-as uint128 0))
    (set! (-> dst vector 0 x) rot-cos)
    (set! (-> dst vector 0 z) (- rot-sin))
    (set! (-> dst vector 1 y) 1.0)
    (set! (-> dst vector 2 x) rot-sin)
    (set! (-> dst vector 2 z) rot-cos)
    )
  (set! (-> dst vector 3 w) 1.0)
  dst
  )

;; definition for function matrix-rotate-z!
;; Used lq/sq
(defun matrix-rotate-z! ((dst matrix) (rot-deg float))
  (let ((rot-sin (sin rot-deg))
        (rot-cos (cos rot-deg))
        )
    (set! (-> dst vector 0 quad) (the-as uint128 0))
    (set! (-> dst vector 1 quad) (the-as uint128 0))
    (set! (-> dst vector 2 quad) (the-as uint128 0))
    (set! (-> dst vector 3 quad) (the-as uint128 0))
    (set! (-> dst vector 0 x) rot-cos)
    (set! (-> dst vector 0 y) rot-sin)
    (set! (-> dst vector 1 x) (- rot-sin))
    (set! (-> dst vector 1 y) rot-cos)
    )
  (set! (-> dst vector 2 z) 1.0)
  (set! (-> dst vector 3 w) 1.0)
  dst
  )

;; definition for function matrix-rotate-zyx!
;; Used lq/sq
(defun matrix-rotate-zyx! ((dst matrix) (rot-xyz-deg vector))
  (let ((temp-mat (new-stack-matrix0))
        (rot-mat (new-stack-matrix0))
        )
    (matrix-rotate-x! dst (-> rot-xyz-deg x))
    (matrix-rotate-y! temp-mat (-> rot-xyz-deg y))
    (matrix*! rot-mat temp-mat dst)
    (matrix-rotate-z! temp-mat (-> rot-xyz-deg z))
    (matrix*! dst temp-mat rot-mat)
    )
  dst
  )

;; definition for function matrix-rotate-xyz!
;; Used lq/sq
(defun matrix-rotate-xyz! ((dst matrix) (rot-xyz-deg vector))
  (let ((temp-mat (new-stack-matrix0))
        (rot-mat (new-stack-matrix0))
        )
    (matrix-rotate-z! dst (-> rot-xyz-deg z))
    (matrix-rotate-y! temp-mat (-> rot-xyz-deg y))
    (matrix*! rot-mat temp-mat dst)
    (matrix-rotate-x! temp-mat (-> rot-xyz-deg x))
    (matrix*! dst temp-mat rot-mat)
    )
  dst
  )

;; definition for function matrix-rotate-zxy!
;; Used lq/sq
(defun matrix-rotate-zxy! ((dst matrix) (rot-xyz-deg vector))
  (let ((temp-mat (new-stack-matrix0))
        (rot-mat (new-stack-matrix0))
        )
    (matrix-rotate-y! dst (-> rot-xyz-deg y))
    (matrix-rotate-x! temp-mat (-> rot-xyz-deg x))
    (matrix*! rot-mat temp-mat dst)
    (matrix-rotate-z! temp-mat (-> rot-xyz-deg z))
    (matrix*! dst temp-mat rot-mat)
    )
  dst
  )

;; definition for function matrix-rotate-yxz!
;; Used lq/sq
(defun matrix-rotate-yxz! ((dst matrix) (rot-xyz-deg vector))
  (let ((temp-mat (new-stack-matrix0))
        (rot-mat (new-stack-matrix0))
        )
    (matrix-rotate-z! dst (-> rot-xyz-deg z))
    (matrix-rotate-x! temp-mat (-> rot-xyz-deg x))
    (matrix*! rot-mat temp-mat dst)
    (matrix-rotate-y! temp-mat (-> rot-xyz-deg y))
    (matrix*! dst temp-mat rot-mat)
    )
  dst
  )

;; definition for function matrix-rotate-yzx!
;; Used lq/sq
(defun matrix-rotate-yzx! ((dst matrix) (rot-xyz-deg vector))
  (let ((temp-mat (new-stack-matrix0))
        (rot-mat (new-stack-matrix0))
        )
    (matrix-rotate-z! dst (-> rot-xyz-deg x))
    (matrix-rotate-x! temp-mat (-> rot-xyz-deg z))
    (matrix*! rot-mat temp-mat dst)
    (matrix-rotate-y! temp-mat (-> rot-xyz-deg y))
    (matrix*! dst temp-mat rot-mat)
    )
  dst
  )

;; definition for function matrix-rotate-yxy!
(defun matrix-rotate-yxy! ((dst matrix) (rots-deg vector))
  (let ((sincos-input (new 'stack-no-clear 'vector))
        (sin-vec (new 'stack-no-clear 'vector))
        (cos-vec (new 'stack-no-clear 'vector))
        )
    (set-vector! sincos-input (-> rots-deg x) (- (-> rots-deg y) (-> rots-deg z)) (-> rots-deg z) 1.0)
    (vector-sincos! sin-vec cos-vec sincos-input)
    (let ((cos-y (-> cos-vec y))
          (sin-y (-> sin-vec y))
          (cos-x (-> cos-vec x))
          (sin-x (-> sin-vec x))
          (cos-z (-> cos-vec z))
          (sin-z (-> sin-vec z))
          )
      (set! (-> dst vector 0 x) (- (* cos-y cos-z) (* sin-y cos-x sin-z)))
      (set! (-> dst vector 0 y) (* sin-y sin-x))
      (set! (-> dst vector 0 z) (- (+ (* cos-y sin-z) (* sin-y cos-x cos-z))))
      (set! (-> dst vector 0 w) 0.0)
      (set! (-> dst vector 1 x) (* sin-x sin-z))
      (set! (-> dst vector 1 y) cos-x)
      (set! (-> dst vector 1 z) (* sin-x cos-z))
      (set! (-> dst vector 1 w) 0.0)
      (set! (-> dst vector 2 x) (+ (* sin-y cos-z) (* cos-y cos-x sin-z)))
      (set! (-> dst vector 2 y) (- (* cos-y sin-x)))
      (set! (-> dst vector 2 z) (- (* cos-y cos-x cos-z) (* sin-y sin-z)))
      )
    )
  (set! (-> dst vector 2 w) 0.0)
  (set! (-> dst vector 3 x) 0.0)
  (set! (-> dst vector 3 y) 0.0)
  (set! (-> dst vector 3 z) 0.0)
  (set! (-> dst vector 3 w) 1.0)
  dst
  )

;; definition for function matrix-rotate-yx!
;; Used lq/sq
(defun matrix-rotate-yx! ((dst matrix) (rot-y-deg float) (rot-x-deg float))
  (matrix-rotate-y! dst rot-y-deg)
  (let ((a1-2 (matrix-rotate-x! (new-stack-matrix0) rot-x-deg)))
    (matrix*! dst a1-2 dst)
    )
  dst
  )

;; definition for function matrix-axis-sin-cos-vu!
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function matrix-axis-sin-cos!
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function matrix-axis-angle!
;; INFO: Return type mismatch matrix vs none.
(defun matrix-axis-angle! ((dst matrix) (axis vector) (angle-deg float))
  (matrix-axis-sin-cos! dst axis (sin angle-deg) (cos angle-deg))
  (none)
  )

;; definition for function matrix-lerp!
(defun matrix-lerp! ((dst matrix) (src1 matrix) (src2 matrix) (alpha float))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         (vf8 :class vf)
         (vf9 :class vf)
         )
    (.mov vf9 alpha)
    (.lvf vf1 (&-> src1 vector 0 quad))
    (.lvf vf2 (&-> src1 vector 1 quad))
    (.lvf vf3 (&-> src1 vector 2 quad))
    (.lvf vf4 (&-> src1 vector 3 quad))
    (.lvf vf5 (&-> src2 vector 0 quad))
    (.lvf vf6 (&-> src2 vector 1 quad))
    (.lvf vf7 (&-> src2 vector 2 quad))
    (.lvf vf8 (&-> src2 vector 3 quad))
    (.sub.vf vf5 vf5 vf1)
    (.sub.vf vf6 vf6 vf2)
    (.sub.vf vf7 vf7 vf3)
    (.sub.vf vf8 vf8 vf4)
    (.mul.x.vf vf5 vf5 vf9)
    (.mul.x.vf vf6 vf6 vf9)
    (.mul.x.vf vf7 vf7 vf9)
    (.mul.x.vf vf8 vf8 vf9)
    (.add.vf vf1 vf1 vf5)
    (.add.vf vf2 vf2 vf6)
    (.add.vf vf3 vf3 vf7)
    (.add.vf vf4 vf4 vf8)
    (.svf (&-> dst vector 0 quad) vf1)
    (.svf (&-> dst vector 1 quad) vf2)
    (.svf (&-> dst vector 2 quad) vf3)
    (.svf (&-> dst vector 3 quad) vf4)
    dst
    )
  )

;; definition for function matrix-3x3-determinant
(defun matrix-3x3-determinant ((mat matrix))
  (let ((f8-0 (-> mat vector 0 x))
        (f1-0 (-> mat vector 0 y))
        (f4-0 (-> mat vector 0 z))
        (f2-0 (-> mat vector 1 x))
        (f5-0 (-> mat vector 1 y))
        (f9-0 (-> mat vector 1 z))
        (f3-0 (-> mat vector 2 x))
        (f6-0 (-> mat vector 2 y))
        (f0-0 (-> mat vector 2 z))
        )
    (- (+ (* f8-0 f5-0 f0-0) (* f1-0 f9-0 f3-0) (* f4-0 f2-0 f6-0))
       (+ (* f8-0 f9-0 f6-0) (* f4-0 f5-0 f3-0) (* f1-0 f2-0 f0-0))
       )
    )
  )

;; definition for function matrix3-determinant
(defun matrix3-determinant ((arg0 matrix))
  (local-vars (v0-0 float))
  (rlet ((acc :class vf)
         (vf10 :class vf)
         (vf11 :class vf)
         (vf12 :class vf)
         (vf13 :class vf)
         )
    (.lvf vf11 (&-> arg0 vector 1 quad))
    (.lvf vf12 (&-> arg0 vector 2 quad))
    (.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)
    (.mov v0-0 vf13)
    v0-0
    )
  )

;; definition for function matrix-3x3-inverse!
(defun matrix-3x3-inverse! ((dst matrix) (src matrix))
  (let ((f0-0 (matrix-3x3-determinant src)))
    (set! (-> dst vector 0 x)
          (/ (- (* (-> src vector 1 y) (-> src vector 2 z)) (* (-> src vector 1 z) (-> src vector 2 y))) f0-0)
          )
    (set! (-> dst vector 1 x)
          (/ (- (* (-> src vector 1 z) (-> src vector 2 x)) (* (-> src vector 1 x) (-> src vector 2 z))) f0-0)
          )
    (set! (-> dst vector 2 x)
          (/ (- (* (-> src vector 1 x) (-> src vector 2 y)) (* (-> src vector 1 y) (-> src vector 2 x))) f0-0)
          )
    (set! (-> dst vector 0 y)
          (/ (- (* (-> src vector 2 y) (-> src vector 0 z)) (* (-> src vector 2 z) (-> src vector 0 y))) f0-0)
          )
    (set! (-> dst vector 1 y)
          (/ (- (* (-> src vector 2 z) (-> src vector 0 x)) (* (-> src vector 2 x) (-> src vector 0 z))) f0-0)
          )
    (set! (-> dst vector 2 y)
          (/ (- (* (-> src vector 2 x) (-> src vector 0 y)) (* (-> src vector 2 y) (-> src vector 0 x))) f0-0)
          )
    (set! (-> dst vector 0 z)
          (/ (- (* (-> src vector 0 y) (-> src vector 1 z)) (* (-> src vector 0 z) (-> src vector 1 y))) f0-0)
          )
    (set! (-> dst vector 1 z)
          (/ (- (* (-> src vector 0 z) (-> src vector 1 x)) (* (-> src vector 0 x) (-> src vector 1 z))) f0-0)
          )
    (set! (-> dst vector 2 z)
          (/ (- (* (-> src vector 0 x) (-> src vector 1 y)) (* (-> src vector 0 y) (-> src vector 1 x))) f0-0)
          )
    )
  dst
  )

;; definition for function matrix-3x3-inverse-transpose!
(defun matrix-3x3-inverse-transpose! ((dst matrix) (src matrix))
  (let ((f0-0 (matrix-3x3-determinant src)))
    (set! (-> dst vector 0 x)
          (/ (- (* (-> src vector 1 y) (-> src vector 2 z)) (* (-> src vector 1 z) (-> src vector 2 y))) f0-0)
          )
    (set! (-> dst vector 0 y)
          (/ (- (* (-> src vector 1 z) (-> src vector 2 x)) (* (-> src vector 1 x) (-> src vector 2 z))) f0-0)
          )
    (set! (-> dst vector 0 z)
          (/ (- (* (-> src vector 1 x) (-> src vector 2 y)) (* (-> src vector 1 y) (-> src vector 2 x))) f0-0)
          )
    (set! (-> dst vector 1 x)
          (/ (- (* (-> src vector 2 y) (-> src vector 0 z)) (* (-> src vector 2 z) (-> src vector 0 y))) f0-0)
          )
    (set! (-> dst vector 1 y)
          (/ (- (* (-> src vector 2 z) (-> src vector 0 x)) (* (-> src vector 2 x) (-> src vector 0 z))) f0-0)
          )
    (set! (-> dst vector 1 z)
          (/ (- (* (-> src vector 2 x) (-> src vector 0 y)) (* (-> src vector 2 y) (-> src vector 0 x))) f0-0)
          )
    (set! (-> dst vector 2 x)
          (/ (- (* (-> src vector 0 y) (-> src vector 1 z)) (* (-> src vector 0 z) (-> src vector 1 y))) f0-0)
          )
    (set! (-> dst vector 2 y)
          (/ (- (* (-> src vector 0 z) (-> src vector 1 x)) (* (-> src vector 0 x) (-> src vector 1 z))) f0-0)
          )
    (set! (-> dst vector 2 z)
          (/ (- (* (-> src vector 0 x) (-> src vector 1 y)) (* (-> src vector 0 y) (-> src vector 1 x))) f0-0)
          )
    )
  dst
  )

;; definition for function matrix3-inverse-transpose!
(defun matrix3-inverse-transpose! ((dst matrix) (src matrix))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf10 :class vf)
         (vf11 :class vf)
         (vf12 :class vf)
         (vf13 :class vf)
         (vf14 :class vf)
         (vf15 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf10 (&-> src vector 0 quad))
    (.lvf vf11 (&-> src vector 1 quad))
    (.lvf vf12 (&-> src vector 2 quad))
    (.outer.product.a.vf acc vf11 vf12)
    (.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)
    (.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)
    (.nop.vf)
    (.nop.vf)
    (.nop.vf)
    (.add.z.vf vf1 vf1 vf1 :mask #b1)
    (.nop.vf)
    (.nop.vf)
    (.nop.vf)
    (.div.vf Q vf0 vf1 :fsf #b11 :ftf #b0)
    (.wait.vf)
    (.mul.vf vf13 vf13 Q)
    (.mul.vf vf14 vf14 Q)
    (.mul.vf vf15 vf15 Q)
    (.nop.vf)
    (.nop.vf)
    (.svf (&-> dst vector 0 quad) vf13)
    (.svf (&-> dst vector 1 quad) vf14)
    (.svf (&-> dst vector 2 quad) vf15)
    dst
    )
  )

;; definition for function matrix-4x4-determinant
(defun matrix-4x4-determinant ((dst matrix))
  (let ((f15-0 (-> dst vector 0 x))
        (f14-0 (-> dst vector 0 y))
        (f10-0 (-> dst vector 0 z))
        (f2-0 (-> dst vector 0 w))
        (f9-0 (-> dst vector 1 x))
        (f6-0 (-> dst vector 1 y))
        (f3-0 (-> dst vector 1 z))
        (f11-0 (-> dst vector 1 w))
        (f5-0 (-> dst vector 2 x))
        (f1-0 (-> dst vector 2 y))
        (f8-0 (-> dst vector 2 z))
        (f13-0 (-> dst vector 2 w))
        (f0-0 (-> dst vector 3 x))
        (f7-0 (-> dst vector 3 y))
        (f4-0 (-> dst vector 3 z))
        (f12-0 (-> dst vector 3 w))
        )
    (- (+ (* f15-0 f6-0 f8-0 f12-0)
          (* f15-0 f3-0 f13-0 f7-0)
          (* f15-0 f11-0 f1-0 f4-0)
          (* f14-0 f9-0 f13-0 f4-0)
          (* f14-0 f3-0 f5-0 f4-0)
          (* f14-0 f11-0 f8-0 f0-0)
          (* f10-0 f9-0 f1-0 f12-0)
          (* f10-0 f6-0 f13-0 f0-0)
          (* f10-0 f11-0 f5-0 f7-0)
          (* f2-0 f9-0 f1-0 f4-0)
          (* f2-0 f6-0 f8-0 f0-0)
          (* f2-0 f3-0 f5-0 f7-0)
          )
       (+ (* f15-0 f6-0 f13-0 f4-0)
          (* f15-0 f3-0 f1-0 f12-0)
          (* f15-0 f11-0 f8-0 f7-0)
          (* f14-0 f9-0 f8-0 f12-0)
          (* f14-0 f3-0 f13-0 f0-0)
          (* f14-0 f11-0 f5-0 f4-0)
          (* f10-0 f9-0 f13-0 f7-0)
          (* f10-0 f6-0 f5-0 f12-0)
          (* f10-0 f11-0 f1-0 f0-0)
          (* f2-0 f9-0 f8-0 f7-0)
          (* f2-0 f6-0 f5-0 f4-0)
          (* f2-0 f3-0 f1-0 f0-0)
          )
       )
    )
  )

;; definition for function matrix-4x4-inverse-transpose!
(defun matrix-4x4-inverse-transpose! ((dst matrix) (src matrix))
  (let ((f0-0 (matrix-4x4-determinant src)))
    (let ((f9-0 (-> src vector 1 y))
          (f2-0 (-> src vector 1 z))
          (f5-0 (-> src vector 1 w))
          (f3-0 (-> src vector 2 y))
          (f6-0 (-> src vector 2 z))
          (f10-0 (-> src vector 2 w))
          (f4-0 (-> src vector 3 y))
          (f7-0 (-> src vector 3 z))
          (f1-0 (-> src vector 3 w))
          )
      (set! (-> dst vector 0 x) (/ (- (+ (* f9-0 f6-0 f1-0) (* f2-0 f10-0 f4-0) (* f5-0 f3-0 f7-0))
                                      (+ (* f9-0 f10-0 f7-0) (* f5-0 f6-0 f4-0) (* f2-0 f3-0 f1-0))
                                      )
                                   f0-0
                                   )
            )
      )
    (let ((f9-2 (-> src vector 1 x))
          (f2-2 (-> src vector 1 z))
          (f5-2 (-> src vector 1 w))
          (f3-1 (-> src vector 2 x))
          (f6-1 (-> src vector 2 z))
          (f10-1 (-> src vector 2 w))
          (f4-3 (-> src vector 3 x))
          (f7-2 (-> src vector 3 z))
          (f1-6 (-> src vector 3 w))
          )
      (set! (-> dst vector 0 y) (- (/ (- (+ (* f9-2 f6-1 f1-6) (* f2-2 f10-1 f4-3) (* f5-2 f3-1 f7-2))
                                         (+ (* f9-2 f10-1 f7-2) (* f5-2 f6-1 f4-3) (* f2-2 f3-1 f1-6))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f9-4 (-> src vector 1 x))
          (f2-4 (-> src vector 1 y))
          (f5-4 (-> src vector 1 w))
          (f3-2 (-> src vector 2 x))
          (f6-2 (-> src vector 2 y))
          (f10-2 (-> src vector 2 w))
          (f4-6 (-> src vector 3 x))
          (f7-4 (-> src vector 3 y))
          (f1-13 (-> src vector 3 w))
          )
      (set! (-> dst vector 0 z) (/ (- (+ (* f9-4 f6-2 f1-13) (* f2-4 f10-2 f4-6) (* f5-4 f3-2 f7-4))
                                      (+ (* f9-4 f10-2 f7-4) (* f5-4 f6-2 f4-6) (* f2-4 f3-2 f1-13))
                                      )
                                   f0-0
                                   )
            )
      )
    (let ((f9-6 (-> src vector 1 x))
          (f2-6 (-> src vector 1 y))
          (f5-6 (-> src vector 1 z))
          (f3-3 (-> src vector 2 x))
          (f6-3 (-> src vector 2 y))
          (f10-3 (-> src vector 2 z))
          (f4-9 (-> src vector 3 x))
          (f7-6 (-> src vector 3 y))
          (f1-19 (-> src vector 3 z))
          )
      (set! (-> dst vector 0 w) (- (/ (- (+ (* f9-6 f6-3 f1-19) (* f2-6 f10-3 f4-9) (* f5-6 f3-3 f7-6))
                                         (+ (* f9-6 f10-3 f7-6) (* f5-6 f6-3 f4-9) (* f2-6 f3-3 f1-19))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f9-8 (-> src vector 0 y))
          (f2-8 (-> src vector 0 z))
          (f5-8 (-> src vector 0 w))
          (f3-4 (-> src vector 2 y))
          (f6-4 (-> src vector 2 z))
          (f10-4 (-> src vector 2 w))
          (f4-12 (-> src vector 3 y))
          (f7-8 (-> src vector 3 z))
          (f1-26 (-> src vector 3 w))
          )
      (set! (-> dst vector 1 x) (- (/ (- (+ (* f9-8 f6-4 f1-26) (* f2-8 f10-4 f4-12) (* f5-8 f3-4 f7-8))
                                         (+ (* f9-8 f10-4 f7-8) (* f5-8 f6-4 f4-12) (* f2-8 f3-4 f1-26))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f9-10 (-> src vector 0 x))
          (f2-10 (-> src vector 0 z))
          (f5-10 (-> src vector 0 w))
          (f3-5 (-> src vector 2 x))
          (f6-5 (-> src vector 2 z))
          (f10-5 (-> src vector 2 w))
          (f4-15 (-> src vector 3 x))
          (f7-10 (-> src vector 3 z))
          (f1-33 (-> src vector 3 w))
          )
      (set! (-> dst vector 1 y) (/ (- (+ (* f9-10 f6-5 f1-33) (* f2-10 f10-5 f4-15) (* f5-10 f3-5 f7-10))
                                      (+ (* f9-10 f10-5 f7-10) (* f5-10 f6-5 f4-15) (* f2-10 f3-5 f1-33))
                                      )
                                   f0-0
                                   )
            )
      )
    (let ((f9-12 (-> src vector 0 x))
          (f2-12 (-> src vector 0 y))
          (f5-12 (-> src vector 0 w))
          (f3-6 (-> src vector 2 x))
          (f6-6 (-> src vector 2 y))
          (f10-6 (-> src vector 2 w))
          (f4-18 (-> src vector 3 x))
          (f7-12 (-> src vector 3 y))
          (f1-39 (-> src vector 3 w))
          )
      (set! (-> dst vector 1 z) (- (/ (- (+ (* f9-12 f6-6 f1-39) (* f2-12 f10-6 f4-18) (* f5-12 f3-6 f7-12))
                                         (+ (* f9-12 f10-6 f7-12) (* f5-12 f6-6 f4-18) (* f2-12 f3-6 f1-39))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f9-14 (-> src vector 0 x))
          (f2-14 (-> src vector 0 y))
          (f5-14 (-> src vector 0 z))
          (f3-7 (-> src vector 2 x))
          (f6-7 (-> src vector 2 y))
          (f10-7 (-> src vector 2 z))
          (f4-21 (-> src vector 3 x))
          (f7-14 (-> src vector 3 y))
          (f1-46 (-> src vector 3 z))
          )
      (set! (-> dst vector 1 w) (/ (- (+ (* f9-14 f6-7 f1-46) (* f2-14 f10-7 f4-21) (* f5-14 f3-7 f7-14))
                                      (+ (* f9-14 f10-7 f7-14) (* f5-14 f6-7 f4-21) (* f2-14 f3-7 f1-46))
                                      )
                                   f0-0
                                   )
            )
      )
    (let ((f9-16 (-> src vector 0 y))
          (f2-16 (-> src vector 0 z))
          (f5-16 (-> src vector 0 w))
          (f3-8 (-> src vector 1 y))
          (f6-8 (-> src vector 1 z))
          (f10-8 (-> src vector 1 w))
          (f4-24 (-> src vector 3 y))
          (f7-16 (-> src vector 3 z))
          (f1-52 (-> src vector 3 w))
          )
      (set! (-> dst vector 2 x) (/ (- (+ (* f9-16 f6-8 f1-52) (* f2-16 f10-8 f4-24) (* f5-16 f3-8 f7-16))
                                      (+ (* f9-16 f10-8 f7-16) (* f5-16 f6-8 f4-24) (* f2-16 f3-8 f1-52))
                                      )
                                   f0-0
                                   )
            )
      )
    (let ((f9-18 (-> src vector 0 x))
          (f2-18 (-> src vector 0 z))
          (f5-18 (-> src vector 0 w))
          (f3-9 (-> src vector 1 x))
          (f6-9 (-> src vector 1 z))
          (f10-9 (-> src vector 1 w))
          (f4-27 (-> src vector 3 x))
          (f7-18 (-> src vector 3 z))
          (f1-58 (-> src vector 3 w))
          )
      (set! (-> dst vector 2 y) (- (/ (- (+ (* f9-18 f6-9 f1-58) (* f2-18 f10-9 f4-27) (* f5-18 f3-9 f7-18))
                                         (+ (* f9-18 f10-9 f7-18) (* f5-18 f6-9 f4-27) (* f2-18 f3-9 f1-58))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f9-20 (-> src vector 0 x))
          (f2-20 (-> src vector 0 y))
          (f5-20 (-> src vector 0 w))
          (f3-10 (-> src vector 1 x))
          (f6-10 (-> src vector 1 y))
          (f10-10 (-> src vector 1 w))
          (f4-30 (-> src vector 3 x))
          (f7-20 (-> src vector 3 y))
          (f1-65 (-> src vector 3 w))
          )
      (set! (-> dst vector 2 z) (/ (- (+ (* f9-20 f6-10 f1-65) (* f2-20 f10-10 f4-30) (* f5-20 f3-10 f7-20))
                                      (+ (* f9-20 f10-10 f7-20) (* f5-20 f6-10 f4-30) (* f2-20 f3-10 f1-65))
                                      )
                                   f0-0
                                   )
            )
      )
    (let ((f9-22 (-> src vector 0 x))
          (f2-22 (-> src vector 0 y))
          (f5-22 (-> src vector 0 z))
          (f3-11 (-> src vector 1 x))
          (f6-11 (-> src vector 1 y))
          (f10-11 (-> src vector 1 z))
          (f4-33 (-> src vector 3 x))
          (f7-22 (-> src vector 3 y))
          (f1-71 (-> src vector 3 z))
          )
      (set! (-> dst vector 2 w) (- (/ (- (+ (* f9-22 f6-11 f1-71) (* f2-22 f10-11 f4-33) (* f5-22 f3-11 f7-22))
                                         (+ (* f9-22 f10-11 f7-22) (* f5-22 f6-11 f4-33) (* f2-22 f3-11 f1-71))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f9-24 (-> src vector 0 y))
          (f2-24 (-> src vector 0 z))
          (f5-24 (-> src vector 0 w))
          (f3-12 (-> src vector 1 y))
          (f6-12 (-> src vector 1 z))
          (f10-12 (-> src vector 1 w))
          (f4-36 (-> src vector 2 y))
          (f7-24 (-> src vector 2 z))
          (f1-78 (-> src vector 2 w))
          )
      (set! (-> dst vector 3 x) (- (/ (- (+ (* f9-24 f6-12 f1-78) (* f2-24 f10-12 f4-36) (* f5-24 f3-12 f7-24))
                                         (+ (* f9-24 f10-12 f7-24) (* f5-24 f6-12 f4-36) (* f2-24 f3-12 f1-78))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f9-26 (-> src vector 0 x))
          (f2-26 (-> src vector 0 z))
          (f5-26 (-> src vector 0 w))
          (f3-13 (-> src vector 1 x))
          (f6-13 (-> src vector 1 z))
          (f10-13 (-> src vector 1 w))
          (f4-39 (-> src vector 2 x))
          (f7-26 (-> src vector 2 z))
          (f1-85 (-> src vector 2 w))
          )
      (set! (-> dst vector 3 y) (/ (- (+ (* f9-26 f6-13 f1-85) (* f2-26 f10-13 f4-39) (* f5-26 f3-13 f7-26))
                                      (+ (* f9-26 f10-13 f7-26) (* f5-26 f6-13 f4-39) (* f2-26 f3-13 f1-85))
                                      )
                                   f0-0
                                   )
            )
      )
    (let ((f9-28 (-> src vector 0 x))
          (f2-28 (-> src vector 0 y))
          (f5-28 (-> src vector 0 w))
          (f3-14 (-> src vector 1 x))
          (f6-14 (-> src vector 1 y))
          (f10-14 (-> src vector 1 w))
          (f4-42 (-> src vector 2 x))
          (f7-28 (-> src vector 2 y))
          (f1-91 (-> src vector 2 w))
          )
      (set! (-> dst vector 3 z) (- (/ (- (+ (* f9-28 f6-14 f1-91) (* f2-28 f10-14 f4-42) (* f5-28 f3-14 f7-28))
                                         (+ (* f9-28 f10-14 f7-28) (* f5-28 f6-14 f4-42) (* f2-28 f3-14 f1-91))
                                         )
                                      f0-0
                                      )
                                   )
            )
      )
    (let ((f8-60 (-> src vector 0 x))
          (f1-98 (-> src vector 0 y))
          (f5-30 (-> src vector 0 z))
          (f2-30 (-> src vector 1 x))
          (f6-15 (-> src vector 1 y))
          (f9-30 (-> src vector 1 z))
          (f4-45 (-> src vector 2 x))
          (f7-30 (-> src vector 2 y))
          (f3-15 (-> src vector 2 z))
          )
      (set! (-> dst vector 3 w) (/ (- (+ (* f8-60 f6-15 f3-15) (* f1-98 f9-30 f4-45) (* f5-30 f2-30 f7-30))
                                      (+ (* f8-60 f9-30 f7-30) (* f5-30 f6-15 f4-45) (* f1-98 f2-30 f3-15))
                                      )
                                   f0-0
                                   )
            )
      )
    )
  dst
  )

;; definition for function matrix-y-angle
(defun matrix-y-angle ((mat matrix))
  (let ((z-row (-> mat vector 2)))
    (atan (-> z-row x) (-> z-row z))
    )
  )

;; definition for method 9 of type matrix
;; ERROR: function was not converted to expressions. Cannot decompile.
