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

;; definition for symbol *particle-300hz-timer*, type int
(define *particle-300hz-timer* 0)

;; definition of type sparticle-birthinfo
(deftype sparticle-birthinfo (structure)
  ((sprite       uint32   :offset-assert   0)
   (anim         int32    :offset-assert   4)
   (anim-speed   float    :offset-assert   8)
   (birth-func   basic    :offset-assert  12)
   (joint-ppoint int32    :offset-assert  16)
   (num-to-birth float    :offset-assert  20)
   (sound        basic    :offset-assert  24)
   (dataf        float  1 :offset          0)
   (data         uint32 1 :offset          0)
   )
  :method-count-assert 9
  :size-assert         #x1c
  :flag-assert         #x90000001c
  )

;; definition for method 3 of type sparticle-birthinfo
(defmethod inspect sparticle-birthinfo ((obj sparticle-birthinfo))
  (format #t "[~8x] ~A~%" obj 'sparticle-birthinfo)
  (format #t "~Tsprite: ~D~%" (-> obj sprite))
  (format #t "~Tanim: ~D~%" (-> obj anim))
  (format #t "~Tanim-speed: ~f~%" (-> obj anim-speed))
  (format #t "~Tbirth-func: ~A~%" (-> obj birth-func))
  (format #t "~Tjoint-ppoint: ~D~%" (-> obj joint-ppoint))
  (format #t "~Tnum-to-birth: ~f~%" (-> obj num-to-birth))
  (format #t "~Tsound: ~A~%" (-> obj sound))
  (format #t "~Tdataf[1] @ #x~X~%" (&-> obj sprite))
  (format #t "~Tdata[1] @ #x~X~%" (&-> obj sprite))
  obj
  )

;; 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 sparticle-launcher ((obj sparticle-launcher))
  (format #t "~X: sparticle-launcher~%" obj)
  (let ((s5-0 0))
    (while (!= (-> obj init-specs s5-0 field) (sp-field-id spt-end))
      (let* ((v1-1 (-> obj init-specs s5-0))
             (t9-1 format)
             (a0-3 #t)
             (a1-1 "~T~S : ~F / #x~X / ~D~%")
             (a2-1 (-> v1-1 field))
             )
        (t9-1
          a0-3
          a1-1
          (cond
            ((= a2-1 (sp-field-id spt-end))
             "spt-end"
             )
            ((= a2-1 (sp-field-id spt-scalevel))
             "spt-scalevel"
             )
            ((= a2-1 (sp-field-id spt-scale))
             "spt-scale"
             )
            ((= a2-1 (sp-field-id launch-fields-end))
             "launch-fields-end"
             )
            ((= a2-1 (sp-field-id spt-rotate-y))
             "spt-rotate-y"
             )
            ((= a2-1 (sp-field-id spt-conerot-radius))
             "spt-conerot-radius"
             )
            ((= a2-1 (sp-field-id spt-conerot-w))
             "spt-conerot-w"
             )
            ((= a2-1 (sp-field-id spt-conerot-z))
             "spt-conerot-z"
             )
            ((= a2-1 (sp-field-id spt-conerot-y))
             "spt-conerot-y"
             )
            ((= a2-1 (sp-field-id spt-conerot-x))
             "spt-conerot-x"
             )
            ((= a2-1 (sp-field-id spt-launchrot-w))
             "spt-launchrot-w"
             )
            ((= a2-1 (sp-field-id spt-launchrot-z))
             "spt-launchrot-z"
             )
            ((= a2-1 (sp-field-id spt-launchrot-y))
             "spt-launchrot-y"
             )
            ((= a2-1 (sp-field-id spt-launchrot-x))
             "spt-launchrot-x"
             )
            ((= a2-1 (sp-field-id launch-fields-start))
             "launch-fields-start"
             )
            ((= a2-1 (sp-field-id cpu-fields-end))
             "cpu-fields-end"
             )
            ((= a2-1 (sp-field-id spt-next-launcher))
             "spt-next-launcher"
             )
            ((= a2-1 (sp-field-id spt-next-time))
             "spt-next-time"
             )
            ((= a2-1 (sp-field-id spt-func))
             "spt-func"
             )
            ((= a2-1 (sp-field-id spt-userdata))
             "spt-userdata"
             )
            ((= a2-1 (sp-field-id spt-flags))
             "spt-flags"
             )
            ((= a2-1 (sp-field-id spt-timer))
             "spt-timer"
             )
            ((= a2-1 (sp-field-id spt-friction))
             "spt-friction"
             )
            ((= a2-1 (sp-field-id spt-quad-w))
             "spt-quad-w"
             )
            ((= a2-1 (sp-field-id spt-quat-z))
             "spt-quat-z"
             )
            ((= a2-1 (sp-field-id spt-quat-y))
             "spt-quat-y"
             )
            ((= a2-1 (sp-field-id spt-quat-x))
             "spt-quat-x"
             )
            ((= a2-1 (sp-field-id spt-dummy))
             "spt-dummy"
             )
            ((= a2-1 (sp-field-id spt-accel-z))
             "spt-accel-z"
             )
            ((= a2-1 (sp-field-id spt-accel-y))
             "spt-accel-y"
             )
            ((= a2-1 (sp-field-id spt-accel-x))
             "spt-accel-x"
             )
            ((= a2-1 (sp-field-id spt-fade-a))
             "spt-fade-a"
             )
            ((= a2-1 (sp-field-id spt-fade-b))
             "spt-fade-b"
             )
            ((= a2-1 (sp-field-id spt-fade-g))
             "spt-fade-g"
             )
            ((= a2-1 (sp-field-id spt-fade-r))
             "spt-fade-r"
             )
            ((= a2-1 (sp-field-id spt-scalevel-y))
             "spt-scalevel-y"
             )
            ((= a2-1 (sp-field-id spt-rotvel-z))
             "spt-rotvel-z"
             )
            ((= a2-1 (sp-field-id spt-rotvel-y))
             "spt-rotvel-y"
             )
            ((= a2-1 (sp-field-id spt-rotvel-x))
             "spt-rotvel-x"
             )
            ((= a2-1 (sp-field-id spt-scalevel-x))
             "spt-scalevel-x"
             )
            ((= a2-1 (sp-field-id spt-vel-z))
             "spt-vel-z"
             )
            ((= a2-1 (sp-field-id spt-vel-y))
             "spt-vel-y"
             )
            ((= a2-1 (sp-field-id spt-vel-x))
             "spt-vel-x"
             )
            ((= a2-1 (sp-field-id spt-omega))
             "spt-omega"
             )
            ((= a2-1 (sp-field-id cpu-fields-start))
             "cpu-fields-start"
             )
            ((= a2-1 (sp-field-id sprite-fields-end))
             "sprite-fields-end"
             )
            ((= a2-1 (sp-field-id spt-a))
             "spt-a"
             )
            ((= a2-1 (sp-field-id spt-b))
             "spt-b"
             )
            ((= a2-1 (sp-field-id spt-g))
             "spt-g"
             )
            ((= a2-1 (sp-field-id spt-r))
             "spt-r"
             )
            ((= a2-1 (sp-field-id spt-scale-y))
             "spt-scale-y"
             )
            ((= a2-1 (sp-field-id spt-rot-z))
             "spt-rot-z"
             )
            ((= a2-1 (sp-field-id spt-rot-y))
             "spt-rot-y"
             )
            ((= a2-1 (sp-field-id spt-rot-x))
             "spt-rot-x"
             )
            ((= a2-1 (sp-field-id spt-scale-x))
             "spt-scale-x"
             )
            ((= a2-1 (sp-field-id spt-z))
             "spt-z"
             )
            ((= a2-1 (sp-field-id spt-y))
             "spt-y"
             )
            ((= a2-1 (sp-field-id spt-x))
             "spt-x"
             )
            ((= a2-1 (sp-field-id sprite-fields-start))
             "sprite-fields-start"
             )
            ((= a2-1 (sp-field-id misc-fields-end))
             "misc-fields-end"
             )
            ((= a2-1 (sp-field-id spt-sound))
             "spt-sound"
             )
            ((= a2-1 (sp-field-id spt-num))
             "spt-num"
             )
            ((= a2-1 (sp-field-id spt-joint/refpoint))
             "spt-joint/refpoint"
             )
            ((= a2-1 (sp-field-id spt-birth-func))
             "spt-birth-func"
             )
            ((= a2-1 (sp-field-id spt-anim-speed))
             "spt-anim-speed"
             )
            ((= a2-1 (sp-field-id spt-anim))
             "spt-anim"
             )
            ((= a2-1 (sp-field-id spt-texture))
             "spt-texture"
             )
            ((= a2-1 (sp-field-id misc-fields-start))
             "misc-fields-start"
             )
            (else
              "*unknown*"
              )
            )
          (-> v1-1 initial-valuef)
          (-> v1-1 initial-valuef)
          (-> v1-1 initial-valuef)
          )
        )
      (+! s5-0 1)
      )
    )
  (the-as sparticle-launcher 0)
  )

;; definition for symbol *part-id-table*, type (array sparticle-launcher)
(define *part-id-table*
  (the-as (array sparticle-launcher) (new 'global 'boxed-array sparticle-launcher 3584))
  )

;; definition for symbol *part-group-id-table*, type (array sparticle-launch-group)
(define *part-group-id-table*
  (the-as (array sparticle-launch-group) (new 'global 'boxed-array sparticle-launch-group 1024))
  )

;; definition for function lookup-part-group-by-name
;; INFO: Return type mismatch sparticle-launch-group vs basic.
(defun lookup-part-group-by-name ((arg0 string))
  (let* ((s5-0 *part-group-id-table*)
         (s4-0 (-> s5-0 length))
         )
    (dotimes (s3-0 s4-0)
      (let ((s2-0 (-> s5-0 s3-0)))
        (if (and (nonzero? s2-0) (string= arg0 (-> s2-0 name)))
            (return (the-as basic s2-0))
            )
        )
      )
    )
  (the-as sparticle-launch-group #f)
  )

;; definition for function lookup-part-group-pointer-by-name
(defun lookup-part-group-pointer-by-name ((arg0 string))
  (let* ((s4-0 *part-group-id-table*)
         (s3-0 (-> s4-0 length))
         )
    (dotimes (gp-0 s3-0)
      (let ((v1-2 (-> s4-0 gp-0)))
        (if (and (nonzero? v1-2) (string= arg0 (-> v1-2 name)))
            (return (&+ (-> s4-0 data) (* gp-0 4)))
            )
        )
      )
    )
  (the-as (pointer sparticle-launch-group) #f)
  )

;; definition for function part-group-pointer?
(defun part-group-pointer? ((arg0 pointer))
  (let ((v1-0 *part-group-id-table*))
    (and (>= (the-as int arg0) (the-as int (-> v1-0 data))) (< (the-as int arg0) (the-as int (&-> v1-0 1024))))
    )
  )

;; definition for function unlink-part-group-by-heap
(defun unlink-part-group-by-heap ((arg0 kheap))
  (let* ((v1-0 *part-group-id-table*)
         (a2-0 (-> v1-0 length))
         (a1-0 (-> arg0 base))
         (a0-1 (-> arg0 top-base))
         )
    (while (nonzero? a2-0)
      (+! a2-0 -1)
      (let ((a3-2 (-> v1-0 a2-0)))
        (when (and (>= (the-as int a3-2) (the-as int a1-0)) (< (the-as int a3-2) (the-as int a0-1)))
          (set! (-> v1-0 a2-0) (the-as sparticle-launch-group 0))
          0
          )
        )
      )
    )
  0
  )

;; definition for function sp-init-fields!
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition of type sp-queued-launch-particles
(deftype sp-queued-launch-particles (structure)
  ((sp-system   sparticle-system           :offset-assert   0)
   (sp-launcher sparticle-launcher         :offset-assert   4)
   (pos         vector             :inline :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

;; definition for method 3 of type sp-queued-launch-particles
(defmethod inspect sp-queued-launch-particles ((obj sp-queued-launch-particles))
  (format #t "[~8x] ~A~%" obj 'sp-queued-launch-particles)
  (format #t "~Tsp-system: ~A~%" (-> obj sp-system))
  (format #t "~Tsp-launcher: ~A~%" (-> obj sp-launcher))
  (format #t "~Tpos: #<vector @ #x~X>~%" (-> obj pos))
  obj
  )

;; definition of type sp-launch-queue
(deftype sp-launch-queue (basic)
  ((in-use int32                                 :offset-assert   4)
   (queue  sp-queued-launch-particles 32 :inline :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x410
  :flag-assert         #x900000410
  )

;; definition for method 3 of type sp-launch-queue
(defmethod inspect sp-launch-queue ((obj sp-launch-queue))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tin-use: ~D~%" (-> obj in-use))
  (format #t "~Tqueue[32] @ #x~X~%" (-> obj queue))
  obj
  )

;; definition for symbol *sp-launcher-lock*, type symbol
(define *sp-launcher-lock* #f)

;; definition for symbol *sp-launch-queue*, type sp-launch-queue
(define *sp-launch-queue* (new 'global 'sp-launch-queue))

;; definition for symbol *sp-launcher-enable*, type symbol
(define *sp-launcher-enable* #t)

;; definition for function particle-setup-adgif
;; INFO: Return type mismatch int vs none.
(defun particle-setup-adgif ((arg0 adgif-shader) (arg1 texture-id))
  (let ((a1-1 (lookup-texture-by-id arg1)))
    (set! (-> arg0 tex1) (new 'static 'gs-tex1 :mmag #x1 :mmin #x1))
    (set! (-> arg0 tex0 tfx) 0)
    (if a1-1
        (adgif-shader<-texture! arg0 a1-1)
        )
    )
  (set! (-> arg0 prims 1) (gs-reg64 tex0-1))
  (set! (-> arg0 prims 3) (gs-reg64 tex1-1))
  (set! (-> arg0 prims 5) (gs-reg64 miptbp1-1))
  (set! (-> arg0 clamp-reg) (gs-reg64 zbuf-1))
  (set! (-> arg0 prims 9) (gs-reg64 alpha-1))
  (set! (-> arg0 alpha) (new 'static 'gs-alpha :b #x1 :d #x1))
  (set! (-> arg0 clamp) (new 'static 'gs-clamp :minu #x1c :minv #x101))
  0
  (none)
  )

;; definition of type particle-adgif-cache
(deftype particle-adgif-cache (basic)
  ((used    int32                   :offset-assert   4)
   (last    uint16                  :offset-assert   8)
   (lastgif adgif-shader            :offset-assert  12)
   (tidhash uint16       80         :offset-assert  16)
   (spadgif adgif-shader 80 :inline :offset-assert 176)
   )
  :method-count-assert 9
  :size-assert         #x19b0
  :flag-assert         #x9000019b0
  )

;; definition for method 3 of type particle-adgif-cache
(defmethod inspect particle-adgif-cache ((obj particle-adgif-cache))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tused: ~D~%" (-> obj used))
  (format #t "~Tlast: ~D~%" (-> obj last))
  (format #t "~Tlastgif: #<adgif-shader @ #x~X>~%" (-> obj lastgif))
  (format #t "~Ttidhash[80] @ #x~X~%" (-> obj tidhash))
  (format #t "~Tspadgif[80] @ #x~X~%" (-> obj spadgif))
  obj
  )

;; definition for symbol *particle-adgif-cache*, type particle-adgif-cache
(define *particle-adgif-cache* (new 'global 'particle-adgif-cache))

;; failed to figure out what this is:
(set! (-> *particle-adgif-cache* used) 0)

;; definition for function particle-adgif
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function sp-queue-launch
;; INFO: Used lq/sq
(defun sp-queue-launch ((arg0 sparticle-system) (arg1 sparticle-launcher) (arg2 vector))
  (let ((v1-0 *sp-launch-queue*))
    (when (= (-> v1-0 in-use) 32)
      (format 0 "ERROR: sp-launch-particles called during processing, and queue is full~%")
      (return 0)
      )
    (let ((a3-5 (-> v1-0 queue (-> v1-0 in-use))))
      (set! (-> a3-5 sp-system) arg0)
      (set! (-> a3-5 sp-launcher) arg1)
      (set! (-> a3-5 pos quad) (-> arg2 quad))
      )
    (let ((v0-1 (+ (-> v1-0 in-use) 1)))
      (set! (-> v1-0 in-use) v0-1)
      v0-1
      )
    )
  )

;; definition for function sp-adjust-launch
;; INFO: Return type mismatch int vs none.
(defun sp-adjust-launch ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo) (arg2 (inline-array sp-field-init-spec)))
  (let ((s5-0 (new 'stack-no-clear 'sparticle-launchinfo)))
    (let ((s2-0 (new 'stack-no-clear 'matrix))
          (s3-0 (new 'stack-no-clear 'vector))
          )
      (sp-init-fields!
        (-> s5-0 launchrot)
        arg2
        (sp-field-id launch-fields-start)
        (sp-field-id launch-fields-end)
        #t
        )
      (matrix-rotate-xyz! s2-0 (-> s5-0 launchrot))
      (vector3s-matrix*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s2-0)
      (matrix-rotate-xyz! s2-0 (-> s5-0 conerot))
      (vector3s-matrix*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s2-0)
      (if (logtest? (sp-cpuinfo-flag launch-along-z) (-> arg1 flags))
          (set-vector! s3-0 0.0 0.0 (-> s5-0 coneradius) 1.0)
          (set-vector! s3-0 0.0 (-> s5-0 coneradius) 0.0 1.0)
          )
      (vector-matrix*! s3-0 s3-0 s2-0)
      (+! (-> arg0 launchrot x) (-> s3-0 x))
      (+! (-> arg0 launchrot y) (-> s3-0 y))
      (+! (-> arg0 launchrot z) (-> s3-0 z))
      )
    (when (!= (-> s5-0 rotate-y) 0.0)
      (let ((s3-1 (new 'stack-no-clear 'matrix)))
        (matrix-rotate-y! s3-1 (-> s5-0 rotate-y))
        (vector3s-rotate*! (the-as vector3s (-> arg0 launchrot)) (the-as vector3s (-> arg0 launchrot)) s3-1)
        (vector3s-rotate*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s3-1)
        (if (zero? (logand (sp-cpuinfo-flag use-global-acc) (-> arg1 flags)))
            (vector3s-rotate*! (the-as vector3s (-> arg1 acc)) (the-as vector3s (-> arg1 acc)) s3-1)
            )
        )
      (if (logtest? (sp-cpuinfo-flag set-conerot) (-> arg1 flags))
          (set! (-> arg0 conerot y) (+ 16384.0 (-> s5-0 rotate-y)))
          )
      )
    )
  0
  (none)
  )

;; definition for function sp-euler-convert
;; INFO: Return type mismatch int vs none.
(defun sp-euler-convert ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo))
  (local-vars (v1-1 float) (v1-2 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
    (init-vf0-vector)
    (let ((a1-1 (new 'stack-no-clear 'vector))
          (s5-0 (new 'stack-no-clear 'quaternion))
          )
      (set-vector! a1-1 (-> arg0 conerot x) (-> arg0 conerot y) (-> arg0 conerot z) 1.0)
      (quaternion-zxy! s5-0 a1-1)
      (cond
        ((< (-> s5-0 w) 0.0)
         (.lvf vf1 (&-> arg0 conerot quad))
         (.lvf vf2 (&-> s5-0 vec quad))
         (.sub.vf vf1 vf0 vf2 :mask #b111)
         (.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)
          (.svf (&-> arg0 conerot quad) vf1)
          (.mov v1-2 vf1)
          )
        )
      )
    (cond
      (*sp-60-hz*
        (set! (-> arg1 rot-syvel x) (* 5.0 (-> arg1 rot-syvel x)))
        (set! (-> arg1 rot-syvel y) (* 5.0 (-> arg1 rot-syvel y)))
        (set! (-> arg1 rot-syvel z) (* 5.0 (-> arg1 rot-syvel z)))
        )
      (else
        (set! (-> arg1 rot-syvel x) (* 6.0 (-> arg1 rot-syvel x)))
        (set! (-> arg1 rot-syvel y) (* 6.0 (-> arg1 rot-syvel y)))
        (set! (-> arg1 rot-syvel z) (* 6.0 (-> arg1 rot-syvel z)))
        )
      )
    (quaternion-zxy! (-> arg1 rotvel3d) (-> arg1 rot-syvel))
    0
    (none)
    )
  )

;; definition for function sp-rotate-system
;; INFO: Return type mismatch int vs none.
(defun sp-rotate-system ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo) (arg2 transformq))
  (let ((s5-0 (new 'stack-no-clear 'matrix)))
    (let ((a1-1 (new 'stack-no-clear 'quaternion)))
      (let* ((v1-0 a1-1)
             (a0-1 arg2)
             (f0-0 (-> a0-1 quat x))
             (f1-0 (-> a0-1 quat y))
             (f3-0 (-> a0-1 quat z))
             )
        (set! (-> v1-0 x) f0-0)
        (set! (-> v1-0 y) f1-0)
        (set! (-> v1-0 z) f3-0)
        (set! (-> v1-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
        )
      (quaternion->matrix s5-0 a1-1)
      )
    (vector3s-rotate*! (the-as vector3s (-> arg0 launchrot)) (the-as vector3s (-> arg0 launchrot)) s5-0)
    (vector3s-rotate*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s5-0)
    (if (zero? (logand (sp-cpuinfo-flag use-global-acc) (-> arg1 flags)))
        (vector3s-rotate*! (the-as vector3s (-> arg1 acc)) (the-as vector3s (-> arg1 acc)) s5-0)
        )
    )
  0
  (none)
  )

;; definition for function sp-launch-particles-var
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for symbol *death-adgif*, type adgif-shader
(define *death-adgif* (the-as adgif-shader #f))

;; definition for function sp-launch-particles-death
;; INFO: Used lq/sq
;; INFO: Return type mismatch int vs none.
;; WARN: Function sp-launch-particles-death has a return type of none, but the expression builder found a return statement.
(defun sp-launch-particles-death ((arg0 sparticle-system) (arg1 sparticle-launcher) (arg2 vector))
  (local-vars (v1-25 float) (v1-27 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf30 :class vf)
         (vf31 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf30 (&-> arg2 quad))
    (let ((v1-0 #x437f0000))
      (.mov vf31 v1-0)
      )
    (let ((s5-0 (new 'stack-no-clear 'sprite-vec-data-2d))
          (gp-0 (sp-get-particle arg0 0 (the-as sparticle-launch-state #f)))
          )
      (if (not gp-0)
          (return 0)
          )
      (let* ((a1-2 (-> arg1 init-specs 0))
             (a1-3
               (sp-init-fields!
                 (&-> s5-0 x)
                 (the-as (inline-array sp-field-init-spec) a1-2)
                 (sp-field-id sprite-fields-start)
                 (sp-field-id sprite-fields-end)
                 #t
                 )
               )
             )
        (sp-init-fields!
          (&-> gp-0 omega)
          (the-as (inline-array sp-field-init-spec) a1-3)
          (sp-field-id cpu-fields-start)
          (sp-field-id cpu-fields-end)
          #t
          )
        )
      (set! (-> s5-0 matrix) 0)
      (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)
      (.svf (&-> s5-0 color quad) vf4)
      (.svf (&-> s5-0 x-y-z-sx quad) vf5)
      (when (not *death-adgif*)
        (set! *death-adgif* (new 'static 'adgif-shader))
        (particle-adgif *death-adgif* (new 'static 'texture-id :index #x18 :page #x2))
        (set! (-> *death-adgif* alpha) (new 'static 'gs-alpha :b #x2 :d #x1))
        )
      (let ((v1-14 (-> *death-adgif* quad 0 quad)))
        (set! (-> gp-0 adgif quad 0 quad) v1-14)
        )
      (let ((v1-16 (-> *death-adgif* quad 1 quad)))
        (set! (-> gp-0 adgif quad 1 quad) v1-16)
        )
      (let ((v1-18 (-> *death-adgif* quad 2 quad)))
        (set! (-> gp-0 adgif quad 2 quad) v1-18)
        )
      (let ((v1-20 (-> *death-adgif* quad 3 quad)))
        (set! (-> gp-0 adgif quad 3 quad) v1-20)
        )
      (let ((v1-22 (-> *death-adgif* quad 4 quad)))
        (set! (-> gp-0 adgif quad 4 quad) v1-22)
        )
      (.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)
      (.svf (&-> s5-0 color quad) vf5)
      (.svf (&-> gp-0 fade quad) vf6)
      (.mov v1-25 vf6)
      (set! (-> gp-0 key) (the-as sparticle-launch-control 0))
      (set! (-> gp-0 binding) #f)
      (let ((v1-26 (-> gp-0 sprite)))
        (.lvf vf1 (&-> s5-0 x-y-z-sx quad))
        (.lvf vf2 (&-> s5-0 flag-rot-sy quad))
        (.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)
        (.svf (&-> v1-26 color quad) vf3)
        )
      (.mov v1-27 vf3)
      (logior! (-> gp-0 flags) (sp-cpuinfo-flag ready-to-launch))
      (set! (-> gp-0 cache-alpha) (-> s5-0 a))
      )
    0
    (none)
    )
  )

;; definition for function sp-clear-queue
;; INFO: Return type mismatch int vs none.
(defun sp-clear-queue ()
  (let ((gp-0 *sp-launch-queue*))
    (when (> (-> gp-0 in-use) 0)
      (dotimes (s5-0 (-> gp-0 in-use))
        (let ((v1-4 (-> gp-0 queue s5-0)))
          (sp-launch-particles-var
            (-> v1-4 sp-system)
            (-> v1-4 sp-launcher)
            (-> v1-4 pos)
            (the-as sparticle-launch-state #f)
            (the-as sparticle-launch-control #f)
            1.0
            )
          )
        )
      (set! (-> gp-0 in-use) 0)
      0
      )
    )
  0
  (none)
  )

;; definition for function sp-relaunch-setup-fields
;; INFO: Return type mismatch int vs none.
(defun sp-relaunch-setup-fields ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d))
  (let ((a1-1 (-> arg1 init-specs 0))
        (s4-0 (logand (-> arg2 flags) (sp-cpuinfo-flag level0 level1)))
        )
    (set! (-> arg2 next-launcher) (the-as basic 0))
    (cond
      ((and (logtest? (-> arg2 flags) (sp-cpuinfo-flag bit12))
            (zero? (logand (-> arg2 flags) (sp-cpuinfo-flag aux-list)))
            )
       (let ((f20-0 (-> arg3 r-g-b-a x))
             (f22-0 (-> arg3 r-g-b-a y))
             (f24-0 (-> arg3 r-g-b-a z))
             (f26-0 (-> arg2 fade x))
             (f28-0 (-> arg2 fade y))
             (f30-0 (-> arg2 fade z))
             )
         (set! (-> arg3 r-g-b-a x) 99999.0)
         (set! (-> arg3 r-g-b-a y) 99999.0)
         (set! (-> arg3 r-g-b-a z) 99999.0)
         (set! (-> arg2 fade x) 99999.0)
         (set! (-> arg2 fade y) 99999.0)
         (set! (-> arg2 fade z) 99999.0)
         (let ((a1-2
                 (sp-init-fields!
                   (-> arg3 x-y-z-sx)
                   (the-as (inline-array sp-field-init-spec) a1-1)
                   (sp-field-id sprite-fields-start)
                   (sp-field-id sprite-fields-end)
                   #f
                   )
                 )
               )
           (sp-init-fields!
             (&-> arg2 omega)
             (the-as (inline-array sp-field-init-spec) a1-2)
             (sp-field-id cpu-fields-start)
             (sp-field-id cpu-fields-end)
             #f
             )
           )
         (logior! (-> arg2 flags) s4-0)
         (if (logtest? (-> arg2 flags) (sp-cpuinfo-flag level1))
             (-> *level* level1)
             (-> *level* level0)
             )
         (let ((v1-16 (-> *time-of-day-context* current-prt-color)))
           (if (= (-> arg3 r-g-b-a x) 99999.0)
               (set! (-> arg3 r-g-b-a x) f20-0)
               (set! (-> arg3 r-g-b-a x) (* (-> arg3 r-g-b-a x) (-> v1-16 x)))
               )
           (if (= (-> arg3 r-g-b-a y) 99999.0)
               (set! (-> arg3 r-g-b-a y) f22-0)
               (set! (-> arg3 r-g-b-a y) (* (-> arg3 r-g-b-a y) (-> v1-16 y)))
               )
           (if (= (-> arg3 r-g-b-a z) 99999.0)
               (set! (-> arg3 r-g-b-a z) f24-0)
               (set! (-> arg3 r-g-b-a z) (* (-> arg3 r-g-b-a z) (-> v1-16 z)))
               )
           (if (= (-> arg2 fade x) 99999.0)
               (set! (-> arg2 fade x) f26-0)
               (set! (-> arg2 fade x) (* (-> arg2 fade x) (-> v1-16 x)))
               )
           (if (= (-> arg2 fade y) 99999.0)
               (set! (-> arg2 fade y) f28-0)
               (set! (-> arg2 fade y) (* (-> arg2 fade y) (-> v1-16 y)))
               )
           (if (= (-> arg2 fade z) 99999.0)
               (set! (-> arg2 fade z) f30-0)
               (set! (-> arg2 fade z) (* (-> arg2 fade z) (-> v1-16 z)))
               )
           )
         )
       )
      (else
        (let ((a1-3
                (sp-init-fields!
                  (-> arg3 x-y-z-sx)
                  (the-as (inline-array sp-field-init-spec) a1-1)
                  (sp-field-id sprite-fields-start)
                  (sp-field-id sprite-fields-end)
                  #f
                  )
                )
              )
          (sp-init-fields!
            (&-> arg2 omega)
            (the-as (inline-array sp-field-init-spec) a1-3)
            (sp-field-id cpu-fields-start)
            (sp-field-id cpu-fields-end)
            #f
            )
          )
        )
      )
    )
  0
  0
  (none)
  )

;; definition for function sp-relaunch-particle-2d
;; INFO: Return type mismatch int vs none.
(defun sp-relaunch-particle-2d ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d))
  (sp-relaunch-setup-fields arg0 arg1 arg2 arg3)
  (when (logtest? (-> arg2 flags) (sp-cpuinfo-flag aux-list))
    (set! (-> arg2 func) add-to-sprite-aux-list)
    (set! (-> arg3 r-g-b-a w) 0.0)
    (set! (-> arg2 fade w) 0.0)
    (logclear! (-> arg2 flags) (sp-cpuinfo-flag bit2))
    )
  0
  (none)
  )

;; definition for function sp-relaunch-particle-3d
;; INFO: Return type mismatch int vs none.
(defun sp-relaunch-particle-3d ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d))
  (local-vars (v1-9 float) (v1-10 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
    (init-vf0-vector)
    (let ((s4-0 (new 'stack-no-clear 'quaternion)))
      (let* ((v1-0 s4-0)
             (a2-1 arg3)
             (f0-0 (-> a2-1 qx-qy-qz-sy x))
             (f1-0 (-> a2-1 qx-qy-qz-sy y))
             (f3-0 (-> a2-1 qx-qy-qz-sy z))
             )
        (set! (-> v1-0 x) f0-0)
        (set! (-> v1-0 y) f1-0)
        (set! (-> v1-0 z) f3-0)
        (set! (-> v1-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
        )
      (set! (-> arg3 qx-qy-qz-sy x) 0.0)
      (set! (-> arg3 qx-qy-qz-sy y) 0.0)
      (set! (-> arg3 qx-qy-qz-sy z) 0.0)
      (sp-relaunch-setup-fields arg0 arg1 arg2 arg3)
      (let ((a1-1 (new 'stack-no-clear 'vector))
            (s3-0 (new 'stack-no-clear 'quaternion))
            )
        (set-vector! a1-1 (-> arg3 qx-qy-qz-sy x) (-> arg3 qx-qy-qz-sy y) (-> arg3 qx-qy-qz-sy z) 1.0)
        (quaternion-zxy! s3-0 a1-1)
        (cond
          ((logtest? (sp-cpuinfo-flag left-multiply-quat) (-> arg2 flags))
           (quaternion*! s3-0 s4-0 s3-0)
           )
          (else
            (if (logtest? (sp-cpuinfo-flag right-multiply-quat) (-> arg2 flags))
                (quaternion*! s3-0 s3-0 s4-0)
                )
            )
          )
        (cond
          ((< (-> 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)
           (.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)
            (.svf (&-> arg3 qx-qy-qz-sy quad) vf1)
            (.mov v1-10 vf1)
            )
          )
        )
      )
    (cond
      (*sp-60-hz*
        (set! (-> arg2 rot-syvel x) (* 5.0 (-> arg2 rot-syvel x)))
        (set! (-> arg2 rot-syvel y) (* 5.0 (-> arg2 rot-syvel y)))
        (set! (-> arg2 rot-syvel z) (* 5.0 (-> arg2 rot-syvel z)))
        )
      (else
        (set! (-> arg2 rot-syvel x) (* 6.0 (-> arg2 rot-syvel x)))
        (set! (-> arg2 rot-syvel y) (* 6.0 (-> arg2 rot-syvel y)))
        (set! (-> arg2 rot-syvel z) (* 6.0 (-> arg2 rot-syvel z)))
        )
      )
    (quaternion-zxy! (-> arg2 rotvel3d) (-> arg2 rot-syvel))
    0
    (none)
    )
  )

;; definition for method 9 of type sparticle-launch-control
;; INFO: Return type mismatch int vs none.
(defmethod initialize sparticle-launch-control ((obj sparticle-launch-control) (arg0 sparticle-launch-group) (arg1 process))
  (let ((s5-0 0))
    (set! (-> obj group) arg0)
    (set! (-> obj proc) arg1)
    (set! (-> obj local-clock) 0)
    (set! (-> obj fade) 1.0)
    (set! (-> obj matrix) 0)
    (set! (-> obj last-spawn-frame) (the-as int (+ (-> *display* real-actual-frame-counter) (seconds -0.007))))
    (set! (-> obj last-spawn-time) 0)
    (dotimes (s3-0 (-> arg0 length))
      (let* ((a0-2 (-> arg0 launcher s3-0))
             (a1-2 (-> *part-id-table* (-> a0-2 launcher)))
             (v1-9 (-> obj data s5-0))
             )
        (when (nonzero? a1-2)
          (set! (-> v1-9 group-item) a0-2)
          (cond
            ((= (-> a1-2 type) sparticle-launcher)
             (set! (-> v1-9 accum) 0.0)
             (set! (-> v1-9 spawn-time) (the-as uint (+ *particle-300hz-timer* -30000)))
             (set! (-> v1-9 offset) (-> a0-2 offset))
             (set! (-> v1-9 randomize) (the-as uint 0))
             (cond
               ((logtest? (-> a0-2 flags) (sp-group-item-flag start-dead))
                (logclear! (-> v1-9 flags) (sp-launch-state-flags launcher-active))
                (set! (-> v1-9 origin) #f)
                (set! (-> v1-9 sprite3d) #f)
                (set! (-> v1-9 sprite) #f)
                )
               (else
                 (logior! (-> v1-9 flags) (sp-launch-state-flags launcher-active))
                 (set! (-> v1-9 origin) (-> obj center))
                 (set! (-> v1-9 sprite3d) #f)
                 (set! (-> v1-9 sprite) #f)
                 )
               )
             (+! s5-0 1)
             )
            (else
              (format 0 "initialize called with non-particle-launcher~%")
              )
            )
          )
        )
      )
    (set! (-> obj length) s5-0)
    )
  0
  (none)
  )

;; definition for method 9 of type sparticle-launch-group
;; INFO: Return type mismatch object vs sparticle-launch-control.
(defmethod create-launch-control sparticle-launch-group ((obj sparticle-launch-group) (arg0 process))
  (let ((gp-0 (the-as object (new 'process 'sparticle-launch-control (-> obj length)))))
    (when (zero? (the-as sparticle-launch-control gp-0))
      (go process-drawable-art-error "memory")
      (set! gp-0 0)
      (goto cfg-4)
      )
    (initialize (the-as sparticle-launch-control gp-0) obj arg0)
    (label cfg-4)
    (the-as sparticle-launch-control gp-0)
    )
  )

;; definition for method 12 of type sparticle-launch-control
;; INFO: Return type mismatch int vs none.
(defmethod kill-and-free-particles sparticle-launch-control ((obj sparticle-launch-control))
  (countdown (v1-0 (-> obj length))
    (let ((a0-3 (-> obj data v1-0)))
      (logclear! (-> a0-3 flags) (sp-launch-state-flags particles-active))
      )
    )
  (set! (-> obj local-clock) 0)
  (set! (-> obj fade) 1.0)
  (kill-all-particles-with-key obj)
  (if (> (-> obj matrix) 0)
      (sprite-release-user-hvdf (-> obj matrix))
      )
  0
  (none)
  )

;; definition for method 13 of type sparticle-launch-control
;; INFO: Return type mismatch int vs none.
(defmethod kill-particles sparticle-launch-control ((obj sparticle-launch-control))
  (kill-all-particles-with-key obj)
  0
  (none)
  )

;; definition for method 10 of type sparticle-launch-control
(defmethod is-visible? sparticle-launch-control ((obj sparticle-launch-control) (arg0 vector))
  (let* ((v1-0 (-> obj group))
         (f0-0 (-> v1-0 bounds w))
         )
    (cond
      ((= f0-0 0.0)
       #t
       )
      ((nonzero? (-> obj matrix))
       #t
       )
      (else
        (let ((gp-1 (vector+! (new 'stack-no-clear 'vector) arg0 (the-as vector (-> v1-0 bounds)))))
          (set! (-> gp-1 w) f0-0)
          (if (and *display-actor-vis* (or (not *display-actor-anim*) (name= *display-actor-anim* (-> obj proc name))))
              (add-debug-sphere *display-actor-vis* (bucket-id debug) gp-1 (-> gp-1 w) (new 'static 'rgba :g #xff :a #x80))
              )
          (sphere-in-view-frustum? (the-as sphere gp-1))
          )
        )
      )
    )
  )

;; definition for method 11 of type sparticle-launch-control
;; INFO: Used lq/sq
;; INFO: Return type mismatch int vs object.
(defmethod spawn sparticle-launch-control ((obj sparticle-launch-control) (arg0 vector))
  (set! (-> obj center quad) (-> arg0 quad))
  (if (not (or (is-visible? obj arg0) (logtest? (-> obj group flags) (sp-group-flag always-draw screen-space))))
      (return (the-as object 0))
      )
  (let ((s4-0 *particle-300hz-timer*)
        (s5-0 (-> obj last-spawn-time))
        )
    (let ((v1-8 (-> *display* real-actual-frame-counter)))
      (if (!= v1-8 (+ (-> obj last-spawn-frame) 1))
          (set! s5-0 (- s4-0 (logand (the-as int (-> *sp-frame-time* x)) 255)))
          )
      )
    (set! (-> obj last-spawn-frame) (the-as int (-> *display* real-actual-frame-counter)))
    (set! (-> obj last-spawn-time) s4-0)
    (when (logtest? (-> obj group flags) (sp-group-flag use-local-clock))
      (set! s5-0 (-> obj local-clock))
      (+! (-> obj local-clock) (logand (the-as int (-> *sp-frame-time* x)) 255))
      (set! s4-0 (-> obj local-clock))
      )
    (let ((f30-0 (vector-vector-distance arg0 (math-camera-pos)))
          (s3-1 (ash 1 (if *time-of-day-proc*
                           (-> *time-of-day-proc* 0 hour)
                           0
                           )
                     )
                )
          )
      (if (nonzero? (-> obj matrix))
          (set! f30-0 0.0)
          )
      (let ((s2-1 (-> obj length)))
        (while (begin (label cfg-79) (nonzero? s2-1))
          (+! s2-1 -1)
          (let* ((a3-0 (-> obj data s2-1))
                 (v1-29 (-> a3-0 group-item))
                 (a1-4 (-> *part-id-table* (-> v1-29 launcher)))
                 )
            (when (and a1-4 (nonzero? a1-4) (logtest? (-> a3-0 flags) (sp-launch-state-flags launcher-active)))
              (let ((f0-2 1.0))
                (if (!= (-> v1-29 falloff-to) 0.0)
                    (set! f0-2 (- 1.0 (/ f30-0 (-> v1-29 falloff-to))))
                    )
                (let ((a0-26 sparticle-launcher))
                  (b! (!= (-> a1-4 type) a0-26) cfg-78 :delay (nop!))
                  )
                (b! (zero? (logand (-> v1-29 flags) (sp-group-item-flag launch-asap))) cfg-36 :delay (nop!))
                (when (zero? (logand (-> a3-0 flags) (sp-launch-state-flags particles-active)))
                  (set! (-> a3-0 spawn-time) (the-as uint s4-0))
                  (logior! (-> a3-0 flags) (sp-launch-state-flags particles-active))
                  (if (< 0.0 f0-2)
                      (sp-launch-particles-var
                        (if (logtest? (-> v1-29 flags) (sp-group-item-flag is-3d))
                            *sp-particle-system-3d*
                            *sp-particle-system-2d*
                            )
                        a1-4
                        (-> a3-0 origin)
                        a3-0
                        obj
                        f0-2
                        )
                      )
                  )
                (b! #t cfg-77 :delay (nop!))
                (label cfg-36)
                (when (logtest? s3-1 (-> v1-29 hour-mask))
                  0
                  (goto cfg-77)
                  )
                (when (not (or (= (-> v1-29 fade-after) 0.0) (< f30-0 (-> v1-29 fade-after))))
                  0
                  (b! #t cfg-77 :delay (nop!))
                  (set! v1-29 (the-as sparticle-group-item 0))
                  )
                (b! (nonzero? (-> v1-29 period)) cfg-50 :delay (empty-form))
                (let ((f0-4 (* 0.2 (the float (- s4-0 s5-0)) f0-2)))
                  (b! #t cfg-72 :delay (nop!))
                  (label cfg-50)
                  (let ((a2-5 (mod (+ s5-0 (-> obj data s2-1 offset)) (the-as int (-> v1-29 period))))
                        (a0-56 (mod (the-as uint (+ s4-0 (-> obj data s2-1 offset))) (-> v1-29 period)))
                        (t0-2 (-> v1-29 length))
                        )
                    (set! f0-4 (cond
                                 ((and (< a2-5 (the-as int t0-2)) (< a0-56 t0-2))
                                  (* 0.2 (the float (- s4-0 s5-0)) f0-2)
                                  )
                                 ((and (< a2-5 (the-as int t0-2)) (>= a0-56 t0-2))
                                  (* 0.2 (the float (- t0-2 (the-as uint a2-5))) f0-2)
                                  )
                                 ((and (>= a2-5 (the-as int t0-2)) (< a0-56 t0-2))
                                  (* 0.2 (the float a0-56) f0-2)
                                  )
                                 (else
                                   (when (zero? (logand (-> v1-29 flags) (sp-group-item-flag bit1)))
                                     0
                                     (goto cfg-77)
                                     )
                                   (when (< (the-as uint (- s4-0 (the-as int (-> obj data s2-1 spawn-time)))) (-> v1-29 period))
                                     0
                                     (goto cfg-77)
                                     )
                                   (set! (-> obj data s2-1 offset) (- (-> v1-29 period) a0-56))
                                   (* 0.2 (the float (- s4-0 s5-0)) f0-2)
                                   )
                                 )
                          )
                    )
                  (label cfg-72)
                  (set! (-> a3-0 spawn-time) (the-as uint s4-0))
                  (logior! (-> a3-0 flags) (sp-launch-state-flags particles-active))
                  (if (< 0.0 f0-4)
                      (sp-launch-particles-var
                        (if (logtest? (-> v1-29 flags) (sp-group-item-flag is-3d))
                            *sp-particle-system-3d*
                            *sp-particle-system-2d*
                            )
                        a1-4
                        (-> a3-0 origin)
                        a3-0
                        obj
                        f0-4
                        )
                      )
                  )
                )
              (label cfg-77)
              (b! #t cfg-79 :delay (nop!))
              (label cfg-78)
              (format 0 "spawn called for non-sparticle-launcher~%")
              )
            )
          )
        )
      )
    )
  0
  )

;; definition for function sparticle-track-root
;; INFO: Return type mismatch int vs none.
(defun sparticle-track-root ((arg0 object) (arg1 sparticle-cpuinfo) (arg2 vector))
  (let ((v1-3 (-> (the-as process-drawable (-> arg1 key proc)) root trans)))
    (set! (-> arg2 x) (-> v1-3 x))
    (set! (-> arg2 y) (-> v1-3 y))
    (set! (-> arg2 z) (-> v1-3 z))
    )
  0
  (none)
  )

;; definition for function sparticle-track-root-prim
;; INFO: Return type mismatch int vs none.
(defun sparticle-track-root-prim ((arg0 object) (arg1 sparticle-cpuinfo) (arg2 vector))
  (let ((v1-4 (-> (the-as collide-shape (-> (the-as process-drawable (-> arg1 key proc)) root)) root-prim prim-core))
        )
    (set! (-> arg2 x) (-> v1-4 world-sphere x))
    (set! (-> arg2 y) (-> v1-4 world-sphere y))
    (set! (-> arg2 z) (-> v1-4 world-sphere z))
    )
  0
  (none)
  )

;; definition for function birth-func-copy-rot-color
;; INFO: Return type mismatch int vs none.
(defun birth-func-copy-rot-color ((arg0 sparticle-system)
                         (arg1 sparticle-cpuinfo)
                         (arg2 sprite-vec-data-3d)
                         (arg3 sparticle-launcher)
                         (arg4 sparticle-launch-state)
                         )
  (local-vars (v1-4 float) (v1-5 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
    (init-vf0-vector)
    (let ((s5-0 (-> arg4 sprite)))
      (let ((s4-0 (new 'stack-no-clear 'vector)))
        (let* ((v1-0 arg2)
               (f0-0 (-> v1-0 qx-qy-qz-sy x))
               (f1-0 (-> v1-0 qx-qy-qz-sy y))
               (f3-0 (-> v1-0 qx-qy-qz-sy z))
               )
          (set! (-> s4-0 x) f0-0)
          (set! (-> s4-0 y) f1-0)
          (set! (-> s4-0 z) f3-0)
          (set! (-> s4-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
          )
        (quaternion-rotate-y! (the-as quaternion s4-0) (the-as quaternion s4-0) (-> s5-0 sprite rot))
        (let ((v1-3 arg2))
          (cond
            ((< (-> 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)
             (.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)
              (.svf (&-> v1-3 qx-qy-qz-sy quad) vf1)
              (.mov v1-5 vf1)
              )
            )
          )
        )
      (set! (-> arg2 r-g-b-a x) (-> s5-0 sprite r))
      (set! (-> arg2 r-g-b-a y) (-> s5-0 sprite g))
      (set! (-> arg2 r-g-b-a z) (-> s5-0 sprite b))
      )
    0
    (none)
    )
  )

;; definition for symbol *global-toggle*, type int
(define *global-toggle* 0)

;; definition for function birth-func-copy2-rot-color
;; INFO: Used lq/sq
;; INFO: Return type mismatch int vs none.
(defun birth-func-copy2-rot-color ((arg0 sparticle-system)
                          (arg1 sparticle-cpuinfo)
                          (arg2 sprite-vec-data-3d)
                          (arg3 sparticle-launcher)
                          (arg4 sparticle-launch-state)
                          )
  (local-vars (v1-15 float) (v1-16 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
    (init-vf0-vector)
    (let ((s5-0 (-> arg4 sprite)))
      (let ((s4-0 (new 'stack-no-clear 'vector)))
        (let* ((v1-0 arg2)
               (f0-0 (-> v1-0 qx-qy-qz-sy x))
               (f1-0 (-> v1-0 qx-qy-qz-sy y))
               (f3-0 (-> v1-0 qx-qy-qz-sy z))
               )
          (set! (-> s4-0 x) f0-0)
          (set! (-> s4-0 y) f1-0)
          (set! (-> s4-0 z) f3-0)
          (set! (-> s4-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
          )
        (let ((a1-1 (new-stack-vector0)))
          (set! (-> a1-1 y) (-> s5-0 sprite rot))
          (set! (-> a1-1 z) (if (logtest? *global-toggle* 1)
                                (the float (sar (shl (the int (- 16384.0 (-> s5-0 sprite sx))) 48) 48))
                                (the float (sar (shl (the int (+ 16384.0 (-> s5-0 sprite sx))) 48) 48))
                                )
                )
          (quaternion-zxy! (the-as quaternion s4-0) a1-1)
          )
        (let ((v1-14 arg2))
          (cond
            ((< (-> 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)
             (.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)
              (.svf (&-> v1-14 qx-qy-qz-sy quad) vf1)
              (.mov v1-16 vf1)
              )
            )
          )
        )
      (set! (-> arg2 r-g-b-a x) (-> s5-0 sprite r))
      (set! (-> arg2 r-g-b-a y) (-> s5-0 sprite g))
      (set! (-> arg2 r-g-b-a z) (-> s5-0 sprite b))
      )
    (set! *global-toggle* (+ *global-toggle* 1))
    0
    (none)
    )
  )

;; definition for function birth-func-copy-omega-to-z
;; INFO: Return type mismatch int vs none.
(defun birth-func-copy-omega-to-z ((arg0 sparticle-system)
                          (arg1 sparticle-cpuinfo)
                          (arg2 sprite-vec-data-3d)
                          (arg3 sparticle-launcher)
                          (arg4 sparticle-launch-state)
                          )
  (set! (-> arg2 qx-qy-qz-sy z) (+ -16384.0 (-> arg1 omega)))
  (set! (-> arg1 next-time) (-> arg4 sprite next-time))
  (set! (-> arg2 x-y-z-sx w) (* 163.85638 (the float (-> arg4 sprite next-time))))
  0
  (none)
  )

;; definition for function birth-func-random-next-time
;; INFO: Return type mismatch int vs none.
(defun birth-func-random-next-time ((arg0 sparticle-system)
                           (arg1 sparticle-cpuinfo)
                           (arg2 sprite-vec-data-3d)
                           (arg3 sparticle-launcher)
                           (arg4 sparticle-launch-state)
                           )
  (set! (-> arg1 next-time) (the-as uint (the int (rand-vu-float-range 0.0 (-> arg1 user-float)))))
  0
  (none)
  )
