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

;; definition of type collide-rider
(deftype collide-rider (structure)
  "Something that rides a moving object."
  ((rider-handle     handle)
   (sticky-prim      collide-shape-prim)
   (prim-ry          float)
   (rider-local-pos  vector  :inline)
   )
  )

;; definition for method 3 of type collide-rider
(defmethod inspect ((this collide-rider))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'collide-rider)
  (format #t "~1Trider-handle: ~D~%" (-> this rider-handle))
  (format #t "~1Tsticky-prim: ~A~%" (-> this sticky-prim))
  (format #t "~1Tprim-ry: ~f~%" (-> this prim-ry))
  (format #t "~1Trider-local-pos: #<vector @ #x~X>~%" (-> this rider-local-pos))
  (label cfg-4)
  this
  )

;; definition of type collide-rider-pool
(deftype collide-rider-pool (basic)
  "A pool containing all the riders of an object."
  ((alloc-count  int32)
   (riders       collide-rider  20 :inline)
   )
  (:methods
    (add-rider (_type_ handle) collide-rider)
    (prepare (_type_) none)
    )
  )

;; definition for method 3 of type collide-rider-pool
(defmethod inspect ((this collide-rider-pool))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Talloc-count: ~D~%" (-> this alloc-count))
  (format #t "~1Triders[20] @ #x~X~%" (-> this riders))
  (label cfg-4)
  this
  )

;; definition for method 10 of type collide-rider-pool
;; WARN: Return type mismatch int vs none.
(defmethod prepare ((this collide-rider-pool))
  "Gets this pool ready to be used to allow allocations.  This should be called once at the start of every frame."
  (set! (-> this alloc-count) 0)
  0
  (none)
  )

;; definition of type pull-rider-info
(deftype pull-rider-info (structure)
  ((rider           collide-rider)
   (rider-cshape    collide-shape-moving)
   (rider-delta-ry  float)
   (rider-dest      vector  :inline)
   )
  )

;; definition for method 3 of type pull-rider-info
(defmethod inspect ((this pull-rider-info))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'pull-rider-info)
  (format #t "~1Trider: #<collide-rider @ #x~X>~%" (-> this rider))
  (format #t "~1Trider-cshape: ~A~%" (-> this rider-cshape))
  (format #t "~1Trider-delta-ry: ~f~%" (-> this rider-delta-ry))
  (format #t "~1Trider-dest: #<vector @ #x~X>~%" (-> this rider-dest))
  (label cfg-4)
  this
  )

;; failed to figure out what this is:
(kmemopen global "collide-lists")

;; definition for symbol *collide-hit-by-player-list*, type engine
(define *collide-hit-by-player-list* (new 'global 'engine 'collide-hit-by-player-list 640 connection))

;; definition for symbol *collide-hit-by-others-list*, type engine
(define *collide-hit-by-others-list* (new 'global 'engine 'collide-hit-by-others-list 768 connection))

;; definition for symbol *collide-player-list*, type engine
(define *collide-player-list* (new 'global 'engine 'collide-player-list 32 connection))

;; failed to figure out what this is:
(kmemclose)

;; definition of type overlaps-others-params
(deftype overlaps-others-params (structure)
  ((options                      overlaps-others-options)
   (collide-with-filter          collide-spec)
   (tlist                        touching-list)
   (filtered-root-collide-with   collide-spec)
   (filtered-child-collide-with  collide-spec)
   (filtered-other-collide-as    collide-spec)
   )
  )

;; definition for method 3 of type overlaps-others-params
(defmethod inspect ((this overlaps-others-params))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'overlaps-others-params)
  (format #t "~1Toptions: ~D~%" (-> this options))
  (format #t "~1Tcollide-with-filter: ~D~%" (-> this collide-with-filter))
  (format #t "~1Ttlist: ~A~%" (-> this tlist))
  (format #t "~1Tfiltered-root-collide-with: ~D~%" (-> this filtered-root-collide-with))
  (format #t "~1Tfiltered-child-collide-with: ~D~%" (-> this filtered-child-collide-with))
  (format #t "~1Tfiltered-other-collide-as: ~D~%" (-> this filtered-other-collide-as))
  (label cfg-4)
  this
  )

;; definition of type move-above-ground-params
(deftype move-above-ground-params (structure)
  ((gnd-collide-with        collide-spec)
   (popup                   float)
   (dont-move-if-overlaps?  symbol)
   (hover-if-no-ground?     symbol)
   (overlaps-params         overlaps-others-params  :inline)
   (new-pos                 vector                  :inline)
   (old-gspot-pos           vector                  :inline)
   (old-gspot-normal        vector                  :inline)
   (pat                     pat-surface)
   (on-ground?              symbol)
   (do-move?                symbol)
   )
  )

;; definition for method 3 of type move-above-ground-params
(defmethod inspect ((this move-above-ground-params))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'move-above-ground-params)
  (format #t "~1Tgnd-collide-with: ~D~%" (-> this gnd-collide-with))
  (format #t "~1Tpopup: ~f~%" (-> this popup))
  (format #t "~1Tdont-move-if-overlaps?: ~A~%" (-> this dont-move-if-overlaps?))
  (format #t "~1Thover-if-no-ground?: ~A~%" (-> this hover-if-no-ground?))
  (format #t "~1Toverlaps-params: #<overlaps-others-params @ #x~X>~%" (-> this overlaps-params))
  (format #t "~1Tnew-pos: #<vector @ #x~X>~%" (-> this new-pos))
  (format #t "~1Told-gspot-pos: #<vector @ #x~X>~%" (-> this old-gspot-pos))
  (format #t "~1Told-gspot-normal: #<vector @ #x~X>~%" (-> this old-gspot-normal))
  (format #t "~1Tpat: ~D~%" (-> this pat))
  (format #t "~1Ton-ground?: ~A~%" (-> this on-ground?))
  (format #t "~1Tdo-move?: ~A~%" (-> this do-move?))
  (label cfg-4)
  this
  )

;; definition of type collide-prim-core
(deftype collide-prim-core (structure)
  "Collide primitives use this to store their world sphere and their collision flags."
  ((world-sphere  vector        :inline)
   (collide-as    collide-spec    :offset  16)
   (collide-with  collide-spec)
   (action        collide-action)
   (prim-type     prim-type)
   (unused1       uint8         3)
   (quad          uint128       2 :overlay-at (-> world-sphere data 0))
   )
  )

;; definition for method 3 of type collide-prim-core
(defmethod inspect ((this collide-prim-core))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'collide-prim-core)
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> this world-sphere))
  (format #t "~1Tcollide-as: ~D~%" (-> this collide-as))
  (format #t "~1Tcollide-with: ~D~%" (-> this collide-with))
  (format #t "~1Taction: ~D~%" (-> this action))
  (format #t "~1Tprim-type: ~D~%" (-> this prim-type))
  (format #t "~1Tunused1[3] @ #x~X~%" (-> this unused1))
  (format #t "~1Tquad[2] @ #x~X~%" (-> this world-sphere))
  (label cfg-4)
  this
  )

;; definition of type collide-shape-prim
(deftype collide-shape-prim (basic)
  "Base class for collide primitives."
  ((cshape           collide-shape)
   (prim-id          uint32)
   (transform-index  int8)
   (unused2          int8               3)
   (prim-core        collide-prim-core  :inline)
   (local-sphere     vector             :inline)
   (world-sphere     vector             :inline :overlay-at (-> prim-core world-sphere))
   (collide-as       collide-spec               :overlay-at (-> prim-core collide-as))
   (collide-with     collide-spec               :overlay-at (-> prim-core collide-with))
   (action           collide-action             :overlay-at (-> prim-core action))
   (prim-type        int8                       :overlay-at (-> prim-core prim-type))
   (radius           float                      :overlay-at (-> local-sphere data 3))
   (specific         uint8              16)
   )
  (:methods
    (new (symbol type collide-shape uint int) _type_)
    (debug-draw (_type_) none)
    (add-fg-prim-using-box (_type_ collide-cache) none)
    (add-fg-prim-using-line-sphere (_type_ collide-cache object) none)
    (overlaps-others-test (_type_ overlaps-others-params collide-shape-prim) symbol)
    (overlaps-others-group (_type_ overlaps-others-params collide-shape-prim-group) symbol)
    (collide-shape-prim-method-14 () none)
    (collide-with-collide-cache-prim-mesh (_type_ collide-query collide-cache-prim) none)
    (collide-with-collide-cache-prim-sphere (_type_ collide-query collide-cache-prim) none)
    (on-platform-test (_type_ collide-shape-prim collide-query float) none)
    (should-push-away-test (_type_ collide-shape-prim collide-query) none)
    (should-push-away-a-group-test (_type_ collide-shape-prim-group collide-query) none)
    )
  )

;; definition for method 3 of type collide-shape-prim
(defmethod inspect ((this collide-shape-prim))
  (when (not this)
    (set! this this)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tcshape: ~A~%" (-> this cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> this prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> this transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> this unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (-> this specific))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> this prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> this prim-core collide-as))
  (let ((s5-0 (-> this prim-core collide-as)))
    (if (= (logand (collide-spec special-obstacle) s5-0) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-0) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-0 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-0 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-0) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-0) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-0) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-0 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-0 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-0 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-0 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-0) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-0) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-0 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-0) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-0 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-0 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-0 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-0 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-0) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-0 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-0) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-0 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-0) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-0 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tcollide-with: #x~X : (collide-spec " (-> this prim-core collide-with))
  (let ((s5-1 (-> this prim-core collide-with)))
    (if (= (logand (collide-spec special-obstacle) s5-1) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-1) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-1 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-1 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-1) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-1) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-1) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-1 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-1 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-1 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-1 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-1) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-1) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-1 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-1) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-1 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-1 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-1 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-1 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-1) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-1 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-1) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-1 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-1) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-1 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Taction: #x~X : (collide-action " (-> this prim-core action))
  (let ((s5-2 (-> this prim-core action)))
    (if (= (logand s5-2 (collide-action deadly)) (collide-action deadly))
        (format #t "deadly ")
        )
    (if (= (logand s5-2 (collide-action rideable)) (collide-action rideable))
        (format #t "rideable ")
        )
    (if (= (logand s5-2 (collide-action can-ride)) (collide-action can-ride))
        (format #t "can-ride ")
        )
    (if (= (logand s5-2 (collide-action persistent-attack)) (collide-action persistent-attack))
        (format #t "persistent-attack ")
        )
    (if (= (logand (collide-action nav-sphere) s5-2) (collide-action nav-sphere))
        (format #t "nav-sphere ")
        )
    (if (= (logand s5-2 (collide-action block-turn-around)) (collide-action block-turn-around))
        (format #t "block-turn-around ")
        )
    (if (= (logand s5-2 (collide-action pull-rider-can-collide)) (collide-action pull-rider-can-collide))
        (format #t "pull-rider-can-collide ")
        )
    (if (= (logand s5-2 (collide-action no-standon)) (collide-action no-standon))
        (format #t "no-standon ")
        )
    (if (= (logand s5-2 (collide-action dont-push-away)) (collide-action dont-push-away))
        (format #t "dont-push-away ")
        )
    (if (= (logand s5-2 (collide-action check-stuck)) (collide-action check-stuck))
        (format #t "check-stuck ")
        )
    (if (= (logand s5-2 (collide-action no-smack)) (collide-action no-smack))
        (format #t "no-smack ")
        )
    (if (= (logand s5-2 (collide-action semi-solid)) (collide-action semi-solid))
        (format #t "semi-solid ")
        )
    (if (= (logand s5-2 (collide-action edge-grabbed)) (collide-action edge-grabbed))
        (format #t "edge-grabbed ")
        )
    (if (= (logand s5-2 (collide-action stuck-wall-escape)) (collide-action stuck-wall-escape))
        (format #t "stuck-wall-escape ")
        )
    (if (= (logand s5-2 (collide-action check-edge)) (collide-action check-edge))
        (format #t "check-edge ")
        )
    (if (= (logand s5-2 (collide-action no-normal-reset)) (collide-action no-normal-reset))
        (format #t "no-normal-reset ")
        )
    (if (= (logand s5-2 (collide-action solid)) (collide-action solid))
        (format #t "solid ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tprim-type: ~D~%" (-> this prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> this local-sphere w))
  (label cfg-146)
  this
  )

;; definition of type collide-shape-prim-sphere
(deftype collide-shape-prim-sphere (collide-shape-prim)
  "A sphere primitive for collide shapes."
  ((pat         pat-surface  :overlay-at (-> specific 0))
   (nav-radius  float        :overlay-at (-> specific 4))
   )
  (:methods
    (new (symbol type collide-shape uint) _type_)
    )
  )

;; definition for method 3 of type collide-shape-prim-sphere
(defmethod inspect ((this collide-shape-prim-sphere))
  (when (not this)
    (set! this this)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tcshape: ~A~%" (-> this cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> this prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> this transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> this unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (&-> this pat))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> this prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> this prim-core collide-as))
  (let ((s5-0 (-> this prim-core collide-as)))
    (if (= (logand (collide-spec special-obstacle) s5-0) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-0) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-0 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-0 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-0) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-0) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-0) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-0 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-0 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-0 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-0 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-0) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-0) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-0 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-0) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-0 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-0 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-0 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-0 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-0) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-0 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-0) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-0 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-0) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-0 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tcollide-with: #x~X : (collide-spec " (-> this prim-core collide-with))
  (let ((s5-1 (-> this prim-core collide-with)))
    (if (= (logand (collide-spec special-obstacle) s5-1) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-1) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-1 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-1 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-1) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-1) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-1) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-1 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-1 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-1 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-1 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-1) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-1) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-1 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-1) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-1 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-1 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-1 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-1 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-1) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-1 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-1) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-1 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-1) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-1 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Taction: #x~X : (collide-action " (-> this prim-core action))
  (let ((s5-2 (-> this prim-core action)))
    (if (= (logand s5-2 (collide-action deadly)) (collide-action deadly))
        (format #t "deadly ")
        )
    (if (= (logand s5-2 (collide-action rideable)) (collide-action rideable))
        (format #t "rideable ")
        )
    (if (= (logand s5-2 (collide-action can-ride)) (collide-action can-ride))
        (format #t "can-ride ")
        )
    (if (= (logand s5-2 (collide-action persistent-attack)) (collide-action persistent-attack))
        (format #t "persistent-attack ")
        )
    (if (= (logand (collide-action nav-sphere) s5-2) (collide-action nav-sphere))
        (format #t "nav-sphere ")
        )
    (if (= (logand s5-2 (collide-action block-turn-around)) (collide-action block-turn-around))
        (format #t "block-turn-around ")
        )
    (if (= (logand s5-2 (collide-action pull-rider-can-collide)) (collide-action pull-rider-can-collide))
        (format #t "pull-rider-can-collide ")
        )
    (if (= (logand s5-2 (collide-action no-standon)) (collide-action no-standon))
        (format #t "no-standon ")
        )
    (if (= (logand s5-2 (collide-action dont-push-away)) (collide-action dont-push-away))
        (format #t "dont-push-away ")
        )
    (if (= (logand s5-2 (collide-action check-stuck)) (collide-action check-stuck))
        (format #t "check-stuck ")
        )
    (if (= (logand s5-2 (collide-action no-smack)) (collide-action no-smack))
        (format #t "no-smack ")
        )
    (if (= (logand s5-2 (collide-action semi-solid)) (collide-action semi-solid))
        (format #t "semi-solid ")
        )
    (if (= (logand s5-2 (collide-action edge-grabbed)) (collide-action edge-grabbed))
        (format #t "edge-grabbed ")
        )
    (if (= (logand s5-2 (collide-action stuck-wall-escape)) (collide-action stuck-wall-escape))
        (format #t "stuck-wall-escape ")
        )
    (if (= (logand s5-2 (collide-action check-edge)) (collide-action check-edge))
        (format #t "check-edge ")
        )
    (if (= (logand s5-2 (collide-action no-normal-reset)) (collide-action no-normal-reset))
        (format #t "no-normal-reset ")
        )
    (if (= (logand s5-2 (collide-action solid)) (collide-action solid))
        (format #t "solid ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tprim-type: ~D~%" (-> this prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> this local-sphere w))
  (format #t "~1Tpat: ~D~%" (-> this pat))
  (format #t "~1Tnav-radius: ~f~%" (-> this nav-radius))
  (label cfg-146)
  this
  )

;; definition of type collide-shape-prim-mesh
(deftype collide-shape-prim-mesh (collide-shape-prim)
  "A mesh primitive for collide shapes."
  ((mesh              collide-mesh              :overlay-at (-> specific 0))
   (mesh-id           int32                     :overlay-at (-> specific 4))
   (mesh-cache-id     uint32                    :overlay-at (-> specific 8))
   (mesh-cache-entry  collide-mesh-cache-entry  :overlay-at (-> specific 12))
   )
  (:methods
    (new (symbol type collide-shape uint uint) _type_)
    )
  )

;; definition for method 3 of type collide-shape-prim-mesh
(defmethod inspect ((this collide-shape-prim-mesh))
  (when (not this)
    (set! this this)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tcshape: ~A~%" (-> this cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> this prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> this transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> this unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (&-> this mesh))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> this prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> this prim-core collide-as))
  (let ((s5-0 (-> this prim-core collide-as)))
    (if (= (logand (collide-spec special-obstacle) s5-0) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-0) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-0 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-0 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-0) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-0) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-0) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-0 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-0 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-0 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-0 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-0) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-0) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-0 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-0) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-0 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-0 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-0 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-0 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-0) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-0 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-0) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-0 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-0) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-0 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tcollide-with: #x~X : (collide-spec " (-> this prim-core collide-with))
  (let ((s5-1 (-> this prim-core collide-with)))
    (if (= (logand (collide-spec special-obstacle) s5-1) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-1) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-1 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-1 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-1) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-1) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-1) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-1 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-1 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-1 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-1 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-1) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-1) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-1 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-1) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-1 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-1 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-1 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-1 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-1) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-1 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-1) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-1 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-1) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-1 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Taction: #x~X : (collide-action " (-> this prim-core action))
  (let ((s5-2 (-> this prim-core action)))
    (if (= (logand s5-2 (collide-action deadly)) (collide-action deadly))
        (format #t "deadly ")
        )
    (if (= (logand s5-2 (collide-action rideable)) (collide-action rideable))
        (format #t "rideable ")
        )
    (if (= (logand s5-2 (collide-action can-ride)) (collide-action can-ride))
        (format #t "can-ride ")
        )
    (if (= (logand s5-2 (collide-action persistent-attack)) (collide-action persistent-attack))
        (format #t "persistent-attack ")
        )
    (if (= (logand (collide-action nav-sphere) s5-2) (collide-action nav-sphere))
        (format #t "nav-sphere ")
        )
    (if (= (logand s5-2 (collide-action block-turn-around)) (collide-action block-turn-around))
        (format #t "block-turn-around ")
        )
    (if (= (logand s5-2 (collide-action pull-rider-can-collide)) (collide-action pull-rider-can-collide))
        (format #t "pull-rider-can-collide ")
        )
    (if (= (logand s5-2 (collide-action no-standon)) (collide-action no-standon))
        (format #t "no-standon ")
        )
    (if (= (logand s5-2 (collide-action dont-push-away)) (collide-action dont-push-away))
        (format #t "dont-push-away ")
        )
    (if (= (logand s5-2 (collide-action check-stuck)) (collide-action check-stuck))
        (format #t "check-stuck ")
        )
    (if (= (logand s5-2 (collide-action no-smack)) (collide-action no-smack))
        (format #t "no-smack ")
        )
    (if (= (logand s5-2 (collide-action semi-solid)) (collide-action semi-solid))
        (format #t "semi-solid ")
        )
    (if (= (logand s5-2 (collide-action edge-grabbed)) (collide-action edge-grabbed))
        (format #t "edge-grabbed ")
        )
    (if (= (logand s5-2 (collide-action stuck-wall-escape)) (collide-action stuck-wall-escape))
        (format #t "stuck-wall-escape ")
        )
    (if (= (logand s5-2 (collide-action check-edge)) (collide-action check-edge))
        (format #t "check-edge ")
        )
    (if (= (logand s5-2 (collide-action no-normal-reset)) (collide-action no-normal-reset))
        (format #t "no-normal-reset ")
        )
    (if (= (logand s5-2 (collide-action solid)) (collide-action solid))
        (format #t "solid ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tprim-type: ~D~%" (-> this prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> this local-sphere w))
  (format #t "~1Tmesh: ~A~%" (-> this mesh))
  (format #t "~1Tmesh-id: ~D~%" (-> this mesh-id))
  (format #t "~1Tmesh-cache-id: ~D~%" (-> this mesh-cache-id))
  (format #t "~1Tmesh-cache-entry: #<collide-mesh-cache-entry @ #x~X>~%" (-> this mesh-cache-entry))
  (label cfg-146)
  this
  )

;; definition of type collide-shape-prim-group
(deftype collide-shape-prim-group (collide-shape-prim)
  "A group of collide primitives."
  ((num-children        uint8                              :overlay-at (-> specific 0))
   (num-alloc-children  uint8                              :overlay-at (-> specific 1))
   (child               (inline-array collide-shape-prim)  :overlay-at (-> specific 4))
   )
  (:methods
    (new (symbol type collide-shape uint int) _type_)
    )
  )

;; definition for method 3 of type collide-shape-prim-group
(defmethod inspect ((this collide-shape-prim-group))
  (when (not this)
    (set! this this)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tcshape: ~A~%" (-> this cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> this prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> this transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> this unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (&-> this num-children))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> this prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> this prim-core collide-as))
  (let ((s5-0 (-> this prim-core collide-as)))
    (if (= (logand (collide-spec special-obstacle) s5-0) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-0) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-0 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-0 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-0) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-0) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-0) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-0 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-0 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-0 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-0 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-0) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-0) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-0 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-0) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-0 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-0 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-0 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-0 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-0) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-0 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-0) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-0 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-0 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-0) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-0 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tcollide-with: #x~X : (collide-spec " (-> this prim-core collide-with))
  (let ((s5-1 (-> this prim-core collide-with)))
    (if (= (logand (collide-spec special-obstacle) s5-1) (collide-spec special-obstacle))
        (format #t "special-obstacle ")
        )
    (if (= (logand (collide-spec bot-targetable) s5-1) (collide-spec bot-targetable))
        (format #t "bot-targetable ")
        )
    (if (= (logand s5-1 (collide-spec collectable)) (collide-spec collectable))
        (format #t "collectable ")
        )
    (if (= (logand s5-1 (collide-spec projectile)) (collide-spec projectile))
        (format #t "projectile ")
        )
    (if (= (logand (collide-spec mech-punch) s5-1) (collide-spec mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (collide-spec vehicle-mesh-probeable) s5-1) (collide-spec vehicle-mesh-probeable))
        (format #t "vehicle-mesh-probeable ")
        )
    (if (= (logand (collide-spec obstacle-for-jak) s5-1) (collide-spec obstacle-for-jak))
        (format #t "obstacle-for-jak ")
        )
    (if (= (logand s5-1 (collide-spec bot)) (collide-spec bot))
        (format #t "bot ")
        )
    (if (= (logand s5-1 (collide-spec blocking-plane)) (collide-spec blocking-plane))
        (format #t "blocking-plane ")
        )
    (if (= (logand s5-1 (collide-spec enemy)) (collide-spec enemy))
        (format #t "enemy ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-player-list)) (collide-spec hit-by-player-list))
        (format #t "hit-by-player-list ")
        )
    (if (= (logand s5-1 (collide-spec obstacle)) (collide-spec obstacle))
        (format #t "obstacle ")
        )
    (if (= (logand (collide-spec jak-vehicle) s5-1) (collide-spec jak-vehicle))
        (format #t "jak-vehicle ")
        )
    (if (= (logand (collide-spec vehicle-mesh) s5-1) (collide-spec vehicle-mesh))
        (format #t "vehicle-mesh ")
        )
    (if (= (logand s5-1 (collide-spec water)) (collide-spec water))
        (format #t "water ")
        )
    (if (= (logand (collide-spec notice-blue-eco-powerup) s5-1) (collide-spec notice-blue-eco-powerup))
        (format #t "notice-blue-eco-powerup ")
        )
    (if (= (logand s5-1 (collide-spec civilian)) (collide-spec civilian))
        (format #t "civilian ")
        )
    (if (= (logand s5-1 (collide-spec player-list)) (collide-spec player-list))
        (format #t "player-list ")
        )
    (if (= (logand s5-1 (collide-spec backgnd)) (collide-spec backgnd))
        (format #t "backgnd ")
        )
    (if (= (logand s5-1 (collide-spec jak)) (collide-spec jak))
        (format #t "jak ")
        )
    (if (= (logand (collide-spec pusher) s5-1) (collide-spec pusher))
        (format #t "pusher ")
        )
    (if (= (logand s5-1 (collide-spec jak-vulnerable)) (collide-spec jak-vulnerable))
        (format #t "jak-vulnerable ")
        )
    (if (= (logand (collide-spec camera-blocker) s5-1) (collide-spec camera-blocker))
        (format #t "camera-blocker ")
        )
    (if (= (logand s5-1 (collide-spec hit-by-others-list)) (collide-spec hit-by-others-list))
        (format #t "hit-by-others-list ")
        )
    (if (= (logand s5-1 (collide-spec crate)) (collide-spec crate))
        (format #t "crate ")
        )
    (if (= (logand (collide-spec tobot) s5-1) (collide-spec tobot))
        (format #t "tobot ")
        )
    (if (= (logand s5-1 (collide-spec vehicle-sphere)) (collide-spec vehicle-sphere))
        (format #t "vehicle-sphere ")
        )
    )
  (format #t ")~%")
  (format #t "~1Taction: #x~X : (collide-action " (-> this prim-core action))
  (let ((s5-2 (-> this prim-core action)))
    (if (= (logand s5-2 (collide-action deadly)) (collide-action deadly))
        (format #t "deadly ")
        )
    (if (= (logand s5-2 (collide-action rideable)) (collide-action rideable))
        (format #t "rideable ")
        )
    (if (= (logand s5-2 (collide-action can-ride)) (collide-action can-ride))
        (format #t "can-ride ")
        )
    (if (= (logand s5-2 (collide-action persistent-attack)) (collide-action persistent-attack))
        (format #t "persistent-attack ")
        )
    (if (= (logand (collide-action nav-sphere) s5-2) (collide-action nav-sphere))
        (format #t "nav-sphere ")
        )
    (if (= (logand s5-2 (collide-action block-turn-around)) (collide-action block-turn-around))
        (format #t "block-turn-around ")
        )
    (if (= (logand s5-2 (collide-action pull-rider-can-collide)) (collide-action pull-rider-can-collide))
        (format #t "pull-rider-can-collide ")
        )
    (if (= (logand s5-2 (collide-action no-standon)) (collide-action no-standon))
        (format #t "no-standon ")
        )
    (if (= (logand s5-2 (collide-action dont-push-away)) (collide-action dont-push-away))
        (format #t "dont-push-away ")
        )
    (if (= (logand s5-2 (collide-action check-stuck)) (collide-action check-stuck))
        (format #t "check-stuck ")
        )
    (if (= (logand s5-2 (collide-action no-smack)) (collide-action no-smack))
        (format #t "no-smack ")
        )
    (if (= (logand s5-2 (collide-action semi-solid)) (collide-action semi-solid))
        (format #t "semi-solid ")
        )
    (if (= (logand s5-2 (collide-action edge-grabbed)) (collide-action edge-grabbed))
        (format #t "edge-grabbed ")
        )
    (if (= (logand s5-2 (collide-action stuck-wall-escape)) (collide-action stuck-wall-escape))
        (format #t "stuck-wall-escape ")
        )
    (if (= (logand s5-2 (collide-action check-edge)) (collide-action check-edge))
        (format #t "check-edge ")
        )
    (if (= (logand s5-2 (collide-action no-normal-reset)) (collide-action no-normal-reset))
        (format #t "no-normal-reset ")
        )
    (if (= (logand s5-2 (collide-action solid)) (collide-action solid))
        (format #t "solid ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tprim-type: ~D~%" (-> this prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> this local-sphere w))
  (format #t "~1Tnum-children: ~D~%" (-> this num-children))
  (format #t "~1Tnum-alloc-children: ~D~%" (-> this num-alloc-children))
  (format #t "~1Tchild: #x~X~%" (-> this child))
  (label cfg-146)
  this
  )

;; definition of type collide-shape
(deftype collide-shape (trsqv)
  "The parent of all of an object's collide primitives.
Most [[process-drawable]]s have a [[collide-shape]] that represents their root transform."
  ((actor-hash-index     int16  :offset  12)
   (process              process-drawable)
   (max-iteration-count  uint8)
   (nav-flags            nav-flags)
   (total-prims          uint8)
   (num-riders           uint8)
   (pat-ignore-mask      pat-surface)
   (event-self           symbol)
   (event-other          symbol)
   (root-prim            collide-shape-prim)
   (riders               (inline-array collide-rider))
   (penetrate-using      penetrate)
   (penetrated-by        penetrate)
   (backup-collide-as    collide-spec)
   (backup-collide-with  collide-spec)
   (event-priority       uint8)
   (rider-max-momentum   float)
   )
  (:methods
    (new (symbol type process-drawable collide-list-enum) _type_)
    (move-by-vector! (_type_ vector) none)
    (move-to-point! (_type_ vector) none)
    (debug-draw (_type_) none)
    (fill-cache-for-shape (_type_ float collide-query) none)
    (fill-cache-integrate-and-collide (_type_ vector collide-query meters) none)
    (find-prim-by-id (_type_ uint) collide-shape-prim)
    (find-prim-by-id-logtest (_type_ uint) collide-shape-prim)
    (detect-riders! (_type_) symbol)
    (build-bounding-box-for-shape (_type_ bounding-box float collide-spec) symbol)
    (integrate-and-collide! (_type_ vector) none)
    (find-collision-meshes (_type_) none)
    (on-platform (_type_ collide-shape collide-query) symbol)
    (find-overlapping-shapes (_type_ overlaps-others-params) symbol)
    (shove-to-closest-point-on-path (_type_ attack-info float) vector)
    (should-push-away (_type_ collide-shape collide-query) symbol)
    (pull-rider! (_type_ pull-rider-info) none)
    (pull-riders! (_type_) symbol)
    (do-push-aways (_type_) collide-spec)
    (update-transforms (_type_) none)
    (set-collide-with! (_type_ collide-spec) none)
    (set-collide-as! (_type_ collide-spec) none)
    (modify-collide-as! (_type_ int collide-spec collide-spec) none)
    (send-shoves (_type_ process touching-shapes-entry float float float) symbol)
    (above-ground? (_type_ collide-query vector collide-spec float float float) symbol)
    (water-info-init! (_type_ water-info collide-action) water-info)
    (iterate-prims (_type_ (function collide-shape-prim none)) none)
    (pusher-init (_type_) none)
    )
  )

;; definition for method 3 of type collide-shape
(defmethod inspect ((this collide-shape))
  (when (not this)
    (set! this this)
    (goto cfg-136)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
  (format #t "~1Trot: ~`vector`P~%" (-> this quat))
  (format #t "~1Tscale: ~`vector`P~%" (-> this scale))
  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
  (format #t "~1Tpause-adjust-distance: (meters ~m)~%" (-> this pause-adjust-distance))
  (format #t "~1Tnav-radius: (meters ~m)~%" (-> this nav-radius))
  (format #t "~1Ttransv: ~`vector`P~%" (-> this transv))
  (format #t "~1Trotv: ~`vector`P~%" (-> this rotv))
  (format #t "~1Tscalev: ~`vector`P~%" (-> this scalev))
  (format #t "~1Tdir-targ: #<quaternion @ #x~X>~%" (-> this dir-targ))
  (format #t "~1Tangle-change-time: ~D~%" (-> this angle-change-time))
  (format #t "~1Told-y-angle-diff: ~f~%" (-> this old-y-angle-diff))
  (format #t "~1Tactor-hash-index: ~D~%" (-> this actor-hash-index))
  (format #t "~1Tprocess: ~A~%" (-> this process))
  (format #t "~1Tmax-iteration-count: ~D~%" (-> this max-iteration-count))
  (format #t "~1Tnav-flags: ~D~%" (-> this nav-flags))
  (format #t "~1Ttotal-prims: ~D~%" (-> this total-prims))
  (format #t "~1Tnum-riders: ~D~%" (-> this num-riders))
  (format #t "~1Tpat-ignore-mask: ~D~%" (-> this pat-ignore-mask))
  (format #t "~1Tevent-self: ~A~%" (-> this event-self))
  (format #t "~1Tevent-other: ~A~%" (-> this event-other))
  (format #t "~1Troot-prim: ~A~%" (-> this root-prim))
  (format #t "~1Triders: #x~X~%" (-> this riders))
  (format #t "~1Tpenetrate-using: #x~X : (penetrate " (-> this penetrate-using))
  (let ((s5-0 (-> this penetrate-using)))
    (if (= (logand s5-0 (penetrate mech-bonk)) (penetrate mech-bonk))
        (format #t "mech-bonk ")
        )
    (if (= (logand (penetrate eco-blue) s5-0) (penetrate eco-blue))
        (format #t "eco-blue ")
        )
    (if (= (logand (penetrate explode) s5-0) (penetrate explode))
        (format #t "explode ")
        )
    (if (= (logand s5-0 (penetrate bonk)) (penetrate bonk))
        (format #t "bonk ")
        )
    (if (= (logand (penetrate eco-red) s5-0) (penetrate eco-red))
        (format #t "eco-red ")
        )
    (if (= (logand s5-0 (penetrate roll)) (penetrate roll))
        (format #t "roll ")
        )
    (if (= (logand s5-0 (penetrate mech)) (penetrate mech))
        (format #t "mech ")
        )
    (if (= (logand s5-0 (penetrate flut-attack)) (penetrate flut-attack))
        (format #t "flut-attack ")
        )
    (if (= (logand s5-0 (penetrate mech-punch)) (penetrate mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (penetrate jak-dark-shot) s5-0) (penetrate jak-dark-shot))
        (format #t "jak-dark-shot ")
        )
    (if (= (logand s5-0 (penetrate flop)) (penetrate flop))
        (format #t "flop ")
        )
    (if (= (logand s5-0 (penetrate spin)) (penetrate spin))
        (format #t "spin ")
        )
    (if (= (logand (penetrate dark-bomb) s5-0) (penetrate dark-bomb))
        (format #t "dark-bomb ")
        )
    (if (= (logand s5-0 (penetrate vehicle)) (penetrate vehicle))
        (format #t "vehicle ")
        )
    (if (= (logand s5-0 (penetrate generic-attack)) (penetrate generic-attack))
        (format #t "generic-attack ")
        )
    (if (= (logand s5-0 (penetrate touch)) (penetrate touch))
        (format #t "touch ")
        )
    (if (= (logand (penetrate eco-green) s5-0) (shl #x8000 16))
        (format #t "eco-green ")
        )
    (if (= (logand (penetrate jak-red-shot) s5-0) (penetrate jak-red-shot))
        (format #t "jak-red-shot ")
        )
    (if (= (logand s5-0 (penetrate lunge)) (penetrate lunge))
        (format #t "lunge ")
        )
    (if (= (logand s5-0 (penetrate punch)) (penetrate punch))
        (format #t "punch ")
        )
    (if (= (logand s5-0 (penetrate tube)) (penetrate tube))
        (format #t "tube ")
        )
    (if (= (logand (penetrate enemy-yellow-shot) s5-0) (penetrate enemy-yellow-shot))
        (format #t "enemy-yellow-shot ")
        )
    (if (= (logand (penetrate knocked) s5-0) (shl 1 32))
        (format #t "knocked ")
        )
    (if (= (logand (penetrate dark-giant) s5-0) (penetrate dark-giant))
        (format #t "dark-giant ")
        )
    (if (= (logand s5-0 (penetrate uppercut)) (penetrate uppercut))
        (format #t "uppercut ")
        )
    (if (= (logand (penetrate dark-punch) s5-0) (penetrate dark-punch))
        (format #t "dark-punch ")
        )
    (if (= (logand (penetrate shield) s5-0) (penetrate shield))
        (format #t "shield ")
        )
    (if (= (logand (penetrate jak-yellow-shot) s5-0) (penetrate jak-yellow-shot))
        (format #t "jak-yellow-shot ")
        )
    (if (= (logand s5-0 (penetrate board)) (penetrate board))
        (format #t "board ")
        )
    (if (= (logand (penetrate eco-yellow) s5-0) (penetrate eco-yellow))
        (format #t "eco-yellow ")
        )
    (if (= (logand (penetrate dark-skin) s5-0) (penetrate dark-skin))
        (format #t "dark-skin ")
        )
    (if (= (logand (penetrate enemy-dark-shot) s5-0) (penetrate enemy-dark-shot))
        (format #t "enemy-dark-shot ")
        )
    (if (= (logand (penetrate jak-blue-shot) s5-0) (penetrate jak-blue-shot))
        (format #t "jak-blue-shot ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tpenetrated-by: #x~X : (penetrate " (-> this penetrated-by))
  (let ((s5-1 (-> this penetrated-by)))
    (if (= (logand s5-1 (penetrate mech-bonk)) (penetrate mech-bonk))
        (format #t "mech-bonk ")
        )
    (if (= (logand (penetrate eco-blue) s5-1) (penetrate eco-blue))
        (format #t "eco-blue ")
        )
    (if (= (logand (penetrate explode) s5-1) (penetrate explode))
        (format #t "explode ")
        )
    (if (= (logand s5-1 (penetrate bonk)) (penetrate bonk))
        (format #t "bonk ")
        )
    (if (= (logand (penetrate eco-red) s5-1) (penetrate eco-red))
        (format #t "eco-red ")
        )
    (if (= (logand s5-1 (penetrate roll)) (penetrate roll))
        (format #t "roll ")
        )
    (if (= (logand s5-1 (penetrate mech)) (penetrate mech))
        (format #t "mech ")
        )
    (if (= (logand s5-1 (penetrate flut-attack)) (penetrate flut-attack))
        (format #t "flut-attack ")
        )
    (if (= (logand s5-1 (penetrate mech-punch)) (penetrate mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (penetrate jak-dark-shot) s5-1) (penetrate jak-dark-shot))
        (format #t "jak-dark-shot ")
        )
    (if (= (logand s5-1 (penetrate flop)) (penetrate flop))
        (format #t "flop ")
        )
    (if (= (logand s5-1 (penetrate spin)) (penetrate spin))
        (format #t "spin ")
        )
    (if (= (logand (penetrate dark-bomb) s5-1) (penetrate dark-bomb))
        (format #t "dark-bomb ")
        )
    (if (= (logand s5-1 (penetrate vehicle)) (penetrate vehicle))
        (format #t "vehicle ")
        )
    (if (= (logand s5-1 (penetrate generic-attack)) (penetrate generic-attack))
        (format #t "generic-attack ")
        )
    (if (= (logand s5-1 (penetrate touch)) (penetrate touch))
        (format #t "touch ")
        )
    (if (= (logand (penetrate eco-green) s5-1) (shl #x8000 16))
        (format #t "eco-green ")
        )
    (if (= (logand (penetrate jak-red-shot) s5-1) (penetrate jak-red-shot))
        (format #t "jak-red-shot ")
        )
    (if (= (logand s5-1 (penetrate lunge)) (penetrate lunge))
        (format #t "lunge ")
        )
    (if (= (logand s5-1 (penetrate punch)) (penetrate punch))
        (format #t "punch ")
        )
    (if (= (logand s5-1 (penetrate tube)) (penetrate tube))
        (format #t "tube ")
        )
    (if (= (logand (penetrate enemy-yellow-shot) s5-1) (penetrate enemy-yellow-shot))
        (format #t "enemy-yellow-shot ")
        )
    (if (= (logand (penetrate knocked) s5-1) (shl 1 32))
        (format #t "knocked ")
        )
    (if (= (logand (penetrate dark-giant) s5-1) (penetrate dark-giant))
        (format #t "dark-giant ")
        )
    (if (= (logand s5-1 (penetrate uppercut)) (penetrate uppercut))
        (format #t "uppercut ")
        )
    (if (= (logand (penetrate dark-punch) s5-1) (penetrate dark-punch))
        (format #t "dark-punch ")
        )
    (if (= (logand (penetrate shield) s5-1) (penetrate shield))
        (format #t "shield ")
        )
    (if (= (logand (penetrate jak-yellow-shot) s5-1) (penetrate jak-yellow-shot))
        (format #t "jak-yellow-shot ")
        )
    (if (= (logand s5-1 (penetrate board)) (penetrate board))
        (format #t "board ")
        )
    (if (= (logand (penetrate eco-yellow) s5-1) (penetrate eco-yellow))
        (format #t "eco-yellow ")
        )
    (if (= (logand (penetrate dark-skin) s5-1) (penetrate dark-skin))
        (format #t "dark-skin ")
        )
    (if (= (logand (penetrate enemy-dark-shot) s5-1) (penetrate enemy-dark-shot))
        (format #t "enemy-dark-shot ")
        )
    (if (= (logand (penetrate jak-blue-shot) s5-1) (penetrate jak-blue-shot))
        (format #t "jak-blue-shot ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tbackup-collide-as: ~D~%" (-> this backup-collide-as))
  (format #t "~1Tbackup-collide-with: ~D~%" (-> this backup-collide-with))
  (format #t "~1Tevent-priority: ~D~%" (-> this event-priority))
  (format #t "~1Trider-max-momentum: ~f~%" (-> this rider-max-momentum))
  (label cfg-136)
  this
  )

;; definition of type collide-shape-moving
(deftype collide-shape-moving (collide-shape)
  "A [[collide-shape]] for moving objects."
  ((rider-time          time-frame)
   (rider-last-move     vector       :inline)
   (trans-old           vector       :inline)
   (trans-old-old       vector       :inline :offset 240)
   (trans-old-old-old   vector       :inline :offset 256)
   (poly-pat            pat-surface          :offset 272)
   (cur-pat             pat-surface)
   (ground-pat          pat-surface)
   (status              collide-status)
   (old-status          collide-status)
   (prev-status         collide-status)
   (reaction-flag       cshape-reaction-flags)
   (reaction            (function control-info collide-query vector vector collide-status))
   (no-reaction         (function collide-shape-moving collide-query vector vector object))
   (local-normal        vector       :inline)
   (surface-normal      vector       :inline)
   (poly-normal         vector       :inline)
   (ground-poly-normal  vector       :inline)
   (gspot-pos           vector       :inline)
   (gspot-normal        vector       :inline)
   (grount-touch-point  vector       :inline)
   (ground-impact-vel   meters)
   (surface-angle       float)
   (poly-angle          float)
   (touch-angle         float)
   (coverage            float)
   (dynam               dynamics)
   (surf                surface)
   )
  (:methods
    (new (symbol type process-drawable collide-list-enum) _type_)
    (find-ground (_type_ collide-query collide-spec float float float) symbol)
    (react-to-pat! (_type_ pat-surface) cshape-reaction-flags)
    (integrate-no-collide! (_type_ vector) none)
    (integrate-for-enemy-no-mtg (_type_ vector overlaps-others-params) symbol)
    (move-above-ground (_type_ vector move-above-ground-params) none)
    (move-to-ground (_type_ float float symbol collide-spec) none)
    (move-to-ground-point (_type_ vector vector vector) none)
    (compute-acc-due-to-gravity (_type_ vector float) vector)
    (collide-shape-moving-method-63 (_type_ rigid-body float) none)
    (try-snap-to-surface (_type_ vector float float float) symbol)
    (fill-and-try-snap-to-surface (_type_ vector float float float collide-query) symbol)
    (step-collison! (_type_ vector vector float int) float)
    (collide-with-all-collide-cache-prims (_type_ matrix collide-query) none)
    )
  )

;; definition for method 3 of type collide-shape-moving
(defmethod inspect ((this collide-shape-moving))
  (when (not this)
    (set! this this)
    (goto cfg-136)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
  (format #t "~1Trot: ~`vector`P~%" (-> this quat))
  (format #t "~1Tscale: ~`vector`P~%" (-> this scale))
  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
  (format #t "~1Tpause-adjust-distance: (meters ~m)~%" (-> this pause-adjust-distance))
  (format #t "~1Tnav-radius: (meters ~m)~%" (-> this nav-radius))
  (format #t "~1Ttransv: ~`vector`P~%" (-> this transv))
  (format #t "~1Trotv: ~`vector`P~%" (-> this rotv))
  (format #t "~1Tscalev: ~`vector`P~%" (-> this scalev))
  (format #t "~1Tdir-targ: #<quaternion @ #x~X>~%" (-> this dir-targ))
  (format #t "~1Tangle-change-time: ~D~%" (-> this angle-change-time))
  (format #t "~1Told-y-angle-diff: ~f~%" (-> this old-y-angle-diff))
  (format #t "~1Tactor-hash-index: ~D~%" (-> this actor-hash-index))
  (format #t "~1Tprocess: ~A~%" (-> this process))
  (format #t "~1Tmax-iteration-count: ~D~%" (-> this max-iteration-count))
  (format #t "~1Tnav-flags: ~D~%" (-> this nav-flags))
  (format #t "~1Ttotal-prims: ~D~%" (-> this total-prims))
  (format #t "~1Tnum-riders: ~D~%" (-> this num-riders))
  (format #t "~1Tpat-ignore-mask: ~D~%" (-> this pat-ignore-mask))
  (format #t "~1Tevent-self: ~A~%" (-> this event-self))
  (format #t "~1Tevent-other: ~A~%" (-> this event-other))
  (format #t "~1Troot-prim: ~A~%" (-> this root-prim))
  (format #t "~1Triders: #x~X~%" (-> this riders))
  (format #t "~1Tpenetrate-using: #x~X : (penetrate " (-> this penetrate-using))
  (let ((s5-0 (-> this penetrate-using)))
    (if (= (logand s5-0 (penetrate mech-bonk)) (penetrate mech-bonk))
        (format #t "mech-bonk ")
        )
    (if (= (logand (penetrate eco-blue) s5-0) (penetrate eco-blue))
        (format #t "eco-blue ")
        )
    (if (= (logand (penetrate explode) s5-0) (penetrate explode))
        (format #t "explode ")
        )
    (if (= (logand s5-0 (penetrate bonk)) (penetrate bonk))
        (format #t "bonk ")
        )
    (if (= (logand (penetrate eco-red) s5-0) (penetrate eco-red))
        (format #t "eco-red ")
        )
    (if (= (logand s5-0 (penetrate roll)) (penetrate roll))
        (format #t "roll ")
        )
    (if (= (logand s5-0 (penetrate mech)) (penetrate mech))
        (format #t "mech ")
        )
    (if (= (logand s5-0 (penetrate flut-attack)) (penetrate flut-attack))
        (format #t "flut-attack ")
        )
    (if (= (logand s5-0 (penetrate mech-punch)) (penetrate mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (penetrate jak-dark-shot) s5-0) (penetrate jak-dark-shot))
        (format #t "jak-dark-shot ")
        )
    (if (= (logand s5-0 (penetrate flop)) (penetrate flop))
        (format #t "flop ")
        )
    (if (= (logand s5-0 (penetrate spin)) (penetrate spin))
        (format #t "spin ")
        )
    (if (= (logand (penetrate dark-bomb) s5-0) (penetrate dark-bomb))
        (format #t "dark-bomb ")
        )
    (if (= (logand s5-0 (penetrate vehicle)) (penetrate vehicle))
        (format #t "vehicle ")
        )
    (if (= (logand s5-0 (penetrate generic-attack)) (penetrate generic-attack))
        (format #t "generic-attack ")
        )
    (if (= (logand s5-0 (penetrate touch)) (penetrate touch))
        (format #t "touch ")
        )
    (if (= (logand (penetrate eco-green) s5-0) (shl #x8000 16))
        (format #t "eco-green ")
        )
    (if (= (logand (penetrate jak-red-shot) s5-0) (penetrate jak-red-shot))
        (format #t "jak-red-shot ")
        )
    (if (= (logand s5-0 (penetrate lunge)) (penetrate lunge))
        (format #t "lunge ")
        )
    (if (= (logand s5-0 (penetrate punch)) (penetrate punch))
        (format #t "punch ")
        )
    (if (= (logand s5-0 (penetrate tube)) (penetrate tube))
        (format #t "tube ")
        )
    (if (= (logand (penetrate enemy-yellow-shot) s5-0) (penetrate enemy-yellow-shot))
        (format #t "enemy-yellow-shot ")
        )
    (if (= (logand (penetrate knocked) s5-0) (shl 1 32))
        (format #t "knocked ")
        )
    (if (= (logand (penetrate dark-giant) s5-0) (penetrate dark-giant))
        (format #t "dark-giant ")
        )
    (if (= (logand s5-0 (penetrate uppercut)) (penetrate uppercut))
        (format #t "uppercut ")
        )
    (if (= (logand (penetrate dark-punch) s5-0) (penetrate dark-punch))
        (format #t "dark-punch ")
        )
    (if (= (logand (penetrate shield) s5-0) (penetrate shield))
        (format #t "shield ")
        )
    (if (= (logand (penetrate jak-yellow-shot) s5-0) (penetrate jak-yellow-shot))
        (format #t "jak-yellow-shot ")
        )
    (if (= (logand s5-0 (penetrate board)) (penetrate board))
        (format #t "board ")
        )
    (if (= (logand (penetrate eco-yellow) s5-0) (penetrate eco-yellow))
        (format #t "eco-yellow ")
        )
    (if (= (logand (penetrate dark-skin) s5-0) (penetrate dark-skin))
        (format #t "dark-skin ")
        )
    (if (= (logand (penetrate enemy-dark-shot) s5-0) (penetrate enemy-dark-shot))
        (format #t "enemy-dark-shot ")
        )
    (if (= (logand (penetrate jak-blue-shot) s5-0) (penetrate jak-blue-shot))
        (format #t "jak-blue-shot ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tpenetrated-by: #x~X : (penetrate " (-> this penetrated-by))
  (let ((s5-1 (-> this penetrated-by)))
    (if (= (logand s5-1 (penetrate mech-bonk)) (penetrate mech-bonk))
        (format #t "mech-bonk ")
        )
    (if (= (logand (penetrate eco-blue) s5-1) (penetrate eco-blue))
        (format #t "eco-blue ")
        )
    (if (= (logand (penetrate explode) s5-1) (penetrate explode))
        (format #t "explode ")
        )
    (if (= (logand s5-1 (penetrate bonk)) (penetrate bonk))
        (format #t "bonk ")
        )
    (if (= (logand (penetrate eco-red) s5-1) (penetrate eco-red))
        (format #t "eco-red ")
        )
    (if (= (logand s5-1 (penetrate roll)) (penetrate roll))
        (format #t "roll ")
        )
    (if (= (logand s5-1 (penetrate mech)) (penetrate mech))
        (format #t "mech ")
        )
    (if (= (logand s5-1 (penetrate flut-attack)) (penetrate flut-attack))
        (format #t "flut-attack ")
        )
    (if (= (logand s5-1 (penetrate mech-punch)) (penetrate mech-punch))
        (format #t "mech-punch ")
        )
    (if (= (logand (penetrate jak-dark-shot) s5-1) (penetrate jak-dark-shot))
        (format #t "jak-dark-shot ")
        )
    (if (= (logand s5-1 (penetrate flop)) (penetrate flop))
        (format #t "flop ")
        )
    (if (= (logand s5-1 (penetrate spin)) (penetrate spin))
        (format #t "spin ")
        )
    (if (= (logand (penetrate dark-bomb) s5-1) (penetrate dark-bomb))
        (format #t "dark-bomb ")
        )
    (if (= (logand s5-1 (penetrate vehicle)) (penetrate vehicle))
        (format #t "vehicle ")
        )
    (if (= (logand s5-1 (penetrate generic-attack)) (penetrate generic-attack))
        (format #t "generic-attack ")
        )
    (if (= (logand s5-1 (penetrate touch)) (penetrate touch))
        (format #t "touch ")
        )
    (if (= (logand (penetrate eco-green) s5-1) (shl #x8000 16))
        (format #t "eco-green ")
        )
    (if (= (logand (penetrate jak-red-shot) s5-1) (penetrate jak-red-shot))
        (format #t "jak-red-shot ")
        )
    (if (= (logand s5-1 (penetrate lunge)) (penetrate lunge))
        (format #t "lunge ")
        )
    (if (= (logand s5-1 (penetrate punch)) (penetrate punch))
        (format #t "punch ")
        )
    (if (= (logand s5-1 (penetrate tube)) (penetrate tube))
        (format #t "tube ")
        )
    (if (= (logand (penetrate enemy-yellow-shot) s5-1) (penetrate enemy-yellow-shot))
        (format #t "enemy-yellow-shot ")
        )
    (if (= (logand (penetrate knocked) s5-1) (shl 1 32))
        (format #t "knocked ")
        )
    (if (= (logand (penetrate dark-giant) s5-1) (penetrate dark-giant))
        (format #t "dark-giant ")
        )
    (if (= (logand s5-1 (penetrate uppercut)) (penetrate uppercut))
        (format #t "uppercut ")
        )
    (if (= (logand (penetrate dark-punch) s5-1) (penetrate dark-punch))
        (format #t "dark-punch ")
        )
    (if (= (logand (penetrate shield) s5-1) (penetrate shield))
        (format #t "shield ")
        )
    (if (= (logand (penetrate jak-yellow-shot) s5-1) (penetrate jak-yellow-shot))
        (format #t "jak-yellow-shot ")
        )
    (if (= (logand s5-1 (penetrate board)) (penetrate board))
        (format #t "board ")
        )
    (if (= (logand (penetrate eco-yellow) s5-1) (penetrate eco-yellow))
        (format #t "eco-yellow ")
        )
    (if (= (logand (penetrate dark-skin) s5-1) (penetrate dark-skin))
        (format #t "dark-skin ")
        )
    (if (= (logand (penetrate enemy-dark-shot) s5-1) (penetrate enemy-dark-shot))
        (format #t "enemy-dark-shot ")
        )
    (if (= (logand (penetrate jak-blue-shot) s5-1) (penetrate jak-blue-shot))
        (format #t "jak-blue-shot ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tbackup-collide-as: ~D~%" (-> this backup-collide-as))
  (format #t "~1Tbackup-collide-with: ~D~%" (-> this backup-collide-with))
  (format #t "~1Tevent-priority: ~D~%" (-> this event-priority))
  (format #t "~1Trider-max-momentum: ~f~%" (-> this rider-max-momentum))
  (format #t "~1Trider-time: ~D~%" (-> this rider-time))
  (format #t "~1Trider-last-move: ~`vector`P~%" (-> this rider-last-move))
  (format #t "~1Ttrans-old: ~`vector`P~%" (-> this trans-old))
  (format #t "~1Tpoly-pat: #x~X~%" (-> this poly-pat))
  (format #t "~1Tcur-pat: #x~X~%" (-> this cur-pat))
  (format #t "~1Tground-pat: #x~X~%" (-> this ground-pat))
  (format #t "~1Tstatus: ~D~%" (-> this status))
  (format #t "~1Told-status: ~D~%" (-> this old-status))
  (format #t "~1Tprev-status: ~D~%" (-> this prev-status))
  (format #t "~1Treaction-flag: ~D~%" (-> this reaction-flag))
  (format #t "~1Treaction: ~A~%" (-> this reaction))
  (format #t "~1Tno-reaction: ~A~%" (-> this no-reaction))
  (format #t "~1Tlocal-normal: ~`vector`P~%" (-> this local-normal))
  (format #t "~1Tsurface-normal: ~`vector`P~%" (-> this surface-normal))
  (format #t "~1Tpoly-normal: ~`vector`P~%" (-> this poly-normal))
  (format #t "~1Tground-poly-normal: ~`vector`P~%" (-> this ground-poly-normal))
  (format #t "~1Tgspot-pos: ~`vector`P~%" (-> this gspot-pos))
  (format #t "~1Tgspot-normal: ~`vector`P~%" (-> this gspot-normal))
  (format #t "~1Tground-touch-point: ~`vector`P~%" (-> this grount-touch-point))
  (format #t "~1Tground-impact-vel: (meters ~m)~%" (-> this ground-impact-vel))
  (format #t "~1Tsurface-angle: ~f~%" (-> this surface-angle))
  (format #t "~1Tpoly-angle: ~f~%" (-> this poly-angle))
  (format #t "~1Ttouch-angle: ~f~%" (-> this touch-angle))
  (format #t "~1Tcoverage: ~f~%" (-> this coverage))
  (format #t "~1Tdynam: ~A~%" (-> this dynam))
  (format #t "~1Tsurf: ~A~%" (-> this surf))
  (label cfg-136)
  this
  )

;; definition for method 0 of type collide-shape-prim
(defmethod new collide-shape-prim ((allocation symbol) (type-to-make type) (arg0 collide-shape) (arg1 uint) (arg2 int))
  (let ((v0-0 (object-new allocation type-to-make arg2)))
    (set! (-> v0-0 cshape) arg0)
    (set! (-> v0-0 prim-id) arg1)
    (set! (-> v0-0 prim-core action) (collide-action))
    (set! (-> v0-0 prim-core collide-as) (collide-spec))
    (set! (-> v0-0 prim-core collide-with) (collide-spec))
    (set! (-> v0-0 transform-index) -2)
    (set! (-> v0-0 prim-core prim-type) (prim-type prim))
    v0-0
    )
  )

;; definition for method 0 of type collide-shape-prim-sphere
;; WARN: Return type mismatch collide-shape-prim vs collide-shape-prim-sphere.
(defmethod new collide-shape-prim-sphere ((allocation symbol) (type-to-make type) (arg0 collide-shape) (arg1 uint))
  (let ((v0-0 ((method-of-type collide-shape-prim new) allocation type-to-make arg0 arg1 80)))
    (set! (-> (the-as collide-shape-prim-sphere v0-0) pat)
          (new 'static 'pat-surface :mode (pat-mode obstacle) :material (pat-material stone))
          )
    (set! (-> (the-as collide-shape-prim-sphere v0-0) prim-core prim-type) (prim-type sphere))
    (the-as collide-shape-prim-sphere v0-0)
    )
  )

;; definition for method 0 of type collide-shape-prim-mesh
;; WARN: Return type mismatch collide-shape-prim vs collide-shape-prim-mesh.
(defmethod new collide-shape-prim-mesh ((allocation symbol) (type-to-make type) (arg0 collide-shape) (arg1 uint) (arg2 uint))
  (let ((v0-0 ((method-of-type collide-shape-prim new) allocation type-to-make arg0 arg2 80)))
    (set! (-> (the-as collide-shape-prim-mesh v0-0) mesh) #f)
    (set! (-> (the-as collide-shape-prim-mesh v0-0) mesh-id) (the-as int arg1))
    (set! (-> (the-as collide-shape-prim-mesh v0-0) mesh-cache-id) (the-as uint 0))
    (set! (-> (the-as collide-shape-prim-mesh v0-0) prim-core prim-type) (prim-type mesh))
    (the-as collide-shape-prim-mesh v0-0)
    )
  )

;; definition for method 0 of type collide-shape-prim-group
;; WARN: Return type mismatch collide-shape-prim vs collide-shape-prim-group.
(defmethod new collide-shape-prim-group ((allocation symbol) (type-to-make type) (arg0 collide-shape) (arg1 uint) (arg2 int))
  (let ((v0-0 ((method-of-type collide-shape-prim new) allocation type-to-make arg0 (the-as uint arg2) 80)))
    (set! (-> (the-as collide-shape-prim-group v0-0) num-children) arg1)
    (set! (-> (the-as collide-shape-prim-group v0-0) num-alloc-children) arg1)
    (set! (-> (the-as collide-shape-prim-group v0-0) prim-core prim-type) (prim-type group))
    (set! (-> (the-as collide-shape-prim-group v0-0) child)
          (the-as (inline-array collide-shape-prim) (&+ (the-as collide-shape-prim-group v0-0) 80))
          )
    (the-as collide-shape-prim-group v0-0)
    )
  )

;; definition for method 4 of type collide-shape-prim-group
;; WARN: Return type mismatch uint vs int.
(defmethod length ((this collide-shape-prim-group))
  (the-as int (-> this num-children))
  )

;; definition for method 0 of type collide-shape
(defmethod new collide-shape ((allocation symbol) (type-to-make type) (arg0 process-drawable) (arg1 collide-list-enum))
  (let ((s5-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> s5-0 actor-hash-index) -1)
    (set! (-> s5-0 process) arg0)
    (set! (-> s5-0 max-iteration-count) (the-as uint 1))
    (set! (-> s5-0 nav-flags) (nav-flags has-root-sphere))
    (set! (-> s5-0 event-self) #f)
    (set! (-> s5-0 event-other) #f)
    (set! (-> s5-0 riders) (the-as (inline-array collide-rider) #f))
    (set! (-> s5-0 root-prim) #f)
    (set! (-> s5-0 penetrate-using) (penetrate))
    (set! (-> s5-0 penetrated-by) (penetrate))
    (set! (-> s5-0 event-priority) (the-as uint 0))
    (set! (-> s5-0 rider-max-momentum) 409600.0)
    (case (-> arg0 type symbol)
      (('camera)
       (set! (-> s5-0 pat-ignore-mask) (new 'static 'pat-surface :nocamera #x1 :probe #x1 :noendlessfall #x1))
       )
      (('target)
       (set! (-> s5-0 pat-ignore-mask) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1))
       )
      (else
        (set! (-> s5-0 pat-ignore-mask)
              (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)
              )
        )
      )
    (set! (-> s5-0 trans w) 1.0)
    (quaternion-identity! (-> s5-0 quat))
    (vector-identity! (-> s5-0 scale))
    (cond
      ((= arg1 (collide-list-enum hit-by-player))
       (add-connection *collide-hit-by-player-list* arg0 #f s5-0 #f #f)
       )
      ((= arg1 (collide-list-enum usually-hit-by-player))
       (add-connection *collide-hit-by-others-list* arg0 #f s5-0 #f #f)
       )
      ((= arg1 (collide-list-enum hit-by-others))
       (add-connection *collide-player-list* arg0 #f s5-0 #f #f)
       )
      (else
        (format 0 "Unsupported collide-list-enum in collide-shape constructor!~%")
        )
      )
    s5-0
    )
  )

;; definition for method 0 of type collide-shape-moving
;; INFO: Used lq/sq
;; WARN: Return type mismatch collide-shape vs collide-shape-moving.
(defmethod new collide-shape-moving ((allocation symbol) (type-to-make type) (arg0 process-drawable) (arg1 collide-list-enum))
  (let ((v0-0 ((method-of-type collide-shape new) allocation type-to-make arg0 arg1)))
    (set! (-> (the-as collide-shape-moving v0-0) gspot-pos y) -40959590.0)
    (set! (-> (the-as collide-shape-moving v0-0) gspot-normal quad) (-> *y-vector* quad))
    (set! (-> (the-as collide-shape-moving v0-0) surf) *standard-ground-surface*)
    (the-as collide-shape-moving v0-0)
    )
  )

;; definition for symbol *collide-shape-prim-backgnd*, type collide-shape-prim-mesh
(define *collide-shape-prim-backgnd* (new 'static 'collide-shape-prim-mesh
                                       :cshape #f
                                       :prim-core (new 'static 'collide-prim-core
                                         :world-sphere (new 'static 'vector :w 204800000.0)
                                         :collide-as (collide-spec backgnd)
                                         :action (collide-action solid)
                                         :prim-type (prim-type fake-prim)
                                         )
                                       :local-sphere (new 'static 'vector :w 204800000.0)
                                       :mesh #f
                                       )
        )

;; definition for symbol *collide-shape-prim-water*, type collide-shape-prim-mesh
(define *collide-shape-prim-water* (new 'static 'collide-shape-prim-mesh
                                     :cshape #f
                                     :prim-core (new 'static 'collide-prim-core
                                       :world-sphere (new 'static 'vector :w 204800000.0)
                                       :collide-as (collide-spec water)
                                       :action (collide-action solid)
                                       :prim-type (prim-type fake-prim)
                                       )
                                     :local-sphere (new 'static 'vector :w 204800000.0)
                                     :mesh #f
                                     )
        )

;; definition (perm) for symbol *collide-rider-pool*, type collide-rider-pool
(define-perm *collide-rider-pool* collide-rider-pool (new 'global 'collide-rider-pool))

;; failed to figure out what this is:
0