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

;; definition of type collide-rider
(deftype collide-rider (structure)
  ((rider-handle    uint64         :offset-assert   0)
   (sticky-prim     basic          :offset-assert   8)
   (prim-ry         float          :offset-assert  12)
   (rider-local-pos vector :inline :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

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

;; definition of type collide-rider-pool
(deftype collide-rider-pool (basic)
  ((alloc-count int32                    :offset-assert   4)
   (riders      collide-rider 20 :inline :offset-assert  16)
   )
  :method-count-assert 11
  :size-assert         #x290
  :flag-assert         #xb00000290
  (:methods
    (collide-rider-pool-method-9 () none 9)
    (prepare (_type_) none 10)
    )
  )

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

;; definition for method 10 of type collide-rider-pool
;; WARN: Return type mismatch int vs none.
(defmethod prepare collide-rider-pool ((obj 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! (-> obj alloc-count) 0)
  0
  (none)
  )

;; definition of type pull-rider-info
(deftype pull-rider-info (structure)
  ((rider          collide-rider                :offset-assert   0)
   (rider-cshape   collide-shape-moving         :offset-assert   4)
   (rider-delta-ry float                        :offset-assert   8)
   (rider-dest     vector               :inline :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

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

;; 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  :offset-assert   0)
   (collide-with-filter         collide-spec             :offset-assert   4)
   (tlist                       touching-list            :offset-assert   8)
   (filtered-root-collide-with  collide-spec             :offset-assert  12)
   (filtered-child-collide-with collide-spec             :offset-assert  16)
   (filtered-other-collide-as   collide-spec             :offset-assert  20)
   )
  :method-count-assert 9
  :size-assert         #x18
  :flag-assert         #x900000018
  )

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

;; definition of type move-above-ground-params
(deftype move-above-ground-params (structure)
  ((gnd-collide-with       collide-spec                   :offset-assert   0)
   (popup                  float                          :offset-assert   4)
   (dont-move-if-overlaps? basic                          :offset-assert   8)
   (hover-if-no-ground?    basic                          :offset-assert  12)
   (overlaps-params        overlaps-others-params :inline :offset-assert  16)
   (new-pos                vector                 :inline :offset-assert  48)
   (old-gspot-pos          vector                 :inline :offset-assert  64)
   (old-gspot-normal       vector                 :inline :offset-assert  80)
   (pat                    pat-surface                    :offset-assert  96)
   (on-ground?             basic                          :offset-assert 100)
   (do-move?               basic                          :offset-assert 104)
   )
  :method-count-assert 9
  :size-assert         #x6c
  :flag-assert         #x90000006c
  )

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

;; definition of type collide-prim-core
(deftype collide-prim-core (structure)
  ((world-sphere vector         :inline :offset-assert   0)
   (collide-as   collide-spec           :offset-assert  16)
   (collide-with collide-spec           :offset-assert  20)
   (action       collide-action         :offset-assert  24)
   (prim-type    prim-type              :offset-assert  28)
   (unused1      uint8          3       :offset-assert  29)
   (quad         uint128        2       :offset          0)
   )
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

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

;; definition of type collide-shape-prim
(deftype collide-shape-prim (basic)
  ((cshape          collide-shape             :offset-assert   4)
   (prim-id         uint32                    :offset-assert   8)
   (transform-index int8                      :offset-assert  12)
   (unused2         int8              3       :offset-assert  13)
   (prim-core       collide-prim-core :inline :offset-assert  16)
   (local-sphere    vector            :inline :offset-assert  48)
   (world-sphere    vector            :inline :offset         16)
   (collide-as      collide-spec              :offset         32)
   (collide-with    collide-spec              :offset         36)
   (action          collide-action            :offset         40)
   (prim-type       int8                      :offset         44)
   (radius          float                     :offset         60)
   (specific        uint8             16      :offset-assert  64)
   )
  :method-count-assert 20
  :size-assert         #x50
  :flag-assert         #x1400000050
  (:methods
    (new (symbol type collide-shape uint int) _type_ 0)
    (collide-shape-prim-method-9 () none 9)
    (collide-shape-prim-method-10 () none 10)
    (collide-shape-prim-method-11 () none 11)
    (collide-shape-prim-method-12 () none 12)
    (collide-shape-prim-method-13 () none 13)
    (collide-shape-prim-method-14 () none 14)
    (collide-shape-prim-method-15 () none 15)
    (collide-shape-prim-method-16 () none 16)
    (collide-shape-prim-method-17 () none 17)
    (collide-shape-prim-method-18 () none 18)
    (collide-shape-prim-method-19 () none 19)
    )
  )

;; definition for method 3 of type collide-shape-prim
(defmethod inspect collide-shape-prim ((obj collide-shape-prim))
  (when (not obj)
    (set! obj obj)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tcshape: ~A~%" (-> obj cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> obj prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> obj transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> obj unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> obj prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> obj local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (-> obj specific))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> obj prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> obj prim-core collide-as))
  (let ((s5-0 (-> obj 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 " (-> obj prim-core collide-with))
  (let ((s5-1 (-> obj 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 " (-> obj prim-core action))
  (let ((s5-2 (-> obj 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~%" (-> obj prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> obj local-sphere w))
  (label cfg-146)
  obj
  )

;; definition of type collide-shape-prim-sphere
(deftype collide-shape-prim-sphere (collide-shape-prim)
  ((pat        pat-surface  :offset  64)
   (nav-radius float        :offset  68)
   )
  :method-count-assert 20
  :size-assert         #x50
  :flag-assert         #x1400000050
  (:methods
    (new (symbol type collide-shape uint) _type_ 0)
    )
  )

;; definition for method 3 of type collide-shape-prim-sphere
(defmethod inspect collide-shape-prim-sphere ((obj collide-shape-prim-sphere))
  (when (not obj)
    (set! obj obj)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tcshape: ~A~%" (-> obj cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> obj prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> obj transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> obj unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> obj prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> obj local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (&-> obj pat))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> obj prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> obj prim-core collide-as))
  (let ((s5-0 (-> obj 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 " (-> obj prim-core collide-with))
  (let ((s5-1 (-> obj 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 " (-> obj prim-core action))
  (let ((s5-2 (-> obj 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~%" (-> obj prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> obj local-sphere w))
  (format #t "~1Tpat: ~D~%" (-> obj pat))
  (format #t "~1Tnav-radius: ~f~%" (-> obj nav-radius))
  (label cfg-146)
  obj
  )

;; definition of type collide-shape-prim-mesh
(deftype collide-shape-prim-mesh (collide-shape-prim)
  ((mesh             collide-mesh              :offset  64)
   (mesh-id          int32                     :offset  68)
   (mesh-cache-id    uint32                    :offset  72)
   (mesh-cache-entry collide-mesh-cache-entry  :offset  76)
   )
  :method-count-assert 20
  :size-assert         #x50
  :flag-assert         #x1400000050
  (:methods
    (new (symbol type collide-shape uint uint) _type_ 0)
    )
  )

;; definition for method 3 of type collide-shape-prim-mesh
(defmethod inspect collide-shape-prim-mesh ((obj collide-shape-prim-mesh))
  (when (not obj)
    (set! obj obj)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tcshape: ~A~%" (-> obj cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> obj prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> obj transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> obj unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> obj prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> obj local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (&-> obj mesh))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> obj prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> obj prim-core collide-as))
  (let ((s5-0 (-> obj 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 " (-> obj prim-core collide-with))
  (let ((s5-1 (-> obj 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 " (-> obj prim-core action))
  (let ((s5-2 (-> obj 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~%" (-> obj prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> obj local-sphere w))
  (format #t "~1Tmesh: ~A~%" (-> obj mesh))
  (format #t "~1Tmesh-id: ~D~%" (-> obj mesh-id))
  (format #t "~1Tmesh-cache-id: ~D~%" (-> obj mesh-cache-id))
  (format #t "~1Tmesh-cache-entry: #<collide-mesh-cache-entry @ #x~X>~%" (-> obj mesh-cache-entry))
  (label cfg-146)
  obj
  )

;; definition of type collide-shape-prim-group
(deftype collide-shape-prim-group (collide-shape-prim)
  ((num-children       uint8                         :offset  64)
   (num-alloc-children uint8                         :offset  65)
   (child              (inline-array collide-shape)  :offset  68)
   )
  :method-count-assert 20
  :size-assert         #x50
  :flag-assert         #x1400000050
  (:methods
    (new (symbol type collide-shape uint int) _type_ 0)
    )
  )

;; definition for method 3 of type collide-shape-prim-group
(defmethod inspect collide-shape-prim-group ((obj collide-shape-prim-group))
  (when (not obj)
    (set! obj obj)
    (goto cfg-146)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tcshape: ~A~%" (-> obj cshape))
  (format #t "~1Tprim-id: #x~X~%" (-> obj prim-id))
  (format #t "~1Ttransform-index: ~D~%" (-> obj transform-index))
  (format #t "~1Tunused2[3] @ #x~X~%" (-> obj unused2))
  (format #t "~1Tprim-core: #<collide-prim-core @ #x~X>~%" (-> obj prim-core))
  (format #t "~1Tlocal-sphere: ~`vector`P~%" (-> obj local-sphere))
  (format #t "~1Tspecific[16] @ #x~X~%" (&-> obj num-children))
  (format #t "~1Tworld-sphere: ~`vector`P~%" (-> obj prim-core))
  (format #t "~1Tcollide-as: #x~X : (collide-spec " (-> obj prim-core collide-as))
  (let ((s5-0 (-> obj 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 " (-> obj prim-core collide-with))
  (let ((s5-1 (-> obj 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 " (-> obj prim-core action))
  (let ((s5-2 (-> obj 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~%" (-> obj prim-core prim-type))
  (format #t "~1Tradius: (meters ~m)~%" (-> obj local-sphere w))
  (format #t "~1Tnum-children: ~D~%" (-> obj num-children))
  (format #t "~1Tnum-alloc-children: ~D~%" (-> obj num-alloc-children))
  (format #t "~1Tchild: #x~X~%" (-> obj child))
  (label cfg-146)
  obj
  )

;; definition of type collide-shape
(deftype collide-shape (trsqv)
  ((actor-hash-index    int16               :offset         12)
   (process             process-drawable    :offset-assert 140)
   (max-iteration-count uint8               :offset-assert 144)
   (nav-flags           nav-flags           :offset-assert 145)
   (total-prims         uint8               :offset-assert 146)
   (num-riders          uint8               :offset-assert 147)
   (pat-ignore-mask     pat-surface         :offset-assert 148)
   (event-self          symbol              :offset-assert 152)
   (event-other         symbol              :offset-assert 156)
   (root-prim           collide-shape-prim  :offset-assert 160)
   (riders              pointer             :offset-assert 164)
   (penetrate-using     penetrate           :offset-assert 168)
   (penetrated-by       penetrate           :offset-assert 176)
   (backup-collide-as   collide-spec        :offset-assert 184)
   (backup-collide-with collide-spec        :offset-assert 188)
   (event-priority      uint8               :offset-assert 192)
   (rider-max-momentum  float               :offset-assert 196)
   )
  :method-count-assert 55
  :size-assert         #xc8
  :flag-assert         #x37000000c8
  (:methods
    (new (symbol type process-drawable collide-list-enum) _type_ 0)
    (move-by-vector! (_type_ vector) none 28)
    (collide-shape-method-29 (_type_ vector) none 29)
    (collide-shape-method-30 () none 30)
    (collide-shape-method-31 () none 31)
    (collide-shape-method-32 (_type_ vector collide-query meters) none 32)
    (collide-shape-method-33 () none 33)
    (collide-shape-method-34 () none 34)
    (collide-shape-method-35 () none 35)
    (collide-shape-method-36 () none 36)
    (collide-shape-method-37 () none 37)
    (collide-shape-method-38 () none 38)
    (collide-shape-method-39 () none 39)
    (find-overlapping-shapes (_type_ overlaps-others-params) symbol 40)
    (collide-shape-method-41 () none 41)
    (collide-shape-method-42 () none 42)
    (collide-shape-method-43 () none 43)
    (collide-shape-method-44 () none 44)
    (collide-shape-method-45 () none 45)
    (collide-shape-method-46 (_type_) none 46)
    (collide-shape-method-47 () none 47)
    (collide-shape-method-48 () none 48)
    (collide-shape-method-49 () none 49)
    (collide-shape-method-50 () none 50)
    (collide-shape-method-51 () none 51)
    (collide-shape-method-52 () none 52)
    (collide-shape-method-53 () none 53)
    (collide-shape-method-54 (_type_) none 54)
    )
  )

;; definition for method 3 of type collide-shape
(defmethod inspect collide-shape ((obj collide-shape))
  (when (not obj)
    (set! obj obj)
    (goto cfg-136)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Ttrans: ~`vector`P~%" (-> obj trans))
  (format #t "~1Trot: ~`vector`P~%" (-> obj quat))
  (format #t "~1Tscale: ~`vector`P~%" (-> obj scale))
  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> obj quat))
  (format #t "~1Tpause-adjust-distance: (meters ~m)~%" (-> obj pause-adjust-distance))
  (format #t "~1Tnav-radius: (meters ~m)~%" (-> obj nav-radius))
  (format #t "~1Ttransv: ~`vector`P~%" (-> obj transv))
  (format #t "~1Trotv: ~`vector`P~%" (-> obj rotv))
  (format #t "~1Tscalev: ~`vector`P~%" (-> obj scalev))
  (format #t "~1Tdir-targ: #<quaternion @ #x~X>~%" (-> obj dir-targ))
  (format #t "~1Tangle-change-time: ~D~%" (-> obj angle-change-time))
  (format #t "~1Told-y-angle-diff: ~f~%" (-> obj old-y-angle-diff))
  (format #t "~1Tactor-hash-index: ~D~%" (-> obj actor-hash-index))
  (format #t "~1Tprocess: ~A~%" (-> obj process))
  (format #t "~1Tmax-iteration-count: ~D~%" (-> obj max-iteration-count))
  (format #t "~1Tnav-flags: ~D~%" (-> obj nav-flags))
  (format #t "~1Ttotal-prims: ~D~%" (-> obj total-prims))
  (format #t "~1Tnum-riders: ~D~%" (-> obj num-riders))
  (format #t "~1Tpat-ignore-mask: ~D~%" (-> obj pat-ignore-mask))
  (format #t "~1Tevent-self: ~A~%" (-> obj event-self))
  (format #t "~1Tevent-other: ~A~%" (-> obj event-other))
  (format #t "~1Troot-prim: ~A~%" (-> obj root-prim))
  (format #t "~1Triders: #x~X~%" (-> obj riders))
  (format #t "~1Tpenetrate-using: #x~X : (penetrate " (-> obj penetrate-using))
  (let ((s5-0 (-> obj 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 " (-> obj penetrated-by))
  (let ((s5-1 (-> obj 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~%" (-> obj backup-collide-as))
  (format #t "~1Tbackup-collide-with: ~D~%" (-> obj backup-collide-with))
  (format #t "~1Tevent-priority: ~D~%" (-> obj event-priority))
  (format #t "~1Trider-max-momentum: ~f~%" (-> obj rider-max-momentum))
  (label cfg-136)
  obj
  )

;; definition of type collide-shape-moving
(deftype collide-shape-moving (collide-shape)
  ((rider-time         time-frame                                                                      :offset-assert 200)
   (rider-last-move    vector                                                                  :inline :offset-assert 208)
   (trans-old          vector                                                                  :inline :offset-assert 224)
   (poly-pat           pat-surface                                                                     :offset        272)
   (cur-pat            pat-surface                                                                     :offset-assert 276)
   (ground-pat         pat-surface                                                                     :offset-assert 280)
   (status             cshape-moving-flags                                                             :offset-assert 288)
   (old-status         cshape-moving-flags                                                             :offset-assert 296)
   (prev-status        cshape-moving-flags                                                             :offset-assert 304)
   (reaction-flag      cshape-reaction-flags                                                           :offset-assert 312)
   (reaction           (function control-info collide-query vector vector cshape-moving-flags)         :offset-assert 316)
   (no-reaction        function                                                                        :offset-assert 320)
   (local-normal       vector                                                                  :inline :offset-assert 336)
   (surface-normal     vector                                                                  :inline :offset-assert 352)
   (poly-normal        vector                                                                  :inline :offset-assert 368)
   (ground-poly-normal vector                                                                  :inline :offset-assert 384)
   (gspot-pos          vector                                                                  :inline :offset-assert 400)
   (gspot-normal       vector                                                                  :inline :offset-assert 416)
   (grount-touch-point vector                                                                  :inline :offset-assert 432)
   (ground-impact-vel  meters                                                                          :offset-assert 448)
   (surface-angle      float                                                                           :offset-assert 452)
   (poly-angle         float                                                                           :offset-assert 456)
   (touch-angle        float                                                                           :offset-assert 460)
   (coverage           float                                                                           :offset-assert 464)
   (dynam              dynamics                                                                        :offset-assert 468)
   (surf               surface                                                                         :offset-assert 472)
   )
  :method-count-assert 68
  :size-assert         #x1dc
  :flag-assert         #x44000001dc
  (:methods
    (new (symbol type process-drawable collide-list-enum) _type_ 0)
    (collide-shape-moving-method-55 (_type_ collide-query collide-spec float float float) symbol 55)
    (collide-shape-moving-method-56 () none 56)
    (collide-shape-moving-method-57 () none 57)
    (collide-shape-moving-method-58 () none 58)
    (collide-shape-moving-method-59 () none 59)
    (collide-shape-moving-method-60 () none 60)
    (collide-shape-moving-method-61 () none 61)
    (collide-shape-moving-method-62 (_type_) none 62)
    (collide-shape-moving-method-63 () none 63)
    (collide-shape-moving-method-64 () none 64)
    (collide-shape-moving-method-65 () none 65)
    (collide-shape-moving-method-66 () none 66)
    (collide-shape-moving-method-67 () none 67)
    )
  )

;; definition for method 3 of type collide-shape-moving
(defmethod inspect collide-shape-moving ((obj collide-shape-moving))
  (when (not obj)
    (set! obj obj)
    (goto cfg-136)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Ttrans: ~`vector`P~%" (-> obj trans))
  (format #t "~1Trot: ~`vector`P~%" (-> obj quat))
  (format #t "~1Tscale: ~`vector`P~%" (-> obj scale))
  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> obj quat))
  (format #t "~1Tpause-adjust-distance: (meters ~m)~%" (-> obj pause-adjust-distance))
  (format #t "~1Tnav-radius: (meters ~m)~%" (-> obj nav-radius))
  (format #t "~1Ttransv: ~`vector`P~%" (-> obj transv))
  (format #t "~1Trotv: ~`vector`P~%" (-> obj rotv))
  (format #t "~1Tscalev: ~`vector`P~%" (-> obj scalev))
  (format #t "~1Tdir-targ: #<quaternion @ #x~X>~%" (-> obj dir-targ))
  (format #t "~1Tangle-change-time: ~D~%" (-> obj angle-change-time))
  (format #t "~1Told-y-angle-diff: ~f~%" (-> obj old-y-angle-diff))
  (format #t "~1Tactor-hash-index: ~D~%" (-> obj actor-hash-index))
  (format #t "~1Tprocess: ~A~%" (-> obj process))
  (format #t "~1Tmax-iteration-count: ~D~%" (-> obj max-iteration-count))
  (format #t "~1Tnav-flags: ~D~%" (-> obj nav-flags))
  (format #t "~1Ttotal-prims: ~D~%" (-> obj total-prims))
  (format #t "~1Tnum-riders: ~D~%" (-> obj num-riders))
  (format #t "~1Tpat-ignore-mask: ~D~%" (-> obj pat-ignore-mask))
  (format #t "~1Tevent-self: ~A~%" (-> obj event-self))
  (format #t "~1Tevent-other: ~A~%" (-> obj event-other))
  (format #t "~1Troot-prim: ~A~%" (-> obj root-prim))
  (format #t "~1Triders: #x~X~%" (-> obj riders))
  (format #t "~1Tpenetrate-using: #x~X : (penetrate " (-> obj penetrate-using))
  (let ((s5-0 (-> obj 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 " (-> obj penetrated-by))
  (let ((s5-1 (-> obj 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~%" (-> obj backup-collide-as))
  (format #t "~1Tbackup-collide-with: ~D~%" (-> obj backup-collide-with))
  (format #t "~1Tevent-priority: ~D~%" (-> obj event-priority))
  (format #t "~1Trider-max-momentum: ~f~%" (-> obj rider-max-momentum))
  (format #t "~1Trider-time: ~D~%" (-> obj rider-time))
  (format #t "~1Trider-last-move: ~`vector`P~%" (-> obj rider-last-move))
  (format #t "~1Ttrans-old: ~`vector`P~%" (-> obj trans-old))
  (format #t "~1Tpoly-pat: #x~X~%" (-> obj poly-pat))
  (format #t "~1Tcur-pat: #x~X~%" (-> obj cur-pat))
  (format #t "~1Tground-pat: #x~X~%" (-> obj ground-pat))
  (format #t "~1Tstatus: ~D~%" (-> obj status))
  (format #t "~1Told-status: ~D~%" (-> obj old-status))
  (format #t "~1Tprev-status: ~D~%" (-> obj prev-status))
  (format #t "~1Treaction-flag: ~D~%" (-> obj reaction-flag))
  (format #t "~1Treaction: ~A~%" (-> obj reaction))
  (format #t "~1Tno-reaction: ~A~%" (-> obj no-reaction))
  (format #t "~1Tlocal-normal: ~`vector`P~%" (-> obj local-normal))
  (format #t "~1Tsurface-normal: ~`vector`P~%" (-> obj surface-normal))
  (format #t "~1Tpoly-normal: ~`vector`P~%" (-> obj poly-normal))
  (format #t "~1Tground-poly-normal: ~`vector`P~%" (-> obj ground-poly-normal))
  (format #t "~1Tgspot-pos: ~`vector`P~%" (-> obj gspot-pos))
  (format #t "~1Tgspot-normal: ~`vector`P~%" (-> obj gspot-normal))
  (format #t "~1Tground-touch-point: ~`vector`P~%" (-> obj grount-touch-point))
  (format #t "~1Tground-impact-vel: (meters ~m)~%" (-> obj ground-impact-vel))
  (format #t "~1Tsurface-angle: ~f~%" (-> obj surface-angle))
  (format #t "~1Tpoly-angle: ~f~%" (-> obj poly-angle))
  (format #t "~1Ttouch-angle: ~f~%" (-> obj touch-angle))
  (format #t "~1Tcoverage: ~f~%" (-> obj coverage))
  (format #t "~1Tdynam: ~A~%" (-> obj dynam))
  (format #t "~1Tsurf: ~A~%" (-> obj surf))
  (label cfg-136)
  obj
  )

;; 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) (&+ (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 uint8 vs int.
(defmethod length collide-shape-prim-group ((obj collide-shape-prim-group))
  (the-as int (-> obj 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 nav-flags0))
    (set! (-> s5-0 event-self) #f)
    (set! (-> s5-0 event-other) #f)
    (set! (-> s5-0 riders) (the-as pointer #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