jak-project/test/decompiler/reference/jakx/engine/common-obs/generic-obs-h_REF.gc

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

;; definition of type manipy
(deftype manipy (process-drawable)
  ((new-trans-hook        (function none))
   (cur-trans-hook        (function none))
   (cur-event-hook        (function none))
   (new-joint-anim        art-joint-anim)
   (new-joint-anim-blend  uint64)
   (new-joint-anim-frame  float)
   (anim-mode             symbol)
   (cur-grab-handle       uint64)
   (cur-target-handle     uint64)
   (old-grab-pos          vector     :inline)
   (joint                 joint-mod  4)
   (new-post-hook         (function none))
   (cur-post-hook         (function none))
   (clone-copy-trans      symbol)
   (shadow-backup         shadow-geo)
   (draw?                 symbol)
   (userdata              uint64)
   (prefix                basic)
   (shadow-volume-joint   int32)
   (speed                 float)
   (user-uint64           uint64     4)
   (options               manipy-options)
   )
  (:methods
    (manipy-method-50 () none)
    )
  )

;; definition for method 3 of type manipy
(defmethod inspect ((this manipy))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~2Tnew-trans-hook: ~A~%" (-> this new-trans-hook))
  (format #t "~2Tcur-trans-hook: ~A~%" (-> this cur-trans-hook))
  (format #t "~2Tcur-event-hook: ~A~%" (-> this cur-event-hook))
  (format #t "~2Tnew-joint-anim: ~A~%" (-> this new-joint-anim))
  (format #t "~2Tnew-joint-anim-blend: ~D~%" (-> this new-joint-anim-blend))
  (format #t "~2Tnew-joint-anim-frame: ~f~%" (-> this new-joint-anim-frame))
  (format #t "~2Tanim-mode: ~A~%" (-> this anim-mode))
  (format #t "~2Tcur-grab-handle: ~D~%" (-> this cur-grab-handle))
  (format #t "~2Tcur-target-handle: ~D~%" (-> this cur-target-handle))
  (format #t "~2Told-grab-pos: ~`vector`P~%" (-> this old-grab-pos))
  (format #t "~2Tjoint[4] @ #x~X~%" (-> this joint))
  (format #t "~2Tnew-post-hook: ~A~%" (-> this new-post-hook))
  (format #t "~2Tcur-post-hook: ~A~%" (-> this cur-post-hook))
  (format #t "~2Tclone-copy-trans: ~A~%" (-> this clone-copy-trans))
  (format #t "~2Tshadow-backup: ~A~%" (-> this shadow-backup))
  (format #t "~2Tdraw?: ~A~%" (-> this draw?))
  (format #t "~2Tuserdata: ~A~%" (-> this userdata))
  (format #t "~2Tprefix: ~A~%" (-> this prefix))
  (format #t "~2Tshadow-volume-joint: ~D~%" (-> this shadow-volume-joint))
  (format #t "~2Tspeed: ~f~%" (-> this speed))
  (format #t "~2Tuser-uint64[4] @ #x~X~%" (-> this user-uint64))
  (format #t "~2Toptions: ~D~%" (-> this options))
  (label cfg-4)
  this
  )

;; definition of type part-spawner
(deftype part-spawner (process)
  "A process that spawns a specified particle group."
  ((root           trsqv)
   (part           sparticle-launch-control)
   (path           path-control)
   (sound          ambient-sound)
   (sound-extra    ambient-sound)
   (mode           (pointer sparticle-launch-group))
   (enable         symbol)
   (path-pos       float)
   (path-speed     float)
   (last-velocity  vector  :inline)
   (radius         meters)
   (world-sphere   sphere  :inline)
   )
  (:methods
    (part-spawner-method-15 () none)
    (part-spawner-method-16 () none)
    )
  )

;; definition for method 3 of type part-spawner
(defmethod inspect ((this part-spawner))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 this)
    )
  (format #t "~2Troot: ~A~%" (-> this root))
  (format #t "~2Tpart: ~A~%" (-> this part))
  (format #t "~2Tpath: ~A~%" (-> this path))
  (format #t "~2Tsound: ~A~%" (-> this sound))
  (format #t "~2Tsound-extra: ~A~%" (-> this sound-extra))
  (format #t "~2Tmode: #x~X~%" (-> this mode))
  (format #t "~2Tenable: ~A~%" (-> this enable))
  (format #t "~2Tpath-pos: ~f~%" (-> this path-pos))
  (format #t "~2Tpath-speed: ~f~%" (-> this path-speed))
  (format #t "~2Tlast-velocity: #<vector @ #x~X>~%" (-> this last-velocity))
  (format #t "~2Tradius: (meters ~m)~%" (-> this radius))
  (format #t "~2Tworld-sphere: #<sphere @ #x~X>~%" (-> this world-sphere))
  (label cfg-4)
  this
  )

;; definition of type part-tracker
(deftype part-tracker (process)
  ((root             trsqv)
   (mat              matrix      :inline)
   (offset           vector      :inline)
   (local-offset     vector      :inline)
   (userdata         uint64)
   (user-time        time-frame  2)
   (user-vector      vector      :inline)
   (user-handle      uint32      2 :offset 320)
   (part             sparticle-launch-control)
   (callback         (function part-tracker vector))
   (linger-callback  (function part-tracker vector))
   (duration         uint64)
   (linger-duration  uint64)
   (state-time       uint64)
   (target           uint64)
   (target-joint     int32)
   )
  (:methods
    (part-tracker-method-15 () none)
    (part-tracker-method-16 () none)
    (part-tracker-method-17 () none)
    (part-tracker-method-18 () none)
    )
  )

;; definition for method 3 of type part-tracker
(defmethod inspect ((this part-tracker))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 this)
    )
  (format #t "~2Troot: ~A~%" (-> this root))
  (format #t "~2Tmat: #<matrix @ #x~X>~%" (-> this mat))
  (format #t "~2Toffset: ~`vector`P~%" (-> this offset))
  (format #t "~2Tlocal-offset: ~`vector`P~%" (-> this local-offset))
  (format #t "~2Tuserdata: ~A~%" (-> this userdata))
  (format #t "~2Tuser-time[2] @ #x~X~%" (-> this user-time))
  (format #t "~2Tuser-vector: ~`vector`P~%" (-> this user-vector))
  (format #t "~2Tuser-handle[2] @ #x~X~%" (-> this user-handle))
  (format #t "~2Tpart: ~A~%" (-> this part))
  (format #t "~2Tcallback: ~A~%" (-> this callback))
  (format #t "~2Tlinger-callback: ~A~%" (-> this linger-callback))
  (format #t "~2Tduration: ~D~%" (-> this duration))
  (format #t "~2Tlinger-duration: ~D~%" (-> this linger-duration))
  (format #t "~2Tstate-time: ~D~%" (-> this state-time))
  (format #t "~2Ttarget: ~D~%" (-> this target))
  (format #t "~2Ttarget-joint: ~D~%" (-> this target-joint))
  (label cfg-4)
  this
  )

;; definition of type part-tracker-init-params
(deftype part-tracker-init-params (structure)
  ((local-offset          vector  :inline)
   (userdata              uint64)
   (duration              uint32)
   (local-space-param     int32   :offset  28)
   (group                 sparticle-launch-group)
   (callback              (function part-tracker vector))
   (local-space-callback  basic)
   (target                process-drawable)
   (mat-joint             object)
   (subsampler-num        float)
   )
  )

;; definition for method 3 of type part-tracker-init-params
(defmethod inspect ((this part-tracker-init-params))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'part-tracker-init-params)
  (format #t "~1Tlocal-offset: #<vector @ #x~X>~%" (-> this local-offset))
  (format #t "~1Tuserdata: ~A~%" (-> this userdata))
  (format #t "~1Tduration: ~D~%" (-> this duration))
  (format #t "~1Tlocal-space-param: ~D~%" (-> this local-space-param))
  (format #t "~1Tgroup: ~A~%" (-> this group))
  (format #t "~1Tcallback: ~A~%" (-> this callback))
  (format #t "~1Tlocal-space-callback: ~A~%" (-> this local-space-callback))
  (format #t "~1Ttarget: ~A~%" (-> this target))
  (format #t "~1Tmat-joint: ~A~%" (-> this mat-joint))
  (format #t "~1Tsubsampler-num: ~f~%" (-> this subsampler-num))
  (label cfg-4)
  this
  )

;; definition of type part-tracker-subsampler
(deftype part-tracker-subsampler (part-tracker)
  ((subsampler  sparticle-subsampler)
   )
  )

;; definition for method 3 of type part-tracker-subsampler
(defmethod inspect ((this part-tracker-subsampler))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type part-tracker inspect)))
    (t9-0 this)
    )
  (format #t "~2Tsubsampler: ~A~%" (-> this subsampler))
  (label cfg-4)
  this
  )

;; definition of type lightning-tracker
(deftype lightning-tracker (process)
  ((root           trsqv)
   (lightning      lightning-control)
   (callback       (function lightning-tracker none))
   (duration       uint64)
   (start-time     uint64)
   (offset0        vector      :inline)
   (offset1        vector      :inline)
   (target0        uint64)
   (target1        uint64)
   (target-joint0  int32)
   (target-joint1  int32)
   (sound          sound-id)
   (userdata       uint64)
   (user-time      time-frame  2)
   (user-vector    vector      :inline)
   (user-handle    handle      2 :offset 304)
   )
  (:methods
    (lightning-tracker-method-15 () none)
    (lightning-tracker-method-16 () none)
    (lightning-tracker-method-17 () none)
    )
  )

;; definition for method 3 of type lightning-tracker
(defmethod inspect ((this lightning-tracker))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 this)
    )
  (format #t "~2Troot: ~A~%" (-> this root))
  (format #t "~2Tlightning: ~A~%" (-> this lightning))
  (format #t "~2Tcallback: ~A~%" (-> this callback))
  (format #t "~2Tduration: ~D~%" (-> this duration))
  (format #t "~2Tstart-time: ~D~%" (-> this start-time))
  (format #t "~2Toffset0: ~`vector`P~%" (-> this offset0))
  (format #t "~2Toffset1: ~`vector`P~%" (-> this offset1))
  (format #t "~2Ttarget0: ~D~%" (-> this target0))
  (format #t "~2Ttarget1: ~D~%" (-> this target1))
  (format #t "~2Ttarget-joint0: ~D~%" (-> this target-joint0))
  (format #t "~2Ttarget-joint1: ~D~%" (-> this target-joint1))
  (format #t "~2Tsound: ~D~%" (-> this sound))
  (format #t "~2Tuserdata: ~A~%" (-> this userdata))
  (format #t "~2Tuser-time[2] @ #x~X~%" (-> this user-time))
  (format #t "~2Tuser-vector: ~`vector`P~%" (-> this user-vector))
  (format #t "~2Tuser-handle[2] @ #x~X~%" (-> this user-handle))
  (label cfg-4)
  this
  )

;; definition of type touch-tracker
(deftype touch-tracker (process-drawable)
  ((duration      uint64)
   (target        uint64)
   (event         symbol)
   (run-function  (function object))
   (callback      (function touch-tracker none))
   (event-mode    symbol)
   )
  (:methods
    (touch-tracker-method-50 () none)
    )
  )

;; definition for method 3 of type touch-tracker
(defmethod inspect ((this touch-tracker))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~2Tduration: ~D~%" (-> this duration))
  (format #t "~2Ttarget: ~D~%" (-> this target))
  (format #t "~2Tevent: ~A~%" (-> this event))
  (format #t "~2Trun-function: ~A~%" (-> this run-function))
  (format #t "~2Tcallback: ~A~%" (-> this callback))
  (format #t "~2Tevent-mode: ~A~%" (-> this event-mode))
  (label cfg-4)
  this
  )

;; definition of type gui-query
(deftype gui-query (structure)
  ((x-position         int32)
   (y-position         int32)
   (message            string)
   (decision           symbol)
   (only-allow-cancel  symbol)
   (no-msg             string)
   (message-space      int32)
   )
  (:methods
    (gui-query-method-9 () none)
    (gui-query-method-10 () none)
    )
  )

;; definition for method 3 of type gui-query
(defmethod inspect ((this gui-query))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'gui-query)
  (format #t "~1Tx-position: ~D~%" (-> this x-position))
  (format #t "~1Ty-position: ~D~%" (-> this y-position))
  (format #t "~1Tmessage: ~A~%" (-> this message))
  (format #t "~1Tdecision: ~A~%" (-> this decision))
  (format #t "~1Tonly-allow-cancel: ~A~%" (-> this only-allow-cancel))
  (format #t "~1Tno-msg: ~A~%" (-> this no-msg))
  (format #t "~1Tmessage-space: ~D~%" (-> this message-space))
  (label cfg-4)
  this
  )

;; definition of type othercam
(deftype othercam (process)
  ((hand               uint64)
   (old-global-mask    process-mask)
   (mask-to-clear      process-mask)
   (cam-joint-index    int32)
   (old-pos            vector  :inline)
   (old-mat-z          vector  :inline)
   (had-valid-frame    symbol)
   (border-value       basic)
   (die?               symbol)
   (survive-anim-end?  symbol)
   (spooling?          symbol)
   (fov                float)
   )
  (:states
    othercam-running
    )
  )

;; definition for method 3 of type othercam
(defmethod inspect ((this othercam))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 this)
    )
  (format #t "~2Thand: ~D~%" (-> this hand))
  (format #t "~2Told-global-mask: ~D~%" (-> this old-global-mask))
  (format #t "~2Tmask-to-clear: ~D~%" (-> this mask-to-clear))
  (format #t "~2Tcam-joint-index: ~D~%" (-> this cam-joint-index))
  (format #t "~2Told-pos: #<vector @ #x~X>~%" (-> this old-pos))
  (format #t "~2Told-mat-z: #<vector @ #x~X>~%" (-> this old-mat-z))
  (format #t "~2Thad-valid-frame: ~A~%" (-> this had-valid-frame))
  (format #t "~2Tborder-value: ~A~%" (-> this border-value))
  (format #t "~2Tdie?: ~A~%" (-> this die?))
  (format #t "~2Tsurvive-anim-end?: ~A~%" (-> this survive-anim-end?))
  (format #t "~2Tspooling?: ~A~%" (-> this spooling?))
  (format #t "~2Tfov: ~f~%" (-> this fov))
  (label cfg-4)
  this
  )

;; definition of type explosion-init-params
(deftype explosion-init-params (structure)
  ((spawn-point             vector      :inline)
   (spawn-quat              quaternion  :inline)
   (radius                  float)
   (scale                   float)
   (group                   sparticle-launch-group)
   (group-on-kill           basic)
   (collide-with            collide-spec)
   (collide-lof-check?      basic)
   (damage                  float)
   (damage-scale            float)
   (vehicle-damage-factor   float)
   (vehicle-impulse-factor  float)
   (velocity                vector      :inline)
   (ignore-proc             uint64)
   (attacker                uint64)
   (wpn-type                int8)
   )
  )

;; definition for method 3 of type explosion-init-params
(defmethod inspect ((this explosion-init-params))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'explosion-init-params)
  (format #t "~1Tspawn-point: #<vector @ #x~X>~%" (-> this spawn-point))
  (format #t "~1Tspawn-quat: #<quaternion @ #x~X>~%" (-> this spawn-quat))
  (format #t "~1Tradius: ~f~%" (-> this radius))
  (format #t "~1Tscale: ~f~%" (-> this scale))
  (format #t "~1Tgroup: ~A~%" (-> this group))
  (format #t "~1Tgroup-on-kill: ~A~%" (-> this group-on-kill))
  (format #t "~1Tcollide-with: ~D~%" (-> this collide-with))
  (format #t "~1Tcollide-lof-check?: ~A~%" (-> this collide-lof-check?))
  (format #t "~1Tdamage: ~f~%" (-> this damage))
  (format #t "~1Tdamage-scale: ~f~%" (-> this damage-scale))
  (format #t "~1Tvehicle-damage-factor: ~f~%" (-> this vehicle-damage-factor))
  (format #t "~1Tvehicle-impulse-factor: ~f~%" (-> this vehicle-impulse-factor))
  (format #t "~1Tvelocity: #<vector @ #x~X>~%" (-> this velocity))
  (format #t "~1Tignore-proc: ~D~%" (-> this ignore-proc))
  (format #t "~1Tattacker: ~D~%" (-> this attacker))
  (format #t "~1Twpn-type: ~D~%" (-> this wpn-type))
  (label cfg-4)
  this
  )

;; definition of type explosion
(deftype explosion (process-drawable)
  ((start-time       uint64)
   (duration         uint32)
   (linger-duration  uint32)
   (attack-id        uint32)
   (mat              matrix                 :inline)
   (params           explosion-init-params  :inline)
   (killed-someone?  basic)
   (spawn-proc       uint64)
   (spawn-type       basic)
   )
  (:methods
    (explosion-method-50 () none)
    (explosion-method-51 () none)
    (explosion-method-52 () none)
    )
  )

;; definition for method 3 of type explosion
(defmethod inspect ((this explosion))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~2Tstart-time: ~D~%" (-> this start-time))
  (format #t "~2Tduration: ~D~%" (-> this duration))
  (format #t "~2Tlinger-duration: ~D~%" (-> this linger-duration))
  (format #t "~2Tattack-id: ~D~%" (-> this attack-id))
  (format #t "~2Tmat: #<matrix @ #x~X>~%" (-> this mat))
  (format #t "~2Tparams: #<explosion-init-params @ #x~X>~%" (-> this params))
  (format #t "~2Tkilled-someone?: ~A~%" (-> this killed-someone?))
  (format #t "~2Tspawn-proc: ~D~%" (-> this spawn-proc))
  (format #t "~2Tspawn-type: ~A~%" (-> this spawn-type))
  (label cfg-4)
  this
  )

;; definition of type process-hidden
(deftype process-hidden (process)
  ()
  (:state-methods
    die
    )
  )

;; definition for method 3 of type process-hidden
(defmethod inspect ((this process-hidden))
  (when (not this)
    (set! this this)
    (goto cfg-62)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tmask: #x~X : (process-mask " (-> this mask))
  (let ((s5-0 (-> this mask)))
    (if (= (logand s5-0 (process-mask process-tree)) (process-mask process-tree))
        (format #t "process-tree ")
        )
    (if (= (logand (process-mask network) s5-0) (process-mask network))
        (format #t "network ")
        )
    (if (= (logand s5-0 (process-mask target)) (process-mask target))
        (format #t "target ")
        )
    (if (= (logand (process-mask collectable) s5-0) (process-mask collectable))
        (format #t "collectable ")
        )
    (if (= (logand (process-mask projectile) s5-0) (process-mask projectile))
        (format #t "projectile ")
        )
    (if (= (logand s5-0 (process-mask sleep-code)) (process-mask sleep-code))
        (format #t "sleep-code ")
        )
    (if (= (logand s5-0 (process-mask actor-pause)) (process-mask actor-pause))
        (format #t "actor-pause ")
        )
    (if (= (logand (process-mask bot) s5-0) (process-mask bot))
        (format #t "bot ")
        )
    (if (= (logand (process-mask vehicle) s5-0) (process-mask vehicle))
        (format #t "vehicle ")
        )
    (if (= (logand (process-mask enemy) s5-0) (process-mask enemy))
        (format #t "enemy ")
        )
    (if (= (logand (process-mask entity) s5-0) (process-mask entity))
        (format #t "entity ")
        )
    (if (= (logand s5-0 (process-mask heap-shrunk)) (process-mask heap-shrunk))
        (format #t "heap-shrunk ")
        )
    (if (= (logand (process-mask sidekick) s5-0) (process-mask sidekick))
        (format #t "sidekick ")
        )
    (if (= (logand s5-0 (process-mask going)) (process-mask going))
        (format #t "going ")
        )
    (if (= (logand s5-0 (process-mask execute)) (process-mask execute))
        (format #t "execute ")
        )
    (if (= (logand (process-mask death) s5-0) (process-mask death))
        (format #t "death ")
        )
    (if (= (logand s5-0 (process-mask no-kill)) (process-mask no-kill))
        (format #t "no-kill ")
        )
    (if (= (logand (process-mask platform) s5-0) (process-mask platform))
        (format #t "platform ")
        )
    (if (= (logand s5-0 (process-mask freeze)) (process-mask freeze))
        (format #t "freeze ")
        )
    (if (= (logand s5-0 (process-mask sleep)) (process-mask sleep))
        (format #t "sleep ")
        )
    (if (= (logand s5-0 (process-mask progress)) (process-mask progress))
        (format #t "progress ")
        )
    (if (= (logand s5-0 (process-mask menu)) (process-mask menu))
        (format #t "menu ")
        )
    (if (= (logand (process-mask camera) s5-0) (process-mask camera))
        (format #t "camera ")
        )
    (if (= (logand (process-mask ambient) s5-0) (process-mask ambient))
        (format #t "ambient ")
        )
    (if (= (logand s5-0 (process-mask dark-effect)) (process-mask dark-effect))
        (format #t "dark-effect ")
        )
    (if (= (logand (process-mask crate) s5-0) (process-mask crate))
        (format #t "crate ")
        )
    (if (= (logand s5-0 (process-mask kernel-run)) (process-mask kernel-run))
        (format #t "kernel-run ")
        )
    (if (= (logand s5-0 (process-mask movie)) (process-mask movie))
        (format #t "movie ")
        )
    (if (= (logand s5-0 (process-mask pause)) (process-mask pause))
        (format #t "pause ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tclock: ~A~%" (-> this clock))
  (format #t "~1Tview: ~A~%" (-> this view))
  (format #t "~1Tparent: #x~X~%" (-> this parent))
  (format #t "~1Tbrother: #x~X~%" (-> this brother))
  (format #t "~1Tchild: #x~X~%" (-> this child))
  (format #t "~1Tppointer: #x~X~%" (-> this ppointer))
  (format #t "~1Tself: ~A~%" (-> this self))
  (format #t "~1Tprofile-ticks: ~D~%" (-> this profile-ticks))
  (format #t "~1Tpool: ~A~%" (-> this pool))
  (format #t "~1Tstatus: ~A~%" (-> this status))
  (format #t "~1Tpid: ~D~%" (-> this pid))
  (format #t "~1Tmain-thread: ~A~%" (-> this main-thread))
  (format #t "~1Ttop-thread: ~A~%" (-> this top-thread))
  (format #t "~1Tentity: ~A~%" (-> this entity))
  (format #t "~1Tlevel: ~A~%" (-> this level))
  (format #t "~1Tstate: ~A~%" (-> this state))
  (format #t "~1Tprev-state: ~A~%" (-> this prev-state))
  (format #t "~1Tnext-state: ~A~%" (-> this next-state))
  (format #t "~1Tstate-stack: ~A~%" (-> this state-stack))
  (format #t "~1Ttrans-hook: ~A~%" (-> this trans-hook))
  (format #t "~1Tpost-hook: ~A~%" (-> this post-hook))
  (format #t "~1Tevent-hook: ~A~%" (-> this event-hook))
  (format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
  (format #t "~1Theap-base: #x~X~%" (-> this heap-base))
  (format #t "~1Theap-top: #x~X~%" (-> this heap-top))
  (format #t "~1Theap-cur: #x~X~%" (-> this heap-cur))
  (format #t "~1Tstack-frame-top: ~A~%" (-> this stack-frame-top))
  (format #t "~1Theap: #<kheap @ #x~X>~%" (&-> this heap-base))
  (format #t "~1Tconnection-list: ~`connectable`P~%" (-> this connection-list))
  (format #t "~1Tstack[0] @ #x~X~%" (-> this stack))
  (label cfg-62)
  this
  )

;; definition of type simple-prim
(deftype simple-prim (process-drawable)
  ((strip  prim-strip)
   )
  (:methods
    (simple-prim-method-50 () none)
    (simple-prim-method-51 () none)
    (simple-prim-method-52 () none)
    (simple-prim-method-53 () none)
    (simple-prim-method-54 () none)
    (simple-prim-method-55 () none)
    )
  )

;; definition for method 3 of type simple-prim
(defmethod inspect ((this simple-prim))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~2Tstrip: ~A~%" (-> this strip))
  (label cfg-4)
  this
  )

;; definition for symbol *simple-prim-additive*, type gs-alpha
(define *simple-prim-additive* (new 'static 'gs-alpha :b #x2 :d #x1))

;; definition for symbol *simple-prim-alpha-blend*, type gs-alpha
(define *simple-prim-alpha-blend* (new 'static 'gs-alpha :b #x1 :d #x1))

;; definition for symbol *simple-prim-subtractive*, type gs-alpha
(define *simple-prim-subtractive* (new 'static 'gs-alpha :a #x2 :d #x1))

;; definition of type task-arrow-params
(deftype task-arrow-params (structure)
  ((flags     task-arrow-flags)
   (map-icon  uint16)
   (pos       vector      :inline)
   (quat      quaternion  :inline)
   (color     uint32)
   )
  )

;; definition for method 3 of type task-arrow-params
(defmethod inspect ((this task-arrow-params))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'task-arrow-params)
  (format #t "~1Tflags: ~D~%" (-> this flags))
  (format #t "~1Tmap-icon: ~D~%" (-> this map-icon))
  (format #t "~1Tpos: #<vector @ #x~X>~%" (-> this pos))
  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
  (format #t "~1Tcolor: ~D~%" (-> this color))
  (label cfg-4)
  this
  )

;; definition of type external-camera-controller
(deftype external-camera-controller (process)
  ((pause-time  uint64)
   (blur        symbol)
   )
  (:state-methods
    active
    )
  )

;; definition for method 3 of type external-camera-controller
(defmethod inspect ((this external-camera-controller))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 this)
    )
  (format #t "~2Tpause-time: ~D~%" (-> this pause-time))
  (format #t "~2Tblur: ~A~%" (-> this blur))
  (label cfg-4)
  this
  )

;; failed to figure out what this is:
0