diff --git a/.vs/launch.vs.json b/.vs/launch.vs.json
index 0b5a8576a0..43102f5094 100644
--- a/.vs/launch.vs.json
+++ b/.vs/launch.vs.json
@@ -82,7 +82,7 @@
         "--game",
         "jak2",
         "--file",
-        "atoll-part"
+        "fort-turret"
       ]
     },
     {
diff --git a/Taskfile.yml b/Taskfile.yml
index 17fd4dcb8c..1bcfb2b5c5 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -123,6 +123,9 @@ tasks:
   offline-tests: # ran by jenkins
     cmds:
       - '{{.OFFLINETEST_BIN_RELEASE_DIR}}/offline-test --iso_data_path "./iso_data/{{.GAME}}" --game {{.GAME}} --fail-on-cmp'
+  offline-test-file:
+    cmds:
+      - '{{.OFFLINETEST_BIN_RELEASE_DIR}}/offline-test --iso_data_path "./iso_data/{{.GAME}}" --game {{.GAME}} --file {{.FILE}}'
   offline-tests-fast:
     cmds:
       - '{{.OFFLINETEST_BIN_RELEASE_DIR}}/offline-test --iso_data_path "./iso_data/{{.GAME}}" --game {{.GAME}} --pretty-print --num_threads 32 --dump_current_output --fail-on-cmp'
diff --git a/decompiler/IR2/Form.cpp b/decompiler/IR2/Form.cpp
index 922928c784..0040c4e38c 100644
--- a/decompiler/IR2/Form.cpp
+++ b/decompiler/IR2/Form.cpp
@@ -3260,7 +3260,12 @@ goos::Object DefpartgroupElement::to_form_internal(const Env& env) const {
     }
 
     if (offset) {
-      result += fmt::format(" :offset {}", offset);
+      // jak2 has switched this field to a signed 16 bit number
+      if (env.version == GameVersion::Jak2) {
+        result += fmt::format(" :offset {}", (s16)offset);
+      } else {
+        result += fmt::format(" :offset {}", offset);
+      }
     }
 
     if (hour_mask) {
diff --git a/decompiler/analysis/variable_naming.cpp b/decompiler/analysis/variable_naming.cpp
index aaf410d610..1ac858e51d 100644
--- a/decompiler/analysis/variable_naming.cpp
+++ b/decompiler/analysis/variable_naming.cpp
@@ -736,7 +736,8 @@ void SSA::make_vars(const Function& function, const DecompilerTypeSystem& dts) {
     event_handler_hack = function.guessed_name.is_event_handler() ||
                          function.guessed_name.to_string() == "target-generic-event-handler" ||
                          function.guessed_name.to_string() == "target-standard-event-handler" ||
-                         function.guessed_name.to_string() == "(method 74 pegasus)";
+                         function.guessed_name.to_string() == "(method 74 pegasus)" ||
+                         function.guessed_name.to_string() == "(method 74 crimson-guard-level)";
   }
 
   for (int block_id = 0; block_id < int(blocks.size()); block_id++) {
diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc
index 7734c52e07..18f11e64ce 100644
--- a/decompiler/config/jak2/all-types.gc
+++ b/decompiler/config/jak2/all-types.gc
@@ -584,7 +584,7 @@
    (heap-cur pointer :offset-assert 104)
    (stack-frame-top stack-frame :offset-assert 108)
    (connection-list connectable :inline :offset-assert 112)
-   (stack uint8 :dynamic :offset-assert 128)
+   (stack uint8 :dynamic :offset-assert 128 :score -1)
    )
   (:methods
     (new (symbol type string int) _type_ 0)
@@ -8555,7 +8555,7 @@
    (joint-num int16     :offset-assert 8)
    (geo       drawable     :offset-assert 12)
    (bone      bone      :offset-assert 16)
-   (param0    (function cspace matrix none)  :offset-assert 20) ;; guessed by decompiler
+   (param0    (function cspace transformq none)  :offset-assert 20) ;; guessed by decompiler
    (param1    basic     :offset-assert 24)
    (param2    basic     :offset-assert 28)
    )
@@ -15385,6 +15385,7 @@
 
 (deftype sync-linear (sync-info)
   ()
+  :pack-me
   :method-count-assert 16
   :size-assert         #x10
   :flag-assert         #x1000000010
@@ -15428,6 +15429,7 @@
    (start-time time-frame  :offset-assert 16) ;; time-frame
    (value      float   :offset-assert 24)
    )
+  :pack-me
   :method-count-assert 13
   :size-assert         #x1c
   :flag-assert         #xd0000001c
@@ -15447,6 +15449,7 @@
    (damping float  :offset-assert 16)
    (accel   float  :offset-assert 20)
    )
+  :allow-misaligned
   :method-count-assert 11
   :size-assert         #x18
   :flag-assert         #xb00000018
@@ -15463,6 +15466,7 @@
    (elasticity float                     :offset-assert 32)
    (state      int32                     :offset-assert 36)
    )
+  :allow-misaligned
   :method-count-assert 13
   :size-assert         #x28
   :flag-assert         #xd00000028
@@ -16419,6 +16423,7 @@
 
 (declare-type collide-query structure)
 (declare-type control-info basic)
+(declare-type rigid-body structure)
 (deftype collide-shape-moving (collide-shape)
   ((rider-time         time-frame                                                                      :offset-assert 200)
    (rider-last-move    vector                                                                  :inline :offset-assert 208)
@@ -16462,7 +16467,7 @@
     (move-to-ground (_type_ float float symbol collide-spec) none 60)
     (move-to-ground-point (_type_ vector vector vector) none 61)
     (compute-acc-due-to-gravity (_type_ vector float) vector 62)
-    (collide-shape-moving-method-63 () none 63) ;; ( 63)
+    (collide-shape-moving-method-63 (_type_ rigid-body float) none 63)
     (try-snap-to-surface (_type_ vector float float float) symbol 64)
     (fill-and-try-snap-to-surface (_type_ vector float float float collide-query) symbol 65)
     (step-collison! (_type_ vector vector float int) float 66)
@@ -33122,7 +33127,7 @@
     (rigid-body-object-method-42 (_type_) none :behavior rigid-body-object 42)
     (rigid-body-object-method-43 (_type_) none 43)
     (rigid-body-object-method-44 (_type_ float) none 44)
-    (rigid-body-object-method-45 () none 45)
+    (rigid-body-object-method-45 (_type_ rigid-body-object-constants) sound-id 45)
     (rigid-body-object-method-46 (_type_ process-drawable int symbol event-message-block) none :behavior rigid-body-object 46)
     (rigid-body-object-method-47 (_type_ process-drawable attack-info object penetrate) symbol 47)
     (rigid-body-object-method-48 (_type_ object object) none 48)
@@ -34824,7 +34829,10 @@
   ((anim-index       int32 2 :offset-assert 0)
    (anim-index-front int32     :offset 0)
    (anim-index-back  int32     :offset 4)
+   (unsigned-anim-index-front uint32     :offset 0) ;; added
+   (unsigned-anim-index-back  uint32     :offset 4) ;; added
    )
+  :pack-me
   :method-count-assert 9
   :size-assert         #x8
   :flag-assert         #x900000008
@@ -34833,15 +34841,15 @@
 (deftype guard-level-global-info (basic)
   ((prev-yellow-hit         int8      :offset-assert 4)
    (prev-blue-hit           int8      :offset-assert 5)
-   (knocked                 int32   2 :offset-assert 8)
-   (knocked-land            int32   2 :offset-assert 16)
+   (knocked                 guard-level-anim-info   :inline :offset-assert 8)
    (anim-knocked-front      int32     :offset 8)
    (anim-knocked-back       int32     :offset 12)
+   (knocked-land            guard-level-anim-info :inline :offset-assert 16)
    (anim-knocked-front-land int32     :offset 16)
    (anim-knocked-back-land  int32     :offset 20)
-   (yellow-hit-anim         handle 2 :offset-assert 24)
-   (yellow-land-anim        handle 2 :offset-assert 40)
-   (blue-hit-anim           handle 1 :offset-assert 56)
+   (yellow-hit-anim         guard-level-anim-info 2 :inline :offset-assert 24)
+   (yellow-land-anim        guard-level-anim-info 2 :inline :offset-assert 40)
+   (blue-hit-anim           guard-level-anim-info 1 :inline :offset-assert 56)
    )
   :method-count-assert 9
   :size-assert         #x40
@@ -34853,6 +34861,7 @@
    (start      float  :offset-assert 4)
    (end        float  :offset-assert 8)
    )
+  :pack-me
   :method-count-assert 9
   :size-assert         #xc
   :flag-assert         #x90000000c
@@ -34860,25 +34869,24 @@
 
 (deftype crimson-guard-level (nav-enemy)
   (
-    (info basic :offset-assert 604)
+    (info guard-level-global-info :offset-assert 604)
     (hit-face uint32 :offset-assert 608)
     (anim-get-up-front int32 :offset-assert 612)
     (anim-get-up-back int32 :offset-assert 616)
     (small-hit int32 :offset-assert 620)
-    (yellow-anim uint32 :offset-assert 624)
-    (pad-jh1b23 int32 :offset-assert 628)
+    (yellow-anim guard-level-anim-info :inline :offset-assert 624)
     (flags int64 :offset-assert 632)
     (weapon int32 :offset-assert 640)
     (pad-kjh1n23 int32 :offset-assert 644)
     (last-time-see-target int64 :offset-assert 648)
-    (joint uint32 :offset-assert 656)
-    (joint-enable uint32 :offset-assert 660)
-    (l-control basic :offset-assert 664)
+    (joint joint-mod :offset-assert 656)
+    (joint-enable symbol :offset-assert 660)
+    (l-control lightning-control :offset-assert 664)
     (already-shot uint32 :offset-assert 668)
     (miss-amount float :offset-assert 672)
     (pad-k1jh2n3 int32 :offset-assert 676)
     (next-shot int64 :offset-assert 680)
-    (anim-shoot vector 3 :inline :offset-assert 688)
+    (anim-shoot guard-level-shoot-info 3 :inline :offset-assert 688)
     (target-pos vector :inline :offset-assert 736)
     (target-pos-predict vector :inline :offset-assert 752)
     (target-pos-predict-miss vector :inline :offset-assert 768)
@@ -34890,7 +34898,7 @@
     (target-self-xz-dist float :offset-assert 852)
     (target-y-angle float :offset-assert 856)
     (lazer-sound sound-id :offset-assert 860)
-    (transport int64 :offset-assert 864)
+    (transport handle :offset-assert 864)
     (transport-side uint32 :offset-assert 872)
     (other-side uint32 :offset-assert 876)
     (start-target-pos vector :inline :offset-assert 880)
@@ -34917,17 +34925,17 @@
     (arrest () _type_ :state 190)
     (crimson-guard-level-method-191 (_type_) (pointer process) 191)
     (crimson-guard-level-method-192 (_type_) none 192)
-    (crimson-guard-level-method-193 (_type_) none 193)
-    (crimson-guard-level-method-194 (_type_) none 194)
-    (crimson-guard-level-method-195 (_type_) none 195)
+    (crimson-guard-level-method-193 (_type_) symbol 193)
+    (crimson-guard-level-method-194 (_type_) symbol 194)
+    (crimson-guard-level-method-195 (_type_ vector vector vector) int 195)
     (crimson-guard-level-method-196 (_type_ vector) none 196)
     (crimson-guard-level-method-197 (_type_) quaternion 197)
     (crimson-guard-level-method-198 (_type_) none 198)
-    (crimson-guard-level-method-199 (_type_) none 199)
+    (crimson-guard-level-method-199 (_type_ vector vector vector float) symbol 199)
     (crimson-guard-level-method-200 (_type_) float 200)
-    (crimson-guard-level-method-201 (_type_) none 201)
-    (crimson-guard-level-method-202 (_type_) none 202)
-    (crimson-guard-level-method-203 (_type_) none 203)
+    (crimson-guard-level-method-201 (_type_ float) none 201)
+    (crimson-guard-level-method-202 (_type_ vector) float 202)
+    (crimson-guard-level-method-203 "TODO - probably a flag" (_type_ int) none 203)
     (crimson-guard-level-method-204 (_type_) none 204)))
 
 (deftype crimson-guard-level-params (structure)
@@ -34951,7 +34959,7 @@
 (define-extern *crimson-guard-level-grenade-info* nav-enemy-info)
 (define-extern *crimson-guard-level-sniper-info* nav-enemy-info)
 (define-extern *crimson-guard-level-tazer-info* nav-enemy-info)
-;; (define-extern crimson-guard-level-init-by-other function)
+(define-extern crimson-guard-level-init-by-other (function crimson-guard-level-params none :behavior crimson-guard-level))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; guard-conversation             ;;
@@ -35034,7 +35042,7 @@
     (die-fast () _type_ :state 30)
     (transport-level-method-31 (_type_) none 31)
     (transport-level-method-32 (_type_) none 32)
-    (transport-level-method-33 (_type_) none 33)
+    (transport-level-method-33 (_type_) uint 33)
     (transport-level-method-34 (_type_) none 34)
     )
   )
@@ -36214,10 +36222,9 @@
 ;; dig-digger                     ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype dig-clasp (process-drawable)
-  ((b    basic               :offset-assert 196)
-   (conn connection-minimap  :offset-assert 200)
+  ((b    basic               :offset-assert 200)
+   (conn connection-minimap  :offset-assert 204)
    )
   :method-count-assert 24
   :size-assert         #xd0
@@ -36226,49 +36233,36 @@
     (broken () _type_ :state 20)
     (break-it () _type_ :state 21)
     (idle () _type_ :state 22)
-    (dig-clasp-method-23 () none 23)
+    (dig-clasp-method-23 (_type_ vector) vector 23)
     )
   )
-|#
 
-#|
-(deftype dig-clasp-b (dig-clasp)
-  ()
-  :method-count-assert 24
-  :size-assert         #xd0
-  :flag-assert         #x18005000d0
-  (:methods
-    )
-  )
-|#
+(deftype dig-clasp-b (dig-clasp) ())
 
-#|
 (deftype dig-tether-chain (structure)
   ((position  vector :inline :offset-assert 0)
    (velocity  vector :inline :offset-assert 16)
-   (joint-mod basic          :offset-assert 32)
+   (joint-mod joint-mod          :offset-assert 32)
    )
   :method-count-assert 9
   :size-assert         #x24
   :flag-assert         #x900000024
   )
-|#
 
-#|
 (deftype dig-tether (process-drawable)
-  ((clasp             basic                       :offset-assert 196)
-   (clasp-info-ok     basic                       :offset-assert 200)
-   (clasp-pos         vector              :inline :offset-assert 204)
-   (digger-pos        vector              :inline :offset-assert 220)
-   (digger-vertical   vector              :inline :offset-assert 236)
-   (frame             oscillating-float   :inline :offset-assert 252)
-   (frame-kicker      delayed-rand-float  :inline :offset-assert 276)
-   (old-dist          float                       :offset-assert 304)
-   (chain-joints      UNKNOWN             8       :offset-assert 316)
-   (chain-offset-rand delayed-rand-vector :inline :offset-assert 700)
-   (chain-offset      oscillating-vector  :inline :offset-assert 748)
-   (joint-one         basic                       :offset-assert 808)
-   (snapped-look      lod-set             :inline :offset-assert 812)
+  ((clasp             entity-actor                       :offset-assert 200)
+   (clasp-info-ok     symbol                       :offset-assert 204)
+   (clasp-pos         vector              :inline :offset-assert 208)
+   (digger-pos        vector              :inline :offset-assert 224)
+   (digger-vertical   vector              :inline :offset-assert 240)
+   (frame             oscillating-float   :inline :offset-assert 256)
+   (frame-kicker      delayed-rand-float  :inline :offset-assert 280)
+   (old-dist          float                       :offset-assert 308)
+   (chain-joints      dig-tether-chain             8     :inline  :offset-assert 320)
+   (chain-offset-rand delayed-rand-vector :inline :offset-assert 704)
+   (chain-offset      oscillating-vector  :inline :offset-assert 752)
+   (joint-one         joint-mod                       :offset-assert 812)
+   (snapped-look      lod-set             :inline :offset-assert 816)
    )
   :method-count-assert 25
   :size-assert         #x361
@@ -36276,17 +36270,15 @@
   (:methods
     (broken () _type_ :state 20)
     (idle () _type_ :state 21)
-    (dig-tether-method-22 () none 22)
-    (dig-tether-method-23 () none 23)
-    (dig-tether-method-24 () none 24)
+    (dig-tether-method-22 (_type_) none 22)
+    (dig-tether-method-23 (_type_) none 23)
+    (dig-tether-method-24 (_type_) none 24)
     )
   )
-|#
 
-#|
 (deftype dig-digger-tether-info (structure)
   ((rp       int32   :offset-assert 0)
-   (handle   uint64  :offset-assert 8)
+   (handle   handle  :offset-assert 8)
    (broken-x float   :offset-assert 16)
    (broken-z float   :offset-assert 20)
    )
@@ -36294,46 +36286,59 @@
   :size-assert         #x18
   :flag-assert         #x900000018
   )
-|#
 
-#|
 (deftype dig-digger (process-drawable)
-  ()
+  (
+    (actor-group       (pointer actor-group)       :offset-assert 200)
+    (actor-group-count int32                       :offset-assert 204)
+    (tethers           dig-digger-tether-info 24             :inline     :offset-assert 208) ;; elt size: 32
+    (vertical          oscillating-vector :inline  :offset-assert 976)
+    (vertical-rand     delayed-rand-vector :inline :offset-assert 1040)
+    (start-y           float                       :offset-assert 1088)
+    (y-offset          bouncing-float :inline      :offset-assert 1092)
+    (y-offset-kicker   delayed-rand-float :inline  :offset-assert 1136)
+    (twist             oscillating-float :inline   :offset-assert 1164)
+    (twist-kicker      delayed-rand-float :inline  :offset-assert 1192)
+    (smoke-part        sparticle-launch-control                      :offset-assert 1220)
+    (motor-sound       uint32                      :offset-assert 1224)
+    (bit-sound         uint32                      :offset-assert 1228)
+    (movie-handle      handle                      :offset-assert 1232)
+    (hud-counter       handle                      :offset-assert 1240)
+    (speech-time       time-frame                  :offset-assert 1248)
+    (speech-count      int32                       :offset-assert 1256)
+  )
   :method-count-assert 25
   :size-assert         #x4ec
   :flag-assert         #x19047004ec
-  ;; Failed to read fields.
   (:methods
     (idle () _type_ :state 20)
     (hidden () _type_ :state 21)
-    (dig-digger-method-22 () none 22)
-    (dig-digger-method-23 () none 23)
-    (dig-digger-method-24 () none 24)
+    (dig-digger-method-22 (_type_ int) entity 22)
+    (dig-digger-method-23 (_type_) none 23)
+    (dig-digger-method-24 (_type_) none 24)
     )
   )
-|#
 
-;; (define-extern birth-func-dig-digger-collide function)
-;; (define-extern check-drop-level-dig-digger-rubble-sparks (function sparticle-system sparticle-cpuinfo vector none))
-;; (define-extern *dig-clasp-exploder-params* joint-exploder-static-params)
-;; (define-extern dig-tether-handler function)
-;; (define-extern dig-tether-init-by-other function)
-;; (define-extern bustclasp function)
+(define-extern birth-func-dig-digger-collide (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none))
+(define-extern check-drop-level-dig-digger-rubble-sparks (function sparticle-system sparticle-cpuinfo vector none))
+(define-extern *dig-clasp-exploder-params* joint-exploder-static-params)
+(define-extern dig-tether-handler (function process int symbol event-message-block object :behavior dig-tether))
+(define-extern dig-tether-init-by-other (function vector entity none :behavior dig-tether))
+(define-extern bustclasp (function int none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; dig-obs                        ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype dig-sinking-plat (rigid-body-platform)
-  ((anchor-point      vector      :inline :offset-assert 380)
-   (sync              sync-linear :inline :offset-assert 396)
-   (last-ridden-time  time-frame              :offset-assert 412)
-   (prev-pos          float               :offset-assert 420)
-   (path-pos          float               :offset-assert 424)
-   (surface-height    float               :offset-assert 428)
-   (once              basic               :offset-assert 432)
-   (bubbling-sound-id uint32              :offset-assert 436)
+  ((anchor-point      vector      :inline :offset-assert 384)
+   (sync              sync-linear :inline :offset-assert 400)
+   (last-ridden-time  time-frame              :offset-assert 416)
+   (prev-pos          float               :offset-assert 424)
+   (path-pos          float               :offset-assert 428)
+   (surface-height    float               :offset-assert 432)
+   (once              basic               :offset-assert 436)
+   (bubbling-sound-id uint32              :offset-assert 440)
    )
   :method-count-assert 57
   :size-assert         #x1bc
@@ -36341,26 +36346,23 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype dig-log-button-info (basic)
-  ((cam-ret-mode basic          :offset-assert 4)
+  ((cam-ret-mode symbol         :offset-assert 4)
    (cam-ret-dir  vector :inline :offset-assert 16)
    )
   :method-count-assert 9
   :size-assert         #x20
   :flag-assert         #x900000020
   )
-|#
 
-#|
 (deftype dig-log (process-drawable)
-  ((pressed-count  int8    :offset-assert 196)
-   (total-buttons  int8    :offset-assert 197)
-   (last-button-id int8    :offset-assert 198)
-   (base-y         float   :offset-assert 200)
-   (hud-handle     uint64  :offset-assert 204)
+  ((pressed-count  int8    :offset-assert 200)
+   (total-buttons  int8    :offset-assert 201)
+   (last-button-id int8    :offset-assert 202)
+   (base-y         float   :offset-assert 204)
+   (hud-handle     handle  :offset-assert 208)
+   (pad-ihj1bn234i1b int32 2 :offset-assert 216)
    )
   :method-count-assert 23
   :size-assert         #xe0
@@ -36368,14 +36370,12 @@
   (:methods
     (idle () _type_ :state 20)
     (moving () _type_ :state 21)
-    (dig-log-method-22 () none 22)
+    (dig-log-method-22 (_type_ symbol) symbol 22)
     )
   )
-|#
 
-#|
 (deftype dig-button (process-drawable)
-  ((down-y float  :offset-assert 196)
+  ((down-y float  :offset-assert 200)
    )
   :method-count-assert 23
   :size-assert         #xcc
@@ -36386,21 +36386,19 @@
     (idle-down () _type_ :state 22)
     )
   )
-|#
 
-;; (define-extern *dig-sinking-platform-constants* object)
-;; (define-extern *dig-log-button-infos* array)
-;; (define-extern *dig-log-heights* object)
-;; (define-extern dig-log-event-handler function)
-;; (define-extern dig3-login function)
-;; (define-extern dig3-activate function)
-;; (define-extern dig3-deactivate function)
+(define-extern *dig-sinking-platform-constants* rigid-body-object-constants)
+(define-extern *dig-log-button-infos* (array dig-log-button-info))
+(define-extern *dig-log-heights* (inline-array vector))
+(define-extern dig-log-event-handler (function process int symbol event-message-block object :behavior dig-log))
+(define-extern dig3-login (function none))
+(define-extern dig3-activate (function none))
+(define-extern dig3-deactivate (function none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; dig1-obs                       ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype dig-conveyor (conveyor)
   ()
   :method-count-assert 28
@@ -36409,13 +36407,11 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype dig-bomb-crate-cylinder (rigid-body-object)
-  ((flash-counter int8    :offset-assert 268)
-   (attack-id     uint32  :offset-assert 272)
-   (wait-time     time-frame  :offset-assert 276)
+  ((flash-counter int8    :offset-assert 272)
+   (attack-id     uint32  :offset-assert 276)
+   (wait-time     time-frame  :offset-assert 280)
    )
   :method-count-assert 54
   :size-assert         #x120
@@ -36424,9 +36420,7 @@
     (die () _type_ :state 53)
     )
   )
-|#
 
-#|
 (deftype dig-bomb-crate-cylinder-spawn-params (structure)
   ((pos  vector     :inline :offset-assert 0)
    (vel  vector     :inline :offset-assert 16)
@@ -36437,9 +36431,7 @@
   :size-assert         #x40
   :flag-assert         #x900000040
   )
-|#
 
-#|
 (deftype dig-bomb-crate (process-focusable)
   ()
   :method-count-assert 30
@@ -36448,12 +36440,10 @@
   (:methods
     (idle () _type_ :state 27)
     (die () _type_ :state 28)
-    (dig-bomb-crate-method-29 () none 29)
+    (dig-bomb-crate-method-29 (_type_ vector) none 29)
     )
   )
-|#
 
-#|
 (deftype dig-jump-pad (bouncer)
   ()
   :method-count-assert 25
@@ -36462,23 +36452,21 @@
   (:methods
     )
   )
-|#
 
-;; (define-extern *dig-bomb-crate-cylinder-constants* object)
-;; (define-extern dig-bomb-crate-cylinder-init-by-other function)
-;; (define-extern dig-bomb-crate-cylinder-spawn function)
-;; (define-extern *dig-bomb-crate-exploder-params* joint-exploder-static-params)
-;; (define-extern *dig-bomb-crate-array* object)
+(define-extern *dig-bomb-crate-cylinder-constants* rigid-body-object-constants)
+(define-extern dig-bomb-crate-cylinder-init-by-other (function dig-bomb-crate-cylinder-spawn-params entity-actor none :behavior dig-bomb-crate-cylinder))
+(define-extern dig-bomb-crate-cylinder-spawn (function process-tree dig-bomb-crate-cylinder-spawn-params entity-actor (pointer dig-bomb-crate-cylinder)))
+(define-extern *dig-bomb-crate-exploder-params* joint-exploder-static-params)
+(define-extern *dig-bomb-crate-array* (inline-array vector))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; dig2-obs                       ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype dig-breakable-door (process-focusable)
-  ((anim         basic  :offset-assert 200)
-   (art-name     basic  :offset-assert 204)
-   (collide-mesh int32  :offset-assert 208)
+  ((anim         basic  :offset-assert 204)
+   (art-name     basic  :offset-assert 208)
+   (collide-mesh int32  :offset-assert 212)
    )
   :method-count-assert 28
   :size-assert         #xd8
@@ -36487,21 +36475,19 @@
     (idle () _type_ :state 27)
     )
   )
-|#
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; dig3-obs                       ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype dig-spikey-step (process-drawable)
-  ((smush         smush-control :inline :offset-assert 196)
-   (init-quat     quaternion    :inline :offset-assert 236)
-   (shudder-angle float                 :offset-assert 252)
-   (rot-angle     float                 :offset-assert 256)
-   (cycle-time    float                 :offset-assert 260)
-   (cycle-offset  float                 :offset-assert 264)
+  ((smush         smush-control :inline :offset-assert 208)
+   (init-quat     quaternion    :inline :offset-assert 240)
+   (shudder-angle float                 :offset-assert 256)
+   (rot-angle     float                 :offset-assert 260)
+   (cycle-time    float                 :offset-assert 264)
+   (cycle-offset  float                 :offset-assert 268)
    )
   :method-count-assert 21
   :size-assert         #x110
@@ -36510,12 +36496,10 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype dig-spikey-sphere (projectile-bounce)
-  ((attack-id    uint32  :offset-assert 440)
-   (death-height float   :offset-assert 496)
+  ((death-height float   :offset-assert 496)
+   (pad-i1hb23h1b float :offset-assert 500)
    )
   :method-count-assert 42
   :size-assert         #x1f8
@@ -36523,12 +36507,10 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype dig-spikey-sphere-door (process-drawable)
-  ((sync      sync-linear :inline :offset-assert 196)
-   (prev-sync float               :offset-assert 212)
+  ((sync      sync-linear :inline :offset-assert 200)
+   (prev-sync float               :offset-assert 216)
    )
   :method-count-assert 22
   :size-assert         #xdc
@@ -36538,25 +36520,23 @@
     (active () _type_ :state 21)
     )
   )
-|#
 
-#|
 (deftype dig-balloon-lurker (process-drawable)
-  ((init-quat        quaternion    :inline :offset-assert 204)
-   (sync             sync-eased    :inline :offset-assert 220)
-   (swing-sync       sync-linear   :inline :offset-assert 268)
-   (smush            smush-control :inline :offset-assert 284)
-   (pov-cam-offset   vector        :inline :offset-assert 316)
-   (options          int32                 :offset-assert 332)
-   (bouncing         basic                 :offset-assert 336)
-   (bounce-scale     meters                :offset-assert 340)
-   (bob-counter      float                 :offset-assert 344)
-   (forward-backward basic                 :offset-assert 348)
-   (grabbed          basic                 :offset-assert 352)
-   (trapeze-grabbed  basic                 :offset-assert 356)
-   (pedal-anim-frame float                 :offset-assert 360)
-   (pedal-anim-speed float                 :offset-assert 364)
-   (pedal-sound-id   uint32                :offset-assert 368)
+  ((init-quat        quaternion    :inline :offset-assert 208)
+   (sync             sync-eased    :inline :offset-assert 224)
+   (swing-sync       sync-linear   :inline :offset-assert 272)
+   (smush            smush-control :inline :offset-assert 288)
+   (pov-cam-offset   vector        :inline :offset-assert 320)
+   (options          int32                 :offset-assert 336)
+   (bouncing         basic                 :offset-assert 340)
+   (bounce-scale     meters                :offset-assert 344)
+   (bob-counter      float                 :offset-assert 348)
+   (forward-backward basic                 :offset-assert 352)
+   (grabbed          basic                 :offset-assert 356)
+   (trapeze-grabbed  basic                 :offset-assert 360)
+   (pedal-anim-frame float                 :offset-assert 364)
+   (pedal-anim-speed float                 :offset-assert 368)
+   (pedal-sound-id   uint32                :offset-assert 372)
    )
   :method-count-assert 21
   :size-assert         #x178
@@ -36565,28 +36545,25 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype dig-balloon-lurker-trapeze (process-drawable)
-  ((swing-type       float   :offset-assert 196)
-   (swing-pole       uint32  :offset-assert 200)
-   (swing-anim-frame float   :offset-assert 204)
+  ((parent-ptr       (pointer dig-balloon-lurker) :offset 16 :score 100)
+   (swing-type       float   :offset-assert 200)
+   (swing-pole       (pointer swingpole)  :offset-assert 204)
+   (swing-anim-frame float   :offset-assert 208)
    )
   :method-count-assert 22
   :size-assert         #xd4
   :flag-assert         #x16006000d4
   (:methods
     (idle () _type_ :state 20)
-    (dig-balloon-lurker-trapeze-method-21 () none 21)
+    (dig-balloon-lurker-trapeze-method-21 (_type_) none 21)
     )
   )
-|#
 
-#|
 (deftype dig-wheel-step (process-drawable)
-  ((anim-speed     float   :offset-assert 196)
-   (wheel-sound-id uint32  :offset-assert 200)
+  ((anim-speed     float   :offset-assert 200)
+   (wheel-sound-id uint32  :offset-assert 204)
    )
   :method-count-assert 21
   :size-assert         #xd0
@@ -36595,14 +36572,12 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype dig-tipping-rock (rigid-body-platform)
-  ((anchor-point      vector :inline :offset-assert 380)
-   (last-ridden-time  time-frame         :offset-assert 396)
-   (surface-height    float          :offset-assert 404)
-   (bubbling-sound-id uint32         :offset-assert 408)
+  ((anchor-point      vector :inline :offset-assert 384)
+   (last-ridden-time  time-frame         :offset-assert 400)
+   (surface-height    float          :offset-assert 408)
+   (bubbling-sound-id uint32         :offset-assert 412)
    )
   :method-count-assert 57
   :size-assert         #x1a0
@@ -36610,9 +36585,7 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype dig-wall-bouncer (bouncer)
   ()
   :method-count-assert 25
@@ -36621,12 +36594,10 @@
   (:methods
     )
   )
-|#
 
-#|
 (deftype dig-stomp-block (rigid-body-object)
-  ((desty float  :offset-assert 268)
-   (flag  basic  :offset-assert 272)
+  ((desty float  :offset-assert 272)
+   (flag  basic  :offset-assert 276)
    )
   :method-count-assert 55
   :size-assert         #x118
@@ -36636,12 +36607,10 @@
     (hit () _type_ :state 54)
     )
   )
-|#
 
-#|
 (deftype dig-stomp-block-controller (process-drawable)
-  ((stomp-blocks UNKNOWN 4 :offset-assert 196)
-   (played-fall? basic     :offset-assert 212)
+  ((stomp-blocks (pointer dig-stomp-block) 4 :offset-assert 200)
+   (played-fall? symbol     :offset-assert 216)
    )
   :method-count-assert 21
   :size-assert         #xdc
@@ -36650,9 +36619,7 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype dig-totem (process-drawable)
   ()
   :method-count-assert 21
@@ -36662,17 +36629,16 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-;; (define-extern *dig-spikey-sphere-exploder-params* joint-exploder-static-params)
-;; (define-extern spikey-sphere-update-velocity function)
-;; (define-extern spikey-sphere-reaction function)
-;; (define-extern spikey-sphere-move function)
-;; (define-extern dig-balloon-lurker-trapeze-init-by-other function)
-;; (define-extern *dig-tipping-rock-constants* object)
-;; (define-extern *dig-stomp-block-constants* object)
-;; (define-extern dig-stomp-block-init-by-other function)
-;; (define-extern *dig-stomp-block-table* object)
+(define-extern *dig-spikey-sphere-exploder-params* joint-exploder-static-params)
+(define-extern spikey-sphere-update-velocity (function dig-spikey-sphere none))
+(define-extern spikey-sphere-reaction (function control-info collide-query vector vector collide-status :behavior dig-spikey-sphere))
+(define-extern spikey-sphere-move (function dig-spikey-sphere none))
+(define-extern dig-balloon-lurker-trapeze-init-by-other (function entity-actor none :behavior dig-balloon-lurker-trapeze))
+(define-extern *dig-tipping-rock-constants* rigid-body-platform-constants)
+(define-extern *dig-stomp-block-constants* rigid-body-object-constants)
+(define-extern dig-stomp-block-init-by-other (function vector none :behavior dig-stomp-block))
+(define-extern *dig-stomp-block-table* vector)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; tomb-baby-spider               ;;
@@ -41471,100 +41437,142 @@
 ;; fordumpa-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *fortress-pris-texture-anim-array* texture-anim-array)
-;; (define-extern *fortress-warp-texture-anim-array* texture-anim-array)
-;; (define-extern set-roboscreen-alpha! function)
+(define-extern *fortress-pris-texture-anim-array* texture-anim-array)
+(define-extern *fortress-warp-texture-anim-array* texture-anim-array)
+(define-extern set-roboscreen-alpha! (function float none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; fort-robotank-turret           ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
-(deftype fort-robotank-turret (UNKNOWN)
-  ()
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; Failed to read fields.
+(deftype fort-robotank-turret (process-focusable)
+  (
+    (los                 los-control :inline :offset-assert 208)
+    (reticle             handle               :offset-assert 360)
+    (screen              handle               :offset-assert 368)
+    (tank-quat           quaternion :inline  :offset-assert 384)
+    (tank-quat-vibe-only quaternion :inline  :offset-assert 400)
+    (rotate-quat         quaternion :inline  :offset-assert 416)
+    (rotate-rate         float               :offset-assert 432)
+    (rotate-mult         float               :offset-assert 436)
+    (shot-range          float               :offset-assert 440)
+    (fov-mult            float               :offset-assert 444)
+    (offset              vector :inline      :offset-assert 448)
+    (sight-pos           vector :inline      :offset-assert 464)
+    (firing-sight-pos    vector :inline      :offset-assert 480)
+    (aim-pos             vector 3 :inline    :offset-assert 496) ;; elt size: 16
+    (aim-pos-2           vector   :inline    :offset 512) ;; added TODO - shouldn't have had to do this
+    (aim-pos-1           vector   :inline    :offset 528) ;; added TODO - shouldn't have had to do this
+    (gun-timer           time-frame          :offset-assert 544)
+    (gun-elev-jmod       joint-mod-set-local              :offset-assert 552)
+    (gun-elev            float               :offset-assert 556)
+    (gun-elev-cam        float               :offset-assert 560)
+    (gun-joint-l         int32 2           :offset-assert 564) ;; elt size: 4
+    (gun-joint-r         int32 2           :offset-assert 572) ;; elt size: 4
+    (gun-spread          float               :offset-assert 580)
+    (gun-index           int32               :offset-assert 584)
+    (flags               uint16              :offset-assert 588)
+    (turn-sound-id       uint32              :offset-assert 592)
   )
-|#
-
-#|
-(deftype fort-robotank-reticle (UNKNOWN)
-  ()
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; Failed to read fields.
+  :method-count-assert 35
+  :size-assert         #x254 ;; 596
+  :flag-assert         #x2301e00254
+  (:methods
+    (idle () _type_ :state 27)
+    (ready () _type_ :state 28)
+    (fire () _type_ :state 29)
+    (die () _type_ :state 30)
+    (fort-robotank-turret-method-31 (_type_ vector vector) none 31)
+    (fort-robotank-turret-method-32 (_type_ (inline-array vector)) (pointer process) 32)
+    (fort-robotank-turret-method-33 (_type_) none 33)
+    (fort-robotank-turret-method-34 (_type_ vector float) symbol 34))
   )
-|#
 
-#|
-(deftype fort-roboscreen (UNKNOWN)
-  ()
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; Failed to read fields.
+(deftype fort-robotank-reticle (process-drawable)
+  (
+    (shadow-jmod  joint-mod         :offset-assert 200)
+    (sight-jmod   joint-mod         :offset-assert 204)
+    (ring-jmod    joint-mod 3      :offset-assert 208) ;; elt size: 5.333333333333333
+    (ring-timer   time-frame     :offset-assert 224)
+    (sight-scale  vector :inline :offset-assert 240)
+    (collide-dist float          :offset-assert 256)
   )
-|#
-
-#|
-(deftype fort-robotank-shot (UNKNOWN)
-  ()
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; Failed to read fields.
+  :method-count-assert 22
+  :size-assert         #x104 ;; 260
+  :flag-assert         #x1600900104
+  (:methods
+    (idle () _type_ :state 20)
+    (lock () _type_ :state 21))
   )
-|#
 
-;; (define-extern fort-roboscreen-init-by-other function)
-;; (define-extern fort-robotank-reticle-post function)
-;; (define-extern fort-robotank-reticle-handler function)
-;; (define-extern fort-robotank-reticle-init-by-other function)
-;; (define-extern draw-2d-hud function)
-;; (define-extern turret-post function)
-;; (define-extern robotank-turret-handler function)
-;; (define-extern fort-robotank-turret-init-by-other function)
+(deftype fort-roboscreen (process-drawable)
+  (
+    (anim-frame float  :offset-assert 200)
+    (transition float  :offset-assert 204)
+    (gui-id-1   uint32 :offset-assert 208)
+    (gui-id-2   uint32 :offset-assert 212)
+  )
+  :method-count-assert 25
+  :size-assert         #xd8 ;; 216
+  :flag-assert         #x19006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    (active () _type_ :state 21)
+    (deactive () _type_ :state 22)
+    (die() _type_ :state 23)
+    (fort-roboscreen-method-24 (_type_) none 24))
+  )
+
+(deftype fort-robotank-shot (guard-shot)
+  ()
+  :method-count-assert 40
+  :size-assert         #x1f0 ;; 496
+  :flag-assert         #x28017001f0
+  )
+
+(define-extern fort-roboscreen-init-by-other (function vector quaternion entity-actor none :behavior fort-roboscreen))
+(define-extern fort-robotank-reticle-post (function none :behavior fort-robotank-reticle))
+(define-extern fort-robotank-reticle-handler (function process int symbol event-message-block object :behavior fort-robotank-reticle))
+(define-extern fort-robotank-reticle-init-by-other (function vector none :behavior fort-robotank-reticle))
+(define-extern draw-2d-hud "Unused but, maybe useful? TODO - dma buffer casting" (function vector symbol))
+(define-extern turret-post (function none :behavior fort-robotank-turret))
+(define-extern robotank-turret-handler (function process int symbol event-message-block object :behavior fort-robotank-turret))
+(define-extern fort-robotank-turret-init-by-other (function vector quaternion vector float none :behavior fort-robotank-turret))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; fort-robotank                  ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
-(deftype fort-robotank-segment-event (UNKNOWN)
-  ((source     uint64  :offset-assert 0)
-   (event-type basic   :offset-assert 8)
-   (actor      basic   :offset-assert 12)
+(declare-type fort-robotank process-drawable)
+(deftype fort-robotank-segment-event (structure)
+  ((source     handle  :offset-assert 0)
+   (event-type symbol   :offset-assert 8)
+   (actor      string   :offset-assert 12)
    (pos-norm   float   :offset-assert 16)
-   (param      basic   :offset-assert 20)
+   (param-obj      object :offset-assert 20) ;; TODO - to make the compiler happy
+   (param-func      (function fort-robotank none)   :offset 20)
+   (param-sym      symbol :offset 20)
    )
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; field param uses ~A with a signed load
+  :method-count-assert 9
+  :size-assert         #x18 ;; 24
+  :flag-assert         #x900000018
   )
-|#
 
-#|
-(deftype fort-robotank-segment (UNKNOWN)
+(deftype fort-robotank-segment (structure)
   ((flags              uint16  :offset-assert 0)
    (max-speed          float   :offset-assert 4)
    (next-segment       int32   :offset-assert 8)
    (next-segment-start float   :offset-assert 12)
    (event-count        int32   :offset-assert 16)
-   (event-tbl          uint32  :offset-assert 20)
+   (event-tbl          (inline-array fort-robotank-segment-event)  :offset-assert 20)
    )
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
+  :method-count-assert 9
+  :size-assert         #x18 ;; 24
+  :flag-assert         #x900000018
   )
-|#
 
-#|
-(deftype fort-robotank-path-info (UNKNOWN)
-  ((path          basic          :offset-assert 0)
+(deftype fort-robotank-path-info (structure)
+  ((path          path-control          :offset-assert 0)
    (dir           vector :inline :offset-assert 16)
    (u             float          :offset-assert 32)
    (du            float          :offset-assert 36)
@@ -41575,62 +41583,82 @@
    (dir-y-angle   float          :offset-assert 56)
    (start-y-angle float          :offset-assert 60)
    )
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
+  :method-count-assert 9
+  :size-assert         #x40 ;; 64
+  :flag-assert         #x900000040
   )
-|#
 
-#|
-(deftype fort-robotank-path-info-array (UNKNOWN)
-  ((length           int32            :offset-assert 4)
-   (allocated-length int32            :offset-assert 8)
-   (data             UNKNOWN :dynamic :offset-assert 16)
-   )
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
+(deftype fort-robotank-path-info-array (inline-array-class)
+  ((data             fort-robotank-path-info :inline :dynamic :offset-assert 16))
+  :method-count-assert 9
+  :size-assert         #x10 ;; 16
+  :flag-assert         #x900000010
   )
-|#
 
-#|
-(deftype fort-robotank-wheel-info (UNKNOWN)
-  ((jmod   basic  :offset-assert 0)
+(deftype fort-robotank-wheel-info (structure)
+  ((jmod   joint-mod-spinner  :offset-assert 0)
    (radius float  :offset-assert 4)
    )
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
+  :method-count-assert 9
+  :size-assert         #x8 ;; 8
+  :flag-assert         #x900000008
   )
-|#
 
-#|
-(deftype fort-robotank-tread-info (UNKNOWN)
-  ((wheel         UNKNOWN      7       :offset-assert 0)
+(deftype fort-robotank-tread-info (structure)
+  ((wheel         fort-robotank-wheel-info      7 :inline      :offset-assert 0)
    (texture       texture-anim         :offset-assert 112)
    (locator-joint int32                :offset-assert 116)
    (pos           vector       :inline :offset-assert 128)
    )
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
+  :method-count-assert 9
+  :size-assert         #x90 ;; 144
+  :flag-assert         #x900000090
   )
-|#
 
-#|
-(deftype fort-robotank (UNKNOWN)
-  ()
-  :method-count-assert 0
-  :size-assert         #x0
-  :flag-assert         #x0
-  ;; Failed to read fields.
+(deftype fort-robotank (process-drawable)
+  (
+    (root-override      collide-shape-moving :offset 128 :score 100)
+    (barrel-part        sparticle-launch-control     :offset-assert 200)
+    (roller-jmod        joint-mod     :offset-assert 204)
+    (vibe-jmod          joint-mod     :offset-assert 208)
+    (tread              fort-robotank-tread-info 2 :inline :offset-assert 224 :score 100) ;; elt size: 144
+    (path-info          fort-robotank-path-info-array     :offset-assert 512)
+    (segment-table      (inline-array fort-robotank-segment)    :offset-assert 516)
+    (flags              uint16     :offset-assert 520)
+    (pov-cam-offset     vector 2 :inline  :offset-assert 528) ;; elt size: 16
+    (turret             handle      :offset-assert 560)
+    (no-collision-timer time-frame :offset-assert 568)
+    (buzz-timer         time-frame :offset-assert 576)
+    (player-u           float      :offset-assert 584)
+    (player-prev-u      float      :offset-assert 588)
+    (roller-spin-rate   float      :offset-assert 592)
+    (engine-vibe-rate   float      :offset-assert 596)
+    (engine-vibe-amp    float      :offset-assert 600)
+    (attack-id          uint32     :offset-assert 604)
+    (path-index         int32      :offset-assert 608)
+    (path-count         int32      :offset-assert 612)
+    (continue-index     int32      :offset-assert 616)
+    (idle-sound         ambient-sound     :offset-assert 620)
+    (barrel-sound       ambient-sound     :offset-assert 624)
+  )
+  :method-count-assert 28
+  :size-assert         #x274 ;; 628
+  :flag-assert         #x1c02000274
+  (:methods
+    (idle () _type_ :state 20)
+    (turning () _type_ :state 21)
+    (moving () _type_ :state 22)
+    (pause () _type_ :state 23)
+    (die () _type_ :state 24)
+    (fort-robotank-method-25 (_type_) event-message-block 25)
+    (fort-robotank-method-26 (_type_ int float float) symbol 26)
+    (fort-robotank-method-27 (_type_) none 27))
   )
-|#
 
-;; (define-extern *fort-robotank-1-segment-table* object)
-;; (define-extern *fort-robotank-2-segment-table* object)
-;; (define-extern fort-robotank-post function)
-;; (define-extern fort-robotank-handler function)
+(define-extern *fort-robotank-1-segment-table* (inline-array fort-robotank-segment))
+(define-extern *fort-robotank-2-segment-table* (inline-array fort-robotank-segment))
+(define-extern fort-robotank-post (function none :behavior fort-robotank))
+(define-extern fort-robotank-handler (function process int symbol event-message-block none :behavior fort-robotank))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; fordumpc-part                  ;;
@@ -41648,9 +41676,10 @@
 ;; fordumpc-obs                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype fort-dump-bomb-a (process-drawable)
-  ()
+  (
+    (root-override collide-shape :offset 128 :score 100)
+  )
   :method-count-assert 22
   :size-assert         #xc8
   :flag-assert         #x16005000c8
@@ -41659,12 +41688,11 @@
     (die () _type_ :state 21)
     )
   )
-|#
 
-#|
 (deftype fort-missile-target (process-drawable)
-  ((part-mat UNKNOWN 2 :offset-assert 204)
-   (sound-id uint32    :offset-assert 332)
+  ((root-override collide-shape-moving :offset 128 :score 100)
+   (part-mat matrix 2 :inline :offset-assert 208) ;; a total guess
+   (sound-id uint32    :offset-assert 336)
    )
   :method-count-assert 22
   :size-assert         #x154
@@ -41674,19 +41702,18 @@
     (die () _type_ :state 21)
     )
   )
-|#
 
-#|
 (deftype fort-missile (process-drawable)
-  ((part-doom          basic     :offset-assert 196)
-   (hud                uint64    :offset-assert 204)
-   (door-actor         UNKNOWN 2 :offset-assert 212)
-   (tank-actor         basic     :offset-assert 220)
-   (bomb               UNKNOWN 4 :offset-assert 228)
-   (bomb-count         uint32    :offset-assert 260)
-   (attack-id          uint32    :offset-assert 264)
-   (explosion-sound-id uint32    :offset-assert 268)
-   (alarm-sound-id     uint32    :offset-assert 272)
+  ((root-override      collide-shape :offset 128 :score 100)
+   (part-doom          sparticle-launch-control     :offset-assert 200)
+   (hud                handle    :offset-assert 208)
+   (door-actor         entity-actor 2 :offset-assert 216)
+   (tank-actor         entity-actor     :offset-assert 224)
+   (bomb               handle 4 :offset-assert 232)
+   (bomb-count         uint32    :offset-assert 264)
+   (attack-id          uint32    :offset-assert 268)
+   (explosion-sound-id uint32    :offset-assert 272)
+   (alarm-sound-id     uint32    :offset-assert 276)
    )
   :method-count-assert 25
   :size-assert         #x118
@@ -41699,10 +41726,9 @@
     (dormant () _type_ :state 24)
     )
   )
-|#
 
-;; (define-extern *fort-missile-target-exploder-params* joint-exploder-static-params)
-;; (define-extern fort-missile-target-init-by-other function)
+(define-extern *fort-missile-target-exploder-params* joint-exploder-static-params)
+(define-extern fort-missile-target-init-by-other (function vector vector none :behavior fort-missile-target))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; fortress-scenes                ;;
@@ -43138,27 +43164,32 @@
 ;; fordumpa-obs                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
+
 (deftype fort-elec-switch (process-drawable)
-  ()
+  (
+    (root-override      collide-shape      :offset 128 :score 100)
+    (l-bolt             lightning-control  :offset-assert 200)
+    (notify-actor       entity-actor  :offset-assert 204)
+    (tank-actor         entity-actor  :offset-assert 208)
+    (switch-group       (pointer actor-group) :offset-assert 212)
+    (switch-group-count int32   :offset-assert 216)
+  )
   :method-count-assert 23
   :size-assert         #xdc
   :flag-assert         #x17006000dc
-  ;; Failed to read fields.
   (:methods
     (idle () _type_ :state 20)
     (play-hint () _type_ :state 21)
     (die () _type_ :state 22)
     )
   )
-|#
 
-#|
 (deftype fort-fence (process-drawable)
-  ((anim      basic   :offset-assert 196)
-   (exit-anim basic   :offset-assert 200)
-   (loading?  basic   :offset-assert 204)
-   (tank      uint64  :offset-assert 212)
+  ((root-override      collide-shape      :offset 128 :score 100)
+   (anim      spool-anim   :offset-assert 200)
+   (exit-anim basic   :offset-assert 204)
+   (loading?  symbol   :offset-assert 208)
+   (tank      handle  :offset-assert 216)
    )
   :method-count-assert 24
   :size-assert         #xe0
@@ -43166,59 +43197,39 @@
   (:methods
     (idle () _type_ :state 20)
     (breaking () _type_ :state 21)
-    (fort-fence-method-22 () none 22)
-    (fort-fence-method-23 () none 23)
+    (fort-fence-method-22 (_type_) none 22)
+    (fort-fence-method-23 (_type_) none 23)
     )
   )
-|#
 
-#|
-(deftype fort-fence-a (fort-fence)
-  ()
-  :method-count-assert 24
-  :size-assert         #xe0
-  :flag-assert         #x18006000e0
-  (:methods
-    )
-  )
-|#
+(deftype fort-fence-a (fort-fence)())
 
-#|
-(deftype fort-fence-b (fort-fence)
-  ()
-  :method-count-assert 24
-  :size-assert         #xe0
-  :flag-assert         #x18006000e0
-  (:methods
-    )
-  )
-|#
+(deftype fort-fence-b (fort-fence)())
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; fort-turret                    ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype fort-turret (enemy)
-  ((gun-tilt-jm     basic               :offset-assert 528)
-   (gun-shadow-jm   basic               :offset-assert 532)
-   (aim-pos         vector      :inline :offset-assert 540)
-   (target-bullseye vector      :inline :offset-assert 556)
-   (gun-twist       float               :offset-assert 572)
-   (gun-tilt        float               :offset-assert 576)
-   (desired-twist   float               :offset-assert 580)
-   (desired-tilt    float               :offset-assert 584)
-   (los-clear       basic               :offset-assert 588)
-   (flash-state     basic               :offset-assert 592)
-   (flash-index     uint32              :offset-assert 596)
-   (can-shoot       basic               :offset-assert 600)
-   (last-hit-time   time-frame              :offset-assert 604)
-   (init-mat        matrix      :inline :offset-assert 620)
-   (target-timeout  uint64              :offset-assert 684)
-   (beam-intersect  basic               :offset-assert 692)
-   (sync            sync-linear :inline :offset-assert 700)
-   (invincible      basic               :offset-assert 716)
+  ((gun-tilt-jm     joint-mod               :offset-assert 532)
+   (gun-shadow-jm   joint-mod               :offset-assert 536)
+   (aim-pos         vector      :inline :offset-assert 544)
+   (target-bullseye vector      :inline :offset-assert 560)
+   (gun-twist       float               :offset-assert 576)
+   (gun-tilt        float               :offset-assert 580)
+   (desired-twist   float               :offset-assert 584)
+   (desired-tilt    float               :offset-assert 588)
+   (los-clear       basic               :offset-assert 592)
+   (flash-state     basic               :offset-assert 596)
+   (flash-index     uint32              :offset-assert 600)
+   (can-shoot       symbol               :offset-assert 604)
+   (last-hit-time   time-frame              :offset-assert 608)
+   (init-mat        matrix      :inline :offset-assert 624)
+   (target-timeout  uint64              :offset-assert 688)
+   (beam-intersect  basic               :offset-assert 696)
+   (sync            sync-linear :inline :offset-assert 704)
+   (invincible      symbol               :offset-assert 720)
    )
   :method-count-assert 143
   :size-assert         #x2d4
@@ -43226,18 +43237,17 @@
   (:methods
     (attack () _type_ :state 137)
     (sweep () _type_ :state 138)
-    (fort-turret-method-139 () none 139)
-    (fort-turret-method-140 () none 140)
-    (fort-turret-method-141 () none 141)
-    (fort-turret-method-142 () none 142)
+    (fort-turret-method-139 (_type_) none 139)
+    (fort-turret-method-140 (_type_ float float) quaternion 140)
+    (fort-turret-method-141 (_type_) vector 141)
+    (fort-turret-method-142 (_type_ symbol int) symbol 142)
     )
   )
-|#
 
-;; (define-extern fort-turret-draw-laser-spot function)
-;; (define-extern fort-turret-draw-laser function)
-;; (define-extern *fort-turret-exploder-params* joint-exploder-static-params)
-;; (define-extern *fort-turret-enemy-info* enemy-info)
+(define-extern fort-turret-draw-laser-spot (function vector object symbol none))
+(define-extern fort-turret-draw-laser (function vector vector none))
+(define-extern *fort-turret-exploder-params* joint-exploder-static-params)
+(define-extern *fort-turret-enemy-info* enemy-info)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; whack                          ;;
@@ -43871,10 +43881,9 @@
 ;; fort-floor-spike               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype spike-row-info (structure)
   ((sync      sync-linear :inline :offset-assert 0)
-   (table-ptr uint32              :offset-assert 16)
+   (table-ptr (inline-array vector)              :offset-assert 16)
    (on-ratio  float               :offset-assert 20)
    (state     int32               :offset-assert 24)
    )
@@ -43882,74 +43891,37 @@
   :size-assert         #x1c
   :flag-assert         #x90000001c
   )
-|#
 
-#|
 (deftype spike-row-info-array (inline-array-class)
-  ((length           int32            :offset-assert 4)
-   (allocated-length int32            :offset-assert 8)
-   (data             UNKNOWN :dynamic :offset-assert 16)
-   )
+  ((data             spike-row-info :inline :dynamic :offset-assert 16))
   :method-count-assert 9
   :size-assert         #x10
   :flag-assert         #x900000010
   )
-|#
 
-#|
 (deftype fort-floor-spike (process-drawable)
-  ((pos-table        uint32    :offset-assert 196)
-   (spike-row        basic     :offset-assert 200)
-   (spike-dim        UNKNOWN 2 :offset-assert 204)
-   (attack-id        int32     :offset-assert 212)
-   (no-overlap-timer uint64    :offset-assert 220)
+  ((pos-table        (inline-array vector)    :offset-assert 200)
+   (spike-row        spike-row-info-array     :offset-assert 204)
+   (spike-dim        basic 2 :offset-assert 208)
+   (attack-id        int32     :offset-assert 216)
+   (no-overlap-timer uint64    :offset-assert 224)
    )
   :method-count-assert 24
   :size-assert         #xe8
   :flag-assert         #x18007000e8
   (:methods
     (idle () _type_ :state 20)
-    (fort-floor-spike-method-21 () none 21)
-    (fort-floor-spike-method-22 () none 22)
-    (fort-floor-spike-method-23 () none 23)
+    (fort-floor-spike-method-21 (_type_) none 21)
+    (fort-floor-spike-method-22 (_type_) collide-shape-moving 22)
+    (fort-floor-spike-method-23 (_type_) symbol 23)
     )
   )
-|#
 
-#|
-(deftype fort-floor-spike-a (fort-floor-spike)
-  ()
-  :method-count-assert 24
-  :size-assert         #xe8
-  :flag-assert         #x18007000e8
-  (:methods
-    )
-  )
-|#
+(deftype fort-floor-spike-a (fort-floor-spike) ())
+(deftype fort-floor-spike-b (fort-floor-spike) ())
+(deftype fort-floor-spike-c (fort-floor-spike) ())
 
-#|
-(deftype fort-floor-spike-b (fort-floor-spike)
-  ()
-  :method-count-assert 24
-  :size-assert         #xe8
-  :flag-assert         #x18007000e8
-  (:methods
-    )
-  )
-|#
-
-#|
-(deftype fort-floor-spike-c (fort-floor-spike)
-  ()
-  :method-count-assert 24
-  :size-assert         #xe8
-  :flag-assert         #x18007000e8
-  (:methods
-    )
-  )
-|#
-
-;; (define-extern joint-mod-set-y-callback function)
+(define-extern joint-mod-set-y-callback "TODO - investigate weird casting" (function cspace transformq none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; forrescb-part                  ;;
@@ -45096,9 +45068,8 @@
 ;; fordumpb-obs                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype fort-plat-orbit (process-drawable)
-  ((sync sync-linear :inline :offset-assert 196)
+  ((sync sync-linear :inline :offset-assert 200)
    )
   :method-count-assert 21
   :size-assert         #xd8
@@ -45107,12 +45078,10 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype fort-plat-shuttle-plat (process-drawable)
-  ((path-pos   float  :offset-assert 196)
-   (path-speed float  :offset-assert 200)
+  ((path-pos   float  :offset-assert 200)
+   (path-speed float  :offset-assert 204)
    )
   :method-count-assert 21
   :size-assert         #xd0
@@ -45121,12 +45090,10 @@
     (idle () _type_ :state 20)
     )
   )
-|#
 
-#|
 (deftype fort-plat-shuttle (process-drawable)
-  ((next-spawn-time time-frame              :offset-assert 196)
-   (sync            sync-linear :inline :offset-assert 204)
+  ((next-spawn-time time-frame              :offset-assert 200)
+   (sync            sync-linear :inline :offset-assert 208)
    )
   :method-count-assert 23
   :size-assert         #xe0
@@ -45134,23 +45101,13 @@
   (:methods
     (dormant () _type_ :state 20)
     (idle () _type_ :state 21)
-    (fort-plat-shuttle-method-22 () none 22)
+    (fort-plat-shuttle-method-22 (_type_) symbol 22)
     )
   )
-|#
 
-#|
-(deftype fort-conveyor (conveyor)
-  ()
-  :method-count-assert 28
-  :size-assert         #x100
-  :flag-assert         #x1c00800100
-  (:methods
-    )
-  )
-|#
+(deftype fort-conveyor (conveyor) ())
 
-;; (define-extern fort-plat-shuttle-plat-init-by-other function)
+(define-extern fort-plat-shuttle-plat-init-by-other (function float none :behavior fort-plat-shuttle-plat))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; fordumpb-part                  ;;
@@ -48063,18 +48020,16 @@
 ;; caspad-obs                     ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-#|
 (deftype cpad-elevator (elevator)
-  ((sound-id uint32  :offset-assert 364)
+  ((sound-id sound-id  :offset-assert 368)
    )
   :method-count-assert 50
   :size-assert         #x174
   :flag-assert         #x3201000174
   (:methods
-    (cpad-elevator-method-49 () none 49)
+    (cpad-elevator-method-49 (_type_ symbol) none 49)
     )
   )
-|#
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/decompiler/config/jak2/anonymous_function_types.jsonc b/decompiler/config/jak2/anonymous_function_types.jsonc
index defe88e99e..e1685e4836 100644
--- a/decompiler/config/jak2/anonymous_function_types.jsonc
+++ b/decompiler/config/jak2/anonymous_function_types.jsonc
@@ -671,5 +671,10 @@
     [0, "(function none)"],
     [1, "(function none :behavior task-manager)"],
     [2, "(function symbol :behavior task-manager)"]
+  ],
+  "fort-robotank": [
+    [21, "(function fort-robotank none)"],
+    [22, "(function fort-robotank none)"],
+    [23, "(function none)"]
   ]
 }
diff --git a/decompiler/config/jak2/hacks.jsonc b/decompiler/config/jak2/hacks.jsonc
index dfea1c27c1..70f2210491 100644
--- a/decompiler/config/jak2/hacks.jsonc
+++ b/decompiler/config/jak2/hacks.jsonc
@@ -115,7 +115,6 @@
     "(method 228 hal-sewer)",
     "(method 154 vehicle-city-racer)",
     "(method 53 squid)",
-    "(anon-function 11 fort-floor-spike)",
     "vehicle-explode-post",
     "(method 158 vehicle-guard)",
     "(method 207 metalhead-predator)",
@@ -215,7 +214,10 @@
     "(method 11 mtn-step-plat-rocks-a)",
     "(method 11 mtn-step-plat-rocks-b)",
     "(method 11 mtn-step-plat-rocks-c)",
-    "prototypes-game-visible-set!"
+    "prototypes-game-visible-set!",
+    "(method 22 fort-floor-spike-a)",
+    "(method 22 fort-floor-spike-b)",
+    "(method 22 fort-floor-spike-c)"
   ],
 
   // If format is used with the wrong number of arguments,
@@ -475,9 +477,14 @@
     "(method 45 nav-mesh)": [5, 6],
     "(method 43 nav-mesh)": [0, 1, 2, 12, 13, 14, 15, 16, 17, 18, 19, 20],
     "(anon-function 45 gungame-obs)": [0, 1, 6, 9, 14, 18, 21, 22, 30], // TODO - probably not the best
-
     "(method 142 grenadier)": [0, 1, 3],
-    "(anon-function 34 predator)": [24]
+    "(anon-function 34 predator)": [24],
+    "(anon-function 57 crimson-guard-level)": [22],
+    "(method 48 rigid-body-object)": [0, 1, 2, 3, 4, 5],
+    "(method 15 rigid-body)": [0, 1, 2, 5],
+    "(method 63 collide-shape-moving)": [
+      0, 1, 2, 3, 4, 5, 6, 10, 12, 13, 14, 28, 38, 39, 40, 44
+    ]
   },
 
   // Sometimes the game might use format strings that are fetched dynamically,
diff --git a/decompiler/config/jak2/inputs.jsonc b/decompiler/config/jak2/inputs.jsonc
index 005c9cc65e..c3a7870332 100644
--- a/decompiler/config/jak2/inputs.jsonc
+++ b/decompiler/config/jak2/inputs.jsonc
@@ -127,7 +127,7 @@
     // "DGO/LPORTRUN.DGO",
     // "DGO/LASHGRD.DGO",
     "DGO/CGB.DGO",
-    // "DGO/D3B.DGO",
+    "DGO/D3B.DGO",
     // "DGO/STB.DGO",
     // "DGO/GARAGE.DGO",
     // "DGO/PORTWALL.DGO",
@@ -185,41 +185,45 @@
   "streamed_audio_file_names": [],
 
   "levels_to_extract": [
+    "CAP.DGO",
     "CIB.DGO",
+    "CPO.DGO",
     "CTA.DGO",
     "CTB.DGO",
     "CWI.DGO",
+    "D3A.DGO",
+    "D3B.DGO",
+    "DG1.DGO",
     "DMI.DGO",
+    "DMI.DGO",
+    "DRI.DGO",
+    "DRILLMTN.DGO",
+    "FEA.DGO",
+    "FEB.DGO",
+    "FOB.DGO",
+    "FOR.DGO",
     "GGA.DGO",
     "HIDEOUT.DGO",
+    "HIDEOUT.DGO",
+    "KIOSK.DGO",
     "KIOSK.DGO",
     "LDJAKBRN.DGO",
+    "LDJAKBRN.DGO",
+    "LSACK.DGO",
     "LWIDEA.DGO",
     "LWIDEB.DGO",
     "LWIDEC.DGO",
-    "FEA.DGO",
-    "FEB.DGO",
-    "DRI.DGO",
-    "TOC.DGO",
-    "FOB.DGO",
-    "SAG.DGO",
-    "MTX.DGO",
-    "TOB.DGO",
-    "TOA.DGO",
-    "TOD.DGO",
-    "DRILLMTN.DGO",
-    "FOR.DGO",
-
-    "LDJAKBRN.DGO",
-    "HIDEOUT.DGO",
-    "KIOSK.DGO",
-    "DMI.DGO",
-    "LSACK.DGO",
     "MTN.DGO",
+    "MTX.DGO",
     "PRI.DGO",
     "RUI.DGO",
+    "SAG.DGO",
     "SKA.DGO",
     "STA.DGO",
+    "TOA.DGO",
+    "TOB.DGO",
+    "TOC.DGO",
+    "TOD.DGO",
     "VI1.DGO"
   ]
 }
diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc
index ebf6fb4ff9..00a4d2db02 100644
--- a/decompiler/config/jak2/label_types.jsonc
+++ b/decompiler/config/jak2/label_types.jsonc
@@ -511,7 +511,10 @@
     ["L647", "uint64", true],
     ["L648", "uint64", true],
     ["L565", "uint64", true],
-    ["L567", "uint64", true]
+    ["L567", "uint64", true],
+    ["L566", "uint64", true],
+    ["L564", "uint64", true],
+    ["L539", "attack-info"]
   ],
   "collide-shape": [
     ["L383", "attack-info"],
@@ -896,5 +899,44 @@
   "predator": [
     ["L252", "vector"],
     ["L251", "vector"]
-  ]
+  ],
+  "dig-digger": [["L192", "attack-info"]],
+  "fort-robotank-turret": [
+    ["L315", "uint64", true],
+    ["L313", "uint64", true],
+    ["L316", "uint64", true],
+    ["L314", "uint64", true],
+    ["L258", "uint64", true],
+    ["L263", "uint64", true],
+    ["L259", "uint64", true],
+    ["L262", "uint64", true],
+    ["L256", "uint64", true],
+    ["L261", "uint64", true],
+    ["L257", "uint64", true],
+    ["L264", "uint64", true],
+    ["L260", "uint64", true]
+  ],
+  "fort-robotank": [
+    ["L315", "uint64", true],
+    ["L314", "uint64", true],
+    ["L312", "uint64", true],
+    ["L317", "uint64", true],
+    ["L313", "uint64", true],
+    ["L316", "uint64", true],
+    ["L221", "(inline-array fort-robotank-segment)", 4],
+    ["L220", "(inline-array fort-robotank-segment)", 1],
+    ["L215", "attack-info"]
+  ],
+  "fort-floor-spike": [
+    ["L203", "attack-info"],
+    ["L159", "(inline-array vector)", 8],
+    ["L117", "(inline-array vector)", 8],
+    ["L55", "(inline-array vector)", 8]
+  ],
+  "fordumpc-obs": [
+    ["L138", "attack-info"],
+    ["L135", "attack-info"]
+  ],
+  "dig-obs": [["L111", "(inline-array vector)", 2]],
+  "dig1-obs": [["L91", "(inline-array vector)", 8]]
 }
diff --git a/decompiler/config/jak2/stack_structures.jsonc b/decompiler/config/jak2/stack_structures.jsonc
index bc946c8d69..381903e2fc 100644
--- a/decompiler/config/jak2/stack_structures.jsonc
+++ b/decompiler/config/jak2/stack_structures.jsonc
@@ -1354,5 +1354,69 @@
     [32, "transformq"],
     [80, "vector"],
     [112, "vector"]
-  ]
+  ],
+  "(method 196 crimson-guard-level)": [
+    [32, "vector"],
+    [48, "vector"],
+    [96, "vector"],
+    [160, "vector"],
+    [176, "vector"]
+  ],
+  "(method 199 crimson-guard-level)": [
+    [608, "vector"],
+    [624, "vector"],
+    [640, "vector"],
+    [656, "vector"]
+  ],
+  "(method 198 crimson-guard-level)": [
+    [80, "vector"],
+    [96, "collide-query"],
+    [672, "vector"]
+  ],
+  "(method 202 crimson-guard-level)": [
+    [32, "vector"],
+    [656, "vector"],
+    [720, "vector"]
+  ],
+  "(method 192 crimson-guard-level)": [[32, "vector"]],
+  "check-drop-level-dig-digger-rubble-sparks": [[16, "vector"]],
+  "(method 24 dig-tether)": [[128, "vector"]],
+  "(trans idle dig-digger)": [[16, "vector"]],
+  "(method 23 dig-digger)": [[16, "vector"]],
+  "(code die fort-elec-switch)": [[16, "vector"]],
+  "(method 11 fort-elec-switch)": [
+    [32, "vector"],
+    [48, "vector"]
+  ],
+  "(method 24 fort-roboscreen)": [[32, "vector"]],
+  "fort-robotank-reticle-post": [
+    [16, "vector"],
+    [32, "vector"]
+  ],
+  "robotank-turret-handler": [[96, "vector"]],
+  "fort-robotank-turret-init-by-other": [[16, "vector"]],
+  "(method 11 fort-robotank)": [[32, "vector"]],
+  "(method 26 fort-robotank)": [[16, "event-message-block"]],
+  "(method 31 fort-robotank-turret)": [[16, "collide-query"]],
+  "(method 33 fort-robotank-turret)": [
+    [16, ["inline-array", "vector", 2]],
+    [48, ["inline-array", "vector", 4]]
+  ],
+  "draw-2d-hud": [
+    [16, ["inline-array", "vector4w", 4]],
+    [80, "vector"]
+  ],
+  "fort-turret-draw-laser-spot": [[16, "vector"]],
+  "(method 141 fort-turret)": [[64, "collide-query"]],
+  "(method 33 transport-level)": [[16, "crimson-guard-level-params"]],
+  "joint-mod-set-y-callback": [[16, "transformq"]],
+  "(code die fort-dump-bomb-a)": [[16, "matrix"]],
+  "(code die fort-missile)": [[16, "matrix"]],
+  "birth-func-dig-digger-collide": [[16, ["inline-array", "vector", 5]]],
+  "(method 29 dig-bomb-crate)": [[16, "dig-bomb-crate-cylinder-spawn-params"]],
+  "(method 63 collide-shape-moving)": [[16, ["inline-array", "vector", 51]]],
+  "(code active dig-spikey-sphere-door)": [
+    [32, "projectile-init-by-other-params"]
+  ],
+  "(enter idle dig-stomp-block-controller)": [[16, "vector"]]
 }
diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc
index 0f8d0c2f08..5f024b8c59 100644
--- a/decompiler/config/jak2/type_casts.jsonc
+++ b/decompiler/config/jak2/type_casts.jsonc
@@ -4619,16 +4619,26 @@
   "(trans grenade-hostile crimson-guard-level)": [
     [[62, 66], "a0", "process-focusable"]
   ],
-  "(code arrest crimson-guard-level)": [[29, "v1", "art-joint-anim"]],
+  "(code arrest crimson-guard-level)": [
+    [29, "v1", "art-joint-anim"],
+    [168, "v1", "art-joint-anim"],
+    [103, "v1", "art-joint-anim"]
+  ],
   "(code gun-shoot crimson-guard-level)": [
     [28, "v1", "art-joint-anim"],
-    [[91, 97], "v1", "process-drawable"]
+    [[91, 97], "v1", "process-drawable"],
+    [324, "v1", "art-joint-anim"]
   ],
   "(code close-attack crimson-guard-level)": [[14, "v1", "art-joint-anim"]],
   "(code attack crimson-guard-level)": [
     [257, "a0", "process-focusable"],
     [535, "v1", "art-joint-anim"],
-    [286, "v1", "art-joint-anim"]
+    [286, "v1", "art-joint-anim"],
+    [334, "v1", "collide-shape-prim-group"],
+    [426, "v1", "collide-shape-prim-group"],
+    [463, "v1", "art-joint-anim"],
+    [78, "v1", "art-joint-anim"],
+    [146, "v1", "art-joint-anim"]
   ],
   "(code get-up-front crimson-guard-level)": [[20, "v1", "art-joint-anim"]],
   "(code get-up-back crimson-guard-level)": [[20, "v1", "art-joint-anim"]],
@@ -4645,14 +4655,16 @@
     [100, "a1", "art-joint-anim"],
     [129, "a1", "art-joint-anim"],
     [160, "v1", "art-joint-anim"],
-    [196, "a1", "art-joint-anim"]
+    [196, "a1", "art-joint-anim"],
+    [90, "v1", "(array int32)"]
   ],
   "(method 78 crimson-guard-level)": [
     [18, "a1", "art-joint-anim"],
     [72, "a1", "art-joint-anim"],
     [104, "a1", "art-joint-anim"],
     [136, "v1", "art-joint-anim"],
-    [175, "a1", "art-joint-anim"]
+    [175, "a1", "art-joint-anim"],
+    [62, "v1", "(array int32)"]
   ],
   "(code die-falling crimson-guard-level)": [
     [29, "gp", "art-joint-anim"],
@@ -6325,5 +6337,183 @@
   "(method 11 predator-manager)": [
     ["_stack_", 16, "res-tag"],
     [281, "s2", "process-drawable"]
-  ]
+  ],
+  "(trans gun-shoot crimson-guard-level)": [[21, "v1", "process-focusable"]],
+  "(enter close-attack crimson-guard-level)": [
+    [2, "v1", "collide-shape-prim-group"]
+  ],
+  "(exit close-attack crimson-guard-level)": [
+    [2, "v1", "collide-shape-prim-group"]
+  ],
+  "(exit attack crimson-guard-level)": [
+    [8, "v1", "collide-shape-prim-group"],
+    [16, "v1", "collide-shape-prim-group"]
+  ],
+  "(exit get-up-front crimson-guard-level)": [
+    [3, "v1", "collide-shape-prim-group"],
+    [6, "v1", "collide-shape-prim-group"],
+    [8, "v1", "collide-shape-prim-group"],
+    [11, "v1", "collide-shape-prim-group"],
+    [14, "v1", "collide-shape-prim-group"],
+    [17, "v1", "collide-shape-prim-group"]
+  ],
+  "(exit get-up-back crimson-guard-level)": [
+    [3, "v1", "collide-shape-prim-group"],
+    [6, "v1", "collide-shape-prim-group"],
+    [8, "v1", "collide-shape-prim-group"],
+    [11, "v1", "collide-shape-prim-group"],
+    [14, "v1", "collide-shape-prim-group"],
+    [17, "v1", "collide-shape-prim-group"]
+  ],
+  "(enter knocked crimson-guard-level)": [
+    [8, "v1", "collide-shape-prim-group"],
+    [11, "v1", "collide-shape-prim-group"],
+    [14, "v1", "collide-shape-prim-group"],
+    [17, "v1", "collide-shape-prim-group"],
+    [19, "v1", "collide-shape-prim-group"],
+    [21, "v1", "collide-shape-prim-group"]
+  ],
+  "(method 201 crimson-guard-level)": [[18, "s3", "process-focusable"]],
+  "(method 7 crimson-guard-level)": [
+    [19, "t9", "(function nav-enemy int nav-enemy)"]
+  ],
+  "(method 115 crimson-guard-level)": [[33, "v0", "vector"]],
+  "(method 198 crimson-guard-level)": [[242, "s4", "collide-shape-prim"]],
+  "(enter broken dig-clasp)": [
+    [26, "v1", "art-joint-anim"],
+    [54, "v1", "art-joint-anim"]
+  ],
+  "(event idle dig-clasp)": [[[11, 18], "v1", "attack-info"]],
+  "dig-tether-handler": [
+    [6, "a0", "vector"],
+    [10, "a0", "vector"],
+    [14, "v1", "vector"]
+  ],
+  "(method 23 dig-digger)": [[[1, 23], "s5", "int"]],
+  "(enter breaking fort-fence)": [[[5, 9], "a0", "collide-shape-prim-group"]],
+  "(method 11 fort-elec-switch)": [["_stack_", 16, "res-tag"]],
+  "(method 10 fort-roboscreen)": [
+    [15, "t9", "(function process-drawable none)"]
+  ],
+  "fort-robotank-reticle-handler": [
+    [6, "v1", "vector"],
+    [[17, 34], "s5", "vector"],
+    [56, "v1", "float"]
+  ],
+  "(code lock fort-robotank-reticle)": [[14, "v1", "art-joint-anim"]],
+  "robotank-turret-handler": [
+    [71, "v1", "collide-shape-prim-group"],
+    [106, "v1", "collide-shape-prim-group"],
+    [167, "s4", "cspace"],
+    [162, "s4", "cspace"],
+    [37, "v1", "float"]
+  ],
+  "(code ready fort-robotank-turret)": [[10, "v1", "art-joint-anim"]],
+  "(code fire fort-robotank-turret)": [
+    [79, "v1", "art-joint-anim"],
+    [136, "v1", "art-joint-anim"]
+  ],
+  "fort-robotank-post": [
+    [471, "v1", "fort-robotank-turret"],
+    [498, "v1", "float"]
+  ],
+  "fort-robotank-handler": [[171, "s4", "process-focusable"]],
+  "(method 26 fort-robotank)": [
+    [170, "v1", "collide-shape-prim-group"],
+    [236, "v1", "collide-shape-prim-group"],
+    [89, "t9", "(function fort-robotank none)"]
+  ],
+  "(method 7 fort-robotank)": [
+    [89, "t9", "(function process-drawable int process-drawable)"],
+    [56, "gp", "(pointer uint32)"],
+    [59, "a1", "(pointer uint32)"],
+    [63, "gp", "(pointer uint32)"],
+    [66, "a1", "(pointer uint32)"],
+    [60, "a1", "joint-mod"],
+    [67, "a1", "joint-mod"],
+    [70, "gp", "(pointer uint32)"]
+  ],
+  "(method 11 fort-robotank)": [[463, "s5", "fort-robotank-wheel-info"]],
+  "(method 31 fort-robotank-turret)": [[61, "s3", "collide-shape-prim"]],
+  "(method 139 fort-turret)": [[[15, 19], "a0", "process-focusable"]],
+  "(method 141 fort-turret)": [[59, "s3", "collide-shape-prim"]],
+  "(code attack fort-turret)": [
+    [25, "v1", "art-joint-anim"],
+    [113, "v1", "art-joint-anim"]
+  ],
+  "(method 11 fort-plat-shuttle)": [[52, "v0", "(pointer float)"]],
+  "(event idle fort-floor-spike)": [[15, "s3", "process-drawable"]],
+  "joint-mod-set-y-callback": [
+    [19, "a1", "vector"],
+    [17, "a3", "int"]
+  ],
+  "(event idle fort-dump-bomb-a)": [
+    [11, "s4", "process-drawable"],
+    [[4, 22], "gp", "attack-info"]
+  ],
+  "(event idle fort-missile-target)": [
+    [[9, 22], "s5", "attack-info"],
+    [16, "s4", "projectile"]
+  ],
+  "(enter die fort-missile-target)": [
+    [[2, 5], "v1", "collide-shape-prim-group"]
+  ],
+  "(method 10 fort-missile-target)": [
+    [10, "t9", "(function process-drawable none)"]
+  ],
+  "(code die fort-missile)": [
+    [156, "v1", "process-drawable"],
+    [227, "v1", "collide-shape-prim-group"],
+    [229, "v1", "collide-shape-prim-group"]
+  ],
+  "(method 7 fort-missile)": [
+    [14, "t9", "(function process-drawable int process-drawable)"]
+  ],
+  "birth-func-dig-digger-collide": [
+    [8, "v1", "process"],
+    [12, "s3", "process-drawable"]
+  ],
+  "(method 23 dig-tether)": [[69, "v1", "vector"]],
+  "(method 11 dig-digger)": [["_stack_", 16, "res-tag"]],
+  "(method 29 dig-sinking-plat)": [
+    [9, "t9", "(function rigid-body-platform float none)"]
+  ],
+  "(method 37 dig-sinking-plat)": [
+    [28, "v1", "art-joint-anim"],
+    [157, "v1", "art-joint-anim"],
+    [208, "v0", "sound-rpc-set-param"]
+  ],
+  "(method 11 dig-log)": [
+    ["_stack_", 16, "res-tag"],
+    [94, "v0", "(pointer actor-group)"]
+  ],
+  "(event idle-up dig-button)": [[4, "v1", "attack-info"]],
+  "(code active dig-bomb-crate-cylinder)": [
+    [33, "v1", "art-joint-anim"],
+    [81, "v1", "art-joint-anim"],
+    [117, "v1", "art-joint-anim"],
+    [165, "v1", "art-joint-anim"],
+    [201, "v1", "art-joint-anim"],
+    [249, "v1", "art-joint-anim"],
+    [285, "v1", "art-joint-anim"],
+    [337, "v1", "art-joint-anim"],
+    [373, "v1", "art-joint-anim"],
+    [425, "v1", "art-joint-anim"],
+    [463, "v1", "art-joint-anim"],
+    [515, "v1", "art-joint-anim"]
+  ],
+  "(code fire dig-jump-pad)": [[59, "t9", "(function none)"]],
+  "(code die dig-spikey-sphere)": [[72, "t9", "(function none)"]],
+  "(method 29 dig-tipping-rock)": [
+    [9, "t9", "(function rigid-body-platform float none)"]
+  ],
+  "(event waiting dig-stomp-block)": [[14, "v1", "attack-info"]],
+  "(method 37 dig-stomp-block)": [
+    [[42, 62], "v1", "collide-cache-tri"],
+    [62, "v1", "(inline-array collide-cache-tri)"]
+  ],
+  "(method 11 dig-spikey-step)": [[96, "v0", "(pointer float)"]],
+  "(method 37 dig-tipping-rock)": [[14, "v0", "sound-rpc-set-param"]],
+  "(method 49 cpad-elevator)": [[2, "v1", "collide-shape-prim-group"]],
+  "(method 10 cpad-elevator)": [[10, "t9", "(function elevator none)"]]
 }
diff --git a/decompiler/util/data_decompile.cpp b/decompiler/util/data_decompile.cpp
index 9387ebd067..9dc986ae19 100644
--- a/decompiler/util/data_decompile.cpp
+++ b/decompiler/util/data_decompile.cpp
@@ -736,6 +736,8 @@ const std::unordered_map<
           {"nav-network-info",
            {{"adjacency", ArrayFieldDecompMeta(TypeSpec("nav-network-adjacency"), 16)}}},
           {"sig-path", {{"samples", ArrayFieldDecompMeta(TypeSpec("sig-path-sample"), 64)}}},
+          {"fort-robotank-segment",
+           {{"event-tbl", ArrayFieldDecompMeta(TypeSpec("fort-robotank-segment-event"), 32)}}},
           {"race-info",
            {{"turbo-pad-array", ArrayFieldDecompMeta(TypeSpec("race-turbo-pad"), 32)},
             {"racer-array", ArrayFieldDecompMeta(TypeSpec("race-racer-info"), 16)},
diff --git a/game/graphics/opengl_renderer/OpenGLRenderer.cpp b/game/graphics/opengl_renderer/OpenGLRenderer.cpp
index c3e8d8c30e..df3d3428b5 100644
--- a/game/graphics/opengl_renderer/OpenGLRenderer.cpp
+++ b/game/graphics/opengl_renderer/OpenGLRenderer.cpp
@@ -132,6 +132,7 @@ void OpenGLRenderer::init_bucket_renderers_jak2() {
   init_bucket_renderer<TextureUploadHandler>("tex-l0-shrub", BucketCategory::TEX,
                                              BucketId::TEX_L0_SHRUB);
   init_bucket_renderer<Shrub>("shrub-l0-shrub", BucketCategory::SHRUB, BucketId::SHRUB_L0_SHRUB);
+  init_bucket_renderer<Merc2>("merc-l0-shrub", BucketCategory::MERC, BucketId::MERC_L0_SHRUB);
   // 80
   init_bucket_renderer<TextureUploadHandler>("tex-l1-shrub", BucketCategory::TEX,
                                              BucketId::TEX_L1_SHRUB);
@@ -184,6 +185,7 @@ void OpenGLRenderer::init_bucket_renderers_jak2() {
   init_bucket_renderer<Merc2>("merc-l2-pris", BucketCategory::MERC, BucketId::MERC_L2_PRIS);
   init_bucket_renderer<TextureUploadHandler>("tex-l3-pris", BucketCategory::TEX,
                                              BucketId::TEX_L3_PRIS);
+  init_bucket_renderer<Merc2>("merc-l3-pris", BucketCategory::MERC, BucketId::MERC_L3_PRIS);
   // 210
   init_bucket_renderer<TextureUploadHandler>("tex-l4-pris", BucketCategory::TEX,
                                              BucketId::TEX_L4_PRIS);
diff --git a/game/graphics/opengl_renderer/buckets.h b/game/graphics/opengl_renderer/buckets.h
index 8a78eea4cf..4441821d99 100644
--- a/game/graphics/opengl_renderer/buckets.h
+++ b/game/graphics/opengl_renderer/buckets.h
@@ -105,6 +105,7 @@ enum class BucketId {
   TIE_L4_TFRAG = 53,
   TEX_L0_SHRUB = 73,
   SHRUB_L0_SHRUB = 74,
+  MERC_L0_SHRUB = 79,
   TEX_L1_SHRUB = 82,
   SHRUB_L1_SHRUB = 83,
   TEX_L2_SHRUB = 91,
@@ -128,6 +129,7 @@ enum class BucketId {
   TEX_L2_PRIS = 204,
   MERC_L2_PRIS = 205,
   TEX_L3_PRIS = 208,
+  MERC_L3_PRIS = 209,
   TEX_L4_PRIS = 212,
   MERC_L4_PRIS = 213,
   TEX_LCOM_PRIS = 220,
diff --git a/goal_src/jak2/engine/ai/enemy.gc b/goal_src/jak2/engine/ai/enemy.gc
index 5fc6a14ff5..633783687b 100644
--- a/goal_src/jak2/engine/ai/enemy.gc
+++ b/goal_src/jak2/engine/ai/enemy.gc
@@ -1030,7 +1030,7 @@
   (local-vars (sv-16 res-tag))
   (when (coin-flip? obj)
     (let ((a0-2 (-> obj node-list data 2)))
-      (set! (-> a0-2 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint-flip-z!))
+      (set! (-> a0-2 param0) (the-as (function cspace transformq none) cspace<-parented-matrix-joint-flip-z!))
       (set! (-> a0-2 param1) #f)
       (set! (-> a0-2 param2) #f)
       )
diff --git a/goal_src/jak2/engine/anim/joint-mod-h.gc b/goal_src/jak2/engine/anim/joint-mod-h.gc
index 2ea5e4ef0e..4c3daf32a3 100644
--- a/goal_src/jak2/engine/anim/joint-mod-h.gc
+++ b/goal_src/jak2/engine/anim/joint-mod-h.gc
@@ -197,7 +197,7 @@
     (set! (-> v0-0 angle) 0.0)
     (set-vector! (-> v0-0 last-position) 0.0 0.0 0.0 1.0)
     (let ((a0-3 (-> arg0 node-list data arg1)))
-      (set! (-> a0-3 param0) (the-as (function cspace matrix none) joint-mod-wheel-callback))
+      (set! (-> a0-3 param0) joint-mod-wheel-callback)
       (set! (-> a0-3 param1) v0-0)
       )
     v0-0
@@ -260,7 +260,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-set-local-callback))
+      (set! (-> a0-8 param0) joint-mod-set-local-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -318,7 +318,7 @@
     (quaternion-copy! (-> gp-0 transform quat) *unity-quaternion*)
     (set! (-> gp-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-7 (-> arg0 node-list data arg1)))
-      (set! (-> a0-7 param0) (the-as (function cspace matrix none) joint-mod-add-local-callback))
+      (set! (-> a0-7 param0) joint-mod-add-local-callback)
       (set! (-> a0-7 param1) gp-0)
       )
     gp-0
@@ -357,7 +357,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-set-world-callback))
+      (set! (-> a0-8 param0) joint-mod-set-world-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -411,7 +411,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-blend-local-callback))
+      (set! (-> a0-8 param0) joint-mod-blend-local-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -460,7 +460,7 @@
     (set! (-> v0-0 enable) #t)
     (set! (-> v0-0 angle) 0.0)
     (let ((a0-3 (-> arg0 node-list data arg1)))
-      (set! (-> a0-3 param0) (the-as (function cspace matrix none) joint-mod-spinner-callback))
+      (set! (-> a0-3 param0) joint-mod-spinner-callback)
       (set! (-> a0-3 param1) v0-0)
       )
     v0-0
@@ -570,7 +570,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-blend-world-callback))
+      (set! (-> a0-8 param0) joint-mod-blend-world-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -606,7 +606,7 @@
     (set! (-> gp-0 enable) arg2)
     (quaternion-set! (-> gp-0 rotation) 0.0 0.0 0.0 1.0)
     (let ((a0-3 (-> arg0 node-list data arg1)))
-      (set! (-> a0-3 param0) (the-as (function cspace matrix none) joint-mod-rotate-local-callback))
+      (set! (-> a0-3 param0) joint-mod-rotate-local-callback)
       (set! (-> a0-3 param1) gp-0)
       )
     gp-0
diff --git a/goal_src/jak2/engine/anim/joint-mod.gc b/goal_src/jak2/engine/anim/joint-mod.gc
index 67ddfb5078..4ff63659b5 100644
--- a/goal_src/jak2/engine/anim/joint-mod.gc
+++ b/goal_src/jak2/engine/anim/joint-mod.gc
@@ -20,6 +20,7 @@
 
 ;; DECOMP BEGINS
 
+;; WARN: Return type mismatch matrix vs none.
 ;; WARN: Function joint-mod-ik-callback has a return type of none, but the expression builder found a return statement.
 ;; ERROR: Unsupported inline assembly instruction kind - [mula.s f0, f3]
 ;; ERROR: Unsupported inline assembly instruction kind - [madda.s f1, f4]
@@ -313,7 +314,7 @@
     (set! (-> v0-0 blend) 0.0)
     (logclear! (-> v0-0 flags) (joint-mod-ik-flags enable))
     (let ((a0-5 (-> arg0 node-list data arg1)))
-      (set! (-> a0-5 param0) (the-as (function cspace matrix none) joint-mod-ik-callback))
+      (set! (-> a0-5 param0) joint-mod-ik-callback)
       (set! (-> a0-5 param1) v0-0)
       (set! (-> a0-5 param2) (the-as basic arg1))
       )
@@ -607,13 +608,13 @@
        )
       (((joint-mod-mode look-at))
        (let ((a0-4 v1-0))
-         (set! (-> a0-4 param0) (the-as (function cspace matrix none) joint-mod-look-at-handler))
+         (set! (-> a0-4 param0) joint-mod-look-at-handler)
          (set! (-> a0-4 param1) obj)
          )
        )
       (((joint-mod-mode gun-look-at))
        (let ((a0-5 v1-0))
-         (set! (-> a0-5 param0) (the-as (function cspace matrix none) joint-mod-gun-look-at-handler))
+         (set! (-> a0-5 param0) joint-mod-gun-look-at-handler)
          (set! (-> a0-5 param1) obj)
          )
        )
@@ -621,23 +622,20 @@
        (set-vector! (-> obj twist) 0.0 1.0 0.0 1.0)
        (let ((a0-7 v1-0))
          (set! (-> a0-7 param0)
-               (the-as
-                 (function cspace matrix none)
-                 (lambda ((arg0 cspace) (arg1 transformq)) (joint-mod-foot-rot-handler arg0 arg1) (none))
-                 )
+               (lambda ((arg0 cspace) (arg1 transformq)) (joint-mod-foot-rot-handler arg0 arg1) (none))
                )
          (set! (-> a0-7 param1) obj)
          )
        )
       (((joint-mod-mode world-look-at))
        (let ((a0-8 v1-0))
-         (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-world-look-at-handler))
+         (set! (-> a0-8 param0) joint-mod-world-look-at-handler)
          (set! (-> a0-8 param1) obj)
          )
        )
       (((joint-mod-mode polar-look-at))
        (let ((a0-9 v1-0))
-         (set! (-> a0-9 param0) (the-as (function cspace matrix none) joint-mod-polar-look-at-handler))
+         (set! (-> a0-9 param0) joint-mod-polar-look-at-handler)
          (set! (-> a0-9 param1) obj)
          )
        (set! (-> obj polar-internal-tilt-max) 32768.0)
@@ -647,21 +645,21 @@
        )
       (((joint-mod-mode rotate))
        (let ((a0-11 v1-0))
-         (set! (-> a0-11 param0) (the-as (function cspace matrix none) joint-mod-rotate-handler))
+         (set! (-> a0-11 param0) joint-mod-rotate-handler)
          (set! (-> a0-11 param1) obj)
          )
        (set! (-> obj blend) 1.0)
        )
       (((joint-mod-mode rotate2))
        (let ((a0-13 v1-0))
-         (set! (-> a0-13 param0) (the-as (function cspace matrix none) joint-mod-rotate-handler))
+         (set! (-> a0-13 param0) joint-mod-rotate-handler)
          (set! (-> a0-13 param1) obj)
          )
        (set! (-> obj blend) 1.0)
        )
       (((joint-mod-mode joint-set))
        (let ((a0-15 v1-0))
-         (set! (-> a0-15 param0) (the-as (function cspace matrix none) joint-mod-joint-set-handler))
+         (set! (-> a0-15 param0) joint-mod-joint-set-handler)
          (set! (-> a0-15 param1) obj)
          )
        (vector-reset! (-> obj trans))
@@ -670,7 +668,7 @@
        )
       (((joint-mod-mode joint-set-world))
        (let ((a0-18 v1-0))
-         (set! (-> a0-18 param0) (the-as (function cspace matrix none) joint-mod-joint-set-world-handler))
+         (set! (-> a0-18 param0) joint-mod-joint-set-world-handler)
          (set! (-> a0-18 param1) obj)
          )
        (vector-reset! (-> obj trans))
@@ -680,7 +678,7 @@
        )
       (((joint-mod-mode joint-set*))
        (let ((a0-25 v1-0))
-         (set! (-> a0-25 param0) (the-as (function cspace matrix none) joint-mod-joint-set*-handler))
+         (set! (-> a0-25 param0) joint-mod-joint-set*-handler)
          (set! (-> a0-25 param1) obj)
          )
        (vector-reset! (-> obj trans))
@@ -689,7 +687,7 @@
        )
       (((joint-mod-mode joint-set*-world))
        (let ((a0-29 v1-0))
-         (set! (-> a0-29 param0) (the-as (function cspace matrix none) joint-mod-joint-set*-world-handler))
+         (set! (-> a0-29 param0) joint-mod-joint-set*-world-handler)
          (set! (-> a0-29 param1) obj)
          )
        (vector-reset! (-> obj trans))
@@ -701,6 +699,7 @@
   (none)
   )
 
+;; WARN: Return type mismatch joint-mod vs none.
 (defmethod shut-down joint-mod ((obj joint-mod))
   (set! (-> obj shutting-down?) #t)
   (set! (-> obj blend) 0.0)
diff --git a/goal_src/jak2/engine/anim/mspace-h.gc b/goal_src/jak2/engine/anim/mspace-h.gc
index 141ec06394..4fd1a4ae6d 100644
--- a/goal_src/jak2/engine/anim/mspace-h.gc
+++ b/goal_src/jak2/engine/anim/mspace-h.gc
@@ -65,7 +65,7 @@
    (joint-num int16                          :offset-assert   8)
    (geo       drawable                       :offset-assert  12)
    (bone      bone                           :offset-assert  16)
-   (param0    (function cspace matrix none)  :offset-assert  20)
+   (param0    (function cspace transformq none)  :offset-assert  20)
    (param1    basic                          :offset-assert  24)
    (param2    basic                          :offset-assert  28)
    )
diff --git a/goal_src/jak2/engine/collide/collide-shape-h.gc b/goal_src/jak2/engine/collide/collide-shape-h.gc
index 41896bb51c..2a43f42792 100644
--- a/goal_src/jak2/engine/collide/collide-shape-h.gc
+++ b/goal_src/jak2/engine/collide/collide-shape-h.gc
@@ -15,6 +15,7 @@
 (declare-type collide-cache-prim structure)
 (declare-type collide-shape-prim basic)
 (declare-type collide-cache basic)
+(declare-type rigid-body structure)
 
 (defenum penetrate
   :bitfield #t
@@ -561,7 +562,7 @@
     (move-to-ground (_type_ float float symbol collide-spec) none 60)
     (move-to-ground-point (_type_ vector vector vector) none 61)
     (compute-acc-due-to-gravity (_type_ vector float) vector 62)
-    (collide-shape-moving-method-63 () none 63)
+    (collide-shape-moving-method-63 (_type_ rigid-body float) none 63)
     (try-snap-to-surface (_type_ vector float float float) symbol 64)
     (fill-and-try-snap-to-surface (_type_ vector float float float collide-query) symbol 65)
     (step-collison! (_type_ vector vector float int) float 66)
@@ -618,7 +619,7 @@
     )
   )
 
-;; WARN: Return type mismatch uint8 vs int.
+;; WARN: Return type mismatch uint vs int.
 (defmethod length collide-shape-prim-group ((obj collide-shape-prim-group))
   (the-as int (-> obj num-children))
   )
diff --git a/goal_src/jak2/engine/common_objs/collectables.gc b/goal_src/jak2/engine/common_objs/collectables.gc
index 63a256c288..ea8dc89bd4 100644
--- a/goal_src/jak2/engine/common_objs/collectables.gc
+++ b/goal_src/jak2/engine/common_objs/collectables.gc
@@ -2209,7 +2209,7 @@
      (set-vector! (-> obj root-override2 scale) 3.0 3.0 3.0 1.0)
      (logclear! (-> obj flags) (collectable-flag fadeout))
      (let ((v1-34 (-> obj node-list data)))
-       (set! (-> v1-34 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+       (set! (-> v1-34 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
        (set! (-> v1-34 0 param1) (the-as basic (-> obj root-override2 trans)))
        (set! (-> v1-34 0 param2) (the-as basic (-> obj extra-trans)))
        )
@@ -2237,7 +2237,7 @@
        )
      (set-vector! (-> obj root-override2 scale) 2.0 2.0 2.0 1.0)
      (let ((v1-52 (-> obj node-list data)))
-       (set! (-> v1-52 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+       (set! (-> v1-52 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
        (set! (-> v1-52 0 param1) (the-as basic (-> obj root-override2 trans)))
        (set! (-> v1-52 0 param2) (the-as basic (-> obj extra-trans)))
        )
diff --git a/goal_src/jak2/engine/common_objs/generic-obs.gc b/goal_src/jak2/engine/common_objs/generic-obs.gc
index b65182bf7c..f92d45f8fb 100644
--- a/goal_src/jak2/engine/common_objs/generic-obs.gc
+++ b/goal_src/jak2/engine/common_objs/generic-obs.gc
@@ -743,7 +743,9 @@
            (cond
              ((-> event param 0)
               (set! s4-0 (-> self node-list data 2))
-              (set! (-> (the-as cspace s4-0) param0) (the-as (function cspace matrix none) cspace<-parented-matrix-mirror!))
+              (set! (-> (the-as cspace s4-0) param0)
+                    (the-as (function cspace transformq none) cspace<-parented-matrix-mirror!)
+                    )
               (set! (-> (the-as cspace s4-0) param1) (the-as basic (-> *math-camera* mirror-trans)))
               (set! (-> (the-as cspace s4-0) param2) (the-as basic (-> *math-camera* mirror-normal)))
               )
diff --git a/goal_src/jak2/engine/debug/default-menu.gc b/goal_src/jak2/engine/debug/default-menu.gc
index 8e88c0a6f0..7acac10518 100644
--- a/goal_src/jak2/engine/debug/default-menu.gc
+++ b/goal_src/jak2/engine/debug/default-menu.gc
@@ -2797,6 +2797,7 @@
   )
 
 (defun dm-play-task-with-continue ((arg0 game-task) (arg1 string))
+  (format 0 "hello world - ~D:~S~%" arg0 arg1)
   (let* ((t9-0 play-task)
          (a1-1 'debug)
          (a2-0 (cond
@@ -2821,6 +2822,7 @@
   )
 
 (defun dm-play-task ((arg0 game-task))
+  (format 0 "DEBUG - ~D~%" arg0)
   (dm-play-task-with-continue (the-as game-task (/ (the-as int arg0) 8)) (the-as string #f))
   (none)
   )
diff --git a/goal_src/jak2/engine/nav/nav-enemy.gc b/goal_src/jak2/engine/nav/nav-enemy.gc
index 4b43dbd8d1..715f6ec51e 100644
--- a/goal_src/jak2/engine/nav/nav-enemy.gc
+++ b/goal_src/jak2/engine/nav/nav-enemy.gc
@@ -1076,7 +1076,7 @@
   (local-vars (sv-16 res-tag))
   (when (coin-flip? obj)
     (let ((a0-2 (-> obj node-list data 2)))
-      (set! (-> a0-2 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint-flip-z!))
+      (set! (-> a0-2 param0) (the-as (function cspace transformq none) cspace<-parented-matrix-joint-flip-z!))
       (set! (-> a0-2 param1) #f)
       (set! (-> a0-2 param2) #f)
       )
diff --git a/goal_src/jak2/engine/physics/rigid-body-h.gc b/goal_src/jak2/engine/physics/rigid-body-h.gc
index 6c565b9340..98854f3eb6 100644
--- a/goal_src/jak2/engine/physics/rigid-body-h.gc
+++ b/goal_src/jak2/engine/physics/rigid-body-h.gc
@@ -368,7 +368,7 @@
     (rigid-body-object-method-42 (_type_) none :behavior rigid-body-object 42)
     (rigid-body-object-method-43 (_type_) none 43)
     (rigid-body-object-method-44 (_type_ float) none 44)
-    (rigid-body-object-method-45 () none 45)
+    (rigid-body-object-method-45 (_type_ rigid-body-object-constants) sound-id 45)
     (rigid-body-object-method-46 (_type_ process-drawable int symbol event-message-block) none :behavior rigid-body-object 46)
     (rigid-body-object-method-47 (_type_ process-drawable attack-info object penetrate) symbol 47)
     (rigid-body-object-method-48 (_type_ object object) none 48)
diff --git a/goal_src/jak2/engine/physics/rigid-body.gc b/goal_src/jak2/engine/physics/rigid-body.gc
index 40a6dc634a..a5ae3e3007 100644
--- a/goal_src/jak2/engine/physics/rigid-body.gc
+++ b/goal_src/jak2/engine/physics/rigid-body.gc
@@ -313,7 +313,8 @@
     )
   (rigid-body-method-13 obj)
   (if (logtest? (-> obj flags) (rigid-body-flag enable-collision))
-      ((method-of-object arg0 collide-shape-moving-method-63))
+      ;; TODO - method 63!
+      ;; ((method-of-object arg0 collide-shape-moving-method-63))
       (rigid-body-method-14 obj arg1)
       )
   0
@@ -725,9 +726,9 @@
   (none)
   )
 
-(defmethod rigid-body-object-method-45 rigid-body-object ()
-  0
-  (none)
+;; WARN: Return type mismatch int vs sound-id.
+(defmethod rigid-body-object-method-45 rigid-body-object ((obj rigid-body-object) (arg0 rigid-body-object-constants))
+  (the-as sound-id 0)
   )
 
 (defmethod rigid-body-object-method-49 rigid-body-object ((obj rigid-body-object) (arg0 matrix) (arg1 touching-shapes-entry))
@@ -835,8 +836,8 @@
             )
           )
         )
+      (rigid-body-object-method-45 obj (the-as rigid-body-object-constants s5-0))
       )
-    ((method-of-object obj rigid-body-object-method-45))
     (if (and (-> obj next-state) (= (-> obj next-state name) 'idle))
         (rigid-body-object-method-43 obj)
         )
@@ -849,11 +850,12 @@
 (defmethod rigid-body-object-method-46 rigid-body-object ((obj rigid-body-object) (arg0 process-drawable) (arg1 int) (arg2 symbol) (arg3 event-message-block))
   (case arg2
     (('impact-impulse)
-     (-> arg3 param 0)
-     (if (!= obj arg0)
-         (rigid-body-object-method-42 obj)
-         )
-     ((method-of-object obj rigid-body-object-method-45))
+     (let ((s5-1 (-> arg3 param 0)))
+       (if (!= obj arg0)
+           (rigid-body-object-method-42 obj)
+           )
+       (rigid-body-object-method-45 obj (the-as rigid-body-object-constants s5-1))
+       )
      (if (and (-> obj next-state) (= (-> obj next-state name) 'idle))
          (rigid-body-object-method-43 obj)
          )
diff --git a/goal_src/jak2/engine/process-drawable/process-drawable.gc b/goal_src/jak2/engine/process-drawable/process-drawable.gc
index 09f8a411f5..0b10d1fada 100644
--- a/goal_src/jak2/engine/process-drawable/process-drawable.gc
+++ b/goal_src/jak2/engine/process-drawable/process-drawable.gc
@@ -308,7 +308,6 @@
   obj
   )
 
-;; WARN: Return type mismatch cspace-array vs none.
 (defmethod setup-cspace-and-add draw-control ((obj draw-control) (arg0 art-joint-geo) (arg1 symbol))
   (let ((s5-0 ((method-of-type cspace-array new) arg1 cspace-array (+ (-> arg0 length) 1))))
     (let ((v0-1 ((method-of-type skeleton new) arg1 skeleton (+ (-> arg0 length) 1))))
@@ -323,7 +322,7 @@
           (set! (-> v1-9 bone) (the-as bone (-> s3-1 bones)))
           )
         (let ((v1-10 (-> s5-0 data)))
-          (set! (-> v1-10 0 param0) (the-as (function cspace matrix none) cspace<-transformq!))
+          (set! (-> v1-10 0 param0) (the-as (function cspace transformq none) cspace<-transformq!))
           (set! (-> v1-10 0 param1) (the-as basic (-> (the-as process-drawable (-> obj process)) root trans)))
           )
         (let ((v1-12 (reset-and-assign-geo! (-> s5-0 data 1) (the-as drawable #f))))
@@ -335,7 +334,7 @@
           (set! (-> v1-14 joint) (-> arg0 data 1))
           (set! (-> v1-14 bone) (-> s3-1 bones 2))
           (set! (-> v1-14 parent) (the-as cspace (-> s5-0 data)))
-          (set! (-> v1-14 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint!))
+          (set! (-> v1-14 param0) (the-as (function cspace transformq none) cspace<-parented-matrix-joint!))
           (set! (-> v1-14 param1) (-> obj process))
           )
         (let ((s2-0 3))
@@ -409,7 +408,7 @@
               (let* ((v1-20 (-> arg0 data s1-1))
                      (t9-3 (the-as function (-> v1-20 param0)))
                      )
-                (if (the-as (function cspace matrix none) t9-3)
+                (if (the-as (function cspace transformq none) t9-3)
                     ((the-as (function object object object none) t9-3) v1-20 (-> v1-20 param1) (-> v1-20 param2))
                     )
                 )
@@ -420,7 +419,7 @@
                      (t9-4 (-> a0-11 param0))
                      )
                 (if t9-4
-                    (t9-4 a0-11 (the-as matrix a1-7))
+                    (t9-4 a0-11 (the-as transformq a1-7))
                     )
                 )
               )
@@ -430,7 +429,7 @@
                       (a1-9 (+ (* 48 s0-0) 2528 (scratchpad-object int)))
                       )
                   (if (-> a0-12 param0)
-                      ((-> a0-12 param0) a0-12 (the-as matrix a1-9))
+                      ((-> a0-12 param0) a0-12 (the-as transformq a1-9))
                       (cspace<-parented-transformq-joint! a0-12 (the-as transformq a1-9))
                       )
                   )
@@ -715,7 +714,7 @@
     (set! (-> s2-0 level-index) (the-as uint (-> s3-0 index)))
     )
   (set! (-> s2-0 dma-add-func) (the-as (function process-drawable draw-control symbol object none) nothing))
-  (set! (-> arg2 0) (the-as cspace-array (setup-cspace-and-add s2-0 (the-as art-joint-geo sv-16) 'process)))
+  (set! (-> arg2 0) (setup-cspace-and-add s2-0 (the-as art-joint-geo sv-16) 'process))
   (set! (-> s2-0 dma-add-func) dma-add-process-drawable)
   (set! (-> s2-0 shadow-mask) (res-lump-value (-> arg0 entity) 'shadow-mask uint :time -1000000000.0))
   (set! (-> s2-0 shadow-values) (res-lump-value (-> arg0 entity) 'shadow-values uint :time -1000000000.0))
diff --git a/goal_src/jak2/engine/target/board/target-board.gc b/goal_src/jak2/engine/target/board/target-board.gc
index 6b61c526e5..3b0c776bae 100644
--- a/goal_src/jak2/engine/target/board/target-board.gc
+++ b/goal_src/jak2/engine/target/board/target-board.gc
@@ -763,7 +763,7 @@
   (logclear! (-> self control root-prim prim-core action) (collide-action can-ride))
   (set! (-> self control bend-target) 1.0)
   (let ((v1-82 (-> self node-list data)))
-    (set! (-> v1-82 0 param0) (the-as (function cspace matrix none) cspace<-transformq+world-trans!))
+    (set! (-> v1-82 0 param0) (the-as (function cspace transformq none) cspace<-transformq+world-trans!))
     (set! (-> v1-82 0 param1) (the-as basic (-> self control trans)))
     (set! (-> v1-82 0 param2) (the-as basic (-> self control cspace-offset)))
     )
@@ -840,7 +840,7 @@
     (remove-setting! 'string-spline-max-move-player)
     (remove-setting! 'string-spline-accel-player)
     (let ((v1-43 (-> self node-list data)))
-      (set! (-> v1-43 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+      (set! (-> v1-43 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
       (set! (-> v1-43 0 param1) (the-as basic (-> self control trans)))
       (set! (-> v1-43 0 param2) (the-as basic (-> self control cspace-offset)))
       )
diff --git a/goal_src/jak2/engine/target/logic-target.gc b/goal_src/jak2/engine/target/logic-target.gc
index 958934c55a..f91e403095 100644
--- a/goal_src/jak2/engine/target/logic-target.gc
+++ b/goal_src/jak2/engine/target/logic-target.gc
@@ -3230,7 +3230,7 @@
     )
   (logior! (-> obj skel effect flags) (effect-control-flag ecf0 ecf1))
   (let ((v1-94 (-> obj node-list data)))
-    (set! (-> v1-94 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+    (set! (-> v1-94 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
     (set! (-> v1-94 0 param1) (the-as basic (-> obj control trans)))
     (set! (-> v1-94 0 param2) (the-as basic (-> obj control cspace-offset)))
     )
diff --git a/goal_src/jak2/engine/target/mech_suit/mech.gc b/goal_src/jak2/engine/target/mech_suit/mech.gc
index b149d73c0e..6533b266d3 100644
--- a/goal_src/jak2/engine/target/mech_suit/mech.gc
+++ b/goal_src/jak2/engine/target/mech_suit/mech.gc
@@ -368,7 +368,7 @@
   (set! (-> self shadow-backup) (-> self draw shadow))
   (set! (-> self draw shadow-ctrl) *mech-shadow-control*)
   (let ((v1-27 (-> self node-list data)))
-    (set! (-> v1-27 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+    (set! (-> v1-27 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
     (set! (-> v1-27 0 param1) (the-as basic (-> self root-override trans)))
     (set! (-> v1-27 0 param2) (the-as basic (-> self extra-trans)))
     )
diff --git a/goal_src/jak2/engine/target/mech_suit/target-mech.gc b/goal_src/jak2/engine/target/mech_suit/target-mech.gc
index 3a55dbc9c6..342a272cd8 100644
--- a/goal_src/jak2/engine/target/mech_suit/target-mech.gc
+++ b/goal_src/jak2/engine/target/mech_suit/target-mech.gc
@@ -1160,7 +1160,7 @@
   (set! (-> self focus-status) (logior (focus-status mech) (-> self focus-status)))
   (set! (-> self control bend-target) 0.0)
   (let ((v1-40 (-> self node-list data)))
-    (set! (-> v1-40 0 param0) (the-as (function cspace matrix none) cspace<-transformq+world-trans!))
+    (set! (-> v1-40 0 param0) (the-as (function cspace transformq none) cspace<-transformq+world-trans!))
     (set! (-> v1-40 0 param1) (the-as basic (-> self control trans)))
     (set! (-> v1-40 0 param2) (the-as basic (-> self control cspace-offset)))
     )
@@ -1359,7 +1359,7 @@
     (set! (-> self control dynam gravity-max) (-> self control standard-dynamics gravity-max))
     (set! (-> self control dynam gravity-length) (-> self control standard-dynamics gravity-length))
     (let ((v1-39 (-> self node-list data)))
-      (set! (-> v1-39 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+      (set! (-> v1-39 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
       (set! (-> v1-39 0 param1) (the-as basic (-> self control trans)))
       (set! (-> v1-39 0 param2) (the-as basic (-> self control cspace-offset)))
       )
diff --git a/goal_src/jak2/engine/target/sidekick.gc b/goal_src/jak2/engine/target/sidekick.gc
index ce95f97328..8d00e420d3 100644
--- a/goal_src/jak2/engine/target/sidekick.gc
+++ b/goal_src/jak2/engine/target/sidekick.gc
@@ -182,7 +182,7 @@
          (('play-anim)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace+transformq!)
+                (the-as (function cspace transformq none) cspace<-cspace+transformq!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data))
@@ -192,7 +192,7 @@
          (('copy-parent)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace!)
+                (the-as (function cspace transformq none) cspace<-cspace!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data))
@@ -202,7 +202,7 @@
          (('root)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace-normalized!)
+                (the-as (function cspace transformq none) cspace<-cspace-normalized!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data))
@@ -212,7 +212,7 @@
          (('indax)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-transformq+trans!)
+                (the-as (function cspace transformq none) cspace<-transformq+trans!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 control trans))
@@ -224,7 +224,7 @@
          (('board)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace-normalized!)
+                (the-as (function cspace transformq none) cspace<-cspace-normalized!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data 25))
@@ -234,7 +234,7 @@
          (else
            (set! v0-0 (-> self node-list data))
            (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                 (the-as (function cspace matrix none) cspace<-cspace+transformq!)
+                 (the-as (function cspace transformq none) cspace<-cspace+transformq!)
                  )
            (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                  (the-as basic (-> self parent-override 0 control sidekick-root parent))
@@ -485,7 +485,7 @@
             (send-event (ppointer->process gp-4) 'mirror #t)
             (set! (-> self mirror) gp-4)
             (let ((v0-29 (-> gp-4 0 node-list data)))
-              (set! (-> v0-29 0 param0) (the-as (function cspace matrix none) cspace<-cspace!))
+              (set! (-> v0-29 0 param0) (the-as (function cspace transformq none) cspace<-cspace!))
               (set! (-> v0-29 0 param1) (the-as basic (-> self node-list data)))
               (set! (-> v0-29 0 param2) #f)
               )
@@ -512,7 +512,7 @@
   (logior! (-> self skel status) (joint-control-status sync-math blend-shape eye-anim))
   (set! (-> self draw light-index) (the-as uint 30))
   (let ((v1-14 (-> self node-list data)))
-    (set! (-> v1-14 0 param0) (the-as (function cspace matrix none) cspace<-cspace+transformq!))
+    (set! (-> v1-14 0 param0) (the-as (function cspace transformq none) cspace<-cspace+transformq!))
     (set! (-> v1-14 0 param1) (the-as basic (-> self parent-override 0 control sidekick-root parent)))
     (set! (-> v1-14 0 param2) (the-as basic (-> self offset)))
     )
diff --git a/goal_src/jak2/engine/util/sync-info-h.gc b/goal_src/jak2/engine/util/sync-info-h.gc
index fd547c5184..1de9196649 100644
--- a/goal_src/jak2/engine/util/sync-info-h.gc
+++ b/goal_src/jak2/engine/util/sync-info-h.gc
@@ -52,6 +52,7 @@
 
 (deftype sync-linear (sync-info)
   ()
+  :pack-me
   :method-count-assert 16
   :size-assert         #x10
   :flag-assert         #x1000000010
@@ -92,6 +93,7 @@
    (start-time time-frame  :offset-assert  16)
    (value      float       :offset-assert  24)
    )
+  :pack-me
   :method-count-assert 13
   :size-assert         #x1c
   :flag-assert         #xd0000001c
@@ -112,6 +114,7 @@
    (damping float  :offset-assert  16)
    (accel   float  :offset-assert  20)
    )
+  :allow-misaligned
   :method-count-assert 11
   :size-assert         #x18
   :flag-assert         #xb00000018
@@ -129,6 +132,7 @@
    (elasticity float                     :offset-assert  32)
    (state      int32                     :offset-assert  36)
    )
+  :allow-misaligned
   :method-count-assert 13
   :size-assert         #x28
   :flag-assert         #xd00000028
diff --git a/goal_src/jak2/game.gp b/goal_src/jak2/game.gp
index a726ec63f7..354d62a000 100644
--- a/goal_src/jak2/game.gp
+++ b/goal_src/jak2/game.gp
@@ -1760,7 +1760,6 @@
   "levels/common/enemy/hover/flamer.gc"
   "levels/dig/dig-digger.gc"
   "levels/dig/dig-obs.gc"
-  ;; "levels/dig/dig1-obs.gc"
   "levels/dig/dig2-obs.gc"
   "levels/dig/dig3-obs.gc"
   "levels/common/enemy/baby_spider/tomb-baby-spider.gc"
@@ -1796,16 +1795,13 @@
 ;; ;; D3B
 ;; ;;;;;;;;;;;;;;;;;;;;;
 
-;; (cgo "D3B.DGO" "d3b.gd")
+(cgo "D3B.DGO" "d3b.gd")
 
-;; (copy-textures 2406 2407 3548)
+(copy-textures 2406 2407 3548)
 
-;; (copy-gos
-;;   "jak-pole+0-ag"
-;;   "daxter-highres-ag"
-;;   "jak-highres-ag"
-;;   "dig3b-vis"
-;;   )
+(copy-gos
+  "dig3b-vis"
+  )
 
 ;; ;;;;;;;;;;;;;;;;;;;;;
 ;; ;; DEMO
@@ -1837,31 +1833,19 @@
 (goal-src-sequence
   ""
   :deps ("$OUT/obj/los-control.o")
-  ;; "levels/dig/dig-digger.gc"
-  ;; "levels/dig/dig-obs.gc"
   "levels/dig/dig1-obs.gc"
-  ;; "levels/dig/dig2-obs.gc"
-  ;; "levels/dig/dig3-obs.gc"
-  ;; "levels/common/enemy/baby_spider/tomb-baby-spider.gc"
-  ;; "levels/common/enemy/metalhead_slinger/grenadier.gc"
-  ;; "levels/common/enemy/metalhead_brown/metalmonk.gc"
-  ;; "levels/dig/dig-texture.gc"
-  ;; "levels/dig/dig-scenes.gc"
-  ;; "levels/dig/dig-part.gc"
   )
 
 (copy-textures 2282 2284 2283 2419 2844)
 
 (copy-gos
   "dig-digger-ag"
-  ;; "crimson-guard-ag"
   "dig-bomb-crate-ag"
   "dig-conveyor-ag"
   "dig-clasp-ag"
   "dig-tether-ag"
   "dig-jump-pad-ag"
   "dig-breakable-door-ag"
-  ;; "dig-sinking-plat-ag"
   "dig-clasp-b-ag"
   "dig-bomb-crate-cylinder-ag"
   "dig1-vis"
@@ -2164,50 +2148,36 @@
 ;; ;; FORDUMPC
 ;; ;;;;;;;;;;;;;;;;;;;;;
 
-;; (cgo "FORDUMPC.DGO" "fordumpc.gd")
+(cgo "FORDUMPC.DGO" "fordumpc.gd")
 
-;; (goal-src-sequence
-;;   ""
-;;   :deps ("$OUT/obj/los-control.o")
-;;   "levels/fortress/ammo_dump/fordumpa-texture.gc"
-;;   "levels/fortress/ammo_dump/fort-robotank-turret.gc"
-;;   "levels/fortress/ammo_dump/fort-robotank.gc"
-;;   "levels/fortress/ammo_dump/fordumpc-part.gc"
-;;   "levels/fortress/ammo_dump/fordumpc-obs.gc"
-;;   "levels/fortress/ammo_dump/fortress-scenes.gc"
-;;   )
+(goal-src-sequence
+  ""
+  :deps ("$OUT/obj/los-control.o")
+  "levels/fortress/ammo_dump/fordumpc-part.gc"
+  "levels/fortress/ammo_dump/fordumpc-obs.gc"
+  "levels/fortress/ammo_dump/fortress-scenes.gc"
+  )
 
-;; (copy-textures 1570 1573 1571 2917 2847)
+(copy-textures 1570 1573 1571 2917 2847)
 
-;; (copy-gos
-;;   "daxter-highres-ag"
-;;   "jak-highres-ag"
-;;   "fort-robotank-ag"
-;;   "fort-missile-target-ag"
-;;   "fort-robotank-top-ag"
-;;   "fort-roboscreen-ag"
-;;   "fort-missile-ag"
-;;   "fort-robotank-sight-ag"
-;;   "fort-dump-bomb-a-ag"
-;;   "particleman-ag"
-;;   "fordumpc"
-;;   )
+(copy-gos
+  "fort-missile-target-ag"
+  "fort-missile-ag"
+  "fort-dump-bomb-a-ag"
+  "fordumpc"
+  )
 
 ;; ;;;;;;;;;;;;;;;;;;;;;
 ;; ;; FORDUMPD
 ;; ;;;;;;;;;;;;;;;;;;;;;
 
-;; (cgo "FORDUMPD.DGO" "fordumpd.gd")
+(cgo "FORDUMPD.DGO" "fordumpd.gd")
 
-;; (copy-textures 1574)
+(copy-textures 1574)
 
-;; (copy-gos
-;;   "crimson-guard-highres-ag"
-;;   "crimson-guard-lowres-ag"
-;;   "grunt-fma-ag"
-;;   "palmpilot-ag"
-;;   "fordumpd"
-;;   )
+(copy-gos
+  "fordumpd"
+  )
 
 ;; ;;;;;;;;;;;;;;;;;;;;;
 ;; ;; FRA
@@ -2253,10 +2223,8 @@
 (goal-src-sequence
   ""
   :deps ("$OUT/obj/los-control.o")
-  ;; "levels/common/entities/fort-floor-spike.gc"
   "levels/fortress/rescue/forrescb-part.gc"
   "levels/fortress/rescue/forrescb-obs.gc"
-  ;; "levels/fortress/fort-turret.gc"
   "levels/common/entities/spydroid.gc"
   )
 
@@ -2264,8 +2232,6 @@
 
 (copy-gos
   "spydroid-ag"
-  ;; "fort-turret-ag"
-  ;; "cty-guard-turret-button-ag"
   "fort-elec-belt-ag"
   "forrescb-vis"
   )
diff --git a/goal_src/jak2/kernel/gkernel.gc b/goal_src/jak2/kernel/gkernel.gc
index ab9e2cfc24..302443e255 100644
--- a/goal_src/jak2/kernel/gkernel.gc
+++ b/goal_src/jak2/kernel/gkernel.gc
@@ -89,7 +89,9 @@
         )
 
 ;; the main execution stack that's not on the scratchpad
+;; (define *canary-1* (the-as (pointer uint64) (malloc 'global 8)))
 (define *dram-stack* (the-as (pointer uint8) (malloc 'global DPROCESS_STACK_SIZE)))
+;; (define *canary-2* (the-as (pointer uint64) (malloc 'global 8)))
 
 ;; DECOMP DEVIATION
 ;; the top of the stack.
@@ -119,6 +121,7 @@
   ;; use the same memory for the scratchpad stacks.
   ;; defining it as a separate thing so we can split them for debugging stack corruption easily.
   (define *fake-scratchpad-stack* *fake-scratchpad-data*)
+  ;; (define *canary-3* (the-as (pointer uint64) (malloc 'global 8)))
 
   (defmacro scratchpad-start ()
     "Get the start of the scratchpad. At least 64kB aligned."
@@ -1559,6 +1562,9 @@
   (execute-process-tree
     *active-pool*
     (lambda ((arg0 process))
+      ;; (+! (-> *canary-1*) 1)
+      ;; (+! (-> *canary-2*) 1)
+      ;; (+! (-> *canary-3*) 1)
       (let ((s5-0 *kernel-context*))
         (case (-> arg0 status)
           (('waiting-to-run 'suspended)
@@ -1580,6 +1586,7 @@
              )
 
            ;; run the trans function.
+          ;;  (format 0 "Trans | Proc '~A' | C1: ~X C2: ~X C3: ~X~%" arg0 (-> *canary-1*) (-> *canary-2*) (-> *canary-3*))
            (when (-> arg0 trans-hook)
              (let ((s4-0 (new 'process 'cpu-thread arg0 'trans 256 (-> arg0 main-thread stack-top))))
                (reset-and-call s4-0 (-> arg0 trans-hook))
@@ -1593,10 +1600,12 @@
              )
 
            ;; run the main thread!
+          ;;  (format 0 "Code | Proc '~A' | C1: ~X C2: ~X C3: ~X~%" arg0 (-> *canary-1*) (-> *canary-2*) (-> *canary-3*))
            (if (logtest? (-> arg0 mask) (process-mask sleep-code))
                (set! (-> arg0 status) 'suspended)
                ((-> arg0 main-thread resume-hook) (-> arg0 main-thread))
                )
+          ;;  (format 0 "Finished Code | Proc '~A' | C1: ~X C2: ~X C3: ~X~%" arg0 (-> *canary-1*) (-> *canary-2*) (-> *canary-3*))
 
 
            (cond
@@ -1608,6 +1617,7 @@
              (else
                ;; run post.
                ;; NOTE: post always runs on the dram stack, so you can use ja-post and use the scratchpad for anims.
+              ;;  (format 0 "Post | Proc '~A' | C1: ~X C2: ~X C3: ~X~%" arg0 (-> *canary-1*) (-> *canary-2*) (-> *canary-3*))
                (when (-> arg0 post-hook)
                  (let ((s4-1 (new 'process 'cpu-thread arg0 'post 256 *kernel-dram-stack*)))
                    (reset-and-call s4-1 (-> arg0 post-hook))
diff --git a/goal_src/jak2/kernel/gstate.gc b/goal_src/jak2/kernel/gstate.gc
index 788460e8a7..7fe724dc15 100644
--- a/goal_src/jak2/kernel/gstate.gc
+++ b/goal_src/jak2/kernel/gstate.gc
@@ -314,6 +314,8 @@ It type checks the arguments for the entry function.
 (defun enter-state (arg0 arg1 arg2 arg3 arg4 arg5)
   "Make the process stored in pp enter the state in pp next-state"
   (with-pp
+    (if (zero? (-> pp next-state))
+      (break!))
     ;; unsleep us
     (process-mask-clear! (-> pp mask) sleep sleep-code)
     ;; mark as going
diff --git a/goal_src/jak2/levels/castle/pad/caspad-obs.gc b/goal_src/jak2/levels/castle/pad/caspad-obs.gc
index 0cbe054f3a..64474f95ff 100644
--- a/goal_src/jak2/levels/castle/pad/caspad-obs.gc
+++ b/goal_src/jak2/levels/castle/pad/caspad-obs.gc
@@ -7,3 +7,205 @@
 
 ;; DECOMP BEGINS
 
+(deftype cpad-elevator (elevator)
+  ((sound-id sound-id  :offset-assert 368)
+   )
+  :heap-base #x100
+  :method-count-assert 50
+  :size-assert         #x174
+  :flag-assert         #x3201000174
+  (:methods
+    (cpad-elevator-method-49 (_type_ symbol) none 49)
+    )
+  )
+
+
+(defskelgroup skel-cpad-elevator cpad-elevator 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 18))
+
+(defmethod get-art-group cpad-elevator ((obj cpad-elevator))
+  "@returns The associated [[art-group]]"
+  (art-group-get-by-name *level* "skel-cpad-elevator" (the-as (pointer uint32) #f))
+  )
+
+(defmethod elevator-method-43 cpad-elevator ((obj cpad-elevator) (arg0 vector) (arg1 float) (arg2 float))
+  (let ((s4-0 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) arg1 'interp))
+        (a0-3 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) arg2 'interp))
+        (v1-3 (-> obj root-override trans))
+        )
+    (when (and (< (-> a0-3 y) (-> s4-0 y)) (< (-> arg0 y) (+ -8192.0 (-> v1-3 y))))
+      (let ((s4-2 (vector-! (new 'stack-no-clear 'vector) arg0 v1-3)))
+        (vector-inv-orient-by-quat! s4-2 s4-2 (-> obj root-override quat))
+        (and (< (fabs (-> s4-2 x)) 49152.0) (< (fabs (-> s4-2 z)) 49152.0))
+        )
+      )
+    )
+  )
+
+(defmethod elevator-method-45 cpad-elevator ((obj cpad-elevator))
+  "@returns Stub, or always returns [[#t]]"
+  (let* ((gp-0 *target*)
+         (a0-2 (if (type? gp-0 process-focusable)
+                   gp-0
+                   )
+               )
+         )
+    (when a0-2
+      (let* ((v1-1 (get-trans a0-2 0))
+             (gp-2 (vector-! (new 'stack-no-clear 'vector) v1-1 (-> obj root-override trans)))
+             )
+        (vector-inv-orient-by-quat! gp-2 gp-2 (-> obj root-override quat))
+        (and (< (fabs (-> gp-2 x)) 40960.0) (< (fabs (-> gp-2 z)) 40960.0))
+        )
+      )
+    )
+  )
+
+(defmethod cpad-elevator-method-49 cpad-elevator ((obj cpad-elevator) (arg0 symbol))
+  (let ((v1-3 (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 1)))
+    (cond
+      (arg0
+        (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle pusher))
+        (set! (-> v1-3 prim-core collide-with) (collide-spec jak player-list))
+        )
+      (else
+        (set! (-> v1-3 prim-core collide-as) (collide-spec))
+        (set! (-> v1-3 prim-core collide-with) (collide-spec))
+        0
+        )
+      )
+    )
+  (none)
+  )
+
+(defstate running (cpad-elevator)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type elevator running) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (logtest? (-> self elevator-status) (elevator-status elevator-status-0))
+      (cpad-elevator-method-49 self #t)
+      (set-setting! 'jump #f 0 0)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (sound-stop (-> self sound-id))
+    (sound-play "dig-elevate-end")
+    (let ((t9-3 (-> (method-of-type elevator running) exit)))
+      (if t9-3
+          (t9-3)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (logior! (-> self elevator-status) (elevator-status elevator-status-1))
+    (until #f
+      (sound-play "dig-elevate" :id (-> self sound-id))
+      (suspend)
+      (if (= (-> self path-pos) 1.0)
+          (logclear! (-> self elevator-status) (elevator-status elevator-status-1))
+          )
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate arrived (cpad-elevator)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type elevator arrived) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (logtest? (-> self elevator-status) (elevator-status elevator-status-0))
+      (cpad-elevator-method-49 self #f)
+      (remove-setting! 'jump)
+      )
+    (none)
+    )
+  )
+
+(defmethod elevator-method-40 cpad-elevator ((obj cpad-elevator))
+  "TODO - need to figure out some flags to be confident about this"
+  (if (task-node-closed? (game-task-node dig-knock-down-introduction))
+      (go (method-of-object obj arrived))
+      (go (method-of-object obj dormant))
+      )
+  )
+
+(defmethod deactivate cpad-elevator ((obj cpad-elevator))
+  (sound-stop (-> obj sound-id))
+  ((the-as (function elevator none) (find-parent-method cpad-elevator 10)) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch ambient-sound vs none.
+(defmethod clear-ambient-sound! cpad-elevator ((obj cpad-elevator))
+  "Might be a virtual function, but clears the object's [[ambient-sound]]"
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "cpad-elevator-l" :fo-max 70) (-> obj root-override trans))
+        )
+  (none)
+  )
+
+;; WARN: Return type mismatch sound-id vs none.
+(defmethod base-plat-method-33 cpad-elevator ((obj cpad-elevator))
+  (let ((s5-0 (+ (-> obj path curve num-cverts) -1)))
+    (calc-dist-between-points! obj 0 s5-0)
+    (calc-dist-between-points! obj s5-0 0)
+    )
+  (set! (-> obj sound-id) (new-sound-id))
+  (none)
+  )
+
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod base-plat-method-31 cpad-elevator ((obj cpad-elevator))
+  "TODO - collision stuff"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 73728.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 73728.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 3)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 73728.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-20 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-20 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-20 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  (none)
+  )
diff --git a/goal_src/jak2/levels/common/enemy/amphibian/amphibian.gc b/goal_src/jak2/levels/common/enemy/amphibian/amphibian.gc
index c19b08302d..ce24977902 100644
--- a/goal_src/jak2/levels/common/enemy/amphibian/amphibian.gc
+++ b/goal_src/jak2/levels/common/enemy/amphibian/amphibian.gc
@@ -304,7 +304,7 @@
 ;; WARN: Return type mismatch amphibian-joint-mod vs none.
 (defmethod amphibian-joint-mod-method-9 amphibian-joint-mod ((obj amphibian-joint-mod))
   (let ((v1-3 (-> obj proc node-list data (-> obj joint-index))))
-    (set! (-> v1-3 param0) (the-as (function cspace matrix none) amphibian-joint-mod-callback))
+    (set! (-> v1-3 param0) amphibian-joint-mod-callback)
     (set! (-> v1-3 param1) obj)
     )
   (none)
diff --git a/goal_src/jak2/levels/common/enemy/guards/crimson-guard-level.gc b/goal_src/jak2/levels/common/enemy/guards/crimson-guard-level.gc
index 80017be4b3..7b190266e3 100644
--- a/goal_src/jak2/levels/common/enemy/guards/crimson-guard-level.gc
+++ b/goal_src/jak2/levels/common/enemy/guards/crimson-guard-level.gc
@@ -7,3 +7,4290 @@
 
 ;; DECOMP BEGINS
 
+(define *crimson-guard-fact* (new 'static 'fact-info-enemy-defaults :idle-distance (meters 200)))
+
+(defskelgroup skel-crimson-guard-level crimson-guard 0 4
+              ((1 (meters 20)) (2 (meters 999999)))
+              :bounds (static-spherem 0 0 0 5)
+              :shadow 3
+              :origin-joint-index 3
+              )
+
+(deftype guard-level-anim-info (structure)
+  ((anim-index                int32  2 :offset-assert   0)
+   (anim-index-front          int32    :offset          0)
+   (anim-index-back           int32    :offset          4)
+   (unsigned-anim-index-front uint32   :offset          0)
+   (unsigned-anim-index-back  uint32   :offset          4)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+
+(deftype guard-level-global-info (basic)
+  ((prev-yellow-hit         int8                            :offset-assert   4)
+   (prev-blue-hit           int8                            :offset-assert   5)
+   (knocked                 guard-level-anim-info :inline   :offset-assert   8)
+   (anim-knocked-front      int32                           :offset          8)
+   (anim-knocked-back       int32                           :offset         12)
+   (knocked-land            guard-level-anim-info :inline   :offset-assert  16)
+   (anim-knocked-front-land int32                           :offset         16)
+   (anim-knocked-back-land  int32                           :offset         20)
+   (yellow-hit-anim         guard-level-anim-info 2 :inline :offset-assert  24)
+   (yellow-land-anim        guard-level-anim-info 2 :inline :offset-assert  40)
+   (blue-hit-anim           guard-level-anim-info 1 :inline :offset-assert  56)
+   )
+  :method-count-assert 9
+  :size-assert         #x40
+  :flag-assert         #x900000040
+  )
+
+
+(deftype guard-level-shoot-info (structure)
+  ((anim-index int32  :offset-assert   0)
+   (start      float  :offset-assert   4)
+   (end        float  :offset-assert   8)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #xc
+  :flag-assert         #x90000000c
+  )
+
+
+(define *crimson-guard-level-global-info*
+  (new 'static 'guard-level-global-info
+    :knocked (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 31 8))
+    :knocked-land (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 32 9))
+    :yellow-hit-anim (new 'static 'inline-array guard-level-anim-info 2
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 13 15))
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 15 13))
+      )
+    :yellow-land-anim (new 'static 'inline-array guard-level-anim-info 2
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 14 16))
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 16 14))
+      )
+    :blue-hit-anim (new 'static 'inline-array guard-level-anim-info 1
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 10 10))
+      )
+    )
+  )
+
+(define *crimson-guard-level-info* (new 'static 'nav-enemy-info
+                                     :use-die-falling #t
+                                     :use-victory #f
+                                     :use-jump-blocked #f
+                                     :debug-draw-neck #f
+                                     :jump-debug-draw #f
+                                     :move-to-ground #t
+                                     :hover-if-no-ground #f
+                                     :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+                                     :idle-anim 4
+                                     :notice-anim 7
+                                     :hostile-anim 6
+                                     :hit-anim 4
+                                     :knocked-anim 8
+                                     :knocked-land-anim 9
+                                     :die-anim 17
+                                     :die-falling-anim 39
+                                     :victory-anim 4
+                                     :jump-wind-up-anim 5
+                                     :jump-in-air-anim 5
+                                     :jump-land-anim 5
+                                     :neck-joint 6
+                                     :look-at-joint 6
+                                     :bullseye-joint 5
+                                     :sound-hit (static-sound-name "guard-hit")
+                                     :sound-die (static-sound-name "guard-die")
+                                     :notice-distance (meters 150)
+                                     :notice-distance-delta (meters 40)
+                                     :proximity-notice-distance (meters 4)
+                                     :default-hit-points 4
+                                     :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+                                     :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+                                     :penetrate-knocked #xffffffffffffffff
+                                     :movement-gravity (meters -100)
+                                     :friction 0.5
+                                     :attack-shove-back (meters 3)
+                                     :attack-shove-up (meters 2)
+                                     :attack-mode 'generic
+                                     :attack-damage 2
+                                     :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+                                     :jump-height-min (meters 3)
+                                     :jump-height-factor 0.5
+                                     :knocked-seek-ry-clamp 6371.5557
+                                     :knocked-soft-vxz-lo 32768.0
+                                     :knocked-soft-vxz-hi 53248.0
+                                     :knocked-soft-vy-lo 61440.0
+                                     :knocked-soft-vy-hi 61440.0
+                                     :knocked-medium-vxz-lo 147456.0
+                                     :knocked-medium-vxz-hi 196608.0
+                                     :knocked-medium-vy-lo 135168.0
+                                     :knocked-medium-vy-hi 151552.0
+                                     :knocked-hard-vxz-lo 40960.0
+                                     :knocked-hard-vxz-hi 61440.0
+                                     :knocked-hard-vy-lo 98304.0
+                                     :knocked-hard-vy-hi 106496.0
+                                     :knocked-huge-vxz-lo 164659.2
+                                     :knocked-huge-vxz-hi 249036.8
+                                     :knocked-huge-vy-lo 183500.8
+                                     :knocked-huge-vy-hi 217907.2
+                                     :knocked-yellow-vxz-lo 32768.0
+                                     :knocked-yellow-vxz-hi 49152.0
+                                     :knocked-yellow-vy-lo 32768.0
+                                     :knocked-yellow-vy-hi 49152.0
+                                     :knocked-red-vxz-lo 65536.0
+                                     :knocked-red-vxz-hi 81920.0
+                                     :knocked-red-vy-lo 61440.0
+                                     :knocked-red-vy-hi 61440.0
+                                     :knocked-blue-vxz-lo 32768.0
+                                     :knocked-blue-vxz-hi 65536.0
+                                     :knocked-blue-vy-lo 16384.0
+                                     :knocked-blue-vy-hi 32768.0
+                                     :shadow-size (meters 2)
+                                     :shadow-max-y (meters 1)
+                                     :shadow-min-y (meters -1)
+                                     :shadow-locus-dist (meters 150)
+                                     :gem-joint -1
+                                     :gem-offset (new 'static 'sphere :r 163840.0)
+                                     :callback-info #f
+                                     :use-momentum #f
+                                     :use-frustration #t
+                                     :use-stop-chase #f
+                                     :use-circling #f
+                                     :use-pacing #f
+                                     :walk-anim 5
+                                     :turn-anim 5
+                                     :run-anim 6
+                                     :taunt-anim -1
+                                     :run-travel-speed (meters 12)
+                                     :run-acceleration (meters 2)
+                                     :run-turning-acceleration (meters 50)
+                                     :walk-travel-speed (meters 3)
+                                     :walk-acceleration (meters 1)
+                                     :walk-turning-acceleration (meters 8)
+                                     :maximum-rotation-rate (degrees 720.0)
+                                     :notice-nav-radius (meters 5)
+                                     :frustration-distance (meters 8)
+                                     :frustration-time (seconds 2)
+                                     :blocked-time (seconds 0.3)
+                                     :circle-dist-lo 20480.0
+                                     :circle-dist-hi 61440.0
+                                     :nav-mesh #f
+                                     )
+        )
+
+(set! (-> *crimson-guard-level-info* fact-defaults) *crimson-guard-fact*)
+
+(define *crimson-guard-level-blast-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 100)
+    :notice-distance-delta (meters 3)
+    :proximity-notice-distance (meters 100)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *crimson-guard-level-blast-info* fact-defaults) *crimson-guard-fact*)
+
+(define *crimson-guard-level-grenade-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 300)
+    :notice-distance-delta (meters 300)
+    :proximity-notice-distance (meters 300)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *crimson-guard-level-grenade-info* fact-defaults) *crimson-guard-fact*)
+
+(define *crimson-guard-level-sniper-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 150)
+    :notice-distance-delta (meters 40)
+    :proximity-notice-distance (meters 60)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *crimson-guard-level-sniper-info* fact-defaults) *crimson-guard-fact*)
+
+(define *crimson-guard-level-tazer-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 100)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 100)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+(set! (-> *crimson-guard-level-tazer-info* fact-defaults) *crimson-guard-fact*)
+
+(deftype crimson-guard-level (nav-enemy)
+  ((info                    guard-level-global-info           :offset-assert 604)
+   (hit-face                uint32                            :offset-assert 608)
+   (anim-get-up-front       int32                             :offset-assert 612)
+   (anim-get-up-back        int32                             :offset-assert 616)
+   (small-hit               int32                             :offset-assert 620)
+   (yellow-anim             guard-level-anim-info   :inline   :offset-assert 624)
+   (flags                   int64                             :offset-assert 632)
+   (weapon                  int32                             :offset-assert 640)
+   (pad-kjh1n23             int32                             :offset-assert 644)
+   (last-time-see-target    int64                             :offset-assert 648)
+   (joint                   joint-mod                         :offset-assert 656)
+   (joint-enable            symbol                            :offset-assert 660)
+   (l-control               lightning-control                 :offset-assert 664)
+   (already-shot            uint32                            :offset-assert 668)
+   (miss-amount             float                             :offset-assert 672)
+   (pad-k1jh2n3             int32                             :offset-assert 676)
+   (next-shot               int64                             :offset-assert 680)
+   (anim-shoot              guard-level-shoot-info  3 :inline :offset-assert 688)
+   (target-pos              vector                  :inline   :offset-assert 736)
+   (target-pos-predict      vector                  :inline   :offset-assert 752)
+   (target-pos-predict-miss vector                  :inline   :offset-assert 768)
+   (target-vel-vec          vector                  :inline   :offset-assert 784)
+   (target-vel              float                             :offset-assert 800)
+   (target-self             vector                  :inline   :offset-assert 816)
+   (target-self-xz          vector                  :inline   :offset-assert 832)
+   (target-self-dist        float                             :offset-assert 848)
+   (target-self-xz-dist     float                             :offset-assert 852)
+   (target-y-angle          float                             :offset-assert 856)
+   (lazer-sound             sound-id                          :offset-assert 860)
+   (transport               handle                            :offset-assert 864)
+   (transport-side          uint32                            :offset-assert 872)
+   (other-side              uint32                            :offset-assert 876)
+   (start-target-pos        vector                  :inline   :offset-assert 880)
+   (start-target-vel        vector                  :inline   :offset-assert 896)
+   (trigger                 symbol                            :offset-assert 912)
+   (reachable-target-pos    vector                  :inline   :offset-assert 928)
+   )
+  :heap-base #x330
+  :method-count-assert 205
+  :size-assert         #x3b0
+  :flag-assert         #xcd033003b0
+  (:methods
+    (gun-shoot () _type_ :state 178)
+    (attack () _type_ :state 179)
+    (get-up-front () _type_ :state 180)
+    (get-up-back () _type_ :state 181)
+    (close-attack () _type_ :state 182)
+    (grenade-attack () _type_ :state 183)
+    (exit-transport () _type_ :state 184)
+    (blast-hostile () _type_ :state 185)
+    (grenade-hostile () _type_ :state 186)
+    (tazer-hostile () _type_ :state 187)
+    (roll-right () _type_ :state 188)
+    (roll-left () _type_ :state 189)
+    (arrest () _type_ :state 190)
+    (crimson-guard-level-method-191 (_type_) (pointer process) 191)
+    (crimson-guard-level-method-192 (_type_) none 192)
+    (crimson-guard-level-method-193 (_type_) symbol 193)
+    (crimson-guard-level-method-194 (_type_) symbol 194)
+    (crimson-guard-level-method-195 (_type_ vector vector vector) int 195)
+    (crimson-guard-level-method-196 (_type_ vector) none 196)
+    (crimson-guard-level-method-197 (_type_) quaternion 197)
+    (crimson-guard-level-method-198 (_type_) none 198)
+    (crimson-guard-level-method-199 (_type_ vector vector vector float) symbol 199)
+    (crimson-guard-level-method-200 (_type_) float 200)
+    (crimson-guard-level-method-201 (_type_ float) none 201)
+    (crimson-guard-level-method-202 (_type_ vector) float 202)
+    (crimson-guard-level-method-203 (_type_ int) none 203)
+    (crimson-guard-level-method-204 (_type_) none 204)
+    )
+  )
+
+
+(defmethod enemy-method-72 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (-> obj focus aware)))
+    (cond
+      ((and (= s5-0 (enemy-aware enemy-aware-3)) (enemy-method-107 obj))
+       (go-hostile obj)
+       )
+      ((and (= s5-0 (enemy-aware enemy-aware-2)) (enemy-method-107 obj))
+       (go-hostile obj)
+       )
+      ((<= (the-as int s5-0) 0)
+       (go (method-of-object obj idle))
+       )
+      ((>= 1 (the-as int s5-0))
+       (go (method-of-object obj active))
+       )
+      ((= s5-0 (enemy-aware enemy-aware-4))
+       (go-flee obj)
+       )
+      (else
+        (go-stare obj)
+        )
+      )
+    )
+  (none)
+  )
+
+(defstate active (crimson-guard-level)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (logtest? (-> self flags) 4)
+      (logior! (-> self nav state flags) (nav-state-flag at-target))
+      (let ((v1-9 self))
+        (set! (-> v1-9 enemy-flags) (the-as enemy-flag (logclear (-> v1-9 enemy-flags) (enemy-flag enemy-flag36))))
+        (set! (-> v1-9 nav callback-info) *nav-enemy-null-callback-info*)
+        )
+      0
+      (let ((v1-12 self))
+        (set! (-> v1-12 enemy-flags) (the-as enemy-flag (logclear (-> v1-12 enemy-flags) (enemy-flag enemy-flag37))))
+        )
+      0
+      )
+    (none)
+    )
+  )
+
+(defstate stare (crimson-guard-level)
+  :virtual #t
+  :trans (behavior ()
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (let ((gp-0 (-> self focus aware)))
+        (cond
+          ((>= 1 (the-as int gp-0))
+           (go-virtual active)
+           )
+          ((and (= gp-0 (enemy-aware enemy-aware-3)) (enemy-method-107 self))
+           (go-hostile self)
+           )
+          ((and (= gp-0 (enemy-aware enemy-aware-2)) (enemy-method-107 self))
+           (if (logtest? (-> self flags) 1)
+               (go-virtual arrest)
+               (go-hostile self)
+               )
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch none vs object.
+(defmethod enemy-method-74 crimson-guard-level ((obj crimson-guard-level) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (let ((v1-0 arg2))
+    (the-as
+      object
+      (cond
+        ((= v1-0 'event-death)
+         (when (<= (-> obj hit-points) 0)
+           (set! (-> obj root-override2 penetrated-by) (the-as penetrate -1))
+           (the-as object (do-effect (-> obj skel effect) 'death-default 0.0 -1))
+           )
+         )
+        ((or (= v1-0 'hit) (= v1-0 'hit-flinch) (= v1-0 'hit-knocked))
+         (speech-control-method-13 *speech-control* (the-as handle obj))
+         (let* ((s1-0 (handle->process (-> obj incoming attacker-handle)))
+                (a0-13 (if (type? s1-0 process-focusable)
+                           s1-0
+                           )
+                       )
+                )
+           (if (and a0-13 (logtest? (-> a0-13 mask) (process-mask target)))
+               (speech-control-method-12 *speech-control* obj (speech-type speech-type-0 speech-type-1 speech-type-3))
+               )
+           )
+         ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+         )
+        ((= v1-0 'trigger)
+         (let ((v0-0 (the-as object #t)))
+           (set! (-> obj trigger) (the-as symbol v0-0))
+           v0-0
+           )
+         )
+        ((= v1-0 'untrigger)
+         (set! (-> obj trigger) #f)
+         #f
+         )
+        ((= v1-0 'notify)
+         (let ((a0-21 (-> arg3 param 0))
+               (v1-16 (the-as object (-> arg3 param 1)))
+               )
+           (when (= a0-21 'attack)
+             (when (logtest? (-> (the-as process-focusable v1-16) mask) (process-mask target))
+               (if (logtest? (-> (the-as process-focusable v1-16) focus-status) (focus-status dead))
+                   (speech-control-method-12 *speech-control* obj (speech-type speech-type-1 speech-type-3))
+                   )
+               )
+             )
+           )
+         ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+         )
+        (else
+          ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+          )
+        )
+      )
+    )
+  )
+
+(defmethod crimson-guard-level-method-191 crimson-guard-level ((obj crimson-guard-level))
+  (let* ((s4-0 (-> obj target-pos-predict-miss))
+         (s5-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14)))
+         (v1-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 15)))
+         (v1-3 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) s4-0 v1-2) 1.0))
+         (s4-1 (new 'stack-no-clear 'projectile-init-by-other-params))
+         )
+    (set! (-> s4-1 ent) (-> obj entity))
+    (set! (-> s4-1 charge) 1.0)
+    (set! (-> s4-1 options) (projectile-options))
+    (set! (-> s4-1 notify-handle) (process->handle obj))
+    (set! (-> s4-1 owner-handle) (the-as handle #f))
+    (set! (-> s4-1 ignore-handle) (process->handle obj))
+    (let* ((a0-13 *game-info*)
+           (a1-12 (+ (-> a0-13 attack-id) 1))
+           )
+      (set! (-> a0-13 attack-id) a1-12)
+      (set! (-> s4-1 attack-id) a1-12)
+      )
+    (set! (-> s4-1 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+    (set! (-> s4-1 pos quad) (-> s5-0 quad))
+    (set! (-> s4-1 vel quad) (-> v1-3 quad))
+    (vector-normalize! (-> s4-1 vel) 819200.0)
+    (spawn-projectile guard-shot s4-1 obj *default-dead-pool*)
+    )
+  )
+
+(defmethod crimson-guard-level-method-195 crimson-guard-level ((obj crimson-guard-level) (arg0 vector) (arg1 vector) (arg2 vector))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s5-0 (new 'stack-no-clear 'collide-query)))
+      (let ((f0-0 1228.8)
+            (f30-0 6144.0)
+            )
+        (set! (-> s5-0 start-pos quad) (-> arg0 quad))
+        (vector-! (-> s5-0 move-dist) arg1 arg0)
+        (let ((v1-4 s5-0))
+          (set! (-> v1-4 radius) f0-0)
+          (set! (-> v1-4 collide-with) (collide-spec backgnd))
+          (set! (-> v1-4 ignore-process0) obj)
+          (set! (-> v1-4 ignore-process1) (handle->process (-> obj focus handle)))
+          (set! (-> v1-4 ignore-pat)
+                (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
+                )
+          (set! (-> v1-4 action-mask) (collide-action solid))
+          )
+        (let ((f0-1 (fill-and-probe-using-line-sphere *collide-cache* s5-0)))
+          (cond
+            ((>= f0-1 0.0)
+             (vector-float*! (-> s5-0 move-dist) (-> s5-0 move-dist) f0-1)
+             (cond
+               ((< (vector-dot
+                     (-> s5-0 best-other-tri normal)
+                     (vector-! (new 'stack-no-clear 'vector) arg2 (the-as vector (-> s5-0 best-other-tri)))
+                     )
+                   0.0
+                   )
+                (return 1)
+                )
+               (else
+                 )
+               )
+             )
+            (else
+              (vector-! (-> s5-0 move-dist) arg1 arg0)
+              )
+            )
+          )
+        (set! (-> s5-0 start-pos quad) (-> arg0 quad))
+        (let ((a0-19 (-> s5-0 start-pos)))
+          (let ((v1-15 (-> s5-0 move-dist)))
+            (let ((a1-10 -0.1))
+              (.mov vf7 a1-10)
+              )
+            (.lvf vf5 (&-> v1-15 quad))
+            )
+          (.lvf vf4 (&-> arg0 quad))
+          (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+          (.mul.x.vf acc vf5 vf7 :mask #b111)
+          (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+          (.svf (&-> a0-19 quad) vf6)
+          )
+        (let ((a1-11 (-> s5-0 move-dist)))
+          (let ((v1-16 (-> s5-0 move-dist)))
+            (let ((a0-20 (-> s5-0 move-dist)))
+              (let ((a2-4 0.1))
+                (.mov vf7 a2-4)
+                )
+              (.lvf vf5 (&-> a0-20 quad))
+              )
+            (.lvf vf4 (&-> v1-16 quad))
+            )
+          (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+          (.mul.x.vf acc vf5 vf7 :mask #b111)
+          (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+          (.svf (&-> a1-11 quad) vf6)
+          )
+        (let ((v1-17 s5-0))
+          (set! (-> v1-17 radius) f30-0)
+          (set! (-> v1-17 collide-with) (collide-spec enemy obstacle hit-by-player-list hit-by-others-list))
+          (set! (-> v1-17 ignore-process0) obj)
+          (set! (-> v1-17 ignore-process1) (handle->process (-> obj focus handle)))
+          (set! (-> v1-17 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-17 action-mask) (collide-action solid))
+          )
+        )
+      (cond
+        ((< (fill-and-probe-using-line-sphere *collide-cache* s5-0) 0.0)
+         0
+         )
+        (else
+          (let ((s4-1 (-> s5-0 best-other-tri collide-ptr)))
+            (if (and (if (type? s4-1 collide-shape-prim)
+                         s4-1
+                         )
+                     (< (vector-dot
+                          (-> s5-0 best-other-tri normal)
+                          (vector-! (new 'stack-no-clear 'vector) arg2 (the-as vector (-> s5-0 best-other-tri)))
+                          )
+                        0.0
+                        )
+                     )
+                2
+                0
+                )
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defmethod crimson-guard-level-method-193 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (get-trans obj 3))
+        (s4-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s4-0 quad) (-> obj target-pos quad))
+    (let ((s3-1 (vector-! (new 'stack-no-clear 'vector) s4-0 s5-0)))
+      (vector-normalize! s3-1 409600.0)
+      (zero? (crimson-guard-level-method-195 obj s5-0 (vector+! (new 'stack-no-clear 'vector) s5-0 s3-1) s4-0))
+      )
+    )
+  )
+
+(defmethod crimson-guard-level-method-194 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (new 'stack-no-clear 'vector)))
+    (set! (-> s5-0 quad) (-> obj target-pos-predict-miss quad))
+    (let* ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14)))
+           (a0-3 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 15)))
+           (s3-1 (vector-! (new 'stack-no-clear 'vector) s5-0 a0-3))
+           )
+      (vector-normalize! s3-1 409600.0)
+      (and (crimson-guard-level-method-193 obj)
+           (zero? (crimson-guard-level-method-195 obj s4-0 (vector+! (new 'stack-no-clear 'vector) s4-0 s3-1) s5-0))
+           )
+      )
+    )
+  )
+
+(defmethod crimson-guard-level-method-196 crimson-guard-level ((obj crimson-guard-level) (arg0 vector))
+  (local-vars
+    (sv-240 vector)
+    (sv-256 (function vector vector vector))
+    (sv-272 vector)
+    (sv-288 vector)
+    (sv-304 vector)
+    (sv-320 vector)
+    )
+  (with-pp
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (set! sv-240 arg0)
+      (let ((s0-0 (new 'stack-no-clear 'vector)))
+        (let ((v1-1 (-> obj root-override2 trans)))
+          (let ((a0-1 *y-vector*))
+            (let ((a1-2 8192.0))
+              (.mov vf7 a1-2)
+              )
+            (.lvf vf5 (&-> a0-1 quad))
+            )
+          (.lvf vf4 (&-> v1-1 quad))
+          )
+        (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+        (.mul.x.vf acc vf5 vf7 :mask #b111)
+        (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+        (.svf (&-> s0-0 quad) vf6)
+        (set! sv-320 (new 'stack-no-clear 'vector))
+        (set! sv-304 (new 'stack-no-clear 'vector))
+        (let ((s1-0 (new 'stack-no-clear 'vector))
+              (s2-0 (new 'stack-no-clear 'vector))
+              (s5-0 (new 'stack-no-clear 'vector))
+              )
+          (-> obj node-list data 4 bone transform)
+          (let ((s4-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+                (s3-0 (vector-y-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+                )
+            (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat))
+            (set! (-> s0-0 quad) (-> obj root-override2 trans quad))
+            (cond
+              ((logtest? (enemy-flag dislike-combo) (-> obj enemy-flags))
+               (let ((a1-6 s0-0))
+                 (let ((v1-14 s0-0))
+                   (let ((a0-9 s4-0))
+                     (let ((a2-1 4096.0))
+                       (.mov vf7 a2-1)
+                       )
+                     (.lvf vf5 (&-> a0-9 quad))
+                     )
+                   (.lvf vf4 (&-> v1-14 quad))
+                   )
+                 (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                 (.mul.x.vf acc vf5 vf7 :mask #b111)
+                 (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                 (.svf (&-> a1-6 quad) vf6)
+                 )
+               )
+              (else
+                (let ((a1-7 s0-0))
+                  (let ((v1-15 s0-0))
+                    (let ((a0-10 s4-0))
+                      (let ((a2-3 2048.0))
+                        (.mov vf7 a2-3)
+                        )
+                      (.lvf vf5 (&-> a0-10 quad))
+                      )
+                    (.lvf vf4 (&-> v1-15 quad))
+                    )
+                  (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                  (.mul.x.vf acc vf5 vf7 :mask #b111)
+                  (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                  (.svf (&-> a1-7 quad) vf6)
+                  )
+                )
+              )
+            (let ((a1-8 s0-0))
+              (let ((v1-16 s0-0))
+                (let ((a0-11 s3-0))
+                  (let ((a2-5 8540.16))
+                    (.mov vf7 a2-5)
+                    )
+                  (.lvf vf5 (&-> a0-11 quad))
+                  )
+                (.lvf vf4 (&-> v1-16 quad))
+                )
+              (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+              (.mul.x.vf acc vf5 vf7 :mask #b111)
+              (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+              (.svf (&-> a1-8 quad) vf6)
+              )
+            (vector-normalize! (vector-! sv-320 sv-240 s0-0) 1.0)
+            (set! sv-288 (new 'stack-no-clear 'vector))
+            (let ((v1-20 (-> sv-240 quad)))
+              (set! (-> sv-288 quad) v1-20)
+              )
+            (set! sv-256 vector-rotate90-around-y!)
+            (set! sv-272 (new 'stack-no-clear 'vector))
+            (let* ((a1-13 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) sv-288 s0-0) -2998.272))
+                   (v0-5 (sv-256 sv-272 a1-13))
+                   )
+              (vector+! sv-288 sv-288 v0-5)
+              )
+            (vector-normalize! (vector-! sv-320 sv-288 s0-0) 1.0)
+            (vector-z-quaternion! sv-304 (-> obj root-override2 quat))
+            (rot-zxy-from-vector! s2-0 sv-304)
+            (rot-zxy-from-vector! s1-0 sv-320)
+            (set! (-> s5-0 x) (fmax -14563.556 (fmin 14563.556 (deg- (-> s1-0 x) (-> s2-0 x)))))
+            (set! (-> s5-0 y) (fmax -14563.556 (fmin 14563.556 (deg- (-> s1-0 y) (-> s2-0 y)))))
+            (set! (-> s5-0 z) 0.0)
+            (let ((s2-1 (new 'stack-no-clear 'quaternion)))
+              (let ((s1-1 (new 'stack-no-clear 'quaternion)))
+                (quaternion-vector-angle! s2-1 s4-0 (-> s5-0 x))
+                (quaternion-vector-angle! s1-1 s3-0 (-> s5-0 y))
+                (quaternion*! s2-1 s1-1 s2-1)
+                )
+              (quaternion-pseudo-seek (-> obj joint quat) (-> obj joint quat) s2-1 (-> pp clock seconds-per-frame))
+              )
+            )
+          )
+        )
+      0
+      (none)
+      )
+    )
+  )
+
+(defmethod crimson-guard-level-method-197 crimson-guard-level ((obj crimson-guard-level))
+  (with-pp
+    (quaternion-pseudo-seek
+      (-> obj joint quat)
+      (-> obj joint quat)
+      *unity-quaternion*
+      (-> pp clock seconds-per-frame)
+      )
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod enemy-method-55 crimson-guard-level ((obj crimson-guard-level))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (if (-> obj joint-enable)
+      (crimson-guard-level-method-196 obj (-> obj target-pos-predict-miss))
+      (crimson-guard-level-method-197 obj)
+      )
+  (case (-> obj root-override2 cur-pat event)
+    (((pat-event melt))
+     (if (not (and (-> obj next-state) (= (-> obj next-state name) 'die)))
+         (go (method-of-object obj die))
+         )
+     )
+    )
+  (none)
+  )
+
+(defmethod crimson-guard-level-method-200 crimson-guard-level ((obj crimson-guard-level))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s5-0 (handle->process (-> obj focus handle))))
+      (when s5-0
+        (set! (-> obj target-pos quad) (-> (get-trans (the-as process-focusable s5-0) 3) quad))
+        (if (= (-> obj focus aware) (enemy-aware enemy-aware-3))
+            (cloest-point-on-mesh (-> obj nav) (-> obj reachable-target-pos) (-> obj target-pos) (the-as nav-poly #f))
+            )
+        (set! (-> obj target-vel-vec quad) (-> (the-as process-focusable s5-0) root-override transv quad))
+        (set! (-> obj target-vel) (vector-length (-> obj target-vel-vec)))
+        (let ((s5-2 (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 trans) (-> obj target-pos))))
+          (let ((f0-2 (/ (vector-length s5-2) (if (= (-> obj weapon) 3)
+                                                  90112.0
+                                                  819200.0
+                                                  )
+                         )
+                      )
+                (a1-3 (-> obj target-pos-predict))
+                )
+            (let ((v1-20 (-> obj target-pos)))
+              (let ((a0-12 (-> obj target-vel-vec)))
+                (let ((a2-1 f0-2))
+                  (.mov vf7 a2-1)
+                  )
+                (.lvf vf5 (&-> a0-12 quad))
+                )
+              (.lvf vf4 (&-> v1-20 quad))
+              )
+            (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+            (.mul.x.vf acc vf5 vf7 :mask #b111)
+            (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+            (.svf (&-> a1-3 quad) vf6)
+            )
+          (set! (-> s5-2 y) 0.0)
+          (vector-rotate90-around-y! s5-2 s5-2)
+          (if (-> obj other-side)
+              (vector-negate! s5-2 s5-2)
+              )
+          (vector-normalize! s5-2 (-> obj miss-amount))
+          (vector+! (-> obj target-pos-predict-miss) (-> obj target-pos-predict) s5-2)
+          )
+        (vector-! (-> obj target-self) (-> obj target-pos) (-> obj root-override2 trans))
+        (set! (-> obj target-self-xz quad) (-> obj target-self quad))
+        (set! (-> obj target-self-xz y) 0.0)
+        (set! (-> obj target-self-dist) (vector-length (-> obj target-self)))
+        (set! (-> obj target-self-xz-dist) (vector-length (-> obj target-self-xz)))
+        (set! (-> obj target-y-angle)
+              (deg-diff (quaternion-y-angle (-> obj root-override2 quat)) (vector-y-angle (-> obj target-self)))
+              )
+        )
+      )
+    )
+  )
+
+(defstate notice (crimson-guard-level)
+  :virtual #t
+  :enter (behavior ()
+    (talker-spawn-func (-> *talker-speech* 10) *entity-pool* (target-pos 0) (the-as region #f))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-4 (logior (-> self enemy-flags) (enemy-flag use-notice-distance))))
+      (set! (-> self enemy-flags) (logclear v1-4 (enemy-flag called-dying)))
+      )
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (enemy-method-109 self 1)
+    (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (let ((gp-1 (-> self on-notice)))
+        (if gp-1
+            (eval!
+              (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
+              (the-as pair gp-1)
+              )
+            )
+        )
+      )
+    (let ((gp-2 (-> self focus aware)))
+      (when (logtest? (-> self enemy-flags) (enemy-flag chase-startup))
+        (cond
+          ((and (= gp-2 (enemy-aware enemy-aware-3)) (enemy-method-107 self))
+           (go-hostile self)
+           )
+          ((and (= gp-2 (enemy-aware enemy-aware-2)) (enemy-method-107 self))
+           (go-hostile self)
+           )
+          ((= gp-2 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          (else
+            (go-stare self)
+            )
+          )
+        )
+      )
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-1))
+    (logior! (-> self enemy-flags) (enemy-flag chase-startup))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.075))
+    (let ((f30-0 (get-rand-float-range self 0.8 1.2))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override notice-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override notice-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (vector-! gp-0 (target-pos 0) (-> self root-override2 trans))
+        (seek-toward-heading-vec! (-> self root-override2) gp-0 131072.0 (seconds 0.05))
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (cond
+      ((logtest? (-> self flags) 2)
+       (go-virtual gun-shoot)
+       )
+      ((logtest? (-> self flags) 8)
+       (go-virtual grenade-attack)
+       )
+      (else
+        (enemy-method-72 self)
+        )
+      )
+    (none)
+    )
+  )
+
+(defstate hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (if (logtest? (-> self flags) 4)
+        (go-virtual gun-shoot)
+        )
+    (set! (-> self reaction-time) (the-as uint (the int (* 300.0 (get-rand-float-range self 1.0 3.0)))))
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (< (the-as int gp-0) 2) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (when (handle->process (-> self focus handle))
+      (if (and (< (-> self target-self-xz-dist) 12288.0)
+               (enemy-method-96 self 3640.889 #t)
+               (nav-enemy-method-158 self (-> self target-pos))
+               )
+          (go-virtual close-attack)
+          )
+      (let ((v1-31 (-> self weapon)))
+        (cond
+          ((zero? v1-31)
+           )
+          ((= v1-31 1)
+           (if (< (-> self target-self-xz-dist) 28672.0)
+               (go-virtual attack)
+               )
+           )
+          ((= v1-31 3)
+           (if (and (< (-> self target-self-xz-dist) 12288.0)
+                    (enemy-method-96 self 3640.889 #t)
+                    (nav-enemy-method-158 self (-> self target-pos))
+                    )
+               (go-virtual close-attack)
+               )
+           (if (and (< (-> self target-self-xz-dist) 573440.0) (and (< 81920.0 (-> self target-self-xz-dist))
+                                                                    (enemy-method-96 self 1820.4445 #t)
+                                                                    (crimson-guard-level-method-193 self)
+                                                                    )
+                    )
+               (go-virtual grenade-attack)
+               )
+           )
+          )
+        )
+      )
+    (let ((a0-21 (-> self nav state))
+          (v1-62 (-> self target-pos))
+          )
+      (logclear! (-> a0-21 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-21 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-21 target-post quad) (-> v1-62 quad))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+(defstate tazer-hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    ((-> (method-of-type nav-enemy hostile) enter))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self reaction-time) (the-as uint (the int (* 300.0 (get-rand-float-range self 0.5 1.5)))))
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (>= 2 (the-as int gp-0)) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (when (handle->process (-> self focus handle))
+      (if (and (< (-> self target-self-xz-dist) 12288.0)
+               (enemy-method-96 self 3640.889 #t)
+               (nav-enemy-method-158 self (-> self target-pos))
+               )
+          (go-virtual close-attack)
+          )
+      (if (< (-> self target-self-xz-dist) 28672.0)
+          (go-virtual attack)
+          )
+      )
+    (let ((a0-13 (-> self nav state))
+          (v1-38 (-> self target-pos))
+          )
+      (logclear! (-> a0-13 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-13 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-13 target-post quad) (-> v1-38 quad))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+(defstate blast-hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    ((-> (method-of-type nav-enemy hostile) enter))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (nav-enemy-method-156 self)
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (< (the-as int gp-0) 2) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (let ((a0-8 (handle->process (-> self focus handle))))
+      (when a0-8
+        (cond
+          ((and (< (-> self target-self-xz-dist) 81920.0) (= (-> self focus aware) (enemy-aware enemy-aware-3)))
+           (let ((gp-1 (-> self nav state))
+                 (v1-26 (get-trans (the-as process-focusable a0-8) 1))
+                 )
+             (logclear! (-> gp-1 flags) (nav-state-flag directional-mode))
+             (logior! (-> gp-1 flags) (nav-state-flag target-poly-dirty))
+             (set! (-> gp-1 target-post quad) (-> v1-26 quad))
+             )
+           0
+           (if (and (< (-> self target-self-xz-dist) 12288.0) (enemy-method-96 self 3640.889 #t))
+               (go-virtual close-attack)
+               )
+           )
+          (else
+            (if (logtest? (-> self nav state flags) (nav-state-flag at-target))
+                (nav-enemy-method-156 self)
+                )
+            (if (and (< (-> self target-self-xz-dist) 327680.0)
+                     (crimson-guard-level-method-193 self)
+                     (>= (- (-> self clock frame-counter) (-> self state-time)) (the int (* 300.0 (rand-vu-float-range 1.0 8.0))))
+                     )
+                (go-virtual gun-shoot)
+                )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-3))
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+(defstate grenade-hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    ((-> (method-of-type nav-enemy hostile) enter))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (nav-enemy-method-156 self)
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (< (the-as int gp-0) 2) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (let ((a0-8 (handle->process (-> self focus handle))))
+      (when a0-8
+        (cond
+          ((and (< (-> self target-self-xz-dist) 81920.0) (= (-> self focus aware) (enemy-aware enemy-aware-3)))
+           (let ((gp-1 (-> self nav state))
+                 (v1-26 (get-trans (the-as process-focusable a0-8) 1))
+                 )
+             (logclear! (-> gp-1 flags) (nav-state-flag directional-mode))
+             (logior! (-> gp-1 flags) (nav-state-flag target-poly-dirty))
+             (set! (-> gp-1 target-post quad) (-> v1-26 quad))
+             )
+           0
+           (if (and (< (-> self target-self-xz-dist) 12288.0) (enemy-method-96 self 3640.889 #t))
+               (go-virtual close-attack)
+               )
+           )
+          (else
+            (if (or (and (logtest? (-> self nav state flags) (nav-state-flag at-target))
+                         (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+                         )
+                    (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+                    )
+                (go-virtual grenade-attack)
+                )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-3))
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+(defstate arrest (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (nav-enemy-method-167 self)
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-4 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-7 self))
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (vector-reset! (-> self root-override2 transv))
+    (let ((a0-9 (-> self nav state))
+          (v1-12 *null-vector*)
+          )
+      (set! (-> a0-9 velocity quad) (-> v1-12 quad))
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self last-time-see-target) (the-as int (-> self clock frame-counter)))
+    (set! (-> self miss-amount) 0.0)
+    (set! (-> self next-shot) (the-as int (-> self clock frame-counter)))
+    (set! (-> self joint-enable) #t)
+    (set! (-> self reaction-time) (the-as uint (the int (* 300.0 (get-rand-float-range self 3.0 5.0)))))
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self joint-enable) #f)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (let ((v1-2 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((< (the-as int v1-2) 2)
+           (go-stare self)
+           )
+          ((= v1-2 (enemy-aware enemy-aware-3))
+           (go-hostile self)
+           )
+          ((= v1-2 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-2 speech-type-3))
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (ja-no-eval :group! (-> self draw art-group data 19)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 19)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (until #f
+      (if (or (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+              (< 10922.667 (fabs (-> self target-y-angle)))
+              )
+          (goto cfg-13)
+          )
+      (ja-no-eval :group! (-> self draw art-group data 20)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 20)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (label cfg-13)
+    (let ((f30-1 (get-rand-float-range self 0.9 1.1)))
+      (ja-channel-push! 1 (seconds 0.2))
+      (ja-no-eval :group! (-> self draw art-group data 24)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 24)) frames num-frames) -1))
+                    f30-1
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-1))
+        )
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+(defstate gun-shoot (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self other-side) (the-as uint (if (< (rand-vu) 0.5)
+                                                #t
+                                                #f
+                                                )
+                                       )
+          )
+    (nav-enemy-method-166 self)
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-4 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-7 self))
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (let ((v1-10 (-> self nav state)))
+      (set! (-> v1-10 speed) 0.0)
+      )
+    0
+    (let ((a0-8 (-> self nav state))
+          (v1-13 *null-vector*)
+          )
+      (set! (-> a0-8 velocity quad) (-> v1-13 quad))
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self last-time-see-target) (the-as int (-> self clock frame-counter)))
+    (crimson-guard-level-method-200 self)
+    (if (logtest? (-> self flags) 4)
+        (set! (-> self miss-amount) 16384.0)
+        (set! (-> self miss-amount) (lerp-scale 0.0 16384.0 (-> self target-self-dist) 40960.0 122880.0))
+        )
+    (set! (-> self next-shot) (the-as int (-> self clock frame-counter)))
+    (set! (-> self joint-enable) #t)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self joint-enable) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (let ((v1-4 (handle->process (-> self focus handle))))
+      (when v1-4
+        (when (not (and v1-4
+                        (zero? (logand (-> (the-as process-focusable v1-4) focus-status) (focus-status disable dead ignore grabbed)))
+                        )
+                   )
+          (if (logtest? (-> self flags) 4)
+              (set! (-> self miss-amount) 16384.0)
+              (set! (-> self miss-amount) (lerp-scale 0.0 16384.0 (-> self target-self-dist) 40960.0 122880.0))
+              )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-48 object))
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (ja-no-eval :group! (-> self draw art-group data (-> self anim-shoot 0 anim-index))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-shoot 0 anim-index))) frames num-frames)
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (let ((v1-31 (handle->process (-> self focus handle))))
+      (when v1-31
+        (set! (-> self start-target-pos quad) (-> (the-as process-drawable v1-31) root trans quad))
+        (set! (-> self start-target-vel quad) (-> (the-as process-drawable v1-31) root transv quad))
+        )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (label cfg-10)
+    (when (crimson-guard-level-method-194 self)
+      (when (or (not (logtest? (-> self flags) 256)) (and (logtest? (-> self flags) 256) (-> self trigger)))
+        (set! v1-48 #t)
+        (goto cfg-23)
+        )
+      )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+      (set! v1-48 #f)
+      (goto cfg-23)
+      )
+    (suspend)
+    (b! (not #f) cfg-10 :delay (set! v1-48 #f))
+    (label cfg-23)
+    (when v1-48
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (let ((gp-0 3))
+        (until #f
+          (ja-channel-push! 1 (seconds 0.1))
+          (ja-no-eval :group! (-> self draw art-group data (-> self anim-shoot 1 anim-index)) :num! min)
+          (set! (-> self already-shot) (the-as uint #t))
+          (let ((f0-7 (lerp-scale 1.0 0.2 (-> self target-self-dist) 81920.0 327680.0)))
+            (cond
+              ((logtest? (-> self flags) 4)
+               (if (< (-> self target-vel) 40.96)
+                   (set! (-> self miss-amount) (+ -12288.0 (-> self miss-amount)))
+                   )
+               )
+              ((logtest? (-> self draw status) (draw-control-status on-screen))
+               (when (handle->process (-> self focus handle))
+                 (if (< (-> self target-vel) 40.96)
+                     (set! (-> self miss-amount) (- (-> self miss-amount) (* 12288.0 f0-7)))
+                     (set! (-> self miss-amount) (- (-> self miss-amount) (* 4096.0 f0-7)))
+                     )
+                 )
+               )
+              (else
+                (set! (-> self miss-amount) (- (-> self miss-amount) (* 3276.8 f0-7)))
+                )
+              )
+            )
+          (if (< (-> self miss-amount) 0.0)
+              (set! (-> self miss-amount) 0.0)
+              )
+          (if (= gp-0 3)
+              (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-3))
+              )
+          (crimson-guard-level-method-191 self)
+          (until (ja-done? 0)
+            (ja :num! (seek!))
+            (suspend)
+            )
+          (when (logtest? (-> self flags) 4)
+            (let ((s5-1 (-> self clock frame-counter)))
+              (until (>= (- (-> self clock frame-counter) s5-1) (seconds 1))
+                (suspend)
+                )
+              )
+            (until (crimson-guard-level-method-194 self)
+              (suspend)
+              )
+            )
+          (+! gp-0 -1)
+          (if (< gp-0 0)
+              (goto cfg-57)
+              )
+          )
+        )
+      #f
+      )
+    (label cfg-57)
+    (let ((f30-1 (get-rand-float-range self 0.9 1.1)))
+      (ja-channel-push! 1 (seconds 0.2))
+      (ja-no-eval :group! (-> self draw art-group data (-> self anim-shoot 2 anim-index))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-shoot 2 anim-index))) frames num-frames)
+                            -1
+                            )
+                         )
+                    f30-1
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-1))
+        )
+      )
+    (if (logtest? (-> self flags) 2)
+        (crimson-guard-level-method-204 self)
+        )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+(defmethod crimson-guard-level-method-199 crimson-guard-level ((obj crimson-guard-level) (arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
+  (local-vars (sv-672 vector) (sv-688 vector) (sv-704 vector) (sv-720 vector))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s4-0 (new 'stack-no-clear 'vector)))
+      (set! (-> s4-0 quad) (-> arg0 quad))
+      (let ((s3-0 (new 'stack-no-clear 'vector)))
+        (set! (-> s3-0 quad) (-> arg1 quad))
+        (vector-length arg1)
+        (let ((s2-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s2-0 quad) (-> arg2 quad))
+          (let ((s1-0 (new 'stack-no-clear 'collide-query)))
+            (dotimes (s0-0 6)
+              (cond
+                (arg3
+                  (let ((v1-5 s1-0))
+                    (set! (-> v1-5 radius) 4096.0)
+                    (set! (-> v1-5 collide-with) (collide-spec backgnd obstacle))
+                    (set! (-> v1-5 ignore-process0) #f)
+                    (set! (-> v1-5 ignore-process1) #f)
+                    (set! (-> v1-5 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                    (set! (-> v1-5 action-mask) (collide-action solid))
+                    )
+                  )
+                (else
+                  (let ((v1-6 s1-0))
+                    (set! (-> v1-6 radius) 4096.0)
+                    (set! (-> v1-6 collide-with) (collide-spec jak hit-by-others-list player-list))
+                    (set! (-> v1-6 ignore-process0) #f)
+                    (set! (-> v1-6 ignore-process1) #f)
+                    (set! (-> v1-6 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                    (set! (-> v1-6 action-mask) (collide-action solid))
+                    )
+                  )
+                )
+              (set! (-> s1-0 start-pos quad) (-> s4-0 quad))
+              (set! (-> s1-0 move-dist quad) (-> s3-0 quad))
+              (set-from-point-offset-pad! (-> s1-0 bbox) (-> s1-0 start-pos) (-> s1-0 move-dist) (-> s1-0 radius))
+              (fill-using-bounding-box *collide-cache* s1-0)
+              (set! (-> s1-0 start-pos quad) (-> s4-0 quad))
+              (set! (-> s1-0 move-dist quad) (-> s3-0 quad))
+              (set! (-> s1-0 radius) 409.6)
+              (let ((f0-5 (probe-using-line-sphere *collide-cache* s1-0)))
+                (cond
+                  ((>= f0-5 0.0)
+                   (set! sv-672 (new 'stack-no-clear 'vector))
+                   (let ((v1-16 (-> s1-0 start-pos)))
+                     (let ((a0-20 (-> s1-0 move-dist)))
+                       (let ((a1-4 f0-5))
+                         (.mov vf7 a1-4)
+                         )
+                       (.lvf vf5 (&-> a0-20 quad))
+                       )
+                     (.lvf vf4 (&-> v1-16 quad))
+                     )
+                   (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                   (.mul.x.vf acc vf5 vf7 :mask #b111)
+                   (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                   (.svf (&-> sv-672 quad) vf6)
+                   (set! sv-688 (new 'stack-no-clear 'vector))
+                   (set! (-> s4-0 quad) (-> sv-672 quad))
+                   (+! (-> sv-672 x) (rand-vu-float-range -819.2 819.2))
+                   (+! (-> sv-672 y) (rand-vu-float-range -819.2 819.2))
+                   (+! (-> sv-672 z) (rand-vu-float-range -819.2 819.2))
+                   (set-point! (-> obj l-control) (-> obj l-control state points-to-draw) sv-672)
+                   (+! (-> obj l-control state points-to-draw) 1)
+                   (quaternion-from-two-vectors! (the-as quaternion sv-688) s2-0 (-> s1-0 best-other-tri normal))
+                   (vector-orient-by-quat! s3-0 s3-0 (the-as quaternion sv-688))
+                   (set! (-> s2-0 quad) (-> s1-0 best-other-tri normal quad))
+                   (vector-flatten! s3-0 s3-0 (-> s1-0 best-other-tri normal))
+                   )
+                  (else
+                    (vector+! (-> s1-0 start-pos) s4-0 s3-0)
+                    (let ((a1-14 (-> s1-0 start-pos)))
+                      (let ((v1-33 (-> s1-0 start-pos)))
+                        (let ((a0-35 s2-0))
+                          (let ((a2-7 -2048.0))
+                            (.mov vf7 a2-7)
+                            )
+                          (.lvf vf5 (&-> a0-35 quad))
+                          )
+                        (.lvf vf4 (&-> v1-33 quad))
+                        )
+                      (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                      (.mul.x.vf acc vf5 vf7 :mask #b111)
+                      (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                      (.svf (&-> a1-14 quad) vf6)
+                      )
+                    (vector-negate! (-> s1-0 move-dist) s3-0)
+                    (set! (-> s1-0 radius) 409.6)
+                    (let ((f0-14 (probe-using-line-sphere *collide-cache* s1-0)))
+                      (cond
+                        ((>= f0-14 0.0)
+                         (set! sv-704 (new 'stack-no-clear 'vector))
+                         (let ((v1-37 (-> s1-0 start-pos)))
+                           (let ((a0-38 (-> s1-0 move-dist)))
+                             (let ((a1-17 f0-14))
+                               (.mov vf7 a1-17)
+                               )
+                             (.lvf vf5 (&-> a0-38 quad))
+                             )
+                           (.lvf vf4 (&-> v1-37 quad))
+                           )
+                         (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                         (.mul.x.vf acc vf5 vf7 :mask #b111)
+                         (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                         (.svf (&-> sv-704 quad) vf6)
+                         (set! sv-720 (new 'stack-no-clear 'vector))
+                         (let ((a1-18 sv-704))
+                           (let ((v1-40 sv-704))
+                             (let ((a0-39 s2-0))
+                               (let ((a2-9 2048.0))
+                                 (.mov vf7 a2-9)
+                                 )
+                               (.lvf vf5 (&-> a0-39 quad))
+                               )
+                             (.lvf vf4 (&-> v1-40 quad))
+                             )
+                           (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                           (.mul.x.vf acc vf5 vf7 :mask #b111)
+                           (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                           (.svf (&-> a1-18 quad) vf6)
+                           )
+                         (set! (-> s4-0 quad) (-> sv-704 quad))
+                         (+! (-> sv-704 x) (rand-vu-float-range -819.2 819.2))
+                         (+! (-> sv-704 y) (rand-vu-float-range -819.2 819.2))
+                         (+! (-> sv-704 z) (rand-vu-float-range -819.2 819.2))
+                         (set-point! (-> obj l-control) (-> obj l-control state points-to-draw) sv-704)
+                         (+! (-> obj l-control state points-to-draw) 1)
+                         (quaternion-from-two-vectors! (the-as quaternion sv-720) s2-0 (-> s1-0 best-other-tri normal))
+                         (vector-orient-by-quat! s3-0 s3-0 (the-as quaternion sv-720))
+                         (set! (-> s2-0 quad) (-> s1-0 best-other-tri normal quad))
+                         (vector-flatten! s3-0 s3-0 (-> s1-0 best-other-tri normal))
+                         )
+                        (else
+                          (vector+! s4-0 s4-0 s3-0)
+                          (when (< s0-0 6)
+                            (set-point! (-> obj l-control) (-> obj l-control state points-to-draw) s4-0)
+                            (+! (-> obj l-control state points-to-draw) 1)
+                            )
+                          )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    #f
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod crimson-guard-level-method-198 crimson-guard-level ((obj crimson-guard-level))
+  (local-vars (sv-784 vector))
+  (with-pp
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (let* ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14)))
+             (v0-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 15)))
+             (s2-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) s4-0 v0-1) 16384.0))
+             (s1-0
+               (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> obj target-pos-predict-miss) s4-0) 16384.0)
+               )
+             (s5-0 (new 'stack-no-clear 'vector))
+             (s3-0 (new 'stack-no-clear 'collide-query))
+             )
+        (when (< 1820.4445 (vector-vector-angle-safe s2-0 s1-0))
+          (let* ((a1-9 (vector-normalize! (vector-cross! (new 'stack-no-clear 'vector) s2-0 s1-0) 1.0))
+                 (a2-1 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) a1-9 1820.4445))
+                 )
+            (vector-orient-by-quat! s1-0 s2-0 a2-1)
+            )
+          )
+        (let ((a0-12 s4-0))
+          (let ((v1-8 s4-0))
+            (let ((a1-12 0.2))
+              (.mov vf7 a1-12)
+              )
+            (.lvf vf5 (&-> s2-0 quad))
+            (.lvf vf4 (&-> v1-8 quad))
+            )
+          (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+          (.mul.x.vf acc vf5 vf7 :mask #b111)
+          (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+          (.svf (&-> a0-12 quad) vf6)
+          )
+        (vector+! s5-0 s4-0 s1-0)
+        (let ((v1-10 s3-0))
+          (set! (-> v1-10 radius) 409.6)
+          (set! (-> v1-10 collide-with) (collide-spec backgnd jak bot obstacle hit-by-others-list player-list))
+          (set! (-> v1-10 ignore-process0) #f)
+          (set! (-> v1-10 ignore-process1) #f)
+          (set! (-> v1-10 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-10 action-mask) (collide-action solid))
+          )
+        (set! (-> s3-0 start-pos quad) (-> s4-0 quad))
+        (set! (-> s3-0 move-dist quad) (-> s1-0 quad))
+        (set! (-> s3-0 ignore-process0) #f)
+        (set! (-> s3-0 ignore-process1) #f)
+        (set! (-> s3-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (fill-using-line-sphere *collide-cache* s3-0)
+        (set! (-> obj l-control state points-to-draw) 0)
+        (let ((f0-3 (probe-using-line-sphere *collide-cache* s3-0))
+              (s2-1 (new 'stack-no-clear 'vector))
+              )
+          (cond
+            ((>= f0-3 0.0)
+             (vector-float*! s1-0 (-> s3-0 move-dist) f0-3)
+             (vector+! s5-0 s4-0 s1-0)
+             (point-in-plane-<-point+normal! s2-1 s5-0 (-> s3-0 best-other-tri normal))
+             (vector-! s2-1 s2-1 s5-0)
+             (let ((s1-1 quaternion-vector-angle!)
+                   (s0-0 (new 'stack-no-clear 'quaternion))
+                   )
+               (set! sv-784 (-> s3-0 best-other-tri normal))
+               (let* ((a2-3 (rand-vu-float-range 0.0 65536.0))
+                      (a2-4 (s1-1 s0-0 sv-784 a2-3))
+                      )
+                 (vector-orient-by-quat! s2-1 s2-1 a2-4)
+                 )
+               )
+             (let ((s1-2 (get-process *default-dead-pool* part-tracker #x4000)))
+               (when s1-2
+                 (let ((t9-15 (method-of-type part-tracker activate)))
+                   (t9-15 (the-as part-tracker s1-2) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                   )
+                 (let ((t9-16 run-function-in-process)
+                       (a0-34 s1-2)
+                       (a1-25 part-tracker-init)
+                       (a2-9 (-> *part-group-id-table* 140))
+                       (a3-1 0)
+                       (t0-0 #f)
+                       (t1-0 #f)
+                       (t2-0 #f)
+                       (t3-0 *launch-matrix*)
+                       )
+                   (set! (-> t3-0 trans quad) (-> s4-0 quad))
+                   ((the-as (function object object object object object object object object none) t9-16)
+                    a0-34
+                    a1-25
+                    a2-9
+                    a3-1
+                    t0-0
+                    t1-0
+                    t2-0
+                    t3-0
+                    )
+                   )
+                 (-> s1-2 ppointer)
+                 )
+               )
+             (let ((s1-3 (get-process *default-dead-pool* part-tracker #x4000)))
+               (when s1-3
+                 (let ((t9-18 (method-of-type part-tracker activate)))
+                   (t9-18 (the-as part-tracker s1-3) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                   )
+                 (let ((t9-19 run-function-in-process)
+                       (a0-37 s1-3)
+                       (a1-28 part-tracker-init)
+                       (a2-14 (-> *part-group-id-table* 140))
+                       (a3-3 0)
+                       (t0-1 #f)
+                       (t1-1 #f)
+                       (t2-1 #f)
+                       (t3-1 *launch-matrix*)
+                       )
+                   (set! (-> t3-1 trans quad) (-> s5-0 quad))
+                   ((the-as (function object object object object object object object object none) t9-19)
+                    a0-37
+                    a1-28
+                    a2-14
+                    a3-3
+                    t0-1
+                    t1-1
+                    t2-1
+                    t3-1
+                    )
+                   )
+                 (-> s1-3 ppointer)
+                 )
+               )
+             (set-point! (-> obj l-control) 0 s4-0)
+             (set-point! (-> obj l-control) 1 s5-0)
+             (set! (-> obj l-control spec) (-> *lightning-spec-id-table* 13))
+             (+! (-> obj l-control state points-to-draw) 2)
+             (let* ((s4-1 (-> s3-0 best-other-tri collide-ptr))
+                    (v1-45 (if (type? s4-1 collide-shape-prim)
+                               (the-as collide-shape-prim s4-1)
+                               )
+                           )
+                    (s4-2 #t)
+                    )
+               (when v1-45
+                 (set! s4-2 #f)
+                 (when (logtest? (-> v1-45 prim-core collide-as) (collide-spec jak bot))
+                   (let ((a1-32 (new 'stack-no-clear 'event-message-block)))
+                     (set! (-> a1-32 from) (process->ppointer pp))
+                     (set! (-> a1-32 num-params) 2)
+                     (set! (-> a1-32 message) 'attack)
+                     (set! (-> a1-32 param 0) (the-as uint #f))
+                     (let ((a0-50 (new 'static 'attack-info :mask (attack-info-mask mode id))))
+                       (let* ((a2-18 *game-info*)
+                              (a3-5 (+ (-> a2-18 attack-id) 1))
+                              )
+                         (set! (-> a2-18 attack-id) a3-5)
+                         (set! (-> a0-50 id) a3-5)
+                         )
+                       (set! (-> a0-50 mode) 'shock)
+                       (set! (-> a1-32 param 1) (the-as uint a0-50))
+                       )
+                     (send-event-function (-> v1-45 cshape process) a1-32)
+                     )
+                   )
+                 )
+               (crimson-guard-level-method-199 obj s5-0 s2-1 (-> s3-0 best-other-tri normal) (the-as float s4-2))
+               )
+             )
+            (else
+              (let ((s3-1 (get-process *default-dead-pool* part-tracker #x4000)))
+                (when s3-1
+                  (let ((t9-26 (method-of-type part-tracker activate)))
+                    (t9-26 (the-as part-tracker s3-1) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                    )
+                  (let ((t9-27 run-function-in-process)
+                        (a0-56 s3-1)
+                        (a1-36 part-tracker-init)
+                        (a2-25 (-> *part-group-id-table* 140))
+                        (a3-8 0)
+                        (t0-3 #f)
+                        (t1-2 #f)
+                        (t2-2 #f)
+                        (t3-2 *launch-matrix*)
+                        )
+                    (set! (-> t3-2 trans quad) (-> s4-0 quad))
+                    ((the-as (function object object object object object object object object none) t9-27)
+                     a0-56
+                     a1-36
+                     a2-25
+                     a3-8
+                     t0-3
+                     t1-2
+                     t2-2
+                     t3-2
+                     )
+                    )
+                  (-> s3-1 ppointer)
+                  )
+                )
+              (let ((s3-2 (get-process *default-dead-pool* part-tracker #x4000)))
+                (when s3-2
+                  (let ((t9-29 (method-of-type part-tracker activate)))
+                    (t9-29 (the-as part-tracker s3-2) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                    )
+                  (let ((t9-30 run-function-in-process)
+                        (a0-59 s3-2)
+                        (a1-39 part-tracker-init)
+                        (a2-30 (-> *part-group-id-table* 140))
+                        (a3-10 0)
+                        (t0-4 #f)
+                        (t1-3 #f)
+                        (t2-3 #f)
+                        (t3-3 *launch-matrix*)
+                        )
+                    (set! (-> t3-3 trans quad) (-> s5-0 quad))
+                    ((the-as (function object object object object object object object object none) t9-30)
+                     a0-59
+                     a1-39
+                     a2-30
+                     a3-10
+                     t0-4
+                     t1-3
+                     t2-3
+                     t3-3
+                     )
+                    )
+                  (-> s3-2 ppointer)
+                  )
+                )
+              (set! (-> obj l-control state points-to-draw) 9)
+              (set! (-> obj l-control spec) (-> *lightning-spec-id-table* 14))
+              (let ((v1-67 s4-0))
+                (set! (-> obj l-control state meet data 0 quad) (-> v1-67 quad))
+                )
+              (let ((a0-65 (-> obj l-control))
+                    (v1-69 s5-0)
+                    )
+                (set! (-> a0-65 state meet data (+ (-> a0-65 state points-to-draw) -1) quad) (-> v1-69 quad))
+                )
+              )
+            )
+          )
+        )
+      (none)
+      )
+    )
+  )
+
+(defstate close-attack (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 3)))
+      (logior! (-> v1-3 prim-core action) (collide-action deadly))
+      )
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-8 *game-info*)
+           (a0-4 (+ (-> v1-8 attack-id) 1))
+           )
+      (set! (-> v1-8 attack-id) a0-4)
+      (set! (-> self attack-id) a0-4)
+      )
+    (let ((v1-9 (-> self nav)))
+      (set! (-> v1-9 target-speed) 0.0)
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 3)))
+      (logclear! (-> v1-3 prim-core action) (collide-action deadly))
+      )
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data 18)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 18)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+(defmethod crimson-guard-level-method-192 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14))))
+    (new 'stack-no-clear 'vector)
+    (let ((s5-0 (new 'stack-no-clear 'traj3d-params)))
+      (let ((s3-1 (vector-! (new 'stack-no-clear 'vector) (-> obj target-pos-predict) s4-0)))
+        (set! (-> s3-1 y) 0.0)
+        (vector-rotate-around-y! s3-1 s3-1 (* 182.04445 (+ (if (zero? (rand-vu-int-count 2))
+                                                               90.0
+                                                               -90.0
+                                                               )
+                                                           (rand-vu-float-range -45.0 45.0)
+                                                           )
+                                              )
+                                 )
+        (if (logtest? (-> obj draw status) (draw-control-status on-screen))
+            (vector-normalize! s3-1 (* 4096.0 (rand-vu-float-range 1.0 4.0)))
+            (vector-normalize! s3-1 (* 4096.0 (rand-vu-float-range 4.0 15.0)))
+            )
+        (set! (-> s5-0 dest quad) (-> (vector+! (new 'stack-no-clear 'vector) s3-1 (-> obj target-pos-predict)) quad))
+        )
+      (set! (-> s5-0 src quad) (-> s4-0 quad))
+      (set! (-> s5-0 initial-tilt) 8192.0)
+      (set! (-> s5-0 gravity) 184320.0)
+      (when (traj3d-calc-initial-velocity-using-tilt s5-0)
+        (let ((a1-9 (new 'stack-no-clear 'projectile-init-by-other-params)))
+          (set! (-> a1-9 ent) (-> obj entity))
+          (set! (-> a1-9 charge) 1.0)
+          (set! (-> a1-9 options) (projectile-options))
+          (set! (-> a1-9 pos quad) (-> s5-0 src quad))
+          (set! (-> a1-9 vel quad) (-> s5-0 initial-velocity quad))
+          (set! (-> a1-9 notify-handle) (the-as handle #f))
+          (set! (-> a1-9 owner-handle) (the-as handle #f))
+          (set! (-> a1-9 ignore-handle) (process->handle obj))
+          (let* ((v1-24 *game-info*)
+                 (a0-23 (+ (-> v1-24 attack-id) 1))
+                 )
+            (set! (-> v1-24 attack-id) a0-23)
+            (set! (-> a1-9 attack-id) a0-23)
+            )
+          (set! (-> a1-9 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+          (spawn-projectile vehicle-grenade a1-9 obj *default-dead-pool*)
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defstate grenade-attack (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (let ((v1-6 self))
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logclear (-> v1-6 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-6 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-9 (-> self nav)))
+      (set! (-> v1-9 target-speed) 0.0)
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data 37)
+                :num! (seek! (ja-aframe 12.0 0))
+                :frame-num (ja-aframe 1.0 0)
+                )
+    (until (ja-done? 0)
+      (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+      (suspend)
+      (ja :num! (seek! (ja-aframe 12.0 0)))
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (the int (* 900.0 (you-suck-scale *game-info* #f))))
+        (ja-no-eval :group! (-> self draw art-group data 37)
+                    :num! (seek! (ja-aframe 12.0 0))
+                    :frame-num (ja-aframe 12.0 0)
+                    )
+        (until (ja-done? 0)
+          (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+          (suspend)
+          (ja :num! (seek! (ja-aframe 12.0 0)))
+          )
+        (if (and (< (-> self target-self-xz-dist) 81920.0) (= (-> self focus aware) (enemy-aware enemy-aware-3)))
+            (go-hostile self)
+            )
+        (suspend)
+        )
+      )
+    (crimson-guard-level-method-192 self)
+    (ja-no-eval :group! (-> self draw art-group data 37)
+                :num! (seek! (ja-aframe 32.0 0))
+                :frame-num (ja-aframe 22.0 0)
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! (ja-aframe 32.0 0)))
+      )
+    (ja-no-eval :group! (-> self draw art-group data 37)
+                :num! (seek! (ja-aframe 37.0 0))
+                :frame-num (ja-aframe 33.0 0)
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! (ja-aframe 37.0 0)))
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+(defstate attack (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self joint-enable) #t)
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-5 *game-info*)
+           (a0-2 (+ (-> v1-5 attack-id) 1))
+           )
+      (set! (-> v1-5 attack-id) a0-2)
+      (set! (-> self attack-id) a0-2)
+      )
+    (let ((v1-6 self))
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logclear (-> v1-6 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-6 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-9 self))
+      (set! (-> v1-9 enemy-flags) (the-as enemy-flag (logclear (-> v1-9 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (set! (-> self miss-amount) 0.0)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self next-shot) (the-as int (-> self clock frame-counter)))
+    (set! (-> self lazer-sound) (new 'static 'sound-id))
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (if (nonzero? (-> self lazer-sound))
+        (sound-stop (-> self lazer-sound))
+        )
+    (let ((v1-6 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 2)))
+      (logclear! (-> v1-6 prim-core action) (collide-action deadly))
+      )
+    (let ((v1-10 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 3)))
+      (logclear! (-> v1-10 prim-core action) (collide-action deadly))
+      )
+    (let ((v1-11 (-> self l-control))
+          (a0-5 0)
+          )
+      (let ((a1-3 (!= a0-5 (-> v1-11 state mode))))
+        (case a0-5
+          ((3)
+           (if a1-3
+               (set! (-> v1-11 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-11 state start-color) (-> v1-11 spec start-color))
+           (set! (-> v1-11 state end-color) (-> v1-11 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-11 state mode) (the-as lightning-mode a0-5))
+      )
+    (set! (-> self joint-enable) #f)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+             (< 32768.0 (-> self target-self-xz-dist))
+             )
+        (go-hostile self)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-69 symbol))
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data 19) :num! (seek! (ja-aframe 7.0 0)) :frame-num 0.0)
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! (ja-aframe 7.0 0)))
+      )
+    (until #f
+      (let ((gp-2 #t))
+        (while (or (< 5461.3335 (fabs (-> self target-y-angle))) (>= (-> self next-shot) (-> self clock frame-counter)))
+          (when gp-2
+            (ja-channel-push! 1 (seconds 0.1))
+            (set! gp-2 #f)
+            )
+          (cond
+            ((< 5461.3335 (fabs (-> self target-y-angle)))
+             (ja-no-eval :group! (-> self draw art-group data 25)
+                         :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 25)) frames num-frames) -1)))
+                         :frame-num 0.0
+                         )
+             (until (ja-done? 0)
+               (if (< 5461.3335 (fabs (-> self target-y-angle)))
+                   (seek-to-point-toward-point!
+                     (-> self root-override2)
+                     (-> self target-pos)
+                     (-> self nav max-rotation-rate)
+                     (seconds 0.2)
+                     )
+                   )
+               (suspend)
+               (ja :num! (seek!))
+               )
+             )
+            (else
+              (ja-no-eval :group! (-> self draw art-group data 20)
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 20)) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until v1-69
+                (suspend)
+                (ja :num! (seek!))
+                (set! v1-69
+                      (or (ja-done? 0) (< (-> self target-self-xz-dist) 16384.0) (< 5461.3335 (fabs (-> self target-y-angle))))
+                      )
+                )
+              )
+            )
+          (when (< (-> self target-self-xz-dist) 16384.0)
+            (set! (-> self next-shot) 0)
+            0
+            )
+          )
+        )
+      (cond
+        ((and (crimson-guard-level-method-193 self)
+              (handle->process (-> self focus handle))
+              (zero? (logand (-> (the-as process-focusable (handle->process (-> self focus handle))) focus-status)
+                             (focus-status disable dead ignore grabbed)
+                             )
+                     )
+              )
+         (cond
+           ((< (-> self target-self-xz-dist) 16384.0)
+            (go-virtual close-attack)
+            )
+           (else
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja-no-eval :group! (-> self draw art-group data 21)
+                         :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 21)) frames num-frames) -1)))
+                         :frame-num 0.0
+                         )
+             (until (ja-done? 0)
+               (suspend)
+               (ja :num! (seek!))
+               )
+             (set! (-> self next-shot) (the-as int (+ (-> self clock frame-counter) (seconds 1))))
+             (let ((v1-124 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 2)))
+               (logior! (-> v1-124 prim-core action) (collide-action deadly))
+               )
+             (let* ((v1-125 *game-info*)
+                    (a0-34 (+ (-> v1-125 attack-id) 1))
+                    )
+               (set! (-> v1-125 attack-id) a0-34)
+               (set! (-> self attack-id) a0-34)
+               )
+             (set! (-> self lazer-sound) (sound-play "guard-zap"))
+             (let ((v1-127 (-> self l-control))
+                   (a0-38 1)
+                   )
+               (let ((a1-21 (!= a0-38 (-> v1-127 state mode))))
+                 (case a0-38
+                   ((3)
+                    (if a1-21
+                        (set! (-> v1-127 state counter) 0.0)
+                        )
+                    )
+                   ((1)
+                    (set! (-> v1-127 state start-color) (-> v1-127 spec start-color))
+                    (set! (-> v1-127 state end-color) (-> v1-127 spec end-color))
+                    )
+                   )
+                 )
+               (set! (-> v1-127 state mode) (the-as lightning-mode a0-38))
+               )
+             (let ((gp-4 (-> self clock frame-counter))
+                   (s5-1 150)
+                   (f30-0 1.0)
+                   )
+               (ja-no-eval :group! (-> self draw art-group data 22) :num! (loop! f30-0) :frame-num 0.0)
+               (until (>= (- (-> self clock frame-counter) gp-4) s5-1)
+                 (crimson-guard-level-method-198 self)
+                 (suspend)
+                 (ja :num! (loop! f30-0))
+                 )
+               )
+             (let ((v1-150 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 2)))
+               (logclear! (-> v1-150 prim-core action) (collide-action deadly))
+               )
+             (let ((v1-151 (-> self l-control))
+                   (a0-44 3)
+                   )
+               (let ((a1-34 (!= a0-44 (-> v1-151 state mode))))
+                 (case a0-44
+                   ((3)
+                    (if a1-34
+                        (set! (-> v1-151 state counter) 0.0)
+                        )
+                    )
+                   ((1)
+                    (set! (-> v1-151 state start-color) (-> v1-151 spec start-color))
+                    (set! (-> v1-151 state end-color) (-> v1-151 spec end-color))
+                    )
+                   )
+                 )
+               (set! (-> v1-151 state mode) (the-as lightning-mode a0-44))
+               )
+             (ja-no-eval :group! (-> self draw art-group data 23)
+                         :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 23)) frames num-frames) -1)))
+                         :frame-num 0.0
+                         )
+             (until (ja-done? 0)
+               (suspend)
+               (ja :num! (seek!))
+               )
+             )
+           )
+         )
+        (else
+          (set! (-> self next-shot) (the-as int (+ (-> self clock frame-counter) (seconds 1))))
+          (suspend)
+          0
+          )
+        )
+      (when (not (handle->process (-> self focus handle)))
+        (ja-no-eval :group! (-> self draw art-group data 24)
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 24)) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        #t
+        (goto cfg-81)
+        )
+      )
+    #f
+    (label cfg-81)
+    (go-virtual active)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+(defstate get-up-front (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logclear (-> v1-2 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-2 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logclear (-> v1-5 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-1 (-> self root-override2 root-prim)))
+      (logclear! (-> (the-as collide-shape-prim-group v1-1) child 0 prim-core action) (collide-action no-standon))
+      (logior! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core action) (collide-action no-standon))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-as) (collide-spec enemy))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-with)
+            (collide-spec backgnd jak obstacle hit-by-others-list player-list pusher)
+            )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data (-> self anim-get-up-front))
+                :num! (seek!
+                  (the float
+                       (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-get-up-front))) frames num-frames)
+                          -1
+                          )
+                       )
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (set! (-> self hit-face) (the-as uint -1))
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 *null-vector*)
+          )
+      (logior! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (set! (-> a0-0 travel quad) (-> v1-1 quad))
+      )
+    0
+    (enemy-method-55 self)
+    (none)
+    )
+  )
+
+(defstate get-up-back (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logclear (-> v1-2 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-2 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logclear (-> v1-5 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-1 (-> self root-override2 root-prim)))
+      (logclear! (-> (the-as collide-shape-prim-group v1-1) child 0 prim-core action) (collide-action no-standon))
+      (logior! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core action) (collide-action no-standon))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-as) (collide-spec enemy))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-with)
+            (collide-spec backgnd jak obstacle hit-by-others-list player-list pusher)
+            )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data (-> self anim-get-up-back))
+                :num! (seek!
+                  (the float
+                       (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-get-up-back))) frames num-frames) -1)
+                       )
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (set! (-> self hit-face) (the-as uint -1))
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 *null-vector*)
+          )
+      (logior! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (set! (-> a0-0 travel quad) (-> v1-1 quad))
+      )
+    0
+    (enemy-method-55 self)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod crimson-guard-level-method-204 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s4-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+        (s5-0 (-> obj root-override2))
+        (s3-0 (lambda ((arg0 crimson-guard-level) (arg1 collide-shape-moving) (arg2 vector))
+                (let ((s4-0 (new 'stack-no-clear 'vector))
+                      (s3-0 (new 'stack-no-clear 'vector))
+                      )
+                  (vector+! s3-0 (-> arg1 trans) arg2)
+                  (cloest-point-on-mesh (-> arg0 nav) s4-0 s3-0 (the-as nav-poly #f))
+                  (cond
+                    ((< 409.6 (vector-vector-distance s3-0 s4-0))
+                     #f
+                     )
+                    ((let ((a1-4 (new 'stack-no-clear 'vector)))
+                       (set! (-> a1-4 quad) (-> s4-0 quad))
+                       (set! (-> a1-4 w) (-> arg0 root-override2 nav-radius))
+                       (add-root-sphere-to-hash! (-> arg0 nav) a1-4 #x8046e)
+                       )
+                     #f
+                     )
+                    (else
+                      (let ((a1-5 (new 'stack-no-clear 'collide-query)))
+                        (set! (-> a1-5 start-pos quad) (-> arg1 trans quad))
+                        (vector-! (-> a1-5 move-dist) s4-0 (-> a1-5 start-pos))
+                        (let ((v1-10 a1-5))
+                          (set! (-> v1-10 radius) 2048.0)
+                          (set! (-> v1-10 collide-with) (-> arg1 root-prim prim-core collide-with))
+                          (set! (-> v1-10 ignore-process0) arg0)
+                          (set! (-> v1-10 ignore-process1) #f)
+                          (set! (-> v1-10 ignore-pat) (-> arg1 pat-ignore-mask))
+                          (set! (-> v1-10 action-mask) (collide-action solid))
+                          )
+                        (if (>= (fill-and-probe-using-line-sphere *collide-cache* a1-5) 0.0)
+                            #f
+                            #t
+                            )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+        )
+    (cond
+      ((s3-0 obj s5-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s4-0 24576.0))
+       (go (method-of-object obj roll-right))
+       )
+      ((s3-0 obj s5-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s4-0 -24576.0))
+       (go (method-of-object obj roll-left))
+       )
+      )
+    )
+  (none)
+  )
+
+(defstate roll-right (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :code (behavior ()
+    (vector-reset! (-> self root-override2 transv))
+    (vector-x-quaternion! (-> self root-override2 transv) (-> self root-override2 quat))
+    (set! (-> self root-override2 transv y) 24576.0)
+    (vector-xz-normalize! (-> self root-override2 transv) 40960.0)
+    (let ((v1-7 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-7 enemy-flags)))
+          (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-7 enemy-flags))))
+          )
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-7 enemy-flags))))
+      (set! (-> v1-7 nav callback-info) (-> v1-7 enemy-info-override callback-info))
+      )
+    0
+    (ja-channel-push! 1 (seconds 0.1))
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 40)
+                   :num! (seek! (ja-aframe 6.0 0))
+                   :frame-num (ja-aframe 0.0 0)
+                   )
+       (until (ja-done? 0)
+         (let ((a0-20 (handle->process (-> self focus handle))))
+           (if a0-20
+               (seek-toward-heading-vec!
+                 (-> self root-override2)
+                 (vector-!
+                   (new 'stack-no-clear 'vector)
+                   (get-trans (the-as process-focusable a0-20) 0)
+                   (-> self root-override2 trans)
+                   )
+                 32768.0
+                 (seconds 0.05)
+                 )
+               )
+           )
+         (suspend)
+         (ja :num! (seek! (ja-aframe 6.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 41)
+                    :num! (seek! (ja-aframe 9.0 0))
+                    :frame-num (ja-aframe 0.0 0)
+                    )
+        (until (ja-done? 0)
+          (let ((a0-33 (handle->process (-> self focus handle))))
+            (if a0-33
+                (seek-toward-heading-vec!
+                  (-> self root-override2)
+                  (vector-!
+                    (new 'stack-no-clear 'vector)
+                    (get-trans (the-as process-focusable a0-33) 0)
+                    (-> self root-override2 trans)
+                    )
+                  32768.0
+                  (seconds 0.05)
+                  )
+                )
+            )
+          (suspend)
+          (ja :num! (seek! (ja-aframe 9.0 0)))
+          )
+        )
+      )
+    (let ((v1-59 self))
+      (set! (-> v1-59 enemy-flags) (the-as enemy-flag (logclear (-> v1-59 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-59 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 40)
+                   :num! (seek! (ja-aframe 11.0 0))
+                   :frame-num (ja-aframe 6.0 0)
+                   )
+       (until (ja-done? 0)
+         (suspend)
+         (ja :num! (seek! (ja-aframe 11.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 41)
+                    :num! (seek! (ja-aframe 11.0 0))
+                    :frame-num (ja-aframe 9.0 0)
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! (ja-aframe 11.0 0)))
+          )
+        )
+      )
+    (go-virtual gun-shoot)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 self))
+      (when (logtest? (enemy-flag enemy-flag36) (-> a0-0 enemy-flags))
+        (vector-v++!
+          (-> self root-override2 transv)
+          (compute-acc-due-to-gravity (-> self root-override2) (new 'stack-no-clear 'vector) 0.0)
+          )
+        (let ((a2-1 (new 'stack-no-clear 'collide-query))
+              (a0-5 (-> self root-override2))
+              )
+          (set! (-> a2-1 collide-with) (-> a0-5 root-prim prim-core collide-with))
+          (set! (-> a2-1 ignore-process0) self)
+          (set! (-> a2-1 ignore-process1) #f)
+          (set! (-> a2-1 ignore-pat) (-> a0-5 pat-ignore-mask))
+          (set! (-> a2-1 action-mask) (collide-action solid))
+          (fill-cache-integrate-and-collide a0-5 (-> self root-override2 transv) a2-1 (meters 0))
+          )
+        )
+      )
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+(defstate roll-left (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :code (behavior ()
+    (vector-reset! (-> self root-override2 transv))
+    (vector-x-quaternion! (-> self root-override2 transv) (-> self root-override2 quat))
+    (set! (-> self root-override2 transv y) 24576.0)
+    (vector-xz-normalize! (-> self root-override2 transv) -40960.0)
+    (let ((v1-7 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-7 enemy-flags)))
+          (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-7 enemy-flags))))
+          )
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-7 enemy-flags))))
+      (set! (-> v1-7 nav callback-info) (-> v1-7 enemy-info-override callback-info))
+      )
+    0
+    (ja-channel-push! 1 (seconds 0.1))
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 41)
+                   :num! (seek! (ja-aframe 9.0 0))
+                   :frame-num (ja-aframe 0.0 0)
+                   )
+       (until (ja-done? 0)
+         (let ((a0-20 (handle->process (-> self focus handle))))
+           (if a0-20
+               (seek-toward-heading-vec!
+                 (-> self root-override2)
+                 (vector-!
+                   (new 'stack-no-clear 'vector)
+                   (get-trans (the-as process-focusable a0-20) 0)
+                   (-> self root-override2 trans)
+                   )
+                 32768.0
+                 (seconds 0.05)
+                 )
+               )
+           )
+         (suspend)
+         (ja :num! (seek! (ja-aframe 9.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 40)
+                    :num! (seek! (ja-aframe 6.0 0))
+                    :frame-num (ja-aframe 0.0 0)
+                    )
+        (until (ja-done? 0)
+          (let ((a0-33 (handle->process (-> self focus handle))))
+            (if a0-33
+                (seek-toward-heading-vec!
+                  (-> self root-override2)
+                  (vector-!
+                    (new 'stack-no-clear 'vector)
+                    (get-trans (the-as process-focusable a0-33) 0)
+                    (-> self root-override2 trans)
+                    )
+                  32768.0
+                  (seconds 0.05)
+                  )
+                )
+            )
+          (suspend)
+          (ja :num! (seek! (ja-aframe 6.0 0)))
+          )
+        )
+      )
+    (let ((v1-59 self))
+      (set! (-> v1-59 enemy-flags) (the-as enemy-flag (logclear (-> v1-59 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-59 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 41)
+                   :num! (seek! (ja-aframe 11.0 0))
+                   :frame-num (ja-aframe 9.0 0)
+                   )
+       (until (ja-done? 0)
+         (suspend)
+         (ja :num! (seek! (ja-aframe 11.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 40)
+                    :num! (seek! (ja-aframe 11.0 0))
+                    :frame-num (ja-aframe 6.0 0)
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! (ja-aframe 11.0 0)))
+          )
+        )
+      )
+    (go-virtual gun-shoot)
+    (none)
+    )
+  :post (-> (method-of-type crimson-guard-level roll-right) post)
+  )
+
+(defstate knocked (crimson-guard-level)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-5 (the-as collide-shape-prim-group (-> self root-override2 root-prim))))
+      (logior! (-> v1-5 child 0 prim-core action) (collide-action no-standon))
+      (logclear! (-> v1-5 child 1 prim-core action) (collide-action no-standon))
+      (set! (-> v1-5 child 1 prim-core collide-as) (collide-spec))
+      (set! (-> v1-5 child 1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (if (zero? (-> self hit-points))
+        (set! (-> self root-override2 penetrated-by) (the-as penetrate -1))
+        )
+    (set! (-> self hit-face)
+          (the-as uint (if (< (vector-dot
+                                (-> self root-override2 transv)
+                                (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat))
+                                )
+                              0.0
+                              )
+                           1
+                           0
+                           )
+                  )
+          )
+    (none)
+    )
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (none)
+    )
+  )
+
+(defmethod enemy-method-77 crimson-guard-level ((obj crimson-guard-level) (arg0 (pointer float)))
+  (let ((v1-1 (-> obj root-override2 transv)))
+    (cond
+      ((< (sqrtf (+ (* (-> v1-1 x) (-> v1-1 x)) (* (-> v1-1 z) (-> v1-1 z)))) 57344.0)
+       (set! (-> obj small-hit) 1)
+       )
+      (else
+        (set! (-> obj small-hit) 0)
+        0
+        )
+      )
+    )
+  (cond
+    ((<= (-> obj hit-points) 0)
+     (ja-channel-push! 1 (seconds 0.01))
+     (let ((a1-2 (-> obj draw art-group data (-> obj info knocked anim-index (-> obj hit-face))))
+           (a0-5 (-> obj skel root-channel 0))
+           )
+       (set! (-> a0-5 frame-group) (the-as art-joint-anim a1-2))
+       (set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+       (set! (-> a0-5 param 1) (-> arg0 0))
+       (set! (-> a0-5 frame-num) 0.0)
+       (joint-control-channel-group! a0-5 (the-as art-joint-anim a1-2) num-func-seek!)
+       )
+     )
+    (else
+      (case (-> obj incoming knocked-type)
+        (((knocked-type knocked-type-4) (knocked-type knocked-type-5) (knocked-type knocked-type-7))
+         (ja-channel-push! 1 (seconds 0.01))
+         (cond
+           ((= (-> obj small-hit) 1)
+            (set! (-> obj yellow-anim anim-index-front) (get-rand-int obj 2))
+            (let ((a1-8
+                    (-> obj
+                        draw
+                        art-group
+                        data
+                        (-> (the-as (array int32) (+ (+ (* (-> obj hit-face) 4) (* (-> obj yellow-anim unsigned-anim-index-front) 8))
+                                                     (the-as uint (-> obj info))
+                                                     )
+                                    )
+                            2
+                            )
+                        )
+                    )
+                  (a0-17 (-> obj skel root-channel 0))
+                  )
+              (set! (-> a0-17 frame-group) (the-as art-joint-anim a1-8))
+              (set! (-> a0-17 param 0) (the float (+ (-> (the-as art-joint-anim a1-8) frames num-frames) -1)))
+              (set! (-> a0-17 param 1) (-> arg0 0))
+              (set! (-> a0-17 frame-num) 0.0)
+              (joint-control-channel-group! a0-17 (the-as art-joint-anim a1-8) num-func-seek!)
+              )
+            )
+           (else
+             (let ((a1-9 (-> obj draw art-group data (-> obj info knocked anim-index (-> obj hit-face))))
+                   (a0-21 (-> obj skel root-channel 0))
+                   )
+               (set! (-> a0-21 frame-group) (the-as art-joint-anim a1-9))
+               (set! (-> a0-21 param 0) (the float (+ (-> (the-as art-joint-anim a1-9) frames num-frames) -1)))
+               (set! (-> a0-21 param 1) (-> arg0 0))
+               (set! (-> a0-21 frame-num) 0.0)
+               (joint-control-channel-group! a0-21 (the-as art-joint-anim a1-9) num-func-seek!)
+               )
+             )
+           )
+         )
+        (((knocked-type knocked-type-6))
+         (ja-channel-push! 1 (seconds 0.01))
+         (let ((a0-24 (-> obj skel root-channel 0)))
+           (set! (-> a0-24 frame-group) (the-as art-joint-anim (-> obj draw art-group data 10)))
+           (set! (-> a0-24 param 0)
+                 (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 10)) frames num-frames) -1))
+                 )
+           (set! (-> a0-24 param 1) (-> arg0 0))
+           (set! (-> a0-24 frame-num) 0.0)
+           (joint-control-channel-group! a0-24 (the-as art-joint-anim (-> obj draw art-group data 10)) num-func-seek!)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.1))
+          (let ((a1-13 (-> obj draw art-group data (-> obj info knocked anim-index (-> obj hit-face))))
+                (a0-29 (-> obj skel root-channel 0))
+                )
+            (set! (-> a0-29 frame-group) (the-as art-joint-anim a1-13))
+            (set! (-> a0-29 param 0) (the float (+ (-> (the-as art-joint-anim a1-13) frames num-frames) -1)))
+            (set! (-> a0-29 param 1) (-> arg0 0))
+            (set! (-> a0-29 frame-num) 0.0)
+            (joint-control-channel-group! a0-29 (the-as art-joint-anim a1-13) num-func-seek!)
+            )
+          )
+        )
+      )
+    )
+  #t
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod go-hostile crimson-guard-level ((obj crimson-guard-level))
+  (let ((v1-0 (-> obj hit-face)))
+    (cond
+      ((zero? v1-0)
+       (go (method-of-object obj get-up-front))
+       )
+      ((= v1-0 1)
+       (go (method-of-object obj get-up-back))
+       )
+      ((logtest? (-> obj flags) 1)
+       (go (method-of-object obj tazer-hostile))
+       )
+      ((logtest? (-> obj flags) 2)
+       (go (method-of-object obj blast-hostile))
+       )
+      ((logtest? (-> obj flags) 8)
+       (go (method-of-object obj grenade-hostile))
+       )
+      (else
+        (go (method-of-object obj hostile))
+        )
+      )
+    )
+  (none)
+  )
+
+(defmethod enemy-method-78 crimson-guard-level ((obj crimson-guard-level) (arg0 (pointer float)))
+  (cond
+    ((<= (-> obj hit-points) 0)
+     (let ((a1-1 (-> obj draw art-group data (-> obj info knocked-land anim-index (-> obj hit-face))))
+           (a0-4 (-> obj skel root-channel 0))
+           )
+       (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-1))
+       (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-1) frames num-frames) -1)))
+       (set! (-> a0-4 param 1) (-> arg0 0))
+       (set! (-> a0-4 frame-num) 0.0)
+       (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-1) num-func-seek!)
+       )
+     (set! (-> obj hit-face) (the-as uint -1))
+     #t
+     )
+    (else
+      (case (-> obj incoming knocked-type)
+        (((knocked-type knocked-type-4) (knocked-type knocked-type-5) (knocked-type knocked-type-7))
+         (ja-channel-push! 1 (seconds 0.1))
+         (cond
+           ((= (-> obj small-hit) 1)
+            (let ((a1-6
+                    (-> obj
+                        draw
+                        art-group
+                        data
+                        (-> (the-as (array int32) (+ (+ (* (-> obj hit-face) 4) (* (-> obj yellow-anim unsigned-anim-index-front) 8))
+                                                     (the-as uint (-> obj info))
+                                                     )
+                                    )
+                            6
+                            )
+                        )
+                    )
+                  (a0-15 (-> obj skel root-channel 0))
+                  )
+              (set! (-> a0-15 frame-group) (the-as art-joint-anim a1-6))
+              (set! (-> a0-15 param 0) (the float (+ (-> (the-as art-joint-anim a1-6) frames num-frames) -1)))
+              (set! (-> a0-15 param 1) (-> arg0 0))
+              (set! (-> a0-15 frame-num) 0.0)
+              (joint-control-channel-group! a0-15 (the-as art-joint-anim a1-6) num-func-seek!)
+              )
+            (set! (-> obj hit-face) (the-as uint -1))
+            #t
+            )
+           (else
+             (let ((a1-7 (-> obj draw art-group data (-> obj info knocked-land anim-index (-> obj hit-face))))
+                   (a0-19 (-> obj skel root-channel 0))
+                   )
+               (set! (-> a0-19 frame-group) (the-as art-joint-anim a1-7))
+               (set! (-> a0-19 param 0) (the float (+ (-> (the-as art-joint-anim a1-7) frames num-frames) -1)))
+               (set! (-> a0-19 param 1) (-> arg0 0))
+               (set! (-> a0-19 frame-num) 0.0)
+               (joint-control-channel-group! a0-19 (the-as art-joint-anim a1-7) num-func-seek!)
+               )
+             #t
+             )
+           )
+         )
+        (((knocked-type knocked-type-6))
+         (ja-channel-push! 1 (seconds 0.01))
+         (let ((a0-22 (-> obj skel root-channel 0)))
+           (set! (-> a0-22 frame-group) (the-as art-joint-anim (-> obj draw art-group data 11)))
+           (set! (-> a0-22 param 0)
+                 (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 11)) frames num-frames) -1))
+                 )
+           (set! (-> a0-22 param 1) (-> arg0 0))
+           (set! (-> a0-22 frame-num) 0.0)
+           (joint-control-channel-group! a0-22 (the-as art-joint-anim (-> obj draw art-group data 11)) num-func-seek!)
+           )
+         (set! (-> obj hit-face) (the-as uint -1))
+         #t
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.1))
+          (let ((a1-11 (-> obj draw art-group data (-> obj info knocked-land anim-index (-> obj hit-face))))
+                (a0-27 (-> obj skel root-channel 0))
+                )
+            (set! (-> a0-27 frame-group) (the-as art-joint-anim a1-11))
+            (set! (-> a0-27 param 0) (the float (+ (-> (the-as art-joint-anim a1-11) frames num-frames) -1)))
+            (set! (-> a0-27 param 1) (-> arg0 0))
+            (set! (-> a0-27 frame-num) 0.0)
+            (joint-control-channel-group! a0-27 (the-as art-joint-anim a1-11) num-func-seek!)
+            )
+          #t
+          )
+        )
+      )
+    )
+  )
+
+(defstate die-falling (crimson-guard-level)
+  :virtual #t
+  :code (behavior ()
+    (cond
+      ((enemy-method-133 self)
+       (ja-channel-push! 1 (seconds 0.2))
+       (let ((gp-0 (-> self draw art-group data (-> self enemy-info-override die-falling-anim)))
+             (f30-0 (get-rand-float-range self 0.8 1.2))
+             )
+         (ja-no-eval :group! gp-0
+                     :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0)
+                     :frame-num 0.0
+                     )
+         (until (ja-done? 0)
+           (suspend)
+           (ja :num! (seek! max f30-0))
+           )
+         )
+       )
+      (else
+        (let ((gp-1 #t))
+          (let ((v1-24 (ja-group)))
+            (cond
+              ((and v1-24 (or (= v1-24 (-> self draw art-group data 33)) (= v1-24 (-> self draw art-group data 34))))
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               )
+              ((let ((v1-39 (ja-group)))
+                 (and v1-39 (= v1-39 (-> self draw art-group data 8)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 9)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 9)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               (set! gp-1 #f)
+               )
+              ((let ((v1-79 (ja-group)))
+                 (and v1-79 (= v1-79 (-> self draw art-group data 31)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 32)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 32)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               (set! gp-1 #f)
+               )
+              ((let ((v1-119 (ja-group)))
+                 (and v1-119 (= v1-119 (-> self draw art-group data 9)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 34)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 34)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               )
+              ((let ((v1-158 (ja-group)))
+                 (and v1-158 (= v1-158 (-> self draw art-group data 32)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 33)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 33)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               )
+              )
+            )
+          (when gp-1
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja-no-eval :group! (-> self draw art-group data 17)
+                        :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 17)) frames num-frames) -1)))
+                        :frame-num 0.0
+                        )
+            (until (ja-done? 0)
+              (suspend)
+              (ja :num! (seek!))
+              )
+            )
+          )
+        )
+      )
+    (send-event self 'death-end)
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+(defmethod crimson-guard-level-method-201 crimson-guard-level ((obj crimson-guard-level) (arg0 float))
+  (let* ((s3-0 (handle->process (-> obj transport)))
+         (s4-0 (if (type? s3-0 process-focusable)
+                   (the-as process-focusable s3-0)
+                   )
+               )
+         )
+    (when s4-0
+      (let ((s2-0 (matrix<-transformq! (new 'stack-no-clear 'matrix) (the-as transformq (-> s4-0 root-override trans))))
+            (s3-1 (new 'stack-no-clear 'vector))
+            )
+        (set! (-> s3-1 x) (if (zero? (-> obj transport-side))
+                              -8192.0
+                              8192.0
+                              )
+              )
+        (set! (-> s3-1 y) 12288.0)
+        (set! (-> s3-1 z) (lerp-scale -16384.0 -49152.0 arg0 0.0 1.0))
+        (set! (-> s3-1 w) 1.0)
+        (quaternion-rotate-local-y! (-> obj root-override2 quat) (-> s4-0 root-override quat) 32768.0)
+        (vector-matrix*! (-> obj root-override2 trans) s3-1 s2-0)
+        )
+      )
+    )
+  (let ((f0-5 (fmax 0.0 (fmin 1.0 (* 3.3333333 arg0)))))
+    (set-vector! (-> obj draw color-mult) f0-5 f0-5 f0-5 1.0)
+    )
+  0
+  (none)
+  )
+
+;; ERROR: Unsupported inline assembly instruction kind - [mula.s f0, f3]
+;; ERROR: Unsupported inline assembly instruction kind - [madda.s f1, f4]
+;; ERROR: Unsupported inline assembly instruction kind - [madd.s f0, f2, f5]
+(defmethod crimson-guard-level-method-202 crimson-guard-level ((obj crimson-guard-level) (arg0 vector))
+  (local-vars
+    (f0-8 float)
+    (sv-768 vector)
+    (sv-784 vector)
+    (sv-800 nav-control)
+    (sv-816 nav-poly)
+    (sv-832 vector)
+    )
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+          (f30-0 0.0)
+          )
+      (dotimes (s3-0 2)
+        (vector-normalize! s4-0 (* 4096.0 (+ 4.0 (* 2.0 (the float s3-0)))))
+        (dotimes (s2-0 6)
+          (set! sv-768 (new 'stack-no-clear 'vector))
+          (let ((s1-0 (new 'stack-no-clear 'vector))
+                (s0-0 (new 'stack 'collide-query))
+                )
+            (vector-rotate-around-y! sv-768 s4-0 (* 182.04445 (the float (+ (* 23 s2-0) -70))))
+            (let ((v1-10 s1-0))
+              (let ((a0-6 (-> obj root-override2 trans)))
+                (let ((a1-5 sv-768))
+                  (let ((a2-2 1.0))
+                    (.mov vf7 a2-2)
+                    )
+                  (.lvf vf5 (&-> a1-5 quad))
+                  )
+                (.lvf vf4 (&-> a0-6 quad))
+                )
+              (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+              (.mul.x.vf acc vf5 vf7 :mask #b111)
+              (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+              (.svf (&-> v1-10 quad) vf6)
+              )
+            (if (enemy-method-126 obj s0-0 s1-0 (collide-spec backgnd) 8192.0 81920.0 1024.0)
+                (set! (-> s1-0 y) (-> s0-0 best-other-tri intersect y))
+                )
+            (let ((v1-14 (-> obj nav))
+                  (a0-8 s1-0)
+                  (a1-7 (new 'stack-no-clear 'nav-find-poly-parms))
+                  )
+              (vector-! (-> a1-7 point) a0-8 (-> v1-14 state mesh bounds))
+              (set! (-> a1-7 y-threshold) (-> v1-14 nearest-y-threshold))
+              (set! (-> a1-7 ignore) (the-as uint 2))
+              (set! sv-816 (find-poly-containing-point-local (-> v1-14 state mesh) a1-7))
+              )
+            (when sv-816
+              (let* ((v1-18 s4-0)
+                     (f0-7 (-> sv-768 x))
+                     (f1-4 (-> sv-768 y))
+                     (f2-2 (-> sv-768 z))
+                     (f3-2 (-> v1-18 x))
+                     (f4-0 (-> v1-18 y))
+                     (f5-0 (-> v1-18 z))
+                     )
+                ;; (.mula.s f0-7 f3-2)
+                ;; (.madda.s f1-4 f4-0)
+                ;; (.madd.s f0-8 f2-2 f5-0)
+                (set! f0-8 (+ (* f0-7 f3-2) (* f1-4 f4-0) (* f2-2 f5-0)))
+                )
+              (let ((f28-0 f0-8))
+                #t
+                (new 'stack-no-clear 'vector)
+                (let ((a1-8 (new 'stack-no-clear 'vector)))
+                  (set! (-> a1-8 quad) (-> s1-0 quad))
+                  (set! (-> a1-8 w) 8192.0)
+                  (when (not (add-root-sphere-to-hash! (-> obj nav) a1-8 32))
+                    (when (< f30-0 f28-0)
+                      (set! f30-0 f28-0)
+                      (set! sv-784 (new 'stack-no-clear 'vector))
+                      (let ((a3-3 (new 'stack-no-clear 'vector)))
+                        (set! sv-800 (-> obj nav))
+                        (set! sv-832 sv-784)
+                        (let* ((v1-30 s1-0)
+                               (a0-18 (-> sv-800 state mesh))
+                               (t9-7 (method-of-object a0-18 project-point-onto-plane-of-poly-local))
+                               (a2-7 sv-832)
+                               (t0-2 (vector-! (new 'stack-no-clear 'vector) v1-30 (-> sv-800 state mesh bounds)))
+                               )
+                          (t9-7 a0-18 sv-816 a2-7 a3-3 t0-2)
+                          )
+                        )
+                      (let ((v1-31 sv-832))
+                        (let ((a0-21 (-> sv-800 state mesh bounds)))
+                          (.mov.vf vf6 vf0 :mask #b1000)
+                          (.lvf vf4 (&-> sv-832 quad))
+                          (.lvf vf5 (&-> a0-21 quad))
+                          )
+                        (.add.vf vf6 vf4 vf5 :mask #b111)
+                        (.svf (&-> v1-31 quad) vf6)
+                        )
+                      0
+                      (set! (-> s1-0 y) (-> sv-784 y))
+                      (if (enemy-method-126 obj s0-0 s1-0 (collide-spec backgnd) 8192.0 81920.0 1024.0)
+                          (set! (-> s1-0 y) (-> s0-0 best-other-tri intersect y))
+                          )
+                      (set! (-> arg0 quad) (-> s1-0 quad))
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      f30-0
+      )
+    )
+  )
+
+(defmethod enemy-method-93 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (-> obj nav state))
+        (v1-2 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+        )
+    (set! (-> s5-0 heading quad) (-> v1-2 quad))
+    )
+  0
+  (let ((s5-1 (-> obj nav state)))
+    (set! (-> (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)) quad)
+          (-> s5-1 travel quad)
+          )
+    )
+  (let ((a0-5 (-> obj nav state))
+        (v1-9 *null-vector*)
+        )
+    (set! (-> a0-5 velocity quad) (-> v1-9 quad))
+    )
+  0
+  ((method-of-type nav-enemy enemy-method-93) obj)
+  (none)
+  )
+
+(defmethod enemy-method-89 crimson-guard-level ((obj crimson-guard-level) (arg0 enemy-jump-info))
+  #f
+  )
+
+(defmethod enemy-method-87 crimson-guard-level ((obj crimson-guard-level) (arg0 enemy-jump-info))
+  (let ((a0-1 (-> obj skel root-channel 0)))
+    (set! (-> a0-1 param 0) 1.0)
+    (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!)
+    )
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((s4-0 (-> obj skel root-channel 0)))
+    (set! (-> s4-0 frame-group) (the-as art-joint-anim (-> obj draw art-group data 38)))
+    (set! (-> s4-0 param 0) (ja-aframe 3.0 0))
+    (set! (-> s4-0 param 1) (-> arg0 anim-speed))
+    (set! (-> s4-0 frame-num) (ja-aframe 0.0 0))
+    (joint-control-channel-group! s4-0 (the-as art-joint-anim (-> obj draw art-group data 38)) num-func-seek!)
+    )
+  #t
+  )
+
+(defmethod enemy-method-88 crimson-guard-level ((obj crimson-guard-level) (arg0 enemy-jump-info))
+  (let ((a0-1 (-> obj skel root-channel 0)))
+    (set! (-> a0-1 param 0) 1.0)
+    (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!)
+    )
+  (ja-channel-push! 1 (seconds 0.01))
+  (let ((s4-0 (-> obj skel root-channel 0)))
+    (set! (-> s4-0 frame-group) (the-as art-joint-anim (-> obj draw art-group data 38)))
+    (set! (-> s4-0 param 0) (ja-aframe 9.0 0))
+    (set! (-> s4-0 param 1) (-> arg0 anim-speed))
+    (set! (-> s4-0 frame-num) (ja-aframe 4.0 0))
+    (joint-control-channel-group! s4-0 (the-as art-joint-anim (-> obj draw art-group data 38)) num-func-seek!)
+    )
+  #t
+  )
+
+(defmethod enemy-method-90 crimson-guard-level ((obj crimson-guard-level) (arg0 int) (arg1 enemy-jump-info))
+  (local-vars (s5-0 symbol))
+  (let ((v1-0 arg0))
+    (cond
+      ((zero? v1-0)
+       (not (enemy-method-89 obj arg1))
+       )
+      ((= v1-0 1)
+       (set! s5-0 (ja-done? 0))
+       (let ((s4-1 (-> obj skel root-channel 0)))
+         (set! (-> s4-1 param 0) (ja-aframe 3.0 0))
+         (set! (-> s4-1 param 1) (-> arg1 anim-speed))
+         (joint-control-channel-group-eval! s4-1 (the-as art-joint-anim #f) num-func-seek!)
+         )
+       (ja-blend-eval)
+       s5-0
+       )
+      ((= v1-0 2)
+       (enemy-method-87 obj arg1)
+       #f
+       )
+      ((= v1-0 3)
+       (set! s5-0 (ja-done? 0))
+       (let ((s4-2 (-> obj skel root-channel 0)))
+         (set! (-> s4-2 param 0) (ja-aframe 3.0 0))
+         (set! (-> s4-2 param 1) (-> arg1 anim-speed))
+         (joint-control-channel-group-eval! s4-2 (the-as art-joint-anim #f) num-func-seek!)
+         )
+       (ja-blend-eval)
+       s5-0
+       )
+      ((= v1-0 4)
+       (not (enemy-method-88 obj arg1))
+       )
+      ((= v1-0 5)
+       (set! s5-0 (ja-done? 0))
+       (let ((s4-3 (-> obj skel root-channel 0)))
+         (set! (-> s4-3 param 0) (ja-aframe 9.0 0))
+         (set! (-> s4-3 param 1) (-> arg1 anim-speed))
+         (joint-control-channel-group-eval! s4-3 (the-as art-joint-anim #f) num-func-seek!)
+         )
+       (ja-blend-eval)
+       s5-0
+       )
+      (else
+        #t
+        )
+      )
+    )
+  )
+
+(defstate exit-transport (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (logior! (-> self nav flags) (nav-control-flag output-sphere-hash))
+    (nav-enemy-method-166 self)
+    (let ((v1-7 (-> self nav)))
+      (set! (-> v1-7 target-speed) (-> self enemy-info-override run-travel-speed))
+      )
+    0
+    (set! (-> self already-shot) (the-as uint #f))
+    (none)
+    )
+  :exit (behavior ()
+    (set-vector! (-> self draw color-mult) 1.0 1.0 1.0 1.0)
+    (logclear! (-> self nav flags) (nav-control-flag output-sphere-hash))
+    (none)
+    )
+  :trans (behavior ()
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (when (not (-> self already-shot))
+        (crimson-guard-level-method-201 self 1.0)
+        (let ((gp-0 (new 'stack-no-clear 'vector)))
+          (set! (-> gp-0 quad) (-> self root-override2 trans quad))
+          (let ((s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                (s5-0 (new 'stack 'collide-query))
+                )
+            (let ((a0-3 gp-0))
+              (let ((v1-8 gp-0))
+                (let ((a1-4 20480.0))
+                  (.mov vf7 a1-4)
+                  )
+                (.lvf vf5 (&-> s4-0 quad))
+                (.lvf vf4 (&-> v1-8 quad))
+                )
+              (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+              (.mul.x.vf acc vf5 vf7 :mask #b111)
+              (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+              (.svf (&-> a0-3 quad) vf6)
+              )
+            (if (enemy-method-126 self s5-0 gp-0 (collide-spec backgnd) 8192.0 81920.0 1024.0)
+                (set! (-> gp-0 y) (-> s5-0 best-other-tri intersect y))
+                )
+            )
+          )
+        (when (!= (crimson-guard-level-method-202 self (-> self event-param-point)) 0.0)
+          (let* ((v1-16 (-> self nav))
+                 (a1-7 (-> self event-param-point))
+                 (f0-3 (-> v1-16 extra-nav-sphere w))
+                 )
+            (set! (-> v1-16 extra-nav-sphere quad) (-> a1-7 quad))
+            (set! (-> v1-16 extra-nav-sphere w) f0-3)
+            )
+          0
+          (let ((v1-19 (-> self nav)))
+            (set! (-> v1-19 extra-nav-sphere w) (-> self nav-radius-backup))
+            )
+          0
+          (let ((v1-21 (-> self nav)))
+            (logior! (-> v1-21 shape nav-flags) (nav-flags has-extra-sphere))
+            )
+          0
+          (set! (-> self already-shot) (the-as uint #t))
+          )
+        (crimson-guard-level-method-201 self 0.0)
+        )
+      (none)
+      )
+    )
+  :code (behavior ()
+    (while (not (-> self already-shot))
+      (suspend)
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (ja-channel-set! 1)
+    (let ((gp-0 (-> self clock frame-counter))
+          (s5-0 150)
+          (f30-0 2.0)
+          )
+      (ja-no-eval :group! (-> self draw art-group data 6) :num! (loop! f30-0) :frame-num 0.0)
+      (until (>= (- (-> self clock frame-counter) gp-0) s5-0)
+        (crimson-guard-level-method-201
+          self
+          (* 0.006666667 (the float (- (-> self clock frame-counter) (-> self state-time))))
+          )
+        (suspend)
+        (ja :num! (loop! f30-0))
+        )
+      )
+    (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable))))
+    (send-event self 'jump 0 (-> self event-param-point))
+    (until #f
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (ja-post)
+    (none)
+    )
+  )
+
+(defmethod enemy-method-114 crimson-guard-level ((obj crimson-guard-level))
+  "@abstract"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate
+                                    generic-attack
+                                    lunge
+                                    flop
+                                    punch
+                                    spin
+                                    roll
+                                    uppercut
+                                    bonk
+                                    tube
+                                    vehicle
+                                    flut-attack
+                                    board
+                                    mech-punch
+                                    dark-punch
+                                    dark-giant
+                                    )
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 4) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 5))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak bot obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 8192.0 0.0 24576.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak bot obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-13 local-sphere) 0.0 6144.0 0.0 6144.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak bot obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-15 local-sphere) 0.0 9830.4 0.0 6144.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-17 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list pusher))
+      (set! (-> v1-17 prim-core action) (collide-action semi-solid))
+      (set! (-> v1-17 transform-index) 14)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 2048.0 4096.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-19 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list pusher))
+      (set! (-> v1-19 prim-core action) (collide-action semi-solid))
+      (set! (-> v1-19 transform-index) 14)
+      (set-vector! (-> v1-19 local-sphere) 0.0 0.0 -12288.0 6144.0)
+      )
+    (set! (-> s5-0 nav-radius) 6144.0)
+    (let ((v1-21 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-21 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-21 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 3))
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch nav-enemy vs crimson-guard-level.
+(defmethod relocate crimson-guard-level ((obj crimson-guard-level) (arg0 int))
+  (if (nonzero? (-> obj joint))
+      (&+! (-> obj joint) arg0)
+      )
+  (if (nonzero? (-> obj l-control))
+      (&+! (-> obj l-control) arg0)
+      )
+  (the-as
+    crimson-guard-level
+    ((the-as (function nav-enemy int nav-enemy) (find-parent-method crimson-guard-level 7)) obj arg0)
+    )
+  )
+
+;; WARN: Return type mismatch float vs none.
+(defmethod crimson-guard-level-method-203 crimson-guard-level ((obj crimson-guard-level) (arg0 int))
+  "TODO - probably a flag"
+  (cond
+    ((= arg0 1)
+     (setup-masks (-> obj draw) 16 0)
+     (set! (-> obj weapon) 1)
+     (set! (-> obj root-override2 nav-radius) 10240.0)
+     )
+    ((= arg0 3)
+     (setup-masks (-> obj draw) 16 0)
+     (set! (-> obj weapon) 3)
+     (set! (-> obj root-override2 nav-radius) 10240.0)
+     )
+    ((zero? arg0)
+     (setup-masks (-> obj draw) 8 0)
+     (set! (-> obj weapon) 0)
+     (set! (-> obj root-override2 nav-radius) 6144.0)
+     )
+    )
+  (none)
+  )
+
+(defmethod nav-enemy-method-156 crimson-guard-level ((obj crimson-guard-level))
+  (cond
+    ((logtest? (-> obj flags) 36)
+     (let ((v1-3 (-> obj nav state))
+           (a0-2 (-> obj root-override2 trans))
+           )
+       (logclear! (-> v1-3 flags) (nav-state-flag directional-mode))
+       (logior! (-> v1-3 flags) (nav-state-flag target-poly-dirty))
+       (set! (-> v1-3 target-post quad) (-> a0-2 quad))
+       )
+     0
+     )
+    (else
+      ((method-of-type nav-enemy nav-enemy-method-156) obj)
+      )
+    )
+  (none)
+  )
+
+(defmethod enemy-method-115 crimson-guard-level ((obj crimson-guard-level))
+  "@abstract"
+  (local-vars (sv-16 int))
+  (let ((f0-0 (res-lump-float (-> obj entity) 'rotoffset)))
+    (if (!= f0-0 0.0)
+        (quaternion-rotate-y! (-> obj root-override2 quat) (-> obj root-override2 quat) f0-0)
+        )
+    )
+  (set! sv-16 0)
+  (let ((v1-6 (res-lump-data (-> obj entity) 'trans-offset vector :tag-ptr (the-as (pointer res-tag) (& sv-16)))))
+    (when v1-6
+      (+! (-> obj root-override2 trans x) (-> v1-6 x))
+      (+! (-> obj root-override2 trans y) (-> v1-6 y))
+      (+! (-> obj root-override2 trans z) (-> v1-6 z))
+      )
+    )
+  (initialize-skeleton
+    obj
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-crimson-guard-level" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (let ((a0-13 (-> obj entity)))
+    (set! (-> obj flags) (the-as int ((method-of-object a0-13 get-property-value)
+                                      a0-13
+                                      'crimson-guard-level-flags
+                                      'interp
+                                      -1000000000.0
+                                      (the-as uint128 1)
+                                      (the-as (pointer res-tag) #f)
+                                      *res-static-buf*
+                                      )
+                                 )
+          )
+    )
+  (set! (-> obj info) *crimson-guard-level-global-info*)
+  (enemy-method-113 obj *crimson-guard-level-info*)
+  (cond
+    ((logtest? (-> obj flags) 1)
+     (enemy-method-113 obj *crimson-guard-level-tazer-info*)
+     )
+    ((logtest? (-> obj flags) 4)
+     (enemy-method-113 obj *crimson-guard-level-sniper-info*)
+     )
+    ((logtest? (-> obj flags) 2)
+     (enemy-method-113 obj *crimson-guard-level-blast-info*)
+     )
+    ((logtest? (-> obj flags) 8)
+     (enemy-method-113 obj *crimson-guard-level-grenade-info*)
+     )
+    (else
+      (enemy-method-113 obj *crimson-guard-level-info*)
+      )
+    )
+  (let ((v1-34 (-> obj nav)))
+    (set! (-> v1-34 speed-scale) 1.0)
+    )
+  0
+  (set! (-> obj draw lod-set lod 0 dist) 143360.0)
+  (set! (-> obj draw lod-set lod 1 dist) 491520.0)
+  (set! (-> obj joint) (new 'process 'joint-mod (joint-mod-mode joint-set*-world) obj 4))
+  (set! (-> obj l-control) (new 'process 'lightning-control (-> *lightning-spec-id-table* 13) obj 0.0))
+  (set! (-> obj l-control state points-to-draw) 0)
+  (let ((v1-45 (get-rand-int obj 2)))
+    (if (logtest? (-> obj flags) 4)
+        (set! v1-45 0)
+        )
+    (cond
+      ((zero? v1-45)
+       (set! (-> obj anim-shoot 0 anim-index) 19)
+       (set! (-> obj anim-shoot 0 start) 1.0)
+       (set! (-> obj anim-shoot 0 end) 12.0)
+       (set! (-> obj anim-shoot 1 anim-index) 26)
+       (set! (-> obj anim-shoot 1 start) 12.0)
+       (set! (-> obj anim-shoot 1 end) 22.0)
+       (set! (-> obj anim-shoot 2 anim-index) 24)
+       (set! (-> obj anim-shoot 2 start) 20.0)
+       (set! (-> obj anim-shoot 2 end) 30.0)
+       )
+      ((= v1-45 1)
+       (set! (-> obj anim-shoot 0 anim-index) 27)
+       (set! (-> obj anim-shoot 0 start) 2.0)
+       (set! (-> obj anim-shoot 0 end) 9.0)
+       (set! (-> obj anim-shoot 1 anim-index) 29)
+       (set! (-> obj anim-shoot 1 start) 18.0)
+       (set! (-> obj anim-shoot 1 end) 26.0)
+       (set! (-> obj anim-shoot 2 anim-index) 30)
+       (set! (-> obj anim-shoot 2 start) 26.0)
+       (set! (-> obj anim-shoot 2 end) 35.0)
+       )
+      )
+    )
+  (setup-masks (-> obj draw) 0 -1)
+  (cond
+    ((logtest? (-> obj flags) 1)
+     (crimson-guard-level-method-203 obj 1)
+     )
+    ((logtest? (-> obj flags) 2)
+     (set! (-> obj fact-info-override trig-dist) 409600.0)
+     (crimson-guard-level-method-203 obj 0)
+     )
+    ((logtest? (-> obj flags) 4)
+     (crimson-guard-level-method-203 obj 0)
+     )
+    ((logtest? (-> obj flags) 8)
+     (set! (-> obj fact-info-override trig-dist) 819200.0)
+     (crimson-guard-level-method-203 obj 3)
+     )
+    ((logtest? (-> obj flags) 16)
+     (crimson-guard-level-method-203 obj 0)
+     )
+    )
+  (cond
+    ((logtest? (-> obj flags) 128)
+     (setup-masks (-> obj draw) 5 0)
+     (set-vector! (-> obj root-override2 scale) 1.1 1.1 1.1 1.0)
+     (set! (-> obj hit-points) (* (-> obj hit-points) 2))
+     (set-vector! (-> obj joint scale) 1.1 1.0 1.1 1.0)
+     (let* ((a0-45 (-> obj neck))
+            (t9-22 (method-of-object a0-45 trs-set!))
+            (a1-22 #f)
+            (a2-10 #f)
+            (a3-5 (new 'stack-no-clear 'vector))
+            )
+       (set! (-> a3-5 x) 0.9090909)
+       (set! (-> a3-5 y) 1.0)
+       (set! (-> a3-5 z) 0.9090909)
+       (set! (-> a3-5 w) 1.0)
+       (t9-22 a0-45 (the-as vector a1-22) (the-as quaternion a2-10) a3-5)
+       )
+     (mode-set! (-> obj neck) (joint-mod-mode rotate2))
+     (set! (-> obj joint parented-scale?) #t)
+     (set! (-> obj neck parented-scale?) #t)
+     )
+    (else
+      (setup-masks (-> obj draw) 3 0)
+      )
+    )
+  (set! (-> obj hit-face) (the-as uint -1))
+  (set! (-> obj anim-get-up-front) 33)
+  (set! (-> obj anim-get-up-back) 34)
+  (set! (-> obj joint-enable) #f)
+  (set! (-> obj fact-info-override pickup-type) (pickup-type ammo-random))
+  (set! (-> obj fact-info-override pickup-amount) 10.0)
+  (set! (-> obj fact-info-override pickup-spawn-amount) 1.0)
+  (set! (-> obj trigger) #f)
+  (set! (-> obj root-override2 pause-adjust-distance) 409600.0)
+  (transform-post)
+  0
+  (none)
+  )
+
+(deftype crimson-guard-level-params (structure)
+  ((pos            vector     :inline :offset-assert   0)
+   (quat           quaternion :inline :offset-assert  16)
+   (nav-mesh       nav-mesh           :offset-assert  32)
+   (handle         uint64             :offset-assert  40)
+   (transport-side uint32             :offset-assert  48)
+   (weapon         int32              :offset-assert  52)
+   (proc           process            :offset-assert  56)
+   )
+  :method-count-assert 9
+  :size-assert         #x3c
+  :flag-assert         #x90000003c
+  )
+
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior crimson-guard-level-init-by-other crimson-guard-level ((arg0 crimson-guard-level-params))
+  (enemy-method-114 self)
+  (set! (-> self root-override2 trans quad) (-> arg0 pos quad))
+  (quaternion-copy! (-> self root-override2 quat) (-> arg0 quat))
+  (vector-identity! (-> self root-override2 scale))
+  (set! (-> self transport-side) (-> arg0 transport-side))
+  (add-process-drawable-to-navmesh (-> arg0 nav-mesh) self #t)
+  (set! (-> arg0 proc) self)
+  (set! (-> self transport) (the-as handle (-> arg0 handle)))
+  (enemy-method-115 self)
+  (crimson-guard-level-method-203 self (-> arg0 weapon))
+  (logior! (-> self flags) 96)
+  (go-virtual exit-transport)
+  (none)
+  )
diff --git a/goal_src/jak2/levels/common/enemy/guards/transport-level.gc b/goal_src/jak2/levels/common/enemy/guards/transport-level.gc
index 30a224c1c0..03d41ef4cf 100644
--- a/goal_src/jak2/levels/common/enemy/guards/transport-level.gc
+++ b/goal_src/jak2/levels/common/enemy/guards/transport-level.gc
@@ -7,3 +7,364 @@
 
 ;; DECOMP BEGINS
 
+(deftype transport-level (process-focusable)
+  ((y-dest                float        :offset-assert 204)
+   (last-guard-spawn-time time-frame   :offset-assert 208)
+   (nav-mesh              nav-mesh     :offset-assert 216)
+   (spawn-side            uint32       :offset-assert 220)
+   (spawn?                symbol       :offset-assert 224)
+   (leave-time            time-frame   :offset-assert 232)
+   (max-guard             uint32       :offset-assert 240)
+   (count-guard           uint32       :offset-assert 244)
+   (max-time              float        :offset-assert 248)
+   (spawn-time            time-frame   :offset-assert 256)
+   (ambient-sound-id      uint32       :offset-assert 264)
+   (num-wanted-guards     uint32       :offset-assert 268)
+   (guards                handle     8 :offset-assert 272)
+   )
+  :heap-base #xd0
+  :method-count-assert 35
+  :size-assert         #x150
+  :flag-assert         #x2300d00150
+  (:methods
+    (come-down () _type_ :state 27)
+    (idle () _type_ :state 28)
+    (leave () _type_ :state 29)
+    (die-fast () _type_ :state 30)
+    (transport-level-method-31 (_type_) none 31)
+    (transport-level-method-32 (_type_) none 32)
+    (transport-level-method-33 (_type_) uint 33)
+    (transport-level-method-34 (_type_) none 34)
+    )
+  )
+
+
+(defskelgroup skel-transport-level transport 0 4
+              ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999)))
+              :bounds (static-spherem 0 5 0 17)
+              )
+
+;; WARN: Return type mismatch object vs transport-level.
+(defbehavior transport-level-event-handler transport-level ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (the-as transport-level (case arg2
+                            (('die-fast)
+                             (go-virtual die-fast)
+                             )
+                            (('leave)
+                             (if (not (and (-> self next-state) (let ((v1-6 (-> self next-state name)))
+                                                                  (or (= v1-6 'leave) (= v1-6 'die-fast))
+                                                                  )
+                                           )
+                                      )
+                                 (go-virtual leave)
+                                 )
+                             )
+                            (('guards-left)
+                             (- (-> self max-guard) (-> self count-guard))
+                             )
+                            (('guards-alive)
+                             (set! v0-0 (-> arg3 param 0))
+                             (set! (-> self num-wanted-guards) (the-as uint v0-0))
+                             v0-0
+                             )
+                            (('guards-alive-count)
+                             (set! v0-0 0)
+                             (dotimes (v1-10 (the-as int (-> self num-wanted-guards)))
+                               (if (handle->process (-> self guards v1-10))
+                                   (set! v0-0 (+ (the-as int v0-0) 1))
+                                   )
+                               )
+                             v0-0
+                             )
+                            (('spawn-time)
+                             (set! v0-0 (-> arg3 param 0))
+                             (set! (-> self spawn-time) (the-as time-frame v0-0))
+                             v0-0
+                             )
+                            (('stop-spawning)
+                             (set! (-> self spawn?) #f)
+                             #f
+                             )
+                            )
+          )
+  )
+
+(defmethod transport-level-method-34 transport-level ((obj transport-level))
+  (let ((f30-0 (lerp-scale 0.0 2.0 (fabs (-> obj root-override transv y)) 0.0 122880.0))
+        (f0-4 (lerp-scale 0.0 1.0 (- (-> obj root-override trans y) (-> obj y-dest)) 143360.0 20480.0))
+        (a0-3 (static-sound-spec "transport" :volume 0.0 :mask (pitch reg0)))
+        )
+    (set! (-> a0-3 volume) (the int (* 1024.0 f0-4)))
+    (set! (-> a0-3 pitch-mod) (the int (* 1524.0 f30-0)))
+    (sound-play-by-spec a0-3 (the-as sound-id (-> obj ambient-sound-id)) (-> obj root-override trans))
+    )
+  0
+  (none)
+  )
+
+(defstate come-down (transport-level)
+  :virtual #t
+  :event transport-level-event-handler
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self last-guard-spawn-time) (-> self clock frame-counter))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (ja-no-eval :group! (-> self draw art-group data 4)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (set! (-> self root-override transv y) (* 2.0 (- (-> self y-dest) (-> self root-override trans y))))
+    (set! (-> self root-override transv y) (fmax -122880.0 (fmin 122880.0 (-> self root-override transv y))))
+    (+! (-> self root-override trans y) (* (-> self root-override transv y) (-> self clock seconds-per-frame)))
+    (if (< (fabs (- (-> self root-override trans y) (-> self y-dest))) 409.6)
+        (go-virtual idle)
+        )
+    (transport-level-method-34 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+(defstate idle (transport-level)
+  :virtual #t
+  :event transport-level-event-handler
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self root-override transv y) 0.0)
+    (set! (-> self last-guard-spawn-time) 0)
+    0
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (sound-play "tran-door-open")
+    (ja-no-eval :group! (-> self draw art-group data 5)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames) -1)) 0.5)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.5))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (local-vars (gp-0 symbol))
+    (if (-> self spawn?)
+        (transport-level-method-33 self)
+        )
+    (if (and (zero? (-> self leave-time))
+             (begin
+               (let ((gp-1 #t)
+                     (a1-0 (new 'stack-no-clear 'event-message-block))
+                     )
+                 (set! (-> a1-0 from) (process->ppointer self))
+                 (set! (-> a1-0 num-params) 1)
+                 (set! (-> a1-0 message) 'get-object-reserve-count)
+                 (set! (-> a1-0 param 0) (the-as uint 6))
+                 (let ((v1-9 (the-as object (send-event-function *traffic-manager* a1-0))))
+                   (cmove-#f-nonzero gp-0 v1-9 gp-1)
+                   )
+                 )
+               gp-0
+               )
+             )
+        (set! (-> self leave-time) (+ (-> self clock frame-counter) (seconds 3)))
+        )
+    (if (and (nonzero? (-> self leave-time)) (< (-> self leave-time) (-> self clock frame-counter)))
+        (go-virtual leave)
+        )
+    (when (and (zero? (-> self leave-time))
+               (nonzero? (-> self max-guard))
+               (>= (-> self count-guard) (-> self max-guard))
+               )
+      (set! (-> self leave-time) (+ (-> self clock frame-counter) (seconds 3)))
+      (send-event self 'stop-spawning)
+      )
+    (transport-level-method-34 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+(defstate die-fast (transport-level)
+  :virtual #t
+  :code (behavior ()
+    (sound-stop (the-as sound-id (-> self ambient-sound-id)))
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+(defstate leave (transport-level)
+  :virtual #t
+  :event transport-level-event-handler
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self root-override transv y) 0.0)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (sound-play "tran-thrust")
+    (sound-play "tran-door-close")
+    (ja-no-eval :group! (-> self draw art-group data 6)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 6)) frames num-frames) -1)) 0.2)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.2))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (transport-level-method-34 self)
+    (+! (-> self root-override transv y) (* 40960.0 (-> self clock seconds-per-frame)))
+    (set! (-> self root-override transv y) (fmax -122880.0 (fmin 122880.0 (-> self root-override transv y))))
+    (+! (-> self root-override trans y) (* (-> self root-override transv y) (-> self clock seconds-per-frame)))
+    (if (and (not (logtest? (-> self draw status) (draw-control-status on-screen)))
+             (< 163840.0 (- (-> self root-override trans y) (-> self y-dest)))
+             )
+        (go-virtual die-fast)
+        )
+    (transform-post)
+    (none)
+    )
+  )
+
+(defmethod transport-level-method-33 transport-level ((obj transport-level))
+  (with-pp
+    (let ((v1-0 0))
+      (dotimes (a0-1 8)
+        (if (handle->process (-> obj guards a0-1))
+            (+! v1-0 1)
+            )
+        )
+      (when (zero? (-> obj count-guard))
+        (set! (-> obj last-guard-spawn-time) 0)
+        0
+        )
+      (when (and (>= (- (-> pp clock frame-counter) (-> obj last-guard-spawn-time)) (-> obj spawn-time))
+                 (< v1-0 (the-as int (-> obj num-wanted-guards)))
+                 )
+        (let ((s5-0 (new 'stack-no-clear 'crimson-guard-level-params)))
+          (set! (-> s5-0 transport-side) (-> obj spawn-side))
+          (set! (-> s5-0 nav-mesh) (-> obj nav-mesh))
+          (set! (-> s5-0 pos quad) (-> obj root-override trans quad))
+          (set! (-> s5-0 pos y) (+ 8192.0 (-> s5-0 pos y)))
+          (quaternion-rotate-local-y! (-> s5-0 quat) (-> obj root-override quat) 32768.0)
+          (set! (-> s5-0 handle) (the-as uint (process->handle obj)))
+          (set! (-> s5-0 weapon) 1)
+          (dotimes (s4-0 (the-as int (-> obj num-wanted-guards)))
+            (when (not (handle->process (-> obj guards s4-0)))
+              (set! (-> obj guards s4-0) (ppointer->handle (process-spawn crimson-guard-level s5-0 :to obj)))
+              #t
+              (goto cfg-38)
+              )
+            )
+          (label cfg-38)
+          (when (-> s5-0 proc)
+            (set! (-> obj spawn-side) (- 1 (the-as int (-> obj spawn-side))))
+            (set! (-> obj last-guard-spawn-time) (-> pp clock frame-counter))
+            (let ((v0-0 (+ (-> obj count-guard) 1)))
+              (set! (-> obj count-guard) v0-0)
+              v0-0
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defmethod transport-level-method-31 transport-level ((obj transport-level))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 20480.0 0.0 69632.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 4)
+      (set-vector! (-> v1-12 local-sphere) 0.0 0.0 0.0 40960.0)
+      )
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 3)
+      (set-vector! (-> v1-14 local-sphere) 0.0 20480.0 0.0 69632.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-17 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-17 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-17 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod transport-level-method-32 transport-level ((obj transport-level))
+  (set! (-> obj spawn-side) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! transport-level ((obj transport-level) (arg0 entity-actor))
+  (transport-level-method-31 obj)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-transport-level" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transport-level-method-32 obj)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (process-entity-status! obj (entity-perm-status no-kill) #t)
+  (set! (-> obj spawn?) #t)
+  (set! (-> obj nav-mesh) (nav-mesh-from-res-tag arg0 'nav-mesh-actor 0))
+  (set! (-> obj num-wanted-guards) (the-as uint 4))
+  (dotimes (v1-11 8)
+    (set! (-> obj guards v1-11) (the-as handle #f))
+    )
+  (set! (-> obj spawn-time) (seconds 4))
+  (set! (-> obj root-override trans y) (+ 40960.0 (-> obj root-override trans y)))
+  (set! (-> obj y-dest) (-> obj root-override trans y))
+  (set! (-> obj root-override trans y) (+ 163840.0 (-> obj root-override trans y)))
+  (go (method-of-object obj come-down))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/common/entities/fort-floor-spike.gc b/goal_src/jak2/levels/common/entities/fort-floor-spike.gc
index 8d45845399..dc6a054993 100644
--- a/goal_src/jak2/levels/common/entities/fort-floor-spike.gc
+++ b/goal_src/jak2/levels/common/entities/fort-floor-spike.gc
@@ -7,3 +7,656 @@
 
 ;; DECOMP BEGINS
 
+(deftype spike-row-info (structure)
+  ((sync      sync-linear           :inline :offset-assert   0)
+   (table-ptr (inline-array vector)         :offset-assert  16)
+   (on-ratio  float                         :offset-assert  20)
+   (state     int32                         :offset-assert  24)
+   )
+  :method-count-assert 9
+  :size-assert         #x1c
+  :flag-assert         #x90000001c
+  )
+
+
+(deftype spike-row-info-array (inline-array-class)
+  ((data spike-row-info :inline :dynamic :offset-assert  16)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+
+(set! (-> spike-row-info-array heap-base) (the-as uint 32))
+
+(deftype fort-floor-spike (process-drawable)
+  ((pos-table        (inline-array vector)   :offset-assert 200)
+   (spike-row        spike-row-info-array    :offset-assert 204)
+   (spike-dim        basic                 2 :offset-assert 208)
+   (attack-id        int32                   :offset-assert 216)
+   (no-overlap-timer uint64                  :offset-assert 224)
+   )
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  (:methods
+    (idle () _type_ :state 20)
+    (fort-floor-spike-method-21 (_type_) none 21)
+    (fort-floor-spike-method-22 (_type_) collide-shape-moving 22)
+    (fort-floor-spike-method-23 (_type_) symbol 23)
+    )
+  )
+
+
+(defun joint-mod-set-y-callback ((arg0 cspace) (arg1 transformq))
+  "TODO - investigate weird casting"
+  (let ((a2-0 (-> arg0 param1))
+        (a3-0 (the-as object (-> arg0 param2)))
+        (v1-0 (new 'stack-no-clear 'transformq))
+        )
+    (set! (-> v1-0 trans quad) (-> arg1 trans quad))
+    (set! (-> v1-0 quat quad) (-> arg1 quat quad))
+    (set! (-> v1-0 scale quad) (-> arg1 scale quad))
+    (set! (-> v1-0 trans y) (fmin -4096.0 (-> (the-as vector (+ (* (the-as int a3-0) 16) (the-as int a2-0))) y)))
+    (cspace<-parented-transformq-joint! arg0 v1-0)
+    )
+  (none)
+  )
+
+(defmethod fort-floor-spike-method-21 fort-floor-spike ((obj fort-floor-spike))
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch int vs collide-shape-moving.
+(defmethod fort-floor-spike-method-22 fort-floor-spike ((obj fort-floor-spike))
+  (the-as collide-shape-moving 0)
+  )
+
+;; WARN: Return type mismatch int vs symbol.
+(defmethod fort-floor-spike-method-23 fort-floor-spike ((obj fort-floor-spike))
+  (the-as symbol 0)
+  )
+
+(defstate idle (fort-floor-spike)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as
+      object
+      (case event-type
+        (('touched)
+         (when (+ (-> self clock frame-counter) (seconds -2))
+           (let* ((s3-0 proc)
+                  (s4-0 (if (type? s3-0 process-drawable)
+                            (the-as process-drawable s3-0)
+                            )
+                        )
+                  )
+             (when s4-0
+               (let ((s3-1 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root quat)))
+                     (s4-1
+                       (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> s4-0 root trans) (-> self root trans)) 1.0)
+                       )
+                     )
+                 (vector-flatten! s4-1 s4-1 s3-1)
+                 (set! (-> s4-1 y) 0.0)
+                 (vector-normalize! s4-1 1.0)
+                 (let ((a1-8 (new 'stack-no-clear 'event-message-block)))
+                   (set! (-> a1-8 from) (process->ppointer self))
+                   (set! (-> a1-8 num-params) 2)
+                   (set! (-> a1-8 message) 'attack)
+                   (set! (-> a1-8 param 0) (-> event param 0))
+                   (let ((v1-11 (new 'static 'attack-info :mask (attack-info-mask vector mode shove-back shove-up id))))
+                     (set! (-> v1-11 id) (the-as uint (-> self attack-id)))
+                     (set! (-> v1-11 mode) 'deadly)
+                     (set! (-> v1-11 shove-up) 24576.0)
+                     (set! (-> v1-11 shove-back) 16384.0)
+                     (set! (-> v1-11 vector quad) (-> s4-1 quad))
+                     (set! (-> a1-8 param 1) (the-as uint v1-11))
+                     )
+                   (send-event-function proc a1-8)
+                   )
+                 )
+               (let ((v0-0 (-> self clock frame-counter)))
+                 (set! (-> self no-overlap-timer) (the-as uint v0-0))
+                 v0-0
+                 )
+               )
+             )
+           )
+         )
+        )
+      )
+    )
+  :enter (behavior ()
+    (set! (-> self no-overlap-timer) (the-as uint 0))
+    0
+    (none)
+    )
+  :code (the-as (function none :behavior fort-floor-spike) sleep-code)
+  :post (behavior ()
+    (dotimes (gp-0 (the-as int (-> self spike-dim 0)))
+      (let ((s5-0 (-> self spike-row data gp-0)))
+        (let ((f0-0 (get-norm! (-> s5-0 sync) 0)))
+          (cond
+            ((< (-> s5-0 on-ratio) f0-0)
+             (set! (-> s5-0 state) 0)
+             0
+             )
+            (else
+              (set! (-> s5-0 state) 1)
+              )
+            )
+          )
+        (dotimes (s4-0 (the-as int (-> self spike-dim 1)))
+          (cond
+            ((zero? (-> s5-0 state))
+             (seek!
+               (-> s5-0 table-ptr s4-0 y)
+               (* 4096.0 (- -4.0 (the float s4-0)))
+               (* 131072.0 (-> self clock seconds-per-frame))
+               )
+             )
+            (else
+              (let ((f30-0 (-> s5-0 table-ptr s4-0 y))
+                    (f28-0 (* 4096.0 (+ -1.0 (the float s4-0))))
+                    )
+                (seek! (-> s5-0 table-ptr s4-0 y) f28-0 (* 131072.0 (-> self clock seconds-per-frame)))
+                (if (and (< f30-0 f28-0) (= (-> s5-0 table-ptr gp-0 y) f28-0))
+                    (sound-play "floor-spike" :position (-> s5-0 table-ptr gp-0))
+                    )
+                )
+              )
+            )
+          )
+        )
+      )
+    (transform-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch process-drawable vs fort-floor-spike.
+(defmethod relocate fort-floor-spike ((obj fort-floor-spike) (arg0 int))
+  (if (nonzero? (-> obj spike-row))
+      (&+! (-> obj spike-row) arg0)
+      )
+  (the-as fort-floor-spike ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-floor-spike ((obj fort-floor-spike) (arg0 entity-actor))
+  (fort-floor-spike-method-22 obj)
+  (process-drawable-from-entity! obj arg0)
+  (fort-floor-spike-method-21 obj)
+  (fort-floor-spike-method-23 obj)
+  (let* ((v1-6 *game-info*)
+         (a0-6 (+ (-> v1-6 attack-id) 1))
+         )
+    (set! (-> v1-6 attack-id) a0-6)
+    (set! (-> obj attack-id) (the-as int a0-6))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(defskelgroup skel-fort-floor-spike-a fort-floor-spike-a 0 4
+              ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+(defskelgroup skel-fort-floor-spike-b fort-floor-spike-b 0 4
+              ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+(defskelgroup skel-fort-floor-spike-c fort-floor-spike-c 0 4
+              ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+(deftype fort-floor-spike-a (fort-floor-spike)
+  ()
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  )
+
+
+(defmethod fort-floor-spike-method-21 fort-floor-spike-a ((obj fort-floor-spike-a))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-floor-spike-a" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a0-3 (-> obj skel root-channel 0)))
+    (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 4)))
+    (set! (-> a0-3 frame-num) 0.0)
+    (joint-control-channel-group-eval!
+      a0-3
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (none)
+  )
+
+(defmethod fort-floor-spike-method-22 fort-floor-spike-a ((obj fort-floor-spike-a))
+  (local-vars (sv-16 collide-shape-prim-mesh) (sv-32 type) (sv-48 collide-shape-moving))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 8) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 9))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 49152.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      (let* ((s3-0 '((0 4 17203) (1 5 17203) (2 6 17203) (3 7 17203) (4 8 17203) (5 9 17203) (6 10 17203) (7 11 17203)))
+             (s2-0 (car s3-0))
+             )
+        (while (not (null? s3-0))
+          (let ((s1-0 (method-of-type collide-shape-prim-mesh new))
+                (s0-0 'process)
+                )
+            (set! sv-32 collide-shape-prim-mesh)
+            (set! sv-48 s5-0)
+            (let ((a3-2 (command-get-int (car s2-0) 0))
+                  (t0-1 0)
+                  )
+              (set! sv-16 (s1-0 s0-0 sv-32 sv-48 (the-as uint a3-2) (the-as uint t0-1)))
+              )
+            )
+          (let ((s1-1 sv-16))
+            (set! (-> s1-1 prim-core collide-as) (-> s4-0 prim-core collide-as))
+            (set! (-> s1-1 prim-core collide-with) (-> s4-0 prim-core collide-with))
+            (set! (-> s1-1 prim-core action) (-> s4-0 prim-core action))
+            (set! (-> s1-1 transform-index) (command-get-int (car (cdr s2-0)) 0))
+            )
+          (set-vector! (-> sv-16 local-sphere) 0.0 0.0 0.0 (command-get-float (car (cdr (cdr s2-0))) 0.0))
+          (set! s3-0 (cdr s3-0))
+          (set! s2-0 (car s3-0))
+          )
+        )
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root) s5-0)
+    s5-0
+    )
+  )
+
+(defmethod fort-floor-spike-method-23 fort-floor-spike-a ((obj fort-floor-spike-a))
+  (local-vars (sv-64 cspace))
+  (let ((s5-0 2)
+        (s4-0 4)
+        )
+    (set! (-> obj spike-dim 0) (the-as basic s5-0))
+    (set! (-> obj spike-dim 1) (the-as basic s4-0))
+    (set! (-> obj spike-row) (new 'process 'spike-row-info-array s5-0))
+    (set! (-> obj pos-table) (new 'static 'inline-array vector 8
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               )
+          )
+    (let ((s3-0 (-> obj pos-table))
+          (s2-0 4)
+          (s1-0 11)
+          )
+      (dotimes (s0-0 (+ (- 1 s2-0) s1-0))
+        (set! sv-64 (-> obj node-list data (+ s2-0 s0-0)))
+        (vector<-cspace! (-> s3-0 s0-0) sv-64)
+        (set! (-> s3-0 s0-0 y) 0.0)
+        (set! (-> sv-64 param0) joint-mod-set-y-callback)
+        (set! (-> sv-64 param1) (the-as basic s3-0))
+        (set! (-> sv-64 param2) (the-as basic s0-0))
+        )
+      )
+    (dotimes (s3-1 s5-0)
+      (let ((s2-1 (-> obj spike-row data s3-1)))
+        (let ((a1-2 (new 'stack-no-clear 'sync-info-params)))
+          (let ((v1-19 0))
+            (if #t
+                (set! v1-19 (logior v1-19 1))
+                )
+            (set! (-> a1-2 sync-type) (the-as basic 'sync-linear))
+            (set! (-> a1-2 sync-flags) (the-as sync-flags v1-19))
+            )
+          (set! (-> a1-2 entity) #f)
+          (set! (-> a1-2 period) (the-as uint 1200))
+          (let ((f0-2 (* 0.25 (the float s3-1))))
+            (set! (-> a1-2 percent) (- f0-2 (* (the float (the int (/ f0-2 1.0))) 1.0)))
+            )
+          (initialize! (-> s2-1 sync) a1-2)
+          )
+        (set! (-> s2-1 on-ratio) 0.375)
+        (set! (-> s2-1 state) 0)
+        (set! (-> s2-1 table-ptr) (the-as (inline-array vector) (-> obj pos-table (* s3-1 s4-0))))
+        )
+      )
+    )
+  #f
+  )
+
+(deftype fort-floor-spike-b (fort-floor-spike)
+  ()
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  )
+
+
+(defmethod fort-floor-spike-method-21 fort-floor-spike-b ((obj fort-floor-spike-b))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-floor-spike-b" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a0-3 (-> obj skel root-channel 0)))
+    (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 4)))
+    (set! (-> a0-3 frame-num) 0.0)
+    (joint-control-channel-group-eval!
+      a0-3
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (none)
+  )
+
+(defmethod fort-floor-spike-method-22 fort-floor-spike-b ((obj fort-floor-spike-b))
+  (local-vars (sv-16 collide-shape-prim-mesh) (sv-32 type) (sv-48 collide-shape-moving))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 10) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 11))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 49152.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      (let* ((s3-0 '((0 4 16384)
+                     (1 5 16384)
+                     (2 6 16384)
+                     (3 7 16384)
+                     (4 8 16384)
+                     (5 9 16384)
+                     (6 10 16384)
+                     (7 11 16384)
+                     (8 12 16384)
+                     (9 13 16384)
+                     )
+                   )
+             (s2-0 (car s3-0))
+             )
+        (while (not (null? s3-0))
+          (let ((s1-0 (method-of-type collide-shape-prim-mesh new))
+                (s0-0 'process)
+                )
+            (set! sv-32 collide-shape-prim-mesh)
+            (set! sv-48 s5-0)
+            (let ((a3-2 (command-get-int (car s2-0) 0))
+                  (t0-1 0)
+                  )
+              (set! sv-16 (s1-0 s0-0 sv-32 sv-48 (the-as uint a3-2) (the-as uint t0-1)))
+              )
+            )
+          (let ((s1-1 sv-16))
+            (set! (-> s1-1 prim-core collide-as) (-> s4-0 prim-core collide-as))
+            (set! (-> s1-1 prim-core collide-with) (-> s4-0 prim-core collide-with))
+            (set! (-> s1-1 prim-core action) (-> s4-0 prim-core action))
+            (set! (-> s1-1 transform-index) (command-get-int (car (cdr s2-0)) 0))
+            )
+          (set-vector! (-> sv-16 local-sphere) 0.0 0.0 0.0 (command-get-float (car (cdr (cdr s2-0))) 0.0))
+          (set! s3-0 (cdr s3-0))
+          (set! s2-0 (car s3-0))
+          )
+        )
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root) s5-0)
+    s5-0
+    )
+  )
+
+(defmethod fort-floor-spike-method-23 fort-floor-spike-b ((obj fort-floor-spike-b))
+  (local-vars (sv-64 cspace))
+  (let ((s5-0 2)
+        (s4-0 5)
+        )
+    (set! (-> obj spike-dim 0) (the-as basic s5-0))
+    (set! (-> obj spike-dim 1) (the-as basic s4-0))
+    (set! (-> obj spike-row) (new 'process 'spike-row-info-array s5-0))
+    (set! (-> obj pos-table) (new 'static 'inline-array vector 8
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               )
+          )
+    (let ((s3-0 (-> obj pos-table))
+          (s2-0 4)
+          (s1-0 13)
+          )
+      (dotimes (s0-0 (+ (- 1 s2-0) s1-0))
+        (set! sv-64 (-> obj node-list data (+ s2-0 s0-0)))
+        (vector<-cspace! (-> s3-0 s0-0) sv-64)
+        (set! (-> s3-0 s0-0 y) 0.0)
+        (set! (-> sv-64 param0) joint-mod-set-y-callback)
+        (set! (-> sv-64 param1) (the-as basic s3-0))
+        (set! (-> sv-64 param2) (the-as basic s0-0))
+        )
+      )
+    (dotimes (s3-1 s5-0)
+      (let ((s2-1 (-> obj spike-row data s3-1)))
+        (let ((a1-2 (new 'stack-no-clear 'sync-info-params)))
+          (let ((v1-19 0))
+            (if #t
+                (set! v1-19 (logior v1-19 1))
+                )
+            (set! (-> a1-2 sync-type) (the-as basic 'sync-linear))
+            (set! (-> a1-2 sync-flags) (the-as sync-flags v1-19))
+            )
+          (set! (-> a1-2 entity) #f)
+          (set! (-> a1-2 period) (the-as uint 1200))
+          (let ((f0-2 (* 0.25 (the float s3-1))))
+            (set! (-> a1-2 percent) (- f0-2 (* (the float (the int (/ f0-2 1.0))) 1.0)))
+            )
+          (initialize! (-> s2-1 sync) a1-2)
+          )
+        (set! (-> s2-1 on-ratio) 0.375)
+        (set! (-> s2-1 state) 0)
+        (set! (-> s2-1 table-ptr) (the-as (inline-array vector) (-> obj pos-table (* s3-1 s4-0))))
+        )
+      )
+    )
+  #f
+  )
+
+(deftype fort-floor-spike-c (fort-floor-spike)
+  ()
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  )
+
+
+(defmethod fort-floor-spike-method-21 fort-floor-spike-c ((obj fort-floor-spike-c))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-floor-spike-c" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a0-3 (-> obj skel root-channel 0)))
+    (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 4)))
+    (set! (-> a0-3 frame-num) 0.0)
+    (joint-control-channel-group-eval!
+      a0-3
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (none)
+  )
+
+(defmethod fort-floor-spike-method-22 fort-floor-spike-c ((obj fort-floor-spike-c))
+  (local-vars (sv-16 collide-shape-prim-mesh) (sv-32 type) (sv-48 collide-shape-moving))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 15) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 16))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 49152.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      (let* ((s3-0 '((0 4 16384)
+                     (1 5 16384)
+                     (2 6 16384)
+                     (3 7 16384)
+                     (4 8 16384)
+                     (5 9 16384)
+                     (6 10 16384)
+                     (7 11 16384)
+                     (8 12 16384)
+                     (9 13 16384)
+                     (10 15 16384)
+                     (11 16 16384)
+                     (12 14 16384)
+                     (13 15 16384)
+                     (14 16 16384)
+                     )
+                   )
+             (s2-0 (car s3-0))
+             )
+        (while (not (null? s3-0))
+          (let ((s1-0 (method-of-type collide-shape-prim-mesh new))
+                (s0-0 'process)
+                )
+            (set! sv-32 collide-shape-prim-mesh)
+            (set! sv-48 s5-0)
+            (let ((a3-2 (command-get-int (car s2-0) 0))
+                  (t0-1 0)
+                  )
+              (set! sv-16 (s1-0 s0-0 sv-32 sv-48 (the-as uint a3-2) (the-as uint t0-1)))
+              )
+            )
+          (let ((s1-1 sv-16))
+            (set! (-> s1-1 prim-core collide-as) (-> s4-0 prim-core collide-as))
+            (set! (-> s1-1 prim-core collide-with) (-> s4-0 prim-core collide-with))
+            (set! (-> s1-1 prim-core action) (-> s4-0 prim-core action))
+            (set! (-> s1-1 transform-index) (command-get-int (car (cdr s2-0)) 0))
+            )
+          (set-vector! (-> sv-16 local-sphere) 0.0 0.0 0.0 (command-get-float (car (cdr (cdr s2-0))) 0.0))
+          (set! s3-0 (cdr s3-0))
+          (set! s2-0 (car s3-0))
+          )
+        )
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root) s5-0)
+    s5-0
+    )
+  )
+
+(defmethod fort-floor-spike-method-23 fort-floor-spike-c ((obj fort-floor-spike-c))
+  (local-vars (sv-64 cspace))
+  (let ((s5-0 3)
+        (s4-0 5)
+        )
+    (set! (-> obj spike-dim 0) (the-as basic s5-0))
+    (set! (-> obj spike-dim 1) (the-as basic s4-0))
+    (set! (-> obj spike-row) (new 'process 'spike-row-info-array s5-0))
+    (set! (-> obj pos-table) (new 'static 'inline-array vector 8
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               )
+          )
+    (let ((s3-0 (-> obj pos-table))
+          (s2-0 4)
+          (s1-0 18)
+          )
+      (dotimes (s0-0 (+ (- 1 s2-0) s1-0))
+        (set! sv-64 (-> obj node-list data (+ s2-0 s0-0)))
+        (vector<-cspace! (-> s3-0 s0-0) sv-64)
+        (set! (-> s3-0 s0-0 y) 0.0)
+        (set! (-> sv-64 param0) joint-mod-set-y-callback)
+        (set! (-> sv-64 param1) (the-as basic s3-0))
+        (set! (-> sv-64 param2) (the-as basic s0-0))
+        )
+      )
+    (dotimes (s3-1 s5-0)
+      (let ((s2-1 (-> obj spike-row data s3-1)))
+        (let ((a1-2 (new 'stack-no-clear 'sync-info-params)))
+          (let ((v1-19 0))
+            (if #t
+                (set! v1-19 (logior v1-19 1))
+                )
+            (set! (-> a1-2 sync-type) (the-as basic 'sync-linear))
+            (set! (-> a1-2 sync-flags) (the-as sync-flags v1-19))
+            )
+          (set! (-> a1-2 entity) #f)
+          (set! (-> a1-2 period) (the-as uint 1200))
+          (let ((f0-2 (* 0.25 (the float s3-1))))
+            (set! (-> a1-2 percent) (- f0-2 (* (the float (the int (/ f0-2 1.0))) 1.0)))
+            )
+          (initialize! (-> s2-1 sync) a1-2)
+          )
+        (set! (-> s2-1 on-ratio) 0.375)
+        (set! (-> s2-1 state) 0)
+        (set! (-> s2-1 table-ptr) (the-as (inline-array vector) (-> obj pos-table (* s3-1 s4-0))))
+        )
+      )
+    )
+  #f
+  )
diff --git a/goal_src/jak2/levels/dig/dig-digger.gc b/goal_src/jak2/levels/dig/dig-digger.gc
index 2519729a35..3e7da4d1cd 100644
--- a/goal_src/jak2/levels/dig/dig-digger.gc
+++ b/goal_src/jak2/levels/dig/dig-digger.gc
@@ -7,3 +7,1701 @@
 
 ;; DECOMP BEGINS
 
+(defpartgroup group-dig-clasp-break
+  :id 1142
+  :duration (seconds 0.05)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 4937 :fade-after (meters 50) :falloff-to (meters 100) :period 600 :length 10)
+    (sp-item 4938 :fade-after (meters 50) :period 600 :length 5)
+    )
+  )
+
+(defpart 4937
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-rnd-flt spt-num 8.0 8.0 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.07) (meters 0.03) 1.0)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-omega 2.048 2.048 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.06666667) 1.0)
+    (sp-rnd-flt spt-fade-g -2.55 -2.55 1.0)
+    (sp-flt spt-fade-b -8.0)
+    (sp-rnd-flt spt-fade-a -0.64 -0.64 1.0)
+    (sp-rnd-flt spt-friction 0.85 0.02 1.0)
+    (sp-int spt-timer 100)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 80.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+(defpart 4938
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 3))
+    (sp-flt spt-rot-x 40.96)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-flt spt-b 0.0)
+    (sp-rnd-flt spt-a 96.0 16.0 1.0)
+    (sp-flt spt-omega 206848.0)
+    (sp-flt spt-scalevel-x (meters 0.08))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-g -10.2)
+    (sp-flt spt-fade-a -4.48)
+    (sp-int spt-timer 25)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 0.0)
+    )
+  )
+
+(defpartgroup group-dig-digger-smoke
+  :id 1143
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 16)
+  :parts ((sp-item 4939 :fade-after (meters 200) :falloff-to (meters 300))
+    (sp-item 4940 :fade-after (meters 200) :flags (bit6))
+    (sp-item 4941 :fade-after (meters 200) :flags (bit6))
+    )
+  )
+
+(defpart 4940
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xca :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-y (meters 0) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 24) (meters 0.1) 1.0)
+    (sp-flt spt-rot-x 1228.8)
+    (sp-rnd-flt spt-rot-z (degrees -4.0) (degrees 8.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-rnd-flt spt-a 12.0 4.0 1.0)
+    (sp-flt spt-omega 822476.8)
+    (sp-flt spt-fade-a -1.0666667)
+    (sp-int spt-timer 15)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 6144.0)
+    )
+  )
+
+(defpart 4941
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-scale-x (meters 6) (meters 2) 1.0)
+    (sp-flt spt-rot-x 1228.8)
+    (sp-rnd-flt spt-rot-z (degrees -4.0) (degrees 8.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-rnd-flt spt-a 20.0 4.0 1.0)
+    (sp-flt spt-omega 822476.8)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 6144.0)
+    )
+  )
+
+(defpart 4939
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.06) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.026666667) (meters 0.02) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.36)
+    (sp-flt spt-fade-b -4.24)
+    (sp-rnd-flt spt-fade-a -0.047407407 -0.047407407 1.0)
+    (sp-rnd-flt spt-accel-x -2.7306666 -1.3653333 1.0)
+    (sp-rnd-flt spt-accel-y 0.4096 0.4096 1.0)
+    (sp-flt spt-friction 0.96)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 #xc00000 #xc00000 #xc03300)
+      )
+    (sp-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 4942)
+    )
+  )
+
+(defpart 4942
+  :init-specs ((sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b 0.0)
+    (sp-int-plain-rnd spt-next-time 10 39 1)
+    (sp-launcher-by-id spt-next-launcher 4943)
+    )
+  )
+
+(defpart 4943
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.0033333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.85333335)
+    (sp-flt spt-fade-g -0.79333335)
+    (sp-flt spt-fade-b -0.14)
+    (sp-int spt-next-time 150)
+    (sp-launcher-by-id spt-next-launcher 4944)
+    )
+  )
+
+(defpart 4944
+  :init-specs ((sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-fade-r 0.0 -0.256 1.0)
+    (sp-copy-from-other spt-fade-g -1)
+    (sp-copy-from-other spt-fade-b -1)
+    (sp-flt spt-fade-a -0.072)
+    )
+  )
+
+;; ERROR: Bad vector register dependency: vf4
+;; ERROR: Bad vector register dependency: vf5
+;; ERROR: Bad vector register dependency: vf6
+;; ERROR: Bad vector register dependency: vf30
+;; ERROR: Bad vector register dependency: vf31
+(defun birth-func-dig-digger-collide ((arg0 sparticle-system)
+                             (arg1 sparticle-cpuinfo)
+                             (arg2 sprite-vec-data-3d)
+                             (arg3 sparticle-launcher)
+                             (arg4 sparticle-launch-state)
+                             )
+  (local-vars (v1-11 float))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf30 :class vf)
+         (vf31 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s5-0 (new 'stack-no-clear 'inline-array 'vector 5)))
+      (.svf (&-> s5-0 0 quad) vf4)
+      (.svf (&-> s5-0 1 quad) vf5)
+      (.svf (&-> s5-0 2 quad) vf6)
+      (.svf (&-> s5-0 3 quad) vf30)
+      (.svf (&-> s5-0 4 quad) vf31)
+      (let ((s3-0 (the-as object (-> (the-as process (-> arg4 control)) brother)))
+            (s4-0 (new 'stack-no-clear 'collide-query))
+            )
+        (let ((s2-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s4-0 start-pos quad) (-> (the-as process-drawable s3-0) root trans quad))
+          (set! (-> s4-0 start-pos y) (+ 61440.0 (-> s4-0 start-pos y)))
+          (set! (-> s2-0 x) (-> arg1 vel-sxvel x))
+          (set! (-> s2-0 z) (-> arg1 vel-sxvel z))
+          (vector-normalize! s2-0 1.0)
+          (let ((a0-5 (-> s4-0 start-pos)))
+            (let ((v1-3 (-> s4-0 start-pos)))
+              (let ((a1-5 (* 245760.0 (- 0.2 (- 0.8 (-> arg1 friction))))))
+                (.mov vf7 a1-5)
+                )
+              (.lvf vf5 (&-> s2-0 quad))
+              (.lvf vf4 (&-> v1-3 quad))
+              )
+            (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+            (.mul.x.vf acc vf5 vf7 :mask #b111)
+            (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+            (.svf (&-> a0-5 quad) vf6)
+            )
+          )
+        (set-vector! (-> s4-0 move-dist) 0.0 -81920.0 0.0 1.0)
+        (let ((v1-5 s4-0))
+          (set! (-> v1-5 radius) 1228.8)
+          (set! (-> v1-5 collide-with) (collide-spec backgnd obstacle hit-by-player-list hit-by-others-list))
+          (set! (-> v1-5 ignore-process0) (the-as process-tree s3-0))
+          (set! (-> v1-5 ignore-process1) #f)
+          (set! (-> v1-5 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-5 action-mask) (collide-action solid))
+          )
+        (if (>= (fill-and-probe-using-line-sphere *collide-cache* s4-0) 0.0)
+            (set! (-> arg1 user-float) (+ 1024.0 (-> s4-0 best-other-tri intersect y)))
+            )
+        )
+      (.lvf vf4 (&-> s5-0 0 quad))
+      (.lvf vf5 (&-> s5-0 1 quad))
+      (.lvf vf6 (&-> s5-0 2 quad))
+      (.lvf vf30 (&-> s5-0 3 quad))
+      (.lvf vf31 (&-> s5-0 4 quad))
+      )
+    (.mov v1-11 vf31)
+    0
+    (none)
+    )
+  )
+
+(defpartgroup group-dig-digger-digging
+  :id 1144
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 64)
+  :parts ((sp-item 4945 :falloff-to (meters 200))
+    (sp-item 4946 :falloff-to (meters 100))
+    (sp-item 4947 :falloff-to (meters 200))
+    (sp-item 4948 :falloff-to (meters 200))
+    (sp-item 4949 :falloff-to (meters 300))
+    )
+  )
+
+(defpart 4945
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-dig-digger-collide)
+    (sp-flt spt-num 2.0)
+    (sp-flt spt-x (meters 8))
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-vel-x (meters 0.083333336) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.16666667) (meters 0.033333335) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00008333333))
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-accel-y -12.288)
+    (sp-rnd-flt spt-friction 0.95 0.04 1.0)
+    (sp-int spt-timer 1200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-func spt-func 'check-drop-level-dig-digger-rubble-sparks)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defun check-drop-level-dig-digger-rubble-sparks ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 vector))
+  (when (and (< (-> arg2 y) (-> arg1 user-float)) (< (-> arg1 vel-sxvel y) 0.0))
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (sp-kill-particle arg0 arg1)
+      (set-vector! gp-0 (-> arg2 x) (-> arg1 user-float) (-> arg2 z) 1.0)
+      (let ((t9-1 sp-launch-particles-var)
+            (a0-2 *sp-particle-system-2d*)
+            (a1-2 (-> *part-id-table* 4950))
+            (a2-1 *launch-matrix*)
+            )
+        (set! (-> a2-1 trans quad) (-> gp-0 quad))
+        (t9-1 a0-2 a1-2 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      (let ((t9-2 sp-launch-particles-var)
+            (a0-3 *sp-particle-system-2d*)
+            (a1-3 (-> *part-id-table* 4951))
+            (a2-2 *launch-matrix*)
+            )
+        (set! (-> a2-2 trans quad) (-> gp-0 quad))
+        (t9-2 a0-3 a1-3 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      (let ((t9-3 sp-launch-particles-var)
+            (a0-4 *sp-particle-system-2d*)
+            (a1-4 (-> *part-id-table* 4952))
+            (a2-3 *launch-matrix*)
+            )
+        (set! (-> a2-3 trans quad) (-> gp-0 quad))
+        (t9-3 a0-4 a1-4 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      )
+    )
+  (none)
+  )
+
+(defpart 4948
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 6.0)
+    (sp-flt spt-x (meters 9))
+    (sp-rnd-flt spt-y (meters 1) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 4) (meters 6) 1.0)
+    (sp-flt spt-rot-x 2048.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-flt spt-a 0.0)
+    (sp-flt spt-fade-g -3.2)
+    (sp-flt spt-fade-b -3.2)
+    (sp-flt spt-fade-a 0.8)
+    (sp-int spt-timer 40)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 4096.0)
+    (sp-int spt-next-time 20)
+    (sp-launcher-by-id spt-next-launcher 4953)
+    (sp-rnd-flt spt-rotate-y (degrees -45.0) (degrees 135.0) 1.0)
+    )
+  )
+
+(defpart 4953
+  :init-specs ((sp-flt spt-fade-a -0.8))
+  )
+
+(defpart 4946
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-flt spt-num 3.0)
+    (sp-flt spt-x (meters 8))
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.02) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-omega 2.048 2.048 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.23333333) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.4) (meters 0.033333335) 1.0)
+    (sp-flt spt-fade-g -0.85333335)
+    (sp-flt spt-fade-b -1.7066667)
+    (sp-flt spt-accel-y -12.288)
+    (sp-rnd-flt spt-friction 0.9 0.04 1.0)
+    (sp-int-plain-rnd spt-timer 100 49 1)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4947
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-flt spt-num 3.0)
+    (sp-flt spt-x (meters 8))
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.3) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-omega 4.096 4.096 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.083333336) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.16666667) (meters 0.033333335) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00008333333))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.14222223 -0.21333334 1.0)
+    (sp-flt spt-accel-y -12.288)
+    (sp-rnd-flt spt-friction 0.95 0.04 1.0)
+    (sp-int spt-timer 900)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 -1758461952 -1758461696 -1758461440 -1758461184 -1758460928)
+      )
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4949
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-flt spt-x (meters 9))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 3) (meters 3) 1.0)
+    (sp-rnd-flt spt-r 80.0 16.0 1.0)
+    (sp-rnd-flt spt-g 70.0 16.0 1.0)
+    (sp-rnd-flt spt-b 70.0 16.0 1.0)
+    (sp-rnd-flt spt-a 96.0 32.0 1.0)
+    (sp-flt spt-vel-x (meters 0.11333334))
+    (sp-rnd-flt spt-vel-y (meters 0.16666667) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.011666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -2.7306666 1.0)
+    (sp-rnd-flt spt-friction 0.9 0.04 1.0)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4950
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 96.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-rnd-flt spt-fade-a -0.42666668 -0.85333335 1.0)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 -1758461952 -1758461696 -1758461440 -1758461184 -1758460928)
+      )
+    (sp-rnd-flt spt-conerot-x (degrees 10.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4951
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 96.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.04) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-rnd-flt spt-friction 0.94 0.02 1.0)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 -1758461952 -1758461696 -1758461440 -1758461184 -1758460928)
+      )
+    (sp-int-plain-rnd spt-next-time 150 299 1)
+    (sp-launcher-by-id spt-next-launcher 4954)
+    (sp-flt spt-conerot-x (degrees 90.0))
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4954
+  :init-specs ((sp-flt spt-rotvel-z (degrees 0.0)) (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0))
+  )
+
+(defpart 4952
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.5 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 1) 1.0)
+    (sp-rnd-flt spt-r 80.0 16.0 1.0)
+    (sp-rnd-flt spt-g 70.0 16.0 1.0)
+    (sp-rnd-flt spt-b 70.0 16.0 1.0)
+    (sp-rnd-flt spt-a 32.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-fade-a -0.053333335 -0.053333335 1.0)
+    (sp-rnd-flt spt-accel-y 0.0 1.3653333 1.0)
+    (sp-rnd-flt spt-friction 0.9 0.05 1.0)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 70.0) (degrees 20.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defmethod draw hud-dig-clasp ((obj hud-dig-clasp))
+  (set-hud-piece-position!
+    (the-as hud-sprite (-> obj sprites))
+    (the int (+ 457.0 (* 130.0 (-> obj offset))))
+    210
+    )
+  (format (clear (-> obj strings 0 text)) "~D" (-> obj values 0 current))
+  (set-as-offset-from! (the-as hud-sprite (-> obj strings 0 pos)) (the-as vector4w (-> obj sprites)) -18 29)
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+(defmethod update-values hud-dig-clasp ((obj hud-dig-clasp))
+  (set! (-> obj values 0 target) (the int (-> *game-info* counter)))
+  ((method-of-type hud update-values) obj)
+  0
+  (none)
+  )
+
+(defmethod init-callback hud-dig-clasp ((obj hud-dig-clasp))
+  (set! (-> obj level) (level-get *level* 'dig1))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :page #xb1c)))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 0 scale-x) 1.2)
+  (set! (-> obj sprites 0 scale-y) 1.2)
+  (alloc-string-if-needed obj 0)
+  (set! (-> obj strings 0 scale) 0.6)
+  (set! (-> obj strings 0 flags) (font-flags kerning middle large))
+  0
+  (none)
+  )
+
+(deftype dig-clasp (process-drawable)
+  ((b    basic               :offset-assert 200)
+   (conn connection-minimap  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 24
+  :size-assert         #xd0
+  :flag-assert         #x18005000d0
+  (:methods
+    (broken () _type_ :state 20)
+    (break-it () _type_ :state 21)
+    (idle () _type_ :state 22)
+    (dig-clasp-method-23 (_type_ vector) vector 23)
+    )
+  )
+
+
+(defskelgroup skel-dig-clasp dig-clasp 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 4))
+
+(defskelgroup skel-dig-clasp-explode dig-clasp 3 5 ((4 (meters 999999))) :bounds (static-spherem 0 0 0 8))
+
+(defskelgroup skel-dig-clasp-b dig-clasp-b 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 4))
+
+(define *dig-clasp-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 3 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    )
+  )
+
+(defmethod dig-clasp-method-23 dig-clasp ((obj dig-clasp) (arg0 vector))
+  (if (-> obj b)
+      (vector<-cspace! arg0 (-> obj node-list data 3))
+      (vector<-cspace! arg0 (-> obj node-list data 6))
+      )
+  )
+
+(defstate broken (dig-clasp)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('broken?)
+                      #t
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (when (-> self conn)
+      (kill-callback (-> *minimap* engine) (-> self conn))
+      (set! (-> self conn) #f)
+      )
+    (cond
+      ((-> self b)
+       (ja :group! (-> self draw art-group data 2)
+           :num! (identity (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+           )
+       (setup-masks (-> self draw) 0 2)
+       )
+      (else
+        (ja :group! (-> self draw art-group data 2)
+            :num! (identity (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+            )
+        (setup-masks (-> self draw) 0 2)
+        )
+      )
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior dig-clasp) sleep-code)
+  )
+
+(defstate break-it (dig-clasp)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('broken?)
+                      #t
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (sound-play "dig-tether-snap")
+    (talker-speech-class-method-10 (-> *talker-speech* 191))
+    (talker-speech-class-method-10 (-> *talker-speech* 192))
+    (cond
+      ((-> self b)
+       (ja :group! (-> self draw art-group data 2) :num! min)
+       (setup-masks (-> self draw) 0 2)
+       )
+      (else
+        (ja :group! (-> self draw art-group data 2) :num! min)
+        (setup-masks (-> self draw) 0 2)
+        )
+      )
+    (let ((gp-3 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-dig-clasp-explode" (the-as (pointer uint32) #f))
+        5
+        gp-3
+        *dig-clasp-exploder-params*
+        :to self
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (if (nonzero? (-> self part))
+        (spawn (-> self part) (dig-clasp-method-23 self (new 'stack-no-clear 'vector)))
+        )
+    (if (ja-done? 0)
+        (go-virtual broken)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-clasp) sleep-code)
+  :post (the-as (function none :behavior dig-clasp) ja-post)
+  )
+
+(defstate idle (dig-clasp)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('tether-position)
+       (dig-clasp-method-23 self (the-as vector (-> event param 0)))
+       )
+      (('attack)
+       (let ((v1-2 (the-as attack-info (-> event param 1))))
+         (when (and (logtest? (-> v1-2 mask) (attack-info-mask mode)) (= (-> v1-2 mode) 'board))
+           (cpad-set-buzz! (-> *cpad-list* cpads 0) 0 85 (seconds 0.1))
+           (go-virtual break-it)
+           self
+           )
+         )
+       )
+      (('break)
+       (go-virtual break-it)
+       self
+       )
+      )
+    )
+  :enter (behavior ()
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior dig-clasp) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-clasp ((obj dig-clasp) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 transform-index) 6)
+      (set-vector! (-> v1-2 local-sphere) 0.0 -3072.0 0.0 4096.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-clasp" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj draw light-index) (the-as uint 1))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1142) obj))
+  (set! (-> obj b) #f)
+  (set! (-> obj conn) (minimap-method-12 *minimap* obj (the-as uint 16) (the-as int #f) (the-as vector #t) 0))
+  (if (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+      (go (method-of-object obj broken))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+(deftype dig-clasp-b (dig-clasp)
+  ()
+  :heap-base #x50
+  :method-count-assert 24
+  :size-assert         #xd0
+  :flag-assert         #x18005000d0
+  )
+
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-clasp-b ((obj dig-clasp-b) (arg0 entity-actor))
+  (when (not (task-node-closed? (game-task-node dig-knock-down-resolution)))
+    (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+      (let ((v1-2 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+        (set! (-> v1-2 prim-core collide-as) (collide-spec enemy))
+        (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+        (set! (-> v1-2 transform-index) 3)
+        (set-vector! (-> v1-2 local-sphere) 0.0 -3072.0 0.0 4096.0)
+        (set! (-> s4-0 total-prims) (the-as uint 1))
+        (set! (-> s4-0 root-prim) v1-2)
+        )
+      (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+      (let ((v1-5 (-> s4-0 root-prim)))
+        (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+        (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+        )
+      (set! (-> obj root) s4-0)
+      )
+    (process-drawable-from-entity! obj arg0)
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-clasp-b" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (set! (-> obj draw light-index) (the-as uint 1))
+    (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1142) obj))
+    (set! (-> obj b) (the-as basic #t))
+    (set! (-> obj conn) (minimap-method-12 *minimap* obj (the-as uint 16) (the-as int #f) (the-as vector #t) 0))
+    (if (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+        (go (method-of-object obj broken))
+        (go (method-of-object obj idle))
+        )
+    )
+  (none)
+  )
+
+(deftype dig-tether-chain (structure)
+  ((position  vector    :inline :offset-assert   0)
+   (velocity  vector    :inline :offset-assert  16)
+   (joint-mod joint-mod         :offset-assert  32)
+   )
+  :method-count-assert 9
+  :size-assert         #x24
+  :flag-assert         #x900000024
+  )
+
+
+(deftype dig-tether (process-drawable)
+  ((clasp             entity-actor                  :offset-assert 200)
+   (clasp-info-ok     symbol                        :offset-assert 204)
+   (clasp-pos         vector              :inline   :offset-assert 208)
+   (digger-pos        vector              :inline   :offset-assert 224)
+   (digger-vertical   vector              :inline   :offset-assert 240)
+   (frame             oscillating-float   :inline   :offset-assert 256)
+   (frame-kicker      delayed-rand-float  :inline   :offset-assert 280)
+   (old-dist          float                         :offset-assert 308)
+   (chain-joints      dig-tether-chain    8 :inline :offset-assert 320)
+   (chain-offset-rand delayed-rand-vector :inline   :offset-assert 704)
+   (chain-offset      oscillating-vector  :inline   :offset-assert 752)
+   (joint-one         joint-mod                     :offset-assert 812)
+   (snapped-look      lod-set             :inline   :offset-assert 816)
+   )
+  :heap-base #x2f0
+  :method-count-assert 25
+  :size-assert         #x361
+  :flag-assert         #x1902f00361
+  (:methods
+    (broken () _type_ :state 20)
+    (idle () _type_ :state 21)
+    (dig-tether-method-22 (_type_) none 22)
+    (dig-tether-method-23 (_type_) none 23)
+    (dig-tether-method-24 (_type_) none 24)
+    )
+  )
+
+
+(defskelgroup skel-dig-tether-unsnapped dig-tether 2 4
+              ((3 (meters 999999)))
+              :bounds (static-spherem 0 0 0 80)
+              )
+
+(defskelgroup skel-dig-tether-snapped dig-tether 0 4 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 80))
+
+(defmethod dig-tether-method-22 dig-tether ((obj dig-tether))
+  (with-pp
+    (when (-> obj clasp)
+      (let* ((s4-0 (-> obj clasp extra process))
+             (s5-0 (if (type? s4-0 dig-clasp)
+                       s4-0
+                       )
+                   )
+             (a1-1 (new 'stack-no-clear 'event-message-block))
+             )
+        (set! (-> a1-1 from) (process->ppointer pp))
+        (set! (-> a1-1 num-params) 0)
+        (set! (-> a1-1 message) 'broken?)
+        (cond
+          ((or (send-event-function s5-0 a1-1)
+               (logtest? (-> obj clasp extra perm status) (entity-perm-status subtask-complete))
+               )
+           (format 0 "FAILURE")
+           (go (method-of-object obj broken))
+           )
+          (s5-0
+            (send-event s5-0 'tether-position (-> obj clasp-pos))
+            (set! (-> obj clasp-info-ok) #t)
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defmethod dig-tether-method-23 dig-tether ((obj dig-tether))
+  (set-params! (-> obj chain-offset-rand) 75 150 2048.0 204.8)
+  (set-params! (-> obj chain-offset) (the-as vector #f) 4.096 20.48 0.9)
+  (mode-set! (-> obj joint-one) (joint-mod-mode joint-set-world))
+  (dotimes (s5-0 7)
+    (cond
+      ((-> obj clasp-info-ok)
+       (vector<-cspace! (the-as vector (-> obj chain-joints s5-0)) (-> obj chain-joints s5-0 joint-mod joint))
+       )
+      (else
+        (set! (-> obj chain-joints s5-0 position quad) (-> obj root trans quad))
+        (set! (-> obj chain-joints s5-0 position y)
+              (- (-> obj chain-joints s5-0 position y) (* 4096.0 (the float s5-0)))
+              )
+        )
+      )
+    ;; original
+    ;; (vector-reset! (+ (the-as uint (-> obj chain-joints 0 velocity)) (* 48 s5-0)))
+    (vector-reset! (-> obj chain-joints s5-0 velocity)) ;; hack
+    (mode-set! (-> obj chain-joints s5-0 joint-mod) (joint-mod-mode joint-set-world))
+    )
+  (set! (-> obj chain-joints 7 position quad) (-> obj chain-joints 6 position quad))
+  (vector-reset! (-> obj chain-joints 7 velocity))
+  (lods-assign! (-> obj draw) (-> obj snapped-look))
+  (none)
+  )
+
+(defmethod dig-tether-method-24 dig-tether ((obj dig-tether))
+  (local-vars (sv-144 dig-tether-chain) (sv-160 vector))
+  (update-with-delay! (-> obj chain-offset-rand))
+  (update! (-> obj chain-offset) (-> obj chain-offset-rand value))
+  (let ((s5-0 (new 'stack-no-clear 'matrix))
+        (s4-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s4-0 quad) (-> obj root trans quad))
+    (let ((s3-0 (new 'stack-no-clear 'vector))
+          (f30-0 0.2)
+          (s2-0 (-> obj chain-offset))
+          (f28-0 0.1)
+          (s1-0 (new 'stack-no-clear 'vector))
+          )
+      (vector-! (-> s5-0 vector 2) (the-as vector (-> obj chain-joints)) (-> obj root trans))
+      (vector-normalize! (-> s5-0 vector 2) 1.0)
+      (vector-cross! (the-as vector (-> s5-0 vector)) (-> obj digger-vertical) (-> s5-0 vector 2))
+      (vector-normalize! (the-as vector (-> s5-0 vector)) 1.0)
+      (vector-cross! (-> s5-0 vector 1) (-> s5-0 vector 2) (the-as vector (-> s5-0 vector)))
+      (matrix->quaternion (-> obj root quat) s5-0)
+      (set! (-> obj joint-one trans quad) (-> obj root trans quad))
+      (quaternion-copy! (-> obj joint-one quat) (-> obj root quat))
+      (set! (-> s3-0 quad) (-> s5-0 vector 1 quad))
+      (dotimes (s0-0 8)
+        (set! sv-144 (-> obj chain-joints s0-0))
+        (set! sv-160 (new 'stack-no-clear 'vector))
+        (let ((v1-23 (-> sv-144 position quad)))
+          (set! (-> sv-160 quad) v1-23)
+          )
+        (set! (-> sv-160 y) (+ -2048.0 (-> sv-160 y)))
+        (vector+float*! sv-160 sv-160 (the-as vector s2-0) f28-0)
+        (set! f28-0 (fmin 1.0 (+ 0.2 f28-0)))
+        (when (< s0-0 7)
+          (vector+float*!
+            sv-160
+            sv-160
+            (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* 48 (+ s0-0 1))))
+            f30-0
+            )
+          (set! f30-0 (fmin 0.9 (+ 0.2 f30-0)))
+          )
+        (vector-! s1-0 sv-160 s4-0)
+        (vector-normalize! s1-0 12288.0)
+        (vector+! sv-160 s1-0 s4-0)
+        (vector-! s1-0 sv-160 (-> obj digger-pos))
+        (vector-flatten! s1-0 s1-0 (-> obj digger-vertical))
+        (let ((f0-6 (vector-normalize-ret-len! s1-0 1.0)))
+          (if (< f0-6 73728.0)
+              (vector+float*! sv-160 sv-160 s1-0 (- 73728.0 f0-6))
+              )
+          )
+        (vector-! (-> sv-144 velocity) sv-160 (-> sv-144 position))
+        (vector-float*! (-> sv-144 velocity) (-> sv-144 velocity) 0.75)
+        (let ((f0-9 (vector-length (-> sv-144 velocity))))
+          (if (< 6144.0 f0-9)
+              (vector-float*! (-> sv-144 velocity) (-> sv-144 velocity) (/ 2048.0 f0-9))
+              )
+          )
+        (vector+! sv-160 (-> sv-144 position) (-> sv-144 velocity))
+        (set! (-> sv-144 position quad) (-> sv-160 quad))
+        (if (-> sv-144 joint-mod)
+            (set! (-> sv-144 joint-mod trans quad) (-> sv-160 quad))
+            )
+        (when (< s0-0 7)
+          (vector-! (-> s5-0 vector 2) (the-as vector (-> obj chain-joints (+ s0-0 1))) sv-160)
+          (vector-normalize! (-> s5-0 vector 2) 1.0)
+          (vector-cross! (the-as vector (-> s5-0 vector)) s3-0 (-> s5-0 vector 2))
+          (vector-normalize! (the-as vector (-> s5-0 vector)) 1.0)
+          (vector-cross! (-> s5-0 vector 1) (-> s5-0 vector 2) (the-as vector (-> s5-0 vector)))
+          (matrix->quaternion (-> sv-144 joint-mod quat) s5-0)
+          (set! (-> s3-0 quad) (-> s5-0 vector 1 quad))
+          )
+        (set! (-> s4-0 quad) (-> sv-160 quad))
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch vector vs object.
+(defbehavior dig-tether-handler dig-tether ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (the-as object (case arg2
+                   (('set-pos)
+                    (set! (-> self root trans quad) (-> (the-as vector (-> arg3 param 0)) quad))
+                    (set! (-> self digger-pos quad) (-> (the-as vector (-> arg3 param 1)) quad))
+                    (let ((v0-0 (-> self digger-vertical)))
+                      (set! (-> v0-0 quad) (-> (the-as vector (-> arg3 param 2)) quad))
+                      v0-0
+                      )
+                    )
+                   )
+          )
+  )
+
+(defstate broken (dig-tether)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('broken?)
+       #t
+       )
+      (else
+        (dig-tether-handler proc arg1 event-type event)
+        )
+      )
+    )
+  :enter (behavior ()
+    (dig-tether-method-23 self)
+    (none)
+    )
+  :trans (behavior ()
+    (dig-tether-method-24 self)
+    (none)
+    )
+  :code (the-as (function none :behavior dig-tether) sleep-code)
+  :post (the-as (function none :behavior dig-tether) ja-post)
+  )
+
+(defstate idle (dig-tether)
+  :virtual #t
+  :event dig-tether-handler
+  :enter (behavior ()
+    (set! (-> self clasp-info-ok) #f)
+    (set-params! (-> self frame) 0.5 0.01 0.02 0.97)
+    (set-params! (-> self frame-kicker) 9 30 0.4)
+    (set! (-> self old-dist) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (dig-tether-method-22 self)
+    (when (-> self clasp-info-ok)
+      (let* ((v1-4 (vector-! (new 'stack-no-clear 'vector) (-> self clasp-pos) (-> self root trans)))
+             (f30-0 (vector-length v1-4))
+             )
+        (let ((gp-0 (new 'stack-no-clear 'matrix)))
+          (vector-float*! (-> gp-0 vector 2) v1-4 (/ 1.0 f30-0))
+          (set-vector! (-> gp-0 vector 0) (-> gp-0 vector 2 z) 0.0 (- (-> gp-0 vector 2 x)) 1.0)
+          (vector-normalize! (the-as vector (-> gp-0 vector)) 1.0)
+          (vector-cross! (-> gp-0 vector 1) (-> gp-0 vector 2) (the-as vector (-> gp-0 vector)))
+          (vector-reset! (-> gp-0 trans))
+          (set! (-> gp-0 vector 0 w) 0.0)
+          (set! (-> gp-0 vector 1 w) 0.0)
+          (set! (-> gp-0 vector 2 w) 0.0)
+          (matrix->quaternion (-> self root quat) gp-0)
+          )
+        (set! (-> self root scale z) (* 0.000003937752 f30-0))
+        (when (!= (-> self old-dist) 0.0)
+          (let ((f2-0 (fabs (- f30-0 (-> self old-dist)))))
+            (set! (-> self frame target) (fmin 1.0 (fmax 0.0 (* 0.0008719308 (- 573.44 f2-0)))))
+            )
+          )
+        (set! (-> self old-dist) f30-0)
+        )
+      (update! (-> self frame-kicker))
+      (update! (-> self frame) (-> self frame-kicker value))
+      (ja :num-func num-func-identity :frame-num (* 10.0 (-> self frame value)))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-tether) sleep-code)
+  :post (the-as (function none :behavior dig-tether) ja-post)
+  )
+
+;; WARN: Return type mismatch process-drawable vs dig-tether.
+(defmethod relocate dig-tether ((obj dig-tether) (arg0 int))
+  (if (nonzero? (-> obj joint-one))
+      (&+! (-> obj joint-one) arg0)
+      )
+  (dotimes (v1-4 7)
+    (if (nonzero? (-> obj chain-joints v1-4 joint-mod))
+        (&+! (-> obj chain-joints v1-4 joint-mod) arg0)
+        )
+    )
+  (the-as dig-tether ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-tether-init-by-other dig-tether ((arg0 vector) (arg1 entity))
+  (set! (-> self root) (new 'process 'trsqv))
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-tether-snapped" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> self draw light-index) (the-as uint 1))
+  (set! (-> self clasp) (the-as entity-actor arg1))
+  (set! (-> self root pause-adjust-distance) 819200.0)
+  (set! (-> self joint-one) (new 'process 'joint-mod (joint-mod-mode flex-blend) self 3))
+  (set! (-> self joint-one track-mode) (track-mode no-scale))
+  (dotimes (gp-1 7)
+    (set! (-> self chain-joints gp-1 joint-mod)
+          (new 'process 'joint-mod (joint-mod-mode flex-blend) self (+ gp-1 4))
+          )
+    (set! (-> self chain-joints gp-1 joint-mod track-mode) (track-mode no-scale))
+    )
+  (set! (-> self chain-joints 7 joint-mod) #f)
+  (setup-lods!
+    (-> self snapped-look)
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-tether-snapped" (the-as (pointer uint32) #f)))
+    (-> self draw art-group)
+    (-> self entity)
+    )
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype dig-digger-tether-info (structure)
+  ((rp       int32   :offset-assert   0)
+   (handle   handle  :offset-assert   8)
+   (broken-x float   :offset-assert  16)
+   (broken-z float   :offset-assert  20)
+   )
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
+
+
+(deftype dig-digger (process-drawable)
+  ((actor-group       (pointer actor-group)               :offset-assert 200)
+   (actor-group-count int32                               :offset-assert 204)
+   (tethers           dig-digger-tether-info   24 :inline :offset-assert 208)
+   (vertical          oscillating-vector       :inline    :offset-assert 976)
+   (vertical-rand     delayed-rand-vector      :inline    :offset-assert 1040)
+   (start-y           float                               :offset-assert 1088)
+   (y-offset          bouncing-float           :inline    :offset-assert 1092)
+   (y-offset-kicker   delayed-rand-float       :inline    :offset-assert 1136)
+   (twist             oscillating-float        :inline    :offset-assert 1164)
+   (twist-kicker      delayed-rand-float       :inline    :offset-assert 1192)
+   (smoke-part        sparticle-launch-control            :offset-assert 1220)
+   (motor-sound       uint32                              :offset-assert 1224)
+   (bit-sound         uint32                              :offset-assert 1228)
+   (movie-handle      handle                              :offset-assert 1232)
+   (hud-counter       handle                              :offset-assert 1240)
+   (speech-time       time-frame                          :offset-assert 1248)
+   (speech-count      int32                               :offset-assert 1256)
+   )
+  :heap-base #x470
+  :method-count-assert 25
+  :size-assert         #x4ec
+  :flag-assert         #x19047004ec
+  (:methods
+    (idle () _type_ :state 20)
+    (hidden () _type_ :state 21)
+    (dig-digger-method-22 (_type_ int) entity 22)
+    (dig-digger-method-23 (_type_) none 23)
+    (dig-digger-method-24 (_type_) none 24)
+    )
+  )
+
+
+(defskelgroup skel-dig-digger dig-digger 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 36 0 40)
+              :origin-joint-index 3
+              )
+
+(defmethod dig-digger-method-22 dig-digger ((obj dig-digger) (arg0 int))
+  (if (and (> (-> obj actor-group-count) 0) (< arg0 (-> obj actor-group 0 length)))
+      (-> obj actor-group 0 data arg0 actor)
+      (the-as entity #f)
+      )
+  )
+
+(defmethod dig-digger-method-23 dig-digger ((obj dig-digger))
+  (dotimes (s5-0 24)
+    (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj tethers s5-0 rp))))
+          (s3-0 (dig-digger-method-22 obj s5-0))
+          )
+      (if (and s3-0 (not (handle->process (-> obj tethers s5-0 handle))))
+          (set! (-> obj tethers s5-0 handle) (ppointer->handle (process-spawn dig-tether s4-0 s3-0 :to obj)))
+          )
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod dig-digger-method-24 dig-digger ((obj dig-digger))
+  (with-pp
+    (set! (-> obj vertical target x) 0.0)
+    (set! (-> obj vertical target z) 0.0)
+    (let ((s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) (the-as vector (-> obj vertical)) 1.0))
+          (s5-0 0)
+          )
+      (dotimes (s3-0 24)
+        (let* ((s2-0 (-> obj tethers s3-0))
+               (s1-0 (handle->process (-> s2-0 handle)))
+               )
+          (cond
+            (s1-0
+              (let ((v1-10 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj tethers s3-0 rp)))))
+                (send-event s1-0 'set-pos v1-10 (-> obj root trans) s4-0)
+                )
+              (cond
+                ((send-event s1-0 'broken?)
+                 (+! (-> obj vertical target x) (-> s2-0 broken-x))
+                 (+! (-> obj vertical target z) (-> s2-0 broken-z))
+                 )
+                (else
+                  (+! s5-0 1)
+                  )
+                )
+              )
+            (else
+              (+! (-> obj vertical target x) (-> s2-0 broken-x))
+              (+! (-> obj vertical target z) (-> s2-0 broken-z))
+              )
+            )
+          )
+        )
+      (set! (-> *game-info* counter) (the float s5-0))
+      (when (and (= s5-0 24)
+                 (>= (- (-> pp clock frame-counter) (-> obj speech-time)) (seconds 20))
+                 *target*
+                 (and (>= 409600.0 (vector-vector-distance (-> obj root trans) (-> *target* control trans)))
+                      (zero? (logand (focus-status teleporting) (-> *target* focus-status)))
+                      )
+                 )
+        (let ((v1-37 (logand (-> obj speech-count) 1)))
+          (cond
+            ((zero? v1-37)
+             (talker-spawn-func (-> *talker-speech* 191) *entity-pool* (target-pos 0) (the-as region #f))
+             (if (and *target* (zero? (logand (focus-status board) (-> *target* focus-status))))
+                 (talker-spawn-func (-> *talker-speech* 115) *entity-pool* (target-pos 0) (the-as region #f))
+                 )
+             )
+            ((= v1-37 1)
+             (talker-spawn-func (-> *talker-speech* 192) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            )
+          )
+        (set! (-> obj speech-time) (-> pp clock frame-counter))
+        (+! (-> obj speech-count) 1)
+        )
+      (cond
+        ((zero? s5-0)
+         (send-event (handle->process (-> obj hud-counter)) 'hide-and-die)
+         (set! (-> obj hud-counter) (the-as handle #f))
+         (when (= (-> obj movie-handle) #f)
+           (set! (-> obj movie-handle)
+                 (ppointer->handle (process-spawn scene-player :init scene-player-init "dig-digger-explode" #t #f))
+                 )
+           (if (handle->process (-> obj movie-handle))
+               (cleanup-for-death obj)
+               )
+           )
+         )
+        ((>= 4 s5-0)
+         (eval!
+           (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (the-as vector #f))
+           '(want-anim "dig-digger-explode")
+           )
+         )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+(defstate idle (dig-digger)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('touch 'attack)
+       (when ((method-of-type touching-shapes-entry prims-touching?)
+              (the-as touching-shapes-entry (-> event param 0))
+              (the-as collide-shape (-> self root))
+              (the-as uint 1)
+              )
+         (let ((a0-7 (if (type? proc process-focusable)
+                         proc
+                         )
+                     )
+               )
+           (when a0-7
+             (let ((a1-4 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-4 from) (process->ppointer self))
+               (set! (-> a1-4 num-params) 2)
+               (set! (-> a1-4 message) 'attack)
+               (set! (-> a1-4 param 0) (-> event param 0))
+               (let ((a2-3 (new 'static 'attack-info :mask (attack-info-mask id))))
+                 (let* ((v1-7 *game-info*)
+                        (a3-2 (+ (-> v1-7 attack-id) 1))
+                        )
+                   (set! (-> v1-7 attack-id) a3-2)
+                   (set! (-> a2-3 id) a3-2)
+                   )
+                 (set! (-> a1-4 param 1) (the-as uint a2-3))
+                 )
+               (if (send-event-function a0-7 a1-4)
+                   #f
+                   )
+               )
+             )
+           )
+         )
+       )
+      (('hide)
+       (go-virtual hidden)
+       )
+      )
+    )
+  :enter (behavior ()
+    (set-params! (-> self vertical) (new 'static 'vector :y 16.0) 0.01 0.1 0.9)
+    (set-params! (-> self vertical-rand) 15 75 1.0 0.0)
+    (set-params! (-> self y-offset) 0.0 1.0 0.0 0.7 0.08 0.3 0.97)
+    (set-params! (-> self y-offset-kicker) 18 30 1.0)
+    (set-params! (-> self twist) 0.0 0.01 0.1 0.9)
+    (set-params! (-> self twist-kicker) 24 75 1.0)
+    (ja-post)
+    (dig-digger-method-23 self)
+    (set! (-> self motor-sound) (the-as uint (new-sound-id)))
+    (set! (-> self bit-sound) (the-as uint (new-sound-id)))
+    (none)
+    )
+  :exit (behavior ()
+    (sound-stop (the-as sound-id (-> self motor-sound)))
+    (sound-stop (the-as sound-id (-> self bit-sound)))
+    (send-event (handle->process (-> self hud-counter)) 'hide-and-die)
+    (set! (-> self hud-counter) (the-as handle #f))
+    (none)
+    )
+  :trans (behavior ()
+    (let ((f0-0 (vector-vector-distance-squared (ear-trans 0) (-> self root trans)))
+          (f1-0 1228800.0)
+          )
+      (when (< f0-0 (* f1-0 f1-0))
+        (let ((gp-1 (new 'stack-no-clear 'vector)))
+          (vector<-cspace! gp-1 (-> self node-list data 29))
+          (sound-play "digger-motor" :id (the-as sound-id (-> self motor-sound)) :position gp-1)
+          )
+        (sound-play "digger-bit" :id (the-as sound-id (-> self bit-sound)) :position (-> self root trans))
+        )
+      )
+    (ja :num! (loop!))
+    (update-with-delay! (-> self vertical-rand))
+    (update! (-> self vertical) (-> self vertical-rand value))
+    (update-and-clear! (-> self twist-kicker))
+    (if (!= (-> self twist-kicker value) 0.0)
+        (set! (-> self twist-kicker value) 1.0)
+        )
+    (update! (-> self twist) (fabs (-> self twist-kicker value)))
+    (let ((gp-2 (new 'stack-no-clear 'matrix)))
+      (vector-normalize-copy! (-> gp-2 vector 1) (the-as vector (-> self vertical)) 1.0)
+      (set-vector!
+        (-> gp-2 vector 0)
+        (cos (* 32768.0 (-> self twist value)))
+        0.0
+        (sin (* 32768.0 (-> self twist value)))
+        1.0
+        )
+      (vector-cross! (-> gp-2 vector 2) (the-as vector (-> gp-2 vector)) (-> gp-2 vector 1))
+      (vector-normalize! (-> gp-2 vector 2) 1.0)
+      (vector-cross! (the-as vector (-> gp-2 vector)) (-> gp-2 vector 1) (-> gp-2 vector 2))
+      (vector-reset! (-> gp-2 trans))
+      (set! (-> gp-2 vector 0 w) 0.0)
+      (set! (-> gp-2 vector 1 w) 0.0)
+      (set! (-> gp-2 vector 2 w) 0.0)
+      (matrix->quaternion (-> self root quat) gp-2)
+      )
+    (update! (-> self y-offset-kicker))
+    (update! (-> self y-offset) (-> self y-offset-kicker value))
+    (set! (-> self root trans y) (+ (-> self start-y) (* 4096.0 (-> self y-offset osc value))))
+    (when (nonzero? (-> self smoke-part))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 28))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 29))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 30))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 31))
+      )
+    (if (nonzero? (-> self part))
+        (spawn (-> self part) (-> self root trans))
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-digger) sleep-code)
+  :post (behavior ()
+    (transform-post)
+    (dig-digger-method-24 self)
+    (none)
+    )
+  )
+
+(defstate hidden (dig-digger)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (let ((v1-0 event-type)
+          (a0-1 'explode)
+          )
+      (the-as object (if (= v1-0 a0-1)
+                         (set-dig1-explosion! (the-as float a0-1))
+                         )
+              )
+      )
+    )
+  :enter (behavior ()
+    (while (-> self child)
+      (deactivate (-> self child 0))
+      )
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (none)
+    )
+  :code (the-as (function none :behavior dig-digger) sleep-code)
+  )
+
+(defmethod deactivate dig-digger ((obj dig-digger))
+  (if (nonzero? (-> obj smoke-part))
+      (kill-and-free-particles (-> obj smoke-part))
+      )
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs dig-digger.
+(defmethod relocate dig-digger ((obj dig-digger) (arg0 int))
+  (when (nonzero? (-> obj smoke-part))
+    (if (nonzero? (-> obj smoke-part))
+        (&+! (-> obj smoke-part) arg0)
+        )
+    )
+  (the-as dig-digger ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-digger ((obj dig-digger) (arg0 entity-actor))
+  (local-vars (sv-16 res-tag))
+  (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s4-0 reaction) cshape-reaction-default)
+    (set! (-> s4-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s4-0 penetrated-by) (penetrate))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 10) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 11))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid deadly))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 143360.0 0.0 159744.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 9) (the-as uint 1))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-13 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-13 transform-index) 3)
+      (set-vector! (-> v1-13 local-sphere) 0.0 36864.0 0.0 65536.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 172032.0 0.0 86016.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-17 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 3)
+      (set-vector! (-> v1-17 local-sphere) 0.0 151552.0 0.0 86016.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-19 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-19 prim-core action) (collide-action solid))
+      (set! (-> v1-19 transform-index) 3)
+      (set-vector! (-> v1-19 local-sphere) 0.0 110592.0 0.0 69632.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-21 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-21 prim-core action) (collide-action solid))
+      (set! (-> v1-21 transform-index) 3)
+      (set-vector! (-> v1-21 local-sphere) 0.0 73728.0 0.0 65536.0)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-23 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-23 prim-core action) (collide-action solid))
+      (set! (-> v1-23 transform-index) 3)
+      (set-vector! (-> v1-23 local-sphere) 0.0 266240.0 0.0 40960.0)
+      )
+    (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (the-as uint 0))))
+      (set! (-> v1-25 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-25 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-25 prim-core action) (collide-action solid))
+      (set! (-> v1-25 transform-index) 3)
+      (set-vector! (-> v1-25 local-sphere) 16384.0 249856.0 -16384.0 20480.0)
+      )
+    (let ((v1-27 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0))))
+      (set! (-> v1-27 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-27 prim-core action) (collide-action solid))
+      (set! (-> v1-27 transform-index) 3)
+      (set-vector! (-> v1-27 local-sphere) 8192.0 245760.0 24576.0 16384.0)
+      )
+    (let ((v1-29 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0))))
+      (set! (-> v1-29 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-29 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-29 prim-core action) (collide-action solid))
+      (set! (-> v1-29 transform-index) 3)
+      (set-vector! (-> v1-29 local-sphere) -61440.0 102400.0 0.0 20480.0)
+      )
+    (let ((v1-31 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (the-as uint 0))))
+      (set! (-> v1-31 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-31 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-31 prim-core action) (collide-action solid))
+      (set! (-> v1-31 transform-index) 3)
+      (set-vector! (-> v1-31 local-sphere) -57344.0 81920.0 0.0 16384.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-34 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-34 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-34 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (set! (-> obj root pause-adjust-distance) 819200.0)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-digger" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj draw light-index) (the-as uint 1))
+  (logior! (-> obj skel status) (joint-control-status sync-math))
+  (set! sv-16 (new 'static 'res-tag))
+  (let ((v1-46 (res-lump-data (-> obj entity) 'actor-groups pointer :tag-ptr (& sv-16))))
+    (cond
+      ((and v1-46 (nonzero? (-> sv-16 elt-count)))
+       (set! (-> obj actor-group) (the-as (pointer actor-group) v1-46))
+       (set! (-> obj actor-group-count) (the-as int (-> sv-16 elt-count)))
+       )
+      (else
+        (set! (-> obj actor-group) (the-as (pointer actor-group) #f))
+        (set! (-> obj actor-group-count) 0)
+        0
+        )
+      )
+    )
+  (dotimes (v1-52 24)
+    (set! (-> obj tethers v1-52 handle) (the-as handle #f))
+    (let ((a0-77 v1-52))
+      (cond
+        ((zero? a0-77)
+         (set! (-> obj tethers v1-52 rp) 18)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) -1.0)
+         )
+        ((= a0-77 1)
+         (set! (-> obj tethers v1-52 rp) 16)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) -1.0)
+         )
+        ((= a0-77 2)
+         (set! (-> obj tethers v1-52 rp) 17)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) -1.0)
+         )
+        ((= a0-77 3)
+         (set! (-> obj tethers v1-52 rp) 24)
+         (set! (-> obj tethers v1-52 broken-x) -1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 4)
+         (set! (-> obj tethers v1-52 rp) 22)
+         (set! (-> obj tethers v1-52 broken-x) -1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 5)
+         (set! (-> obj tethers v1-52 rp) 23)
+         (set! (-> obj tethers v1-52 broken-x) -1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 6)
+         (set! (-> obj tethers v1-52 rp) 6)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) 1.0)
+         )
+        ((= a0-77 7)
+         (set! (-> obj tethers v1-52 rp) 4)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) 1.0)
+         )
+        ((= a0-77 8)
+         (set! (-> obj tethers v1-52 rp) 5)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) 1.0)
+         )
+        ((= a0-77 9)
+         (set! (-> obj tethers v1-52 rp) 12)
+         (set! (-> obj tethers v1-52 broken-x) 1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 10)
+         (set! (-> obj tethers v1-52 rp) 10)
+         (set! (-> obj tethers v1-52 broken-x) 1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 11)
+         (set! (-> obj tethers v1-52 rp) 11)
+         (set! (-> obj tethers v1-52 broken-x) 1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 12)
+         (set! (-> obj tethers v1-52 rp) 25)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 13)
+         (set! (-> obj tethers v1-52 rp) 26)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 14)
+         (set! (-> obj tethers v1-52 rp) 27)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 15)
+         (set! (-> obj tethers v1-52 rp) 19)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 16)
+         (set! (-> obj tethers v1-52 rp) 21)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 17)
+         (set! (-> obj tethers v1-52 rp) 20)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 18)
+         (set! (-> obj tethers v1-52 rp) 14)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 19)
+         (set! (-> obj tethers v1-52 rp) 13)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 20)
+         (set! (-> obj tethers v1-52 rp) 15)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 21)
+         (set! (-> obj tethers v1-52 rp) 8)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 22)
+         (set! (-> obj tethers v1-52 rp) 7)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 23)
+         (set! (-> obj tethers v1-52 rp) 9)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        (else
+          (set! (-> obj tethers v1-52 rp) 3)
+          (set! (-> obj tethers v1-52 broken-x) 0.0)
+          (set! (-> obj tethers v1-52 broken-z) 0.0)
+          )
+        )
+      )
+    )
+  (set! (-> obj start-y) (-> obj root trans y))
+  (set! (-> obj smoke-part) (create-launch-control (-> *part-group-id-table* 1143) obj))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1144) obj))
+  (set! (-> obj motor-sound) (the-as uint 0))
+  (set! (-> obj bit-sound) (the-as uint 0))
+  (set! (-> obj movie-handle) (the-as handle #f))
+  (set! (-> obj hud-counter) (ppointer->handle (process-spawn hud-dig-clasp :init hud-init-by-other :to obj)))
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defun-debug bustclasp ((arg0 int))
+  (format (clear *temp-string*) "dig-clasp-~S" arg0)
+  (let ((v1-0 (entity-by-name *temp-string*)))
+    (when v1-0
+      (send-event
+        (if v1-0
+            (-> v1-0 extra process)
+            )
+        'break
+        )
+      (format #t "found clasp ~D~%" arg0)
+      )
+    )
+  (none)
+  )
diff --git a/goal_src/jak2/levels/dig/dig-obs.gc b/goal_src/jak2/levels/dig/dig-obs.gc
index 3561e5119a..930d65a0fe 100644
--- a/goal_src/jak2/levels/dig/dig-obs.gc
+++ b/goal_src/jak2/levels/dig/dig-obs.gc
@@ -7,3 +7,906 @@
 
 ;; DECOMP BEGINS
 
+(deftype dig-sinking-plat (rigid-body-platform)
+  ((anchor-point      vector      :inline :offset-assert 384)
+   (sync              sync-linear :inline :offset-assert 400)
+   (last-ridden-time  time-frame          :offset-assert 416)
+   (prev-pos          float               :offset-assert 424)
+   (path-pos          float               :offset-assert 428)
+   (surface-height    float               :offset-assert 432)
+   (once              basic               :offset-assert 436)
+   (bubbling-sound-id uint32              :offset-assert 440)
+   )
+  :heap-base #x140
+  :method-count-assert 57
+  :size-assert         #x1bc
+  :flag-assert         #x39014001bc
+  )
+
+
+(defskelgroup skel-dig-sinking-plat dig-sinking-plat 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 -2 0 5.25)
+              )
+
+(defmethod rigid-body-object-method-29 dig-sinking-plat ((obj dig-sinking-plat) (arg0 float))
+  ((the-as (function rigid-body-platform float none) (find-parent-method dig-sinking-plat 29)) obj arg0)
+  (rigid-body-platform-method-56 obj (-> obj anchor-point))
+  0
+  (none)
+  )
+
+(defmethod rigid-body-object-method-32 dig-sinking-plat ((obj dig-sinking-plat))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 -8192.0 0.0 21504.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(define *dig-sinking-platform-constants* (new 'static 'rigid-body-object-constants
+                                           :mass 4.0
+                                           :inv-mass 0.25
+                                           :cm-joint-y (meters -2)
+                                           :cm-joint-w 1.0
+                                           :linear-damping 0.9
+                                           :angular-damping 0.48
+                                           :friction-factor 0.1
+                                           :inertial-tensor-x (meters 6)
+                                           :inertial-tensor-y (meters 4)
+                                           :inertial-tensor-z (meters 6)
+                                           :max-time-step 0.02
+                                           :gravity (meters 80)
+                                           :idle-distance (meters 200)
+                                           :attack-force-scale 2.0
+                                           :name '*dig-sinking-platform-constants*
+                                           )
+        )
+
+(defmethod rigid-body-platform-method-53 dig-sinking-plat ((obj dig-sinking-plat) (arg0 vector))
+  (-> obj surface-height)
+  )
+
+(defmethod rigid-body-object-method-37 dig-sinking-plat ((obj dig-sinking-plat))
+  (with-pp
+    (when (not (logtest? (-> obj path flags) (path-control-flag not-found)))
+      (set! (-> obj prev-pos) (-> obj path-pos))
+      (set! (-> obj path-pos) (get-norm! (-> obj sync) 0))
+      (when (< (-> obj path-pos) (-> obj prev-pos))
+        (let ((a0-2 (-> obj skel root-channel 0)))
+          (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+          (set! (-> a0-2 param 0)
+                (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 2)) frames num-frames) -1))
+                )
+          (set! (-> a0-2 param 1) 1.0)
+          (set! (-> a0-2 frame-num) 0.0)
+          (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-seek!)
+          )
+        (let ((a0-3 (-> obj skel root-channel 0)))
+          (set! (-> a0-3 param 0) (the float (+ (-> a0-3 frame-group frames num-frames) -1)))
+          (set! (-> a0-3 param 1) 1.0)
+          (joint-control-channel-group-eval! a0-3 (the-as art-joint-anim #f) num-func-seek!)
+          )
+        )
+      (let ((f30-0 (/ 300.0 (the float (-> obj sync period)))))
+        (let* ((f0-12 (/ 1.0 (- 1.0 (* 2.0 f30-0))))
+               (f0-13 (* (fmax 0.0 (- (-> obj path-pos) f30-0)) f0-12))
+               )
+          (get-point-at-percent-along-path! (-> obj path) (-> obj anchor-point) f0-13 'interp)
+          )
+        (cond
+          ((< (-> obj path-pos) f30-0)
+           (set! (-> obj float-height-offset) (* -8192.0 (/ (- f30-0 (-> obj path-pos)) f30-0)))
+           )
+          ((< (- 1.0 (* 2.0 f30-0)) (-> obj path-pos))
+           (cond
+             ((< (- 1.0 f30-0) (-> obj path-pos))
+              (set! (-> obj float-height-offset) (* -8192.0 (/ (- (-> obj path-pos) (- 1.0 f30-0)) f30-0)))
+              (let ((a0-5 (-> obj skel root-channel 0)))
+                (set! (-> a0-5 param 0) (the float (+ (-> a0-5 frame-group frames num-frames) -1)))
+                (set! (-> a0-5 param 1) 1.0)
+                (joint-control-channel-group-eval! a0-5 (the-as art-joint-anim #f) num-func-seek!)
+                )
+              )
+             (else
+               (when (-> obj once)
+                 (let ((a0-6 (-> obj skel root-channel 0)))
+                   (set! (-> a0-6 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+                   (set! (-> a0-6 param 0)
+                         (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 3)) frames num-frames) -1))
+                         )
+                   (set! (-> a0-6 param 1) 1.0)
+                   (set! (-> a0-6 frame-num) 0.0)
+                   (joint-control-channel-group! a0-6 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-seek!)
+                   )
+                 (set! (-> obj once) #f)
+                 )
+               (let ((a0-7 (-> obj skel root-channel 0)))
+                 (set! (-> a0-7 param 0) (the float (+ (-> a0-7 frame-group frames num-frames) -1)))
+                 (set! (-> a0-7 param 1) 1.0)
+                 (joint-control-channel-group-eval! a0-7 (the-as art-joint-anim #f) num-func-seek!)
+                 )
+               )
+             )
+           )
+          (else
+            (set! (-> obj float-height-offset) 0.0)
+            )
+          )
+        )
+      )
+    (cond
+      ((>= (- (-> pp clock frame-counter) (-> obj last-ridden-time)) (seconds 0.5))
+       (when (nonzero? (-> obj bubbling-sound-id))
+         (let ((v1-84 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
+           (set! (-> v1-84 command) (sound-command set-param))
+           (set! (-> v1-84 id) (the-as sound-id (-> obj bubbling-sound-id)))
+           (set! (-> v1-84 params volume) -4)
+           (set! (-> v1-84 auto-time) 120)
+           (set! (-> v1-84 auto-from) 2)
+           (set! (-> v1-84 params mask) (the-as uint 17))
+           (-> v1-84 id)
+           )
+         (set! (-> obj bubbling-sound-id) (the-as uint 0))
+         0
+         )
+       )
+      (else
+        (if (zero? (-> obj bubbling-sound-id))
+            (set! (-> obj bubbling-sound-id) (the-as uint (sound-play "lava-plat-sink")))
+            )
+        )
+      )
+    ((method-of-type rigid-body-platform rigid-body-object-method-37) obj)
+    (none)
+    )
+  )
+
+(defmethod rigid-body-platform-method-56 dig-sinking-plat ((obj dig-sinking-plat) (arg0 vector))
+  (when (not (logtest? (-> obj path flags) (path-control-flag not-found)))
+    (let ((v1-4 (new 'stack-no-clear 'vector)))
+      (cond
+        ((< (-> obj prev-pos) (-> obj path-pos))
+         (vector-! v1-4 arg0 (-> obj rbody state position))
+         (set! (-> v1-4 y) 0.0)
+         (let* ((f0-2 (vector-length v1-4))
+                (f1-2 (* 1000.0 (fmax 0.0 (fmin 4096.0 (+ -4096.0 f0-2)))))
+                )
+           (when (< 0.0 f1-2)
+             (vector-float*! v1-4 v1-4 (/ f1-2 f0-2))
+             (rigid-body-method-20 (-> obj rbody state) v1-4)
+             )
+           )
+         )
+        (else
+          (let ((v1-5 (new 'stack-no-clear 'vector)))
+            (set! (-> v1-5 quad) (-> arg0 quad))
+            (set! (-> v1-5 y) (+ -8192.0 (-> v1-5 y)))
+            (let ((a0-16 (-> obj rbody))
+                  (a2-2 (-> obj root-override-2 quat))
+                  )
+              (rigid-body-method-26 (-> a0-16 state) v1-5 a2-2)
+              )
+            )
+          (set! (-> obj once) (the-as basic #t))
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defstate idle (dig-sinking-plat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('ridden)
+       (set! (-> self last-ridden-time) (-> self clock frame-counter))
+       )
+      )
+    (the-as object (rigid-body-object-event-handler proc arg1 event-type event))
+    )
+  )
+
+(defstate active (dig-sinking-plat)
+  :virtual #t
+  :event (-> (method-of-type dig-sinking-plat idle) event)
+  )
+
+(defmethod rigid-body-object-method-33 dig-sinking-plat ((obj dig-sinking-plat))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-sinking-plat" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (rigid-body-object-method-31 obj *dig-sinking-platform-constants*)
+  (set! (-> obj anchor-point quad) (-> obj root-override-2 trans quad))
+  (set! (-> obj surface-height) (+ -4096.0 (-> obj root-override-2 trans y)))
+  (let ((s5-1 (-> obj info-override control-point-count)))
+    (dotimes (s4-1 s5-1)
+      (let ((s3-0 (-> obj control-point-array data s4-1)))
+        (let ((f30-0 (* 65536.0 (/ (the float s4-1) (the float s5-1)))))
+          (set! (-> s3-0 local-pos x) (* 16384.0 (sin f30-0)))
+          (set! (-> s3-0 local-pos y) -8192.0)
+          (set! (-> s3-0 local-pos z) (* 16384.0 (cos f30-0)))
+          )
+        (set! (-> s3-0 local-pos w) 1.0)
+        )
+      )
+    )
+  (let ((s5-2 (-> obj entity)))
+    (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 s5-2 #f))
+    (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+    (set! (-> obj fact)
+          (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+          )
+    (let ((a1-5 (new 'stack-no-clear 'sync-info-params)))
+      (let ((v1-25 0))
+        (if #f
+            (set! v1-25 (logior v1-25 1))
+            )
+        (set! (-> a1-5 sync-type) (the-as basic 'sync-linear))
+        (set! (-> a1-5 sync-flags) (the-as sync-flags v1-25))
+        )
+      (set! (-> a1-5 entity) s5-2)
+      (set! (-> a1-5 period) (the-as uint 3000))
+      (set! (-> a1-5 percent) 0.0)
+      (initialize! (-> obj sync) a1-5)
+      )
+    )
+  (set! (-> obj bubbling-sound-id) (the-as uint 0))
+  (set! (-> obj once) (the-as basic #t))
+  0
+  (none)
+  )
+
+(defpartgroup group-dig-log
+  :id 1145
+  :bounds (static-bspherem 0 0 0 2)
+  :parts ((sp-item 4956)
+    (sp-item 4957)
+    (sp-item 4958 :binding 4955)
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4959)
+    )
+  )
+
+(defpart 4956
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 3.0 2.0 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 128.0)
+    (sp-rnd-flt spt-g 96.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 8.0 8.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.016666668) (meters 0.016666668) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.02) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.006666667))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.053333335)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 900)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+(defpart 4957
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #xade))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.02) (meters 0.02) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-flt spt-fade-a -0.35555556)
+    (sp-flt spt-accel-y -5.4613333)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+(defpart 4958
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #xade))
+    (sp-rnd-flt spt-num 0.05 0.05 1.0)
+    (sp-rnd-flt spt-x (meters -10) (meters 12) 1.0)
+    (sp-flt spt-y (meters 38))
+    (sp-rnd-flt spt-scale-x (meters 0.6) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters -0.00066666666) (meters 0.0013333333) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-flt spt-fade-a -0.16)
+    (sp-flt spt-accel-y -17.749332)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-rotate-y (degrees 90.0))
+    )
+  )
+
+(defpart 4959
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.2 0.2 1.0)
+    (sp-rnd-flt spt-x (meters -8) (meters 8) 1.0)
+    (sp-flt spt-y (meters 38))
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 8.0 8.0 1.0)
+    (sp-flt spt-scalevel-x (meters 0.033333335))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.04)
+    (sp-flt spt-accel-y -5.4613333)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 1200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-rotate-y (degrees 90.0))
+    )
+  )
+
+(defpart 4955
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 2.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 8.0 4.0 1.0)
+    (sp-flt spt-scalevel-x (meters 0.01))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.04)
+    (sp-int spt-timer 1200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    )
+  )
+
+(deftype dig-log-button-info (basic)
+  ((cam-ret-mode symbol         :offset-assert   4)
+   (cam-ret-dir  vector :inline :offset-assert  16)
+   )
+  :method-count-assert 9
+  :size-assert         #x20
+  :flag-assert         #x900000020
+  )
+
+
+(define *dig-log-button-infos* (new 'static 'boxed-array :type dig-log-button-info
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'instant
+                                   :cam-ret-dir (new 'static 'vector :x 0.1464 :z -0.9892 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'normal
+                                   :cam-ret-dir (new 'static 'vector :x 0.9805 :z 0.1963 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'normal
+                                   :cam-ret-dir (new 'static 'vector :x 0.8602 :z 0.5099 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'instant
+                                   :cam-ret-dir (new 'static 'vector :x -0.9946 :z 0.1035 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'normal
+                                   :cam-ret-dir (new 'static 'vector :x 0.9966 :z -0.0813 :w 1.0)
+                                   )
+                                 )
+        )
+
+(define *dig-log-heights* (new 'static 'inline-array vector 2
+                            (new 'static 'vector :x 56320.0 :y 32768.0 :z 23552.0 :w 14336.0)
+                            (new 'static 'vector :x 5120.0 :y -4096.0)
+                            )
+        )
+
+(deftype dig-log (process-drawable)
+  ((pressed-count    int8     :offset-assert 200)
+   (total-buttons    int8     :offset-assert 201)
+   (last-button-id   int8     :offset-assert 202)
+   (base-y           float    :offset-assert 204)
+   (hud-handle       handle   :offset-assert 208)
+   (pad-ihj1bn234i1b int32  2 :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xe0
+  :flag-assert         #x17006000e0
+  (:methods
+    (idle () _type_ :state 20)
+    (moving () _type_ :state 21)
+    (dig-log-method-22 (_type_ symbol) symbol 22)
+    )
+  )
+
+
+(defskelgroup skel-dig-log dig-log 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 7.25 0 11)
+              :origin-joint-index 3
+              )
+
+(defbehavior dig-log-event-handler dig-log ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit)
+     (set! (-> self last-button-id) (the-as int (/ (the-as int (-> arg3 param 0)) 8)))
+     (set! (-> self pressed-count) (min (+ (-> self pressed-count) 1) (-> self total-buttons)))
+     (set! (-> *game-info* counter) (the float (- (-> self total-buttons) (-> self pressed-count))))
+     (cond
+       ((= (-> self pressed-count) (-> self total-buttons))
+        (dig-log-method-22 self #f)
+        (task-node-close! (game-task-node dig-find-totem-raise-log))
+        )
+       (else
+         (dig-log-method-22 self #t)
+         )
+       )
+     (go-virtual moving)
+     )
+    (('hud-dig-button)
+     (dig-log-method-22 self (the-as symbol (-> arg3 param 0)))
+     )
+    )
+  )
+
+(defmethod run-logic? dig-log ((obj dig-log))
+  #t
+  )
+
+;; WARN: Return type mismatch int vs symbol.
+;; WARN: disable def twice: 16. This may happen when a cond (no else) is nested inside of another conditional, but it should be rare.
+(defmethod dig-log-method-22 dig-log ((obj dig-log) (arg0 symbol))
+  (the-as
+    symbol
+    (cond
+      (arg0
+        (when (!= (-> obj pressed-count) (-> obj total-buttons))
+          (when (not (handle->process (-> obj hud-handle)))
+            (let ((v0-0 (ppointer->handle (process-spawn hud-dig-button :init hud-init-by-other :to obj))))
+              (set! (-> obj hud-handle) (the-as handle v0-0))
+              v0-0
+              )
+            )
+          )
+        )
+      (else
+        (send-event (handle->process (-> obj hud-handle)) 'hide-and-die)
+        (set! (-> obj hud-handle) (the-as handle #f))
+        (the-as int #f)
+        )
+      )
+    )
+  )
+
+(defstate idle (dig-log)
+  :virtual #t
+  :event dig-log-event-handler
+  :code (the-as (function none :behavior dig-log) sleep-code)
+  )
+
+(defstate moving (dig-log)
+  :virtual #t
+  :enter (behavior ()
+    (set-setting! 'ignore-target #t 0 0)
+    (none)
+    )
+  :exit (behavior ()
+    (remove-setting! 'ignore-target)
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-12 object))
+    (let ((gp-0 (-> *dig-log-button-infos* (-> self last-button-id))))
+      (let* ((t0-0 (if (= (-> self pressed-count) (-> self total-buttons))
+                       "diglog5"
+                       "diglog1"
+                       )
+                   )
+             (s5-0 (add-process *gui-control* self (gui-channel jak) (gui-action queue) t0-0 -99.0 0))
+             )
+        (set! (-> self state-time) (-> self clock frame-counter))
+        (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.15))
+          (suspend)
+          )
+        (until v1-12
+          (suspend)
+          (set! v1-12
+                (and *target* (not (logtest? (-> *target* focus-status) (focus-status in-air))) (process-grab? *target* #f))
+                )
+          )
+        (while (!= (get-status *gui-control* s5-0) (gui-status ready))
+          (suspend)
+          )
+        (set! (-> self state-time) (-> self clock frame-counter))
+        (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.2))
+          (suspend)
+          )
+        (set-setting! 'entity-name "camera-249" 0 0)
+        (set-action!
+          *gui-control*
+          (gui-action play)
+          s5-0
+          (gui-channel none)
+          (gui-action none)
+          (the-as string #f)
+          (the-as (function gui-connection symbol) #f)
+          (the-as process #f)
+          )
+        )
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5))
+        (suspend)
+        )
+      (let ((f30-0
+              (+ (-> (&-> *dig-log-heights* 0 data (- (-> self total-buttons) (-> self pressed-count))) 0) (-> self base-y))
+              )
+            (s5-1 (-> self clock frame-counter))
+            )
+        (until (>= (-> self root trans y) f30-0)
+          (set! (-> self root trans y)
+                (seek-with-smooth (-> self root trans y) f30-0 (* 4096.0 (-> self clock seconds-per-frame)) 0.25 40.96)
+                )
+          (when (>= (-> self clock frame-counter) s5-1)
+            (activate!
+              *camera-smush-control*
+              (rand-vu-float-range 614.4 1433.6)
+              45
+              75
+              1.0
+              0.95
+              (-> *display* camera-clock)
+              )
+            (set! s5-1 (+ (-> self clock frame-counter) (rand-vu-int-range (seconds 0.05) (seconds 0.15))))
+            )
+          (let ((a1-10 (new 'stack-no-clear 'vector)))
+            (set! (-> a1-10 quad) (-> self root trans quad))
+            (set! (-> a1-10 y) (+ 59592.703 (-> self base-y)))
+            (spawn (-> self part) a1-10)
+            )
+          (suspend)
+          )
+        )
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+        (suspend)
+        )
+      (if (= (-> gp-0 cam-ret-mode) 'instant)
+          (persist-with-delay *setting-control* 'interp-time (seconds 0.05) 'interp-time 'abs 0.0 0)
+          )
+      (set-setting! 'string-startup-vector 'abs (-> gp-0 cam-ret-dir) 0)
+      (remove-setting! 'entity-name)
+      (when (!= (-> gp-0 cam-ret-mode) 'instant)
+        (set! (-> self state-time) (-> self clock frame-counter))
+        (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+          (suspend)
+          )
+        )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (suspend)
+      )
+    (remove-setting! 'string-startup-vector)
+    (until (process-release? *target*)
+      (suspend)
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4))
+      (suspend)
+      )
+    (go-virtual idle)
+    (none)
+    )
+  :post (the-as (function none :behavior dig-log) transform-post)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-log ((obj dig-log) (arg0 entity-actor))
+  (local-vars (r0-0 uint128) (a0-11 object) (a1-8 uint128) (sv-16 int))
+  (set! (-> obj hud-handle) (the-as handle #f))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 29696.0 0.0 45056.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (set! (-> obj base-y) (-> obj root trans y))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-log" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj pressed-count) 0)
+  (set! (-> obj total-buttons) 0)
+  (set! sv-16 0)
+  (let ((v1-19
+          (res-lump-data
+            (-> obj entity)
+            'actor-groups
+            (pointer actor-group)
+            :tag-ptr (the-as (pointer res-tag) (& sv-16))
+            )
+          )
+        )
+    (when (and v1-19 (begin
+                       (let ((a0-12 #t))
+                         (let ((a1-7 (the-as uint128 sv-16)))
+                           (.pcpyud a1-8 a1-7 r0-0)
+                           )
+                         (let ((a1-10 (the-as int (shr (* (the-as int a1-8) 2) 49))))
+                           (cmove-#f-zero a0-11 a1-10 a0-12)
+                           )
+                         )
+                       a0-11
+                       )
+               )
+      (let ((s5-2 (-> v1-19 0)))
+        (countdown (s4-2 (-> s5-2 length))
+          (let ((s3-1 (-> s5-2 data s4-2 actor)))
+            (when s3-1
+              (minimap-method-12 *minimap* obj (the-as uint 16) (the-as int #f) (the-as vector s3-1) 0)
+              (+! (-> obj total-buttons) 1)
+              (if (logtest? (-> s3-1 extra perm status) (entity-perm-status subtask-complete))
+                  (+! (-> obj pressed-count) 1)
+                  )
+              )
+            )
+          )
+        )
+      )
+    )
+  (if (task-node-closed? (game-task-node dig-find-totem-raise-log))
+      (set! (-> obj pressed-count) (-> obj total-buttons))
+      )
+  (set! (-> obj root trans y)
+        (+ (-> (&-> *dig-log-heights* 0 data (- (-> obj total-buttons) (-> obj pressed-count))) 0) (-> obj base-y))
+        )
+  (transform-post)
+  (when (!= (-> obj pressed-count) (-> obj total-buttons))
+    (set! (-> *game-info* counter) (the float (- (-> obj total-buttons) (-> obj pressed-count))))
+    (if (string= (-> *game-info* last-continue name) "dig3b-back-room")
+        (dig-log-method-22 obj #t)
+        )
+    )
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1145) obj))
+  (set! (-> obj event-hook) dig-log-event-handler)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype dig-button (process-drawable)
+  ((down-y float  :offset-assert 200)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xcc
+  :flag-assert         #x17005000cc
+  (:methods
+    (idle-up () _type_ :state 20)
+    (going-down () _type_ :state 21)
+    (idle-down () _type_ :state 22)
+    )
+  )
+
+
+(defskelgroup skel-dig-button dig-button 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 3))
+
+(defmethod run-logic? dig-button ((obj dig-button))
+  #t
+  )
+
+(defstate idle-up (dig-button)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as
+      object
+      (case event-type
+        (('attack)
+         (when (logtest? (-> (the-as attack-info (-> event param 1)) penetrate-using) (penetrate flop))
+           (go-virtual going-down)
+           #f
+           )
+         )
+        )
+      )
+    )
+  :code (behavior ()
+    (transform-post)
+    (suspend)
+    (transform-post)
+    (sleep-code)
+    (none)
+    )
+  )
+
+(defstate going-down (dig-button)
+  :virtual #t
+  :code (behavior ()
+    (sound-play "dig-button")
+    (until (= (-> self root trans y) (-> self down-y))
+      (seek! (-> self root trans y) (-> self down-y) (* 16384.0 (-> self clock seconds-per-frame)))
+      (logior! (-> self skel status) (joint-control-status sync-math))
+      (transform-post)
+      (logclear! (-> self skel status) (joint-control-status sync-math))
+      (suspend)
+      )
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (let ((gp-1 (res-lump-struct (-> self entity) 'on-activate structure)))
+      (if gp-1
+          (eval!
+            (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f))
+            (the-as pair gp-1)
+            )
+          )
+      )
+    (go-virtual idle-down)
+    (none)
+    )
+  )
+
+(defstate idle-down (dig-button)
+  :virtual #t
+  :code (behavior ()
+    (set! (-> self root trans y) (-> self down-y))
+    (transform-post)
+    (suspend)
+    (transform-post)
+    (sleep-code)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-button ((obj dig-button) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 3)
+      (set-vector! (-> v1-2 local-sphere) 0.0 0.0 0.0 12288.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-button" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj down-y) (+ -2048.0 (-> obj root trans y)))
+  (if (task-node-closed? (game-task-node dig-find-totem-raise-log))
+      (process-entity-status! obj (entity-perm-status subtask-complete) #t)
+      )
+  (if (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+      (go (method-of-object obj idle-down))
+      (go (method-of-object obj idle-up))
+      )
+  (none)
+  )
+
+(defmethod draw hud-dig-button ((obj hud-dig-button))
+  (set-hud-piece-position!
+    (the-as hud-sprite (-> obj sprites))
+    (the int (+ 487.0 (* 130.0 (-> obj offset))))
+    210
+    )
+  (format (clear (-> obj strings 0 text)) "~D" (-> obj values 0 current))
+  (set-as-offset-from! (the-as hud-sprite (-> obj strings 0 pos)) (the-as vector4w (-> obj sprites)) -16 20)
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+(defmethod update-values hud-dig-button ((obj hud-dig-button))
+  (set! (-> obj values 0 target) (the int (-> *game-info* counter)))
+  ((method-of-type hud update-values) obj)
+  0
+  (none)
+  )
+
+(defmethod init-callback hud-dig-button ((obj hud-dig-button))
+  (set! (-> obj level) (level-get *level* 'dig3a))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :page #xd21)))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 0 scale-x) 1.0)
+  (set! (-> obj sprites 0 scale-y) 1.0)
+  (alloc-string-if-needed obj 0)
+  (set! (-> obj strings 0 scale) 0.6)
+  (set! (-> obj strings 0 flags) (font-flags kerning middle large))
+  0
+  (none)
+  )
+
+(defun dig3-login ()
+  (set! *nav-network* (new 'loading-level 'nav-network))
+  0
+  (none)
+  )
+
+(defun dig3-activate ()
+  (setup-user-array (-> *part-id-table* 1309) "grenadier-grenade-part")
+  (setup-user-array (-> *part-id-table* 638) "grenadier-grenade-part")
+  (setup-user-array (-> *part-id-table* 639) "grenadier-grenade-part")
+  0
+  (none)
+  )
+
+(defun dig3-deactivate ()
+  (set! *nav-network* (the-as nav-network 0))
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/dig/dig1-obs.gc b/goal_src/jak2/levels/dig/dig1-obs.gc
index b3116eb5c7..05efa091a7 100644
--- a/goal_src/jak2/levels/dig/dig1-obs.gc
+++ b/goal_src/jak2/levels/dig/dig1-obs.gc
@@ -7,3 +7,1113 @@
 
 ;; DECOMP BEGINS
 
+(deftype dig-conveyor (conveyor)
+  ()
+  :heap-base #x80
+  :method-count-assert 28
+  :size-assert         #x100
+  :flag-assert         #x1c00800100
+  )
+
+
+(defskelgroup skel-dig-conveyor dig-conveyor 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 2 -8 10)
+              :longest-edge (meters 8.7193)
+              :origin-joint-index 3
+              )
+
+(defmethod init! dig-conveyor ((obj dig-conveyor))
+  "Initializes defaults for things like the `speed` and `belt-radius`"
+  (set! (-> obj speed) 30720.0)
+  (set! (-> obj belt-radius) 15974.4)
+  (set! (-> obj pull-y-threshold) 10240.0)
+  (set! (-> obj draw light-index) (the-as uint 2))
+  (none)
+  )
+
+(defmethod get-art-group dig-conveyor ((obj dig-conveyor))
+  "@returns The respective [[art-group]] for the [[conveyor]]"
+  (art-group-get-by-name *level* "skel-dig-conveyor" (the-as (pointer uint32) #f))
+  )
+
+(defpartgroup group-dig-cylinder-hit
+  :id 1146
+  :duration (seconds 2)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 6)
+  :parts ((sp-item 4960 :flags (bit6) :period 900 :length 5)
+    (sp-item 4961 :flags (bit6) :period 900 :length 5)
+    (sp-item 4962 :period 900 :length 15)
+    (sp-item 4963 :fade-after (meters 60) :period 900 :length 10 :offset 10)
+    (sp-item 4964 :fade-after (meters 60) :falloff-to (meters 60) :period 900 :length 50 :offset 20)
+    (sp-item 4965 :fade-after (meters 200) :falloff-to (meters 200) :period 900 :length 25 :offset 20)
+    (sp-item 4966 :fade-after (meters 150) :falloff-to (meters 150) :period 900 :length 20 :offset 30)
+    )
+  )
+
+(defpart 4966
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-flt spt-num 0.8)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-rot-z)
+      :flags (sp-flag spflag7)
+      :random-rangef 65536.0
+      :random-multf 1.0
+      )
+    (sp-rnd-flt spt-scale-y (meters 0.8) (meters 0.2) 1.0)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.1) (meters 0.26666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -6.2)
+    (sp-flt spt-fade-b -6.2)
+    (sp-flt spt-fade-a -0.1254902)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 4967)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-conerot-x)
+      :flags (sp-flag from-pointer)
+      :func '*sp-temp*
+      )
+    )
+  )
+
+(defpart 4965
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-flt spt-num 0.8)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (sp-flt spt-rot-z (degrees 0.0))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.26666668) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -6.2)
+    (sp-flt spt-fade-b -6.2)
+    (sp-flt spt-fade-a -0.1254902)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 4967)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4967
+  :init-specs ((sp-flt spt-fade-r -2.1666667)
+    (sp-flt spt-fade-g -5.0)
+    (sp-flt spt-fade-b -5.0)
+    (sp-rnd-flt spt-fade-a -0.062068965 -0.72 1.0)
+    (sp-int-plain-rnd spt-next-time 15 14 1)
+    (sp-launcher-by-id spt-next-launcher 4968)
+    )
+  )
+
+(defpart 4968
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.016666668) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.7)
+    (sp-flt spt-fade-g -1.7)
+    (sp-flt spt-fade-b -0.8)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 4969)
+    )
+  )
+
+(defpart 4969
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0033333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.5833333)
+    (sp-flt spt-fade-g -0.75)
+    (sp-flt spt-fade-b -0.9444444)
+    (sp-int-plain-rnd spt-next-time 150 29 1)
+    (sp-launcher-by-id spt-next-launcher 4970)
+    )
+  )
+
+(defpart 4970
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g 0.0) (sp-flt spt-fade-b 0.0) (sp-flt spt-fade-a -0.1125))
+  )
+
+(defpart 4961
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xca :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 5))
+    (sp-flt spt-rot-x 2048.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.13333334))
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -2.1333334)
+    (sp-flt spt-fade-b -4.266667)
+    (sp-flt spt-fade-a 0.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14 glow)
+    (sp-int spt-next-time 75)
+    (sp-launcher-by-id spt-next-launcher 4971)
+    )
+  )
+
+(defpart 4971
+  :init-specs ((sp-flt spt-scalevel-x (meters 0))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.85333335)
+    (sp-flt spt-fade-g -1.7066667)
+    (sp-flt spt-fade-b -1.7066667)
+    (sp-flt spt-fade-a -0.64)
+    )
+  )
+
+(defpart 4960
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 5))
+    (sp-flt spt-rot-x 2048.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.5))
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -4.266667)
+    (sp-flt spt-fade-b -4.266667)
+    (sp-flt spt-fade-a 0.0)
+    (sp-int spt-timer 65)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-int spt-next-time 30)
+    (sp-launcher-by-id spt-next-launcher 4972)
+    )
+  )
+
+(defpart 4972
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2857143))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.8285714)
+    (sp-flt spt-fade-g -3.6571429)
+    (sp-flt spt-fade-b -3.6571429)
+    (sp-flt spt-fade-a -1.3714286)
+    )
+  )
+
+(defpart 4964
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 6.0 2.0 1.0)
+    (sp-flt spt-x (meters 0.25))
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.25) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 16.0 48.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.083333336) (meters 0.083333336) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -3.1)
+    (sp-flt spt-fade-b -0.1)
+    (sp-rnd-flt spt-accel-y -0.68266666 -1.3653333 1.0)
+    (sp-flt spt-friction 0.87)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 4973)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4973
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0016666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.14444445)
+    (sp-flt spt-fade-g -0.33333334)
+    (sp-flt spt-fade-b -0.33333334)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 4974)
+    )
+  )
+
+(defpart 4974
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g -0.08695652) (sp-flt spt-fade-a -0.18478261))
+  )
+
+(defpart 4962
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 1.0 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 0.6) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2.5) (meters 2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 70.0 20.0 1.0)
+    (sp-rnd-flt spt-g 70.0 20.0 1.0)
+    (sp-rnd-flt spt-b 70.0 20.0 1.0)
+    (sp-rnd-flt spt-a 0.0 40.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.033333335) (meters 0.02) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 3.3)
+    (sp-flt spt-fade-g 1.2)
+    (sp-flt spt-fade-b 1.2)
+    (sp-flt spt-fade-a 1.76)
+    (sp-flt spt-friction 0.88)
+    (sp-int spt-timer 710)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 4975)
+    (sp-rnd-flt spt-conerot-x (degrees -1440.0) (degrees 2880.0) 1.0)
+    )
+  )
+
+(defpart 4975
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.0833334)
+    (sp-flt spt-fade-g -2.1666667)
+    (sp-flt spt-fade-b -2.1666667)
+    (sp-flt spt-fade-a -0.46666667)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 4976)
+    )
+  )
+
+(defpart 4976
+  :init-specs ((sp-flt spt-fade-r -1.7)
+    (sp-flt spt-fade-g -0.8)
+    (sp-flt spt-fade-b -0.8)
+    (sp-flt spt-fade-a -1.0)
+    (sp-int spt-next-time 50)
+    (sp-launcher-by-id spt-next-launcher 4977)
+    )
+  )
+
+(defpart 4977
+  :init-specs ((sp-flt spt-scalevel-x (meters 0))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.17)
+    (sp-flt spt-fade-g -0.3)
+    (sp-flt spt-fade-b -0.3)
+    (sp-flt spt-fade-a -0.1)
+    )
+  )
+
+(defpart 4963
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x31 :page #xc))
+    (sp-rnd-flt spt-num 4.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.5) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-r 192.0 64.0 1.0)
+    (sp-flt spt-g 65.0)
+    (sp-rnd-flt spt-b 128.0 64.0 1.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.13333334) (meters 0.02) 1.0)
+    (sp-flt spt-fade-r -1.4222223)
+    (sp-flt spt-fade-g -1.4222223)
+    (sp-flt spt-fade-b -1.4222223)
+    (sp-flt spt-fade-a -1.4222223)
+    (sp-int spt-timer 90)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    )
+  )
+
+(deftype dig-bomb-crate-cylinder (rigid-body-object)
+  ((flash-counter int8        :offset-assert 272)
+   (attack-id     uint32      :offset-assert 276)
+   (wait-time     time-frame  :offset-assert 280)
+   )
+  :heap-base #xa0
+  :method-count-assert 54
+  :size-assert         #x120
+  :flag-assert         #x3600a00120
+  (:methods
+    (die () _type_ :state 53)
+    )
+  )
+
+
+(deftype dig-bomb-crate-cylinder-spawn-params (structure)
+  ((pos  vector     :inline :offset-assert   0)
+   (vel  vector     :inline :offset-assert  16)
+   (avel vector     :inline :offset-assert  32)
+   (quat quaternion :inline :offset-assert  48)
+   )
+  :method-count-assert 9
+  :size-assert         #x40
+  :flag-assert         #x900000040
+  )
+
+
+(defskelgroup skel-dig-bomb-crate-cylinder dig-bomb-crate-cylinder 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 0 0 1.5)
+              )
+
+(define *dig-bomb-crate-cylinder-constants* (new 'static 'rigid-body-object-constants
+                                              :mass 1.0
+                                              :inv-mass 1.0
+                                              :cm-joint-w 1.0
+                                              :linear-damping 0.99
+                                              :angular-damping 0.9
+                                              :bounce-factor 0.5
+                                              :friction-factor 0.1
+                                              :inertial-tensor-x (meters 1)
+                                              :inertial-tensor-y (meters 3)
+                                              :inertial-tensor-z (meters 1)
+                                              :max-time-step 0.02
+                                              :gravity (meters 80)
+                                              :idle-distance (meters 200)
+                                              :attack-force-scale 2.0
+                                              :name '*dig-bomb-crate-cylinder-constants*
+                                              )
+        )
+
+(defstate idle (dig-bomb-crate-cylinder)
+  :virtual #t
+  :code (behavior ()
+    (go-virtual die)
+    (none)
+    )
+  )
+
+(defstate active (dig-bomb-crate-cylinder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type rigid-body-object active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self flash-counter) 0)
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (and v1-2 (= v1-2 (-> self draw art-group data 3)))
+        (let* ((gp-0 (-> self flash-counter))
+               (v1-5 gp-0)
+               )
+          (cond
+            ((zero? v1-5)
+             (when (>= (ja-aframe-num 0) 1.4)
+               (sound-play "dig-bomb-beep" :position (-> self root-override-2 trans))
+               (set-vector! (-> self draw color-mult) 1.1 0.25 0.25 1.0)
+               (set! (-> self flash-counter) (+ gp-0 1))
+               )
+             )
+            ((= v1-5 1)
+             (set-vector! (-> self draw color-mult) 1.0 1.0 1.0 1.0)
+             (set-vector! (-> self draw color-emissive) 1.0 1.0 1.0 1.0)
+             (set! (-> self flash-counter) (+ gp-0 1))
+             )
+            ((= v1-5 2)
+             (set-vector! (-> self draw color-mult) 1.0 1.0 1.0 1.0)
+             (set-vector! (-> self draw color-emissive) 0.0 0.0 0.0 1.0)
+             (set! (-> self flash-counter) (+ gp-0 1))
+             )
+            ((= v1-5 3)
+             (when (< (ja-aframe-num 0) 1.4)
+               (set! (-> self flash-counter) 0)
+               0
+               )
+             )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((f30-0 (rand-vu-float-range 0.22 0.27)))
+      (set! (-> self wait-time) (+ (-> self clock frame-counter) (the int (rand-vu-float-range 0.0 450.0))))
+      (while (< (-> self clock frame-counter) (-> self wait-time))
+        (suspend)
+        )
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      (ja-no-eval :group! (-> self draw art-group data 2)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (let ((gp-1 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.5))
+          (suspend)
+          )
+        )
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      (ja-no-eval :group! (-> self draw art-group data 2)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (let ((gp-2 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-2) (seconds 0.5))
+          (suspend)
+          )
+        )
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (ja-no-eval :group! (-> self draw art-group data 2)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (let ((gp-3 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (ja-no-eval :group! (-> self draw art-group data 3)
+                :num! (seek!
+                  (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                  0.375
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.375))
+      )
+    (ja-no-eval :group! (-> self draw art-group data 2)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (let ((gp-4 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
+        (suspend)
+        )
+      )
+    (ja-no-eval :group! (-> self draw art-group data 3)
+                :num! (seek!
+                  (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                  0.4375
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.4375))
+      )
+    (ja-no-eval :group! (-> self draw art-group data 2)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (let ((gp-5 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-5) (seconds 0.125))
+        (suspend)
+        )
+      )
+    (dotimes (gp-6 12)
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    0.437
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max 0.437))
+        )
+      (ja-no-eval :group! (-> self draw art-group data 2)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (let ((s5-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) s5-0) (seconds 0.05))
+          (suspend)
+          )
+        )
+      )
+    (go-virtual die)
+    (none)
+    )
+  )
+
+(defstate die (dig-bomb-crate-cylinder)
+  :virtual #t
+  :enter (behavior ()
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (let ((v1-6 (-> self root-override-2 root-prim)))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (none)
+    )
+  :code (behavior ()
+    (sound-play "dig-bomb-explo")
+    (let ((gp-1 (new 'stack-no-clear 'explosion-init-params)))
+      (set! (-> gp-1 spawn-point quad) (-> self root-override-2 trans quad))
+      (quaternion-copy! (-> gp-1 spawn-quat) (-> self root-override-2 quat))
+      (set! (-> gp-1 radius) 28672.0)
+      (set! (-> gp-1 group) (-> *part-group-id-table* 1146))
+      (set! (-> gp-1 collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> gp-1 penetrate-using) (penetrate explode))
+      (explosion-spawn (the-as process-drawable *entity-pool*) explosion gp-1)
+      )
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+(defmethod rigid-body-object-method-46 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder) (arg0 process-drawable) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('track)
+     #t
+     )
+    (else
+      ((method-of-type rigid-body-object rigid-body-object-method-46) obj arg0 arg1 arg2 arg3)
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs symbol.
+(defmethod rigid-body-object-method-47 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder) (arg0 process-drawable) (arg1 attack-info) (arg2 object) (arg3 penetrate))
+  (the-as
+    symbol
+    (cond
+      ((logtest? (penetrate jak-yellow-shot jak-red-shot jak-blue-shot jak-dark-shot enemy-yellow-shot enemy-dark-shot)
+                 arg3
+                 )
+       (go (method-of-object obj die))
+       )
+      (else
+        (if (logtest? (penetrate explode) arg3)
+            (set! arg3 (penetrate spin))
+            )
+        ((method-of-type rigid-body-object rigid-body-object-method-47) obj arg0 arg1 arg2 (the-as penetrate arg3))
+        )
+      )
+    )
+  )
+
+(defmethod rigid-body-object-method-45 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder) (arg0 rigid-body-object-constants))
+  (let* ((f0-0 (-> arg0 info inv-inertial-tensor vector 0 x))
+         (f1-0 28672.0)
+         (f30-0 (* f0-0 (/ 1.0 f1-0) (-> obj info inv-mass)))
+         )
+    (if (< (* 28672.0 (-> obj info mass)) (-> arg0 info inv-inertial-tensor vector 0 x))
+        (sound-play-by-name
+          (static-sound-name "barrel-bomb-hit")
+          (new-sound-id)
+          (the int (* 1024.0 f30-0))
+          0
+          0
+          (sound-group sfx)
+          (-> obj root-override-2 trans)
+          )
+        )
+    )
+  )
+
+(defmethod rigid-body-object-method-37 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder))
+  (with-pp
+    (let ((a1-0 (new 'stack-no-clear 'collide-query)))
+      (set! (-> a1-0 start-pos quad) (-> obj rbody state position quad))
+      (vector-float*! (-> a1-0 move-dist) (-> obj rbody state lin-velocity) (-> pp clock seconds-per-frame))
+      (let ((v1-3 a1-0))
+        (set! (-> v1-3 radius) (+ 4096.0 (-> obj root-override-2 root-prim local-sphere w)))
+        (set! (-> v1-3 collide-with) (-> obj root-override-2 root-prim prim-core collide-with))
+        (set! (-> v1-3 ignore-process0) obj)
+        (set! (-> v1-3 ignore-process1) #f)
+        (set! (-> v1-3 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (set! (-> v1-3 action-mask) (collide-action solid))
+        )
+      (fill-using-line-sphere *collide-cache* a1-0)
+      )
+    (if *display-collide-cache*
+        (debug-draw *collide-cache*)
+        )
+    (rigid-body-object-method-30 obj)
+    (set! (-> obj root-override-2 transv quad) (-> obj rbody state lin-velocity quad))
+    (quaternion-copy! (-> obj root-override-2 quat) (-> obj rbody state rotation))
+    (rigid-body-method-24 (-> obj rbody state))
+    (let ((v1-19 (-> obj rbody))
+          (a1-2 (-> obj root-override-2 trans))
+          )
+      (rigid-body-method-23 (-> v1-19 state) a1-2)
+      )
+    (set! (-> obj node-list data 0 bone transform trans quad) (-> obj root-override-2 trans quad))
+    (transform-post)
+    0
+    (none)
+    )
+  )
+
+(defmethod rigid-body-object-method-32 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak crate enemy obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 7168.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-12 prim-core collide-with)
+            (collide-spec backgnd jak crate enemy obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 0)
+      (set-vector! (-> v1-12 local-sphere) 0.0 2048.0 0.0 4505.6)
+      )
+    (let ((v1-14 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-14 prim-core collide-with)
+            (collide-spec backgnd jak crate enemy obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 0)
+      (set-vector! (-> v1-14 local-sphere) 0.0 -2048.0 0.0 4096.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-17 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-17 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-17 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod rigid-body-object-method-33 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder))
+  (initialize-skeleton
+    obj
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-dig-bomb-crate-cylinder" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (rigid-body-object-method-31 obj *dig-bomb-crate-cylinder-constants*)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logior! (-> obj rbody state flags) (rigid-body-flag enable-collision))
+  (set! (-> obj draw light-index) (the-as uint 10))
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-bomb-crate-cylinder-init-by-other dig-bomb-crate-cylinder ((arg0 dig-bomb-crate-cylinder-spawn-params) (arg1 entity-actor))
+  (process-entity-set! self arg1)
+  (rigid-body-object-method-32 self)
+  (set! (-> self root-override-2 trans quad) (-> arg0 pos quad))
+  (quaternion-copy! (-> self root-override-2 quat) (-> arg0 quat))
+  (rigid-body-object-method-33 self)
+  (set! (-> self mask) (logior (process-mask platform) (-> self mask)))
+  (vector-float*! (-> self rbody state lin-momentum) (-> arg0 vel) (-> self info mass))
+  (vector-float*! (-> self rbody state ang-momentum) (-> arg0 avel) (-> self info mass))
+  (go-virtual idle)
+  (none)
+  )
+
+(defun dig-bomb-crate-cylinder-spawn ((arg0 process-tree) (arg1 dig-bomb-crate-cylinder-spawn-params) (arg2 entity-actor))
+  (process-spawn dig-bomb-crate-cylinder arg1 arg2 :to arg0)
+  )
+
+(deftype dig-bomb-crate (process-focusable)
+  ()
+  :heap-base #x50
+  :method-count-assert 30
+  :size-assert         #xcc
+  :flag-assert         #x1e005000cc
+  (:methods
+    (idle () _type_ :state 27)
+    (die () _type_ :state 28)
+    (dig-bomb-crate-method-29 (_type_ vector) none 29)
+    )
+  )
+
+
+(defskelgroup skel-dig-bomb-crate dig-bomb-crate 0 3
+              ((1 (meters 20)) (2 (meters 999999)))
+              :bounds (static-spherem 0 2 0 4.5)
+              )
+
+(defskelgroup skel-dig-bomb-crate-explode dig-bomb-crate 4 6
+              ((5 (meters 999999)))
+              :bounds (static-spherem 0 2 0 4.5)
+              )
+
+(define *dig-bomb-crate-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 3 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 13 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    :art-level #f
+    )
+  )
+
+(define *dig-bomb-crate-array* (new 'static 'inline-array vector 8
+                                 (new 'static 'vector :x -5038.08 :y 5120.0 :z -5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 5120.0 :z -5038.08)
+                                 (new 'static 'vector :x -5038.08 :y 5120.0 :z 5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 5120.0 :z 5038.08)
+                                 (new 'static 'vector :x -5038.08 :y 15155.2 :z -5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 15155.2 :z -5038.08)
+                                 (new 'static 'vector :x -5038.08 :y 15155.2 :z 5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 15155.2 :z 5038.08)
+                                 )
+        )
+
+(defmethod dig-bomb-crate-method-29 dig-bomb-crate ((obj dig-bomb-crate) (arg0 vector))
+  (let ((s4-0 (-> obj root-override trans)))
+    (dotimes (s3-0 8)
+      (let ((a0-2 (-> *dig-bomb-crate-array* s3-0))
+            (s2-0 (new 'stack-no-clear 'dig-bomb-crate-cylinder-spawn-params))
+            )
+        (vector+! (-> s2-0 pos) s4-0 a0-2)
+        (vector-! (-> s2-0 vel) (-> s2-0 pos) arg0)
+        (vector-normalize! (-> s2-0 vel) (rand-vu-float-range 81920.0 163840.0))
+        (+! (-> s2-0 vel y) (rand-vu-float-range 12288.0 32768.0))
+        (quaternion-identity! (-> s2-0 quat))
+        (set! (-> s2-0 avel x) (rand-vu-float-range -3.0 3.0))
+        (set! (-> s2-0 avel y) (rand-vu-float-range -3.0 3.0))
+        (set! (-> s2-0 avel z) (rand-vu-float-range -3.0 3.0))
+        (dig-bomb-crate-cylinder-spawn
+          *entity-pool*
+          (the-as dig-bomb-crate-cylinder-spawn-params (-> s2-0 pos))
+          (-> obj entity)
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defmethod get-trans dig-bomb-crate ((obj dig-bomb-crate) (arg0 int))
+  "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])"
+  (local-vars (v0-0 vector))
+  (let ((v1-0 (-> obj root-override)))
+    (case arg0
+      ((2 3)
+       (set! v0-0 (new 'static 'vector))
+       (vector+! v0-0 (-> v1-0 trans) (new 'static 'vector :y 12288.0))
+       )
+      (else
+        (set! v0-0 (-> v1-0 trans))
+        )
+      )
+    )
+  v0-0
+  )
+
+(defstate idle (dig-bomb-crate)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (logclear! (-> self mask) (process-mask actor-pause))
+       (go-virtual die)
+       )
+      (('track)
+       #t
+       )
+      )
+    )
+  :code (the-as (function none :behavior dig-bomb-crate) sleep-code)
+  )
+
+(defstate die (dig-bomb-crate)
+  :virtual #t
+  :enter (behavior ()
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (let ((v1-6 (-> self root-override root-prim)))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (let* ((gp-0 *target*)
+           (a0-4 (if (type? gp-0 process-focusable)
+                     gp-0
+                     )
+                 )
+           )
+      (if a0-4
+          (dig-bomb-crate-method-29 self (get-trans a0-4 0))
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (suspend)
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (sound-play "bomb-rack-break")
+    (let ((gp-1 (new 'stack 'joint-exploder-tuning (the-as uint 1))))
+      (let* ((s5-1 *target*)
+             (a0-5 (if (type? s5-1 process-focusable)
+                       s5-1
+                       )
+                   )
+             )
+        (when a0-5
+          (set! (-> gp-1 fountain-rand-transv-lo quad) (-> (get-trans a0-5 0) quad))
+          (set! (-> gp-1 fountain-rand-transv-lo y) (+ -16384.0 (-> gp-1 fountain-rand-transv-lo y)))
+          )
+        )
+      (set! (-> gp-1 fountain-rand-transv-hi x) 24576.0)
+      (set! (-> gp-1 fountain-rand-transv-hi y) 81920.0)
+      (set! (-> gp-1 fountain-rand-transv-hi z) 12288.0)
+      (set! (-> gp-1 fountain-rand-transv-hi w) 32768.0)
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-dig-bomb-crate-explode" (the-as (pointer uint32) #f))
+        6
+        gp-1
+        *dig-bomb-crate-exploder-params*
+        :to self
+        )
+      )
+    (suspend)
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 4))
+        (suspend)
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-bomb-crate ((obj dig-bomb-crate) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 penetrated-by)
+          (penetrate
+            generic-attack
+            lunge
+            flop
+            punch
+            spin
+            roll
+            uppercut
+            bonk
+            tube
+            vehicle
+            flut-attack
+            board
+            mech-punch
+            dark-punch
+            dark-giant
+            )
+          )
+    (let ((v1-3 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-3 prim-core action) (collide-action solid))
+      (set! (-> v1-3 transform-index) 3)
+      (set-vector! (-> v1-3 local-sphere) 0.0 8192.0 0.0 18432.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-3)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-6 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-6 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-6 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-bomb-crate" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj mask) (logior (process-mask enemy) (-> obj mask)))
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(defskelgroup skel-dig-jump-pad dig-jump-pad 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 15))
+
+(deftype dig-jump-pad (bouncer)
+  ()
+  :heap-base #x60
+  :method-count-assert 25
+  :size-assert         #xd4
+  :flag-assert         #x19006000d4
+  )
+
+
+(defmethod init-skeleton! dig-jump-pad ((obj dig-jump-pad))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-jump-pad" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  0
+  (none)
+  )
+
+(defmethod bouncer-method-24 dig-jump-pad ((obj dig-jump-pad))
+  "TODO - collision stuff"
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec crate))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set! (-> s4-0 transform-index) 0)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 61440.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 2))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-8 prim-core action) (collide-action solid))
+      (set! (-> v1-8 transform-index) 0)
+      (set-vector! (-> v1-8 local-sphere) 0.0 0.0 0.0 12288.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 8))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-10 prim-core action) (collide-action))
+      (set-vector! (-> v1-10 local-sphere) 0.0 4096.0 0.0 6144.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-13 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-13 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-13 prim-core collide-with))
+      )
+    (set! (-> obj root) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defstate fire (dig-jump-pad)
+  :virtual #t
+  :code (behavior ()
+    (sound-play "dig-air-lifter")
+    (let ((s5-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+          (gp-1 (get-process *default-dead-pool* part-tracker #x4000))
+          )
+      (when gp-1
+        (let ((t9-4 (method-of-type part-tracker activate)))
+          (t9-4
+            (the-as part-tracker gp-1)
+            *entity-pool*
+            (symbol->string (-> part-tracker symbol))
+            (the-as pointer #x70004000)
+            )
+          )
+        (let ((t9-5 run-function-in-process)
+              (a0-5 gp-1)
+              (a1-4 part-tracker-init)
+              (a2-5 (-> *part-group-id-table* 1147))
+              (a3-2 0)
+              (t0-1 #f)
+              (t1-1 #f)
+              (t2-1 #f)
+              (t3-0 *launch-matrix*)
+              )
+          (set! (-> t3-0 trans quad) (-> s5-1 quad))
+          ((the-as (function object object object object object object object object none) t9-5)
+           a0-5
+           a1-4
+           a2-5
+           a3-2
+           t0-1
+           t1-1
+           t2-1
+           t3-0
+           )
+          )
+        (-> gp-1 ppointer)
+        )
+      )
+    (let ((t9-6 (-> (method-of-type bouncer fire) code)))
+      (if t9-6
+          ((the-as (function none) t9-6))
+          )
+      )
+    (none)
+    )
+  )
diff --git a/goal_src/jak2/levels/dig/dig3-obs.gc b/goal_src/jak2/levels/dig/dig3-obs.gc
index 44575eb41e..af04cad54d 100644
--- a/goal_src/jak2/levels/dig/dig3-obs.gc
+++ b/goal_src/jak2/levels/dig/dig3-obs.gc
@@ -7,3 +7,2011 @@
 
 ;; DECOMP BEGINS
 
+(defpartgroup group-dig-spikey-sphere-bounce
+  :id 1148
+  :duration (seconds 0.017)
+  :linger-duration (seconds 1.5)
+  :bounds (static-bspherem 0 0 0 2)
+  :parts ((sp-item 4978) (sp-item 4979) (sp-item 4980))
+  )
+
+(defpart 4978
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.06666667) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.16)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-rnd-flt spt-friction 0.92 0.03 1.0)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 65.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 4980
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 3) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters -0.026666667) (meters -0.06666667) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.08 -0.08 1.0)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-rnd-flt spt-friction 0.92 0.03 1.0)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+(defpart 4979
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-scale-x (meters 1.5) (meters 0.5) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.10666667) (meters 0.053333335) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.0016666667))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.21333334)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 60.0) (degrees 20.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpartgroup group-dig-spikey-sphere-break
+  :id 1149
+  :duration (seconds 2)
+  :linger-duration (seconds 3)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 4978 :period 1500 :length 15)
+    (sp-item 4979 :period 1500 :length 15)
+    (sp-item 4982 :period 1500 :length 15)
+    (sp-item 4983 :fade-after (meters 130) :falloff-to (meters 130) :flags (is-3d) :period 1500 :length 15 :binding 4981)
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    )
+  )
+
+(defpart 4982
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 32.0)
+    (sp-flt spt-y (meters 3))
+    (sp-rnd-flt spt-scale-x (meters 2.5) (meters 2.5) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 2.5) (meters 2.5) 1.0)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.033333335) (meters 0.13333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-rnd-flt spt-fade-a -0.04 -0.04 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -0.13653333 1.0)
+    (sp-rnd-flt spt-friction 0.9 0.02 1.0)
+    (sp-int spt-timer 800)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 30.0) (degrees 70.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 1) 1.0)
+    )
+  )
+
+(defpart 4981
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y 0.0 -2.048 1.0)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 use-global-acc)
+    )
+  )
+
+(defpart 4983
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xc :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-flt spt-y (meters 3))
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.5) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 0.0 32.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-rotvel-x (degrees -4.8) (degrees 9.6) 1.0)
+    (sp-rnd-flt spt-rotvel-y (degrees -4.8) (degrees 9.6) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -4.8) (degrees 9.6) 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 -6.826667 1.0)
+    (sp-rnd-flt spt-friction 0.95 0.02 1.0)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-int-plain-rnd spt-next-time 100 199 1)
+    (sp-launcher-by-id spt-next-launcher 237)
+    (sp-rnd-flt spt-conerot-x (degrees 30.0) (degrees 70.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 2) 1.0)
+    )
+  )
+
+(defpart 4984
+  :init-specs ((sp-rnd-flt spt-fade-a -1.28 -1.28 1.0))
+  )
+
+(deftype dig-spikey-step (process-drawable)
+  ((smush         smush-control :inline :offset-assert 208)
+   (init-quat     quaternion    :inline :offset-assert 240)
+   (shudder-angle float                 :offset-assert 256)
+   (rot-angle     float                 :offset-assert 260)
+   (cycle-time    float                 :offset-assert 264)
+   (cycle-offset  float                 :offset-assert 268)
+   )
+  :heap-base #x90
+  :method-count-assert 21
+  :size-assert         #x110
+  :flag-assert         #x1500900110
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-dig-spikey-step dig-spikey-step 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 6 9))
+
+(defstate idle (dig-spikey-step)
+  :virtual #t
+  :trans (the-as (function none :behavior dig-spikey-step) rider-trans)
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (the int (-> self cycle-offset)))
+        (suspend)
+        )
+      )
+    (until #f
+      (let ((gp-1 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-1) (the int (-> self cycle-time)))
+          (suspend)
+          )
+        )
+      ((method-of-type smush-control activate!)
+       (the-as smush-control (&-> self stack 72))
+       -1.0
+       60
+       225
+       1.0
+       1.0
+       (-> self clock)
+       )
+      (sound-play "spikey-shake" :position (-> self root trans))
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.75))
+          (set! (-> self shudder-angle)
+                (* 364.0889 ((method-of-type smush-control update!) (the-as smush-control (&-> self stack 72))))
+                )
+          (suspend)
+          )
+        )
+      (set! (-> self shudder-angle) 0.0)
+      ((method-of-type smush-control set-zero!) (the-as smush-control (&-> self stack 72)))
+      (let ((gp-4 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
+          (suspend)
+          )
+        )
+      (sound-play "spikey-turn" :position (-> self root trans))
+      (let* ((f0-7 1.0)
+             (f30-1 (* 65536.0 f0-7))
+             (gp-6 (-> self clock frame-counter))
+             )
+        (until (>= (- (-> self clock frame-counter) gp-6) (seconds 1))
+          (set! (-> self rot-angle)
+                (the float (sar (shl (the int (+ (-> self rot-angle) (* f30-1 (-> self clock seconds-per-frame)))) 48) 48))
+                )
+          (suspend)
+          )
+        )
+      (let ((v1-42 #x10000))
+        (if (< (-> self rot-angle) 0.0)
+            (set! (-> self rot-angle)
+                  (the float (sar (shl (* v1-42 (/ (- (the int (-> self rot-angle)) (/ v1-42 2)) v1-42)) 48) 48))
+                  )
+            (set! (-> self rot-angle)
+                  (the float (sar (shl (* v1-42 (/ (+ (the int (-> self rot-angle)) (/ v1-42 2)) v1-42)) 48) 48))
+                  )
+            )
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a2-1 (quaternion-vector-angle!
+                  (new 'stack-no-clear 'quaternion)
+                  *z-vector*
+                  (+ (-> self rot-angle) (-> self shudder-angle))
+                  )
+                )
+          )
+      (quaternion*! (-> self root quat) (-> self init-quat) a2-1)
+      )
+    (rider-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-spikey-step ((obj dig-spikey-step) (arg0 entity-actor))
+  (local-vars (sv-16 int))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 24576.0 36864.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-spikey-step" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (quaternion-copy! (-> obj init-quat) (-> obj root quat))
+  (let ((f28-0 4.0)
+        (f30-0 0.0)
+        )
+    (set! sv-16 0)
+    (let ((v1-20 (res-lump-data arg0 'cycle-speed (pointer float) :tag-ptr (the-as (pointer res-tag) (& sv-16)))))
+      (when v1-20
+        (set! f28-0 (-> v1-20 0))
+        (set! f30-0 (-> v1-20 1))
+        )
+      )
+    (set! (-> obj cycle-time) (the float (max 0 (+ (the int (* 300.0 f28-0)) -525))))
+    (set! (-> obj cycle-offset) (the float (the int (* 300.0 f30-0))))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype dig-spikey-sphere (projectile-bounce)
+  ((death-height  float  :offset-assert 496)
+   (pad-i1hb23h1b float  :offset-assert 500)
+   )
+  :heap-base #x180
+  :method-count-assert 42
+  :size-assert         #x1f8
+  :flag-assert         #x2a018001f8
+  )
+
+
+(defskelgroup skel-dig-spikey-sphere dig-spikey-sphere 0 3
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 0 0 4.2)
+              :shadow 2
+              )
+
+(defskelgroup skel-dig-spikey-sphere-explode dig-spikey-sphere 4 6
+              ((5 (meters 999999)))
+              :bounds (static-spherem 0 0 0 4.2)
+              )
+
+(define *dig-spikey-sphere-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 3 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    :art-level #f
+    )
+  )
+
+(defstate die (dig-spikey-sphere)
+  :virtual #t
+  :enter (behavior ()
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (let ((v1-6 (-> self root-override root-prim)))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-dig-spikey-sphere-explode" (the-as (pointer uint32) #f))
+        6
+        gp-0
+        *dig-spikey-sphere-exploder-params*
+        :to self
+        )
+      )
+    (sound-play "spikey-break")
+    (suspend)
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 4))
+        (suspend)
+        )
+      )
+    (let ((t9-7 (-> (method-of-type projectile-bounce die) code)))
+      (if t9-7
+          ((the-as (function none) t9-7))
+          )
+      )
+    (none)
+    )
+  )
+
+(defun spikey-sphere-update-velocity ((arg0 dig-spikey-sphere))
+  (with-pp
+    (set! (-> arg0 root-override transv y)
+          (- (-> arg0 root-override transv y) (* 327680.0 (-> pp clock seconds-per-frame)))
+          )
+    0
+    (none)
+    )
+  )
+
+(defbehavior spikey-sphere-reaction dig-spikey-sphere ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector))
+  (cshape-reaction-update-state arg0 arg1 arg3)
+  (let ((f30-0 (vector-dot arg3 (-> arg0 surface-normal)))
+        (s3-0 (new 'stack-no-clear 'vector))
+        )
+    (sound-play "spikey-bounce")
+    (vector-float*! s3-0 (-> arg0 surface-normal) (* 1.6 f30-0))
+    (vector-! arg2 arg3 s3-0)
+    )
+  (-> arg0 status)
+  )
+
+(defmethod init-collision! dig-spikey-sphere ((obj dig-spikey-sphere))
+  "Init the [[projectile]]'s [[collide-shape]]"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) spikey-sphere-reaction)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec backgnd player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 12288.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defun spikey-sphere-move ((arg0 dig-spikey-sphere))
+  (quaternion*! (-> arg0 root-override quat) (-> arg0 tumble-quat) (-> arg0 root-override quat))
+  (projectile-move-fill-all-dirs arg0)
+  (none)
+  )
+
+;; WARN: Return type mismatch time-frame vs sound-id.
+(defmethod play-impact-sound! dig-spikey-sphere ((obj dig-spikey-sphere))
+  "Plays impact sound
+       :virtual"
+  (let* ((a0-1 (-> obj root-override))
+         (s5-0 (-> a0-1 status))
+         )
+    (when (logtest? s5-0 (collide-status touch-surface))
+      (vector-float*! (-> a0-1 transv) (-> a0-1 transv) 0.9)
+      (cond
+        ((< (-> obj root-override trans y) (-> obj pad-i1hb23h1b))
+         (let ((s4-0 (get-process *default-dead-pool* part-tracker #x4000)))
+           (when s4-0
+             (let ((t9-1 (method-of-type part-tracker activate)))
+               (t9-1
+                 (the-as part-tracker s4-0)
+                 *entity-pool*
+                 (symbol->string (-> part-tracker symbol))
+                 (the-as pointer #x70004000)
+                 )
+               )
+             (let ((t9-2 run-function-in-process)
+                   (a0-5 s4-0)
+                   (a1-3 part-tracker-init)
+                   (a2-4 (-> *part-group-id-table* 1149))
+                   (a3-1 0)
+                   (t0-0 #f)
+                   (t1-0 #f)
+                   (t2-0 #f)
+                   (t3-0 *launch-matrix*)
+                   )
+               (set! (-> t3-0 trans quad) (-> obj root-override grount-touch-point quad))
+               ((the-as (function object object object object object object object object none) t9-2)
+                a0-5
+                a1-3
+                a2-4
+                a3-1
+                t0-0
+                t1-0
+                t2-0
+                t3-0
+                )
+               )
+             (-> s4-0 ppointer)
+             )
+           )
+         (go (method-of-object obj die))
+         )
+        (else
+          (let ((s4-1 (get-process *default-dead-pool* part-tracker #x4000)))
+            (when s4-1
+              (let ((t9-5 (method-of-type part-tracker activate)))
+                (t9-5
+                  (the-as part-tracker s4-1)
+                  *entity-pool*
+                  (symbol->string (-> part-tracker symbol))
+                  (the-as pointer #x70004000)
+                  )
+                )
+              (let ((t9-6 run-function-in-process)
+                    (a0-8 s4-1)
+                    (a1-6 part-tracker-init)
+                    (a2-9 (-> *part-group-id-table* 1148))
+                    (a3-3 0)
+                    (t0-1 #f)
+                    (t1-1 #f)
+                    (t2-1 #f)
+                    (t3-1 *launch-matrix*)
+                    )
+                (set! (-> t3-1 trans quad) (-> obj root-override grount-touch-point quad))
+                ((the-as (function object object object object object object object object none) t9-6)
+                 a0-8
+                 a1-6
+                 a2-9
+                 a3-3
+                 t0-1
+                 t1-1
+                 t2-1
+                 t3-1
+                 )
+                )
+              (-> s4-1 ppointer)
+              )
+            )
+          )
+        )
+      )
+    (the-as sound-id (when (and (logtest? s5-0 (collide-status impact-surface))
+                                (>= (- (-> self clock frame-counter) (-> obj played-bounce-time)) (seconds 0.3))
+                                )
+                       (let ((v0-7 (-> self clock frame-counter)))
+                         (set! (-> obj played-bounce-time) v0-7)
+                         v0-7
+                         )
+                       )
+            )
+    )
+  )
+
+(defmethod init-proj-settings! dig-spikey-sphere ((obj dig-spikey-sphere))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+       :virtual"
+  (with-pp
+    (set! (-> obj attack-mode) 'eco-dark)
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-spikey-sphere" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (let ((t9-2 (method-of-type projectile-bounce init-proj-settings!)))
+      (t9-2 obj)
+      )
+    (set! (-> obj max-speed) 163840.0)
+    (set! (-> obj timeout) (seconds 8))
+    (logclear! (-> obj mask) (process-mask actor-pause))
+    (set! (-> obj notify-handle) (the-as handle #f))
+    (set! (-> obj update-velocity) spikey-sphere-update-velocity)
+    (set! (-> obj max-hits) #xffff)
+    (set! (-> obj move) spikey-sphere-move)
+    (set-vector! (-> obj root-override quat) 0.0 0.0 0.0 1.0)
+    (set! (-> obj pad-i1hb23h1b) (+ -204800.0 (-> obj root-override trans y)))
+    (let ((v1-16 (-> obj starting-dir)))
+      (quaternion-axis-angle!
+        (-> obj tumble-quat)
+        (-> v1-16 z)
+        (-> v1-16 y)
+        (-> v1-16 x)
+        (* -65536.0 (-> pp clock seconds-per-frame))
+        )
+      )
+    (set! (-> obj draw light-index) (the-as uint 4))
+    (sound-play "spikey-roll")
+    0
+    (none)
+    )
+  )
+
+(deftype dig-spikey-sphere-door (process-drawable)
+  ((sync      sync-linear :inline :offset-assert 200)
+   (prev-sync float               :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xdc
+  :flag-assert         #x16006000dc
+  (:methods
+    (idle () _type_ :state 20)
+    (active () _type_ :state 21)
+    )
+  )
+
+
+(defskelgroup skel-dig-spikey-sphere-door dig-spikey-sphere-door 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 -4 0 7)
+              :origin-joint-index 4
+              )
+
+(defstate idle (dig-spikey-sphere-door)
+  :virtual #t
+  :trans (behavior ()
+    (let ((f30-0 (-> self prev-sync))
+          (f0-0 (get-norm! (-> self sync) 0))
+          )
+      (set! (-> self prev-sync) f0-0)
+      (if (< f0-0 f30-0)
+          (go-virtual active)
+          )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-spikey-sphere-door) sleep-code)
+  )
+
+(defstate active (dig-spikey-sphere-door)
+  :virtual #t
+  :code (behavior ()
+    (sound-play "spikey-door")
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.1))
+        (suspend)
+        )
+      )
+    (let ((gp-2 (new 'stack-no-clear 'vector))
+          (s5-1 (new 'static 'vector :x -16384.0 :y -16384.0))
+          )
+      (vector-z-quaternion! gp-2 (-> self root quat))
+      (let ((v1-7 (new 'stack-no-clear 'projectile-init-by-other-params)))
+        (set! (-> v1-7 ent) (-> self entity))
+        (set! (-> v1-7 charge) 1.0)
+        (set! (-> v1-7 options) (projectile-options))
+        (set! (-> v1-7 notify-handle) (the-as handle #f))
+        (set! (-> v1-7 owner-handle) (the-as handle #f))
+        (set! (-> v1-7 ignore-handle) (process->handle self))
+        (let* ((a0-8 *game-info*)
+               (a1-6 (+ (-> a0-8 attack-id) 1))
+               )
+          (set! (-> a0-8 attack-id) a1-6)
+          (set! (-> v1-7 attack-id) a1-6)
+          )
+        (set! (-> v1-7 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+        (vector+! (-> v1-7 pos) (-> self root trans) s5-1)
+        (vector-float*! (-> v1-7 vel) gp-2 163840.0)
+        (spawn-projectile
+          dig-spikey-sphere
+          (the-as projectile-init-by-other-params (&-> v1-7 ent))
+          self
+          *default-dead-pool*
+          )
+        )
+      )
+    (ja-no-eval :group! (ja-group)
+                :num! (seek! (the float (+ (-> (ja-group) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-virtual idle)
+    (none)
+    )
+  :post (the-as (function none :behavior dig-spikey-sphere-door) ja-post)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-spikey-sphere-door ((obj dig-spikey-sphere-door) (arg0 entity-actor))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-dig-spikey-sphere-door" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (let ((a1-5 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-4 0))
+      (if #f
+          (set! v1-4 (logior v1-4 1))
+          )
+      (set! (-> a1-5 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-5 sync-flags) (the-as sync-flags v1-4))
+      )
+    (set! (-> a1-5 entity) arg0)
+    (set! (-> a1-5 period) (the-as uint 1200))
+    (set! (-> a1-5 percent) 0.0)
+    (initialize! (-> obj sync) a1-5)
+    )
+  (set! (-> obj prev-sync) (get-norm! (-> obj sync) 0))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj draw light-index) (the-as uint 3))
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(defskelgroup skel-dig-balloon-lurker-trapeze dig-balloon-lurker 3 6
+              ((4 (meters 999999)))
+              :bounds (static-spherem 0 0 0 20)
+              :shadow 5
+              )
+
+(defskelgroup skel-dig-balloon-lurker dig-balloon-lurker 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 8 0 16)
+              )
+
+(deftype dig-balloon-lurker (process-drawable)
+  ((init-quat        quaternion    :inline :offset-assert 208)
+   (sync             sync-eased    :inline :offset-assert 224)
+   (swing-sync       sync-linear   :inline :offset-assert 272)
+   (smush            smush-control :inline :offset-assert 288)
+   (pov-cam-offset   vector        :inline :offset-assert 320)
+   (options          int32                 :offset-assert 336)
+   (bouncing         basic                 :offset-assert 340)
+   (bounce-scale     meters                :offset-assert 344)
+   (bob-counter      float                 :offset-assert 348)
+   (forward-backward basic                 :offset-assert 352)
+   (grabbed          basic                 :offset-assert 356)
+   (trapeze-grabbed  basic                 :offset-assert 360)
+   (pedal-anim-frame float                 :offset-assert 364)
+   (pedal-anim-speed float                 :offset-assert 368)
+   (pedal-sound-id   uint32                :offset-assert 372)
+   )
+  :heap-base #x100
+  :method-count-assert 21
+  :size-assert         #x178
+  :flag-assert         #x1501000178
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(deftype dig-balloon-lurker-trapeze (process-drawable)
+  ((parent-ptr       (pointer dig-balloon-lurker)  :offset         16)
+   (swing-type       float                         :offset-assert 200)
+   (swing-pole       (pointer swingpole)           :offset-assert 204)
+   (swing-anim-frame float                         :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xd4
+  :flag-assert         #x16006000d4
+  (:methods
+    (idle () _type_ :state 20)
+    (dig-balloon-lurker-trapeze-method-21 (_type_) none 21)
+    )
+  )
+
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-balloon-lurker-trapeze-init-by-other dig-balloon-lurker-trapeze ((arg0 entity-actor))
+  (set! (-> self root) (new 'process 'trsqv))
+  (process-drawable-from-entity! self arg0)
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-dig-balloon-lurker-trapeze" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (set! (-> self swing-type) 0.0)
+  (set! (-> self swing-pole) (process-spawn swingpole :init swingpole-init 11 :to self))
+  (set! (-> self swing-anim-frame) 0.0)
+  (set! (-> self draw shadow-ctrl) (new
+                                     'process
+                                     'shadow-control
+                                     0.0
+                                     0.0
+                                     614400.0
+                                     (shadow-flags disable-fade shdf02 shdf03 shdf04 shdf07)
+                                     491520.0
+                                     )
+        )
+  (go-virtual idle)
+  (none)
+  )
+
+(defstate idle (dig-balloon-lurker-trapeze)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 2 0)
+    (ja :group! (-> self draw art-group data 6) :num! min)
+    (ja :chan 1 :group! (-> self draw art-group data 7) :num! min)
+    (until #f
+      (ja :num-func num-func-identity :frame-num (-> self swing-anim-frame))
+      (let ((a0-4 (-> self skel root-channel 1)))
+        (let ((f0-4 (* 0.6 (-> self swing-type))))
+          (set! (-> a0-4 frame-interp 1) f0-4)
+          (set! (-> a0-4 frame-interp 0) f0-4)
+          )
+        (set! (-> a0-4 param 0) 0.0)
+        (joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-chan)
+        )
+      (let* ((f30-0 (the float (ja-num-frames 0)))
+             (f0-10
+               (+ (* 1.5 f30-0 (get-norm! (-> self parent-ptr 0 swing-sync) 0)) (if (= (-> self parent-ptr 0 options) 1)
+                                                                                    (* 0.5 f30-0)
+                                                                                    0.0
+                                                                                    )
+                  )
+               )
+             )
+        (set! (-> self swing-anim-frame) (- f0-10 (* (the float (the int (/ f0-10 f30-0))) f30-0)))
+        )
+      (set! (-> self root trans quad) (-> self parent-ptr 0 root trans quad))
+      (quaternion-copy! (-> self root quat) (-> self parent-ptr 0 root quat))
+      (let ((v1-36 (and (-> self swing-pole 0 next-state) (= (-> self swing-pole 0 next-state name) 'active))))
+        (set! (-> self parent-ptr 0 trapeze-grabbed) (the-as basic v1-36))
+        )
+      (seek!
+        (-> self swing-type)
+        (if (-> self parent-ptr 0 trapeze-grabbed)
+            1.0
+            0.0
+            )
+        (* 0.02 (-> self clock time-adjust-ratio))
+        )
+      (dig-balloon-lurker-trapeze-method-21 self)
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior dig-balloon-lurker-trapeze) ja-post)
+  )
+
+(defmethod dig-balloon-lurker-trapeze-method-21 dig-balloon-lurker-trapeze ((obj dig-balloon-lurker-trapeze))
+  (cond
+    ((and (-> obj draw shadow)
+          (zero? (-> obj draw cur-lod))
+          (logtest? (-> obj draw status) (draw-control-status on-screen))
+          )
+     (let ((s5-0 (new 'stack-no-clear 'collide-query)))
+       (vector<-cspace! (-> s5-0 start-pos) (-> obj node-list data 11))
+       (set! (-> s5-0 start-pos y) (+ -24576.0 (-> obj root trans y)))
+       (set-vector! (-> s5-0 move-dist) 0.0 -34816.0 0.0 1.0)
+       (let ((v1-10 s5-0))
+         (set! (-> v1-10 radius) 8192.0)
+         (set! (-> v1-10 collide-with) (collide-spec backgnd))
+         (set! (-> v1-10 ignore-process0) obj)
+         (set! (-> v1-10 ignore-process1) #f)
+         (set! (-> v1-10 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+         (set! (-> v1-10 action-mask) (collide-action solid))
+         )
+       (cond
+         ((>= (fill-and-probe-using-line-sphere *collide-cache* s5-0) 0.0)
+          (-> s5-0 best-other-tri intersect)
+          (let ((v1-15 (-> obj draw shadow-ctrl)))
+            (logclear! (-> v1-15 settings flags) (shadow-flags disable-draw))
+            )
+          0
+          (let ((v1-18 (-> obj draw shadow-ctrl)))
+            (set! (-> v1-18 settings bot-plane w) (- (+ -6144.0 (-> s5-0 best-other-tri intersect y))))
+            )
+          0
+          (let ((v1-21 (-> obj draw shadow-ctrl)))
+            (set! (-> v1-21 settings top-plane w) (- (+ 6144.0 (-> s5-0 best-other-tri intersect y))))
+            )
+          0
+          (let* ((f1-4 (vector-vector-distance (-> s5-0 best-other-tri intersect) (-> obj root trans)))
+                 (f0-15 (* 0.000030517578 (fmin 32768.0 (fmax 0.0 (+ -57344.0 f1-4)))))
+                 )
+            (set! (-> obj draw shadow-ctrl settings shadow-dir w) (lerp 409600.0 40960.0 f0-15))
+            )
+          )
+         (else
+           (let ((v1-31 (-> obj draw shadow-ctrl)))
+             (logior! (-> v1-31 settings flags) (shadow-flags disable-draw))
+             )
+           0
+           )
+         )
+       )
+     )
+    (else
+      (let ((v1-34 (-> obj draw shadow-ctrl)))
+        (logior! (-> v1-34 settings flags) (shadow-flags disable-draw))
+        )
+      0
+      )
+    )
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-balloon-lurker ((obj dig-balloon-lurker) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 3) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 4))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec crate))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 0)
+      (set-vector! (-> s3-0 local-sphere) 0.0 61440.0 0.0 61440.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-8 prim-core action) (collide-action solid))
+      (set! (-> v1-8 transform-index) 3)
+      (set-vector! (-> v1-8 local-sphere) 0.0 4096.0 0.0 28672.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-10 prim-core action) (collide-action solid))
+      (set! (-> v1-10 transform-index) 3)
+      (set-vector! (-> v1-10 local-sphere) 0.0 4096.0 36864.0 16384.0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 3)
+      (set-vector! (-> v1-12 local-sphere) 0.0 4096.0 -36864.0 20480.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-15 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-15 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-15 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-balloon-lurker" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (process-spawn dig-balloon-lurker-trapeze arg0 :to obj)
+  (quaternion-copy! (-> obj init-quat) (-> obj root quat))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj options) (res-lump-value arg0 'options int :time -1000000000.0))
+  (set! (-> obj path) (new 'process 'curve-control obj 'path -1000000000.0))
+  (set! (-> obj bouncing) #f)
+  (set! (-> obj bounce-scale) 1228.8)
+  (set! (-> obj bob-counter) (if (= (-> obj options) 1)
+                                 145.0
+                                 0.0
+                                 )
+        )
+  (set! (-> obj forward-backward) #f)
+  (set! (-> obj grabbed) #f)
+  (set! (-> obj trapeze-grabbed) #f)
+  (set! (-> obj pedal-anim-frame) 0.0)
+  (set! (-> obj pedal-anim-speed) 0.5)
+  (set-vector! (-> obj pov-cam-offset) 0.0 -20480.0 0.0 1.0)
+  (set! (-> obj pedal-sound-id) (the-as uint (new-sound-id)))
+  (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+  (let ((a1-23 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-39 0))
+      (if #t
+          (set! v1-39 (logior v1-39 1))
+          )
+      (set! (-> a1-23 sync-type) (the-as basic 'sync-eased))
+      (set! (-> a1-23 sync-flags) (the-as sync-flags v1-39))
+      )
+    (set! (-> a1-23 period) (the-as uint 3600))
+    (set! (-> a1-23 entity) arg0)
+    (set! (-> a1-23 percent) 0.0)
+    (set! (-> a1-23 ease-in) 0.15)
+    (set! (-> a1-23 ease-out) 0.15)
+    (set! (-> a1-23 pause-in) 0.0)
+    (set! (-> a1-23 pause-out) 0.0)
+    (initialize! (-> obj sync) a1-23)
+    )
+  (let ((a1-24 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-46 0))
+      (if #t
+          (set! v1-46 (logior v1-46 1))
+          )
+      (set! (-> a1-24 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-24 sync-flags) (the-as sync-flags v1-46))
+      )
+    (set! (-> a1-24 entity) arg0)
+    (set! (-> a1-24 period) (the-as uint 3600))
+    (set! (-> a1-24 percent) 0.0)
+    (initialize! (-> obj swing-sync) a1-24)
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(defmethod deactivate dig-balloon-lurker ((obj dig-balloon-lurker))
+  (sound-stop (the-as sound-id (-> obj pedal-sound-id)))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+(defstate idle (dig-balloon-lurker)
+  :virtual #t
+  :code (behavior ()
+    (until #f
+      (let ((f30-0 (get-norm! (-> self sync) 0)))
+        (cond
+          ((-> self forward-backward)
+           (if (< 0.9 f30-0)
+               (set! (-> self forward-backward) #f)
+               )
+           )
+          (else
+            (if (< f30-0 0.1)
+                (set! (-> self forward-backward) (the-as basic #t))
+                )
+            )
+          )
+        (seek!
+          (-> self pedal-anim-speed)
+          (if (-> self forward-backward)
+              -0.5
+              0.5
+              )
+          (* 0.01 (-> self clock time-adjust-ratio))
+          )
+        (let ((f0-7 (+ -1.0 (fabs (* 2.0 (-> self pedal-anim-speed)))))
+              (f1-5 (* 2.0 (fabs (-> self pedal-anim-speed))))
+              )
+          (sound-play-by-name
+            (static-sound-name "balon-lurk-loop")
+            (the-as sound-id (-> self pedal-sound-id))
+            (the int (* 1024.0 f1-5))
+            (the int (* 1524.0 f0-7))
+            0
+            (sound-group sfx)
+            #t
+            )
+          )
+        (ja :num-func num-func-identity :frame-num (-> self pedal-anim-frame))
+        (+! (-> self pedal-anim-frame) (* (-> self pedal-anim-speed) (-> self clock time-adjust-ratio)))
+        (cond
+          ((>= (-> self pedal-anim-frame) (the float (ja-num-frames 0)))
+           (set! (-> self pedal-anim-frame) (- (-> self pedal-anim-frame) (the float (ja-num-frames 0))))
+           )
+          ((< (-> self pedal-anim-frame) 0.0)
+           (+! (-> self pedal-anim-frame) (the float (ja-num-frames 0)))
+           )
+          )
+        (cond
+          ((-> self trapeze-grabbed)
+           (when (not (-> self grabbed))
+             (set-setting! 'mode-name 'cam-pov-track 0 0)
+             (let ((v1-33 (process->ppointer self)))
+               (set-setting! 'pov-handle v1-33 #x40400000 (-> v1-33 0 pid))
+               )
+             (set! (-> self pov-cam-offset z)
+                   (if (< 0.0 (vector-dot (-> self node-list data 0 bone transform vector 2) (-> (camera-matrix) vector 2)))
+                       -81920.0
+                       81920.0
+                       )
+                   )
+             (set-setting! 'pov-offset 'asdf (-> self pov-cam-offset) 0)
+             (set! (-> self grabbed) (the-as basic #t))
+             )
+           (when (not (-> self bouncing))
+             (activate! (-> self smush) -1.0 210 600 1.0 1.0 (-> self clock))
+             (set! (-> self bouncing) (the-as basic #t))
+             (cond
+               ((< (-> self bob-counter) 90.0)
+                (set! (-> self bob-counter) (- 180.0 (-> self bob-counter)))
+                )
+               ((< 270.0 (-> self bob-counter))
+                (set! (-> self bob-counter) (- 540.0 (-> self bob-counter)))
+                )
+               )
+             )
+           (seek! (-> self bob-counter) 270.0 (* 3.0 (-> self clock time-adjust-ratio)))
+           )
+          (else
+            (when (-> self grabbed)
+              (remove-setting! 'pov-handle)
+              (remove-setting! 'mode-name)
+              (remove-setting! 'pov-offset)
+              (set! (-> self grabbed) #f)
+              )
+            (+! (-> self bob-counter) (* 3.0 (-> self clock time-adjust-ratio)))
+            (if (< 360.0 (-> self bob-counter))
+                (set! (-> self bob-counter) (+ -360.0 (-> self bob-counter)))
+                )
+            (if (not (!= (-> self smush amp) 0.0))
+                (set! (-> self bouncing) #f)
+                )
+            )
+          )
+        (get-point-at-percent-along-path! (-> self path) (-> self root trans) f30-0 'interp)
+        (+! (-> self root trans y) (+ (* 2048.0 (sin (* 182.04445 (the float (the int (-> self bob-counter))))))
+                                      (* (-> self bounce-scale) (update! (-> self smush)))
+                                      )
+            )
+        (when (= (-> self options) 1)
+          (let ((a2-12 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) *y-vector* (* 182.04445 (* 70.0 f30-0)))))
+            (quaternion*! (-> self root quat) (-> self init-quat) a2-12)
+            )
+          )
+        )
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior dig-balloon-lurker) transform-post)
+  )
+
+(deftype dig-wheel-step (process-drawable)
+  ((anim-speed     float   :offset-assert 200)
+   (wheel-sound-id uint32  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xd0
+  :flag-assert         #x15005000d0
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-dig-wheel-step dig-wheel-step 0 2 ((1 (meters 999999))) :bounds (static-spherem 2 0 0 14))
+
+(defstate idle (dig-wheel-step)
+  :virtual #t
+  :trans (behavior ()
+    (sound-play "wheel-plat-loop" :id (the-as sound-id (-> self wheel-sound-id)))
+    (rider-trans)
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-no-eval :group! (ja-group)
+                  :num! (seek! (the float (+ (-> (ja-group) frames num-frames) -1)) (-> self anim-speed))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max (-> self anim-speed)))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior dig-wheel-step) rider-post)
+  )
+
+(defmethod deactivate dig-wheel-step ((obj dig-wheel-step))
+  (sound-stop (the-as sound-id (-> obj wheel-sound-id)))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-wheel-step ((obj dig-wheel-step) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 3) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 4))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 8192.0 0.0 0.0 57344.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-11 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-11 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-11 transform-index) 4)
+      (set-vector! (-> v1-11 local-sphere) 24576.0 0.0 0.0 24576.0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-13 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-13 transform-index) 5)
+      (set-vector! (-> v1-13 local-sphere) 24576.0 0.0 0.0 24576.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 43008.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-18 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-18 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-18 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-wheel-step" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj wheel-sound-id) (the-as uint (new-sound-id)))
+  (set! (-> obj draw light-index) (the-as uint 5))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (let* ((a0-30 (-> obj entity))
+         (f0-18 ((method-of-object a0-30 get-property-value-float)
+                 a0-30
+                 'rotspeed
+                 'interp
+                 -1000000000.0
+                 8192.0
+                 (the-as (pointer res-tag) #f)
+                 *res-static-buf*
+                 )
+                )
+         )
+    (set! (-> obj anim-speed) (* 0.000015258789 f0-18))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype dig-tipping-rock (rigid-body-platform)
+  ((anchor-point      vector     :inline :offset-assert 384)
+   (last-ridden-time  time-frame         :offset-assert 400)
+   (surface-height    float              :offset-assert 408)
+   (bubbling-sound-id uint32             :offset-assert 412)
+   )
+  :heap-base #x120
+  :method-count-assert 57
+  :size-assert         #x1a0
+  :flag-assert         #x39012001a0
+  )
+
+
+(define *dig-tipping-rock-constants* (new 'static 'rigid-body-platform-constants
+                                       :mass 4.0
+                                       :inv-mass 0.25
+                                       :cm-joint-z (meters -6)
+                                       :cm-joint-w 1.0
+                                       :linear-damping 0.9
+                                       :angular-damping 0.48
+                                       :friction-factor 0.1
+                                       :inertial-tensor-x (meters 4)
+                                       :inertial-tensor-y (meters 3)
+                                       :inertial-tensor-z (meters 21)
+                                       :max-time-step 0.02
+                                       :gravity (meters 80)
+                                       :idle-distance (meters 50)
+                                       :attack-force-scale 1.0
+                                       :name '*dig-tipping-rock-constants*
+                                       :drag-factor 2.0
+                                       :buoyancy-factor 1.2
+                                       :max-buoyancy-depth (meters 2)
+                                       :player-weight (meters 80)
+                                       :player-bonk-factor 0.5
+                                       :player-dive-factor 1.0
+                                       :player-force-distance (meters 30)
+                                       :player-force-clamp (meters 1000000)
+                                       :player-force-timeout #x1e
+                                       :explosion-force (meters 1000)
+                                       :control-point-count 4
+                                       :platform #t
+                                       :sound-name "mud-plat"
+                                       )
+        )
+
+(defskelgroup skel-dig-tipping-rock dig-tipping-rock 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 0 0 14.5)
+              :origin-joint-index 3
+              )
+
+(defmethod rigid-body-object-method-37 dig-tipping-rock ((obj dig-tipping-rock))
+  (with-pp
+    (let ((t9-0 (method-of-type rigid-body-platform rigid-body-object-method-37)))
+      (t9-0 obj)
+      )
+    (cond
+      ((>= (- (-> pp clock frame-counter) (-> obj last-ridden-time)) (seconds 0.5))
+       (when (nonzero? (-> obj bubbling-sound-id))
+         (let ((v1-5 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
+           (set! (-> v1-5 command) (sound-command set-param))
+           (set! (-> v1-5 id) (the-as sound-id (-> obj bubbling-sound-id)))
+           (set! (-> v1-5 params volume) -4)
+           (set! (-> v1-5 auto-time) 120)
+           (set! (-> v1-5 auto-from) 2)
+           (set! (-> v1-5 params mask) (the-as uint 17))
+           (-> v1-5 id)
+           )
+         (set! (-> obj bubbling-sound-id) (the-as uint 0))
+         0
+         )
+       )
+      (else
+        (if (zero? (-> obj bubbling-sound-id))
+            (set! (-> obj bubbling-sound-id) (the-as uint (sound-play "lava-plat-tip")))
+            )
+        )
+      )
+    (none)
+    )
+  )
+
+(defstate idle (dig-tipping-rock)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('ridden)
+       (set! (-> self last-ridden-time) (-> self clock frame-counter))
+       )
+      )
+    (the-as object (rigid-body-object-event-handler proc arg1 event-type event))
+    )
+  :trans (the-as (function none :behavior dig-tipping-rock) rider-trans)
+  :code (the-as (function none :behavior dig-tipping-rock) sleep-code)
+  :post (behavior ()
+    (rigid-body-object-method-37 self)
+    (none)
+    )
+  )
+
+(defstate active (dig-tipping-rock)
+  :virtual #t
+  :event (-> (method-of-type dig-tipping-rock idle) event)
+  )
+
+(defmethod rigid-body-object-method-29 dig-tipping-rock ((obj dig-tipping-rock) (arg0 float))
+  ((the-as (function rigid-body-platform float none) (find-parent-method dig-tipping-rock 29)) obj arg0)
+  (rigid-body-platform-method-56 obj (-> obj anchor-point))
+  0
+  (none)
+  )
+
+(defmethod rigid-body-object-method-32 dig-tipping-rock ((obj dig-tipping-rock))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 4096.0 59392.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod rigid-body-platform-method-53 dig-tipping-rock ((obj dig-tipping-rock) (arg0 vector))
+  (-> obj surface-height)
+  )
+
+(defmethod rigid-body-object-method-33 dig-tipping-rock ((obj dig-tipping-rock))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-tipping-rock" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (quaternion-rotate-local-x! (-> obj root-override-2 quat) (-> obj root-override-2 quat) -2555.2202)
+  (rigid-body-object-method-31 obj *dig-tipping-rock-constants*)
+  (set! (-> obj anchor-point quad) (-> obj rbody state position quad))
+  (let ((v1-8 (-> obj control-point-array)))
+    (let ((a0-8 (-> v1-8 data)))
+      (set! (-> a0-8 0 local-pos x) 0.0)
+      (set! (-> a0-8 0 local-pos y) 0.0)
+      (set! (-> a0-8 0 local-pos z) -8192.0)
+      (set! (-> a0-8 0 local-pos w) 1.0)
+      )
+    (let ((a0-9 (-> v1-8 data 1)))
+      (set! (-> a0-9 local-pos x) 0.0)
+      (set! (-> a0-9 local-pos y) 8192.0)
+      (set! (-> a0-9 local-pos z) -40960.0)
+      (set! (-> a0-9 local-pos w) 1.0)
+      )
+    (let ((a0-10 (-> v1-8 data 2)))
+      (set! (-> a0-10 local-pos x) 40960.0)
+      (set! (-> a0-10 local-pos y) 4096.0)
+      (set! (-> a0-10 local-pos z) -24576.0)
+      (set! (-> a0-10 local-pos w) 1.0)
+      )
+    (let ((v1-9 (-> v1-8 data 3)))
+      (set! (-> v1-9 local-pos x) -40960.0)
+      (set! (-> v1-9 local-pos y) 4096.0)
+      (set! (-> v1-9 local-pos z) -24576.0)
+      (set! (-> v1-9 local-pos w) 1.0)
+      )
+    )
+  (set! (-> obj surface-height) (+ 6144.0 (-> obj root-override-2 trans y)))
+  (set! (-> obj bubbling-sound-id) (the-as uint 0))
+  0
+  (none)
+  )
+
+(defskelgroup skel-dig-wall-bouncer dig-wall-bouncer 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 1 4 5.5)
+              )
+
+(deftype dig-wall-bouncer (bouncer)
+  ()
+  :heap-base #x60
+  :method-count-assert 25
+  :size-assert         #xd4
+  :flag-assert         #x19006000d4
+  )
+
+
+(defmethod init-skeleton! dig-wall-bouncer ((obj dig-wall-bouncer))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-wall-bouncer" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  0
+  (none)
+  )
+
+(defmethod bouncer-method-24 dig-wall-bouncer ((obj dig-wall-bouncer))
+  "TODO - collision stuff"
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 5) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 6))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec crate))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set! (-> s4-0 transform-index) 0)
+      (set-vector! (-> s4-0 local-sphere) 0.0 4096.0 16384.0 22528.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 1))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-8 prim-core action) (collide-action solid))
+      (set! (-> v1-8 transform-index) 0)
+      (set-vector! (-> v1-8 local-sphere) 0.0 6144.0 16384.0 16384.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 3) (the-as uint 2))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-10 prim-core action) (collide-action solid))
+      (set! (-> v1-10 transform-index) 0)
+      (set-vector! (-> v1-10 local-sphere) 0.0 4096.0 28672.0 12288.0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 2))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 0)
+      (set-vector! (-> v1-12 local-sphere) 12288.0 4096.0 16384.0 20480.0)
+      )
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 2) (the-as uint 2))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 0)
+      (set-vector! (-> v1-14 local-sphere) -12288.0 4096.0 16384.0 20480.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 4))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-16 prim-core action) (collide-action))
+      (set! (-> v1-16 transform-index) 3)
+      (set-vector! (-> v1-16 local-sphere) 0.0 18432.0 16384.0 16384.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-19 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-19 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-19 prim-core collide-with))
+      )
+    (set! (-> obj root) s5-0)
+    )
+  0
+  (none)
+  )
+
+(deftype dig-stomp-block (rigid-body-object)
+  ((desty float  :offset-assert 272)
+   (flag  basic  :offset-assert 276)
+   )
+  :heap-base #xa0
+  :method-count-assert 55
+  :size-assert         #x118
+  :flag-assert         #x3700a00118
+  (:methods
+    (waiting () _type_ :state 53)
+    (hit () _type_ :state 54)
+    )
+  )
+
+
+(defskelgroup skel-dig-stomp-block dig-stomp-block 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 -3 0 5.5)
+              )
+
+(define *dig-stomp-block-constants* (new 'static 'rigid-body-object-constants
+                                      :mass 1.0
+                                      :inv-mass 1.0
+                                      :cm-joint-w 1.0
+                                      :linear-damping 0.99
+                                      :angular-damping 0.9
+                                      :bounce-factor 0.5
+                                      :friction-factor 0.1
+                                      :inertial-tensor-x (meters 1)
+                                      :inertial-tensor-y (meters 3)
+                                      :inertial-tensor-z (meters 1)
+                                      :max-time-step 0.02
+                                      :gravity (meters 80)
+                                      :idle-distance (meters 200)
+                                      :attack-force-scale 1.0
+                                      :name '*dig-stomp-block-constants*
+                                      )
+        )
+
+(defstate waiting (dig-stomp-block)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('set-flag)
+       (let ((v0-0 (the-as object #t)))
+         (set! (-> self flag) (the-as basic v0-0))
+         v0-0
+         )
+       )
+      (('clear-flag)
+       (set! (-> self flag) #f)
+       #f
+       )
+      (('attack)
+       (case (-> (the-as attack-info (-> event param 1)) mode)
+         (('flop)
+          (when (not (-> self flag))
+            (set! (-> self desty) (+ -12288.0 (-> self root-override-2 trans y)))
+            (send-event (ppointer->process (-> self parent)) 'set-flag)
+            (go-virtual hit)
+            'solid
+            )
+          )
+         )
+       )
+      (('broken)
+       (go-virtual active)
+       )
+      )
+    )
+  :code (the-as (function none :behavior dig-stomp-block) sleep-code)
+  :post (the-as (function none :behavior dig-stomp-block) ja-post)
+  )
+
+(defstate hit (dig-stomp-block)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('broken)
+       (go-virtual active)
+       )
+      )
+    )
+  :code (behavior ()
+    (sound-play "stomp-block")
+    (while (< (-> self desty) (-> self root-override-2 trans y))
+      (set! (-> self root-override-2 trans y) (seek-with-smooth
+                                                (-> self root-override-2 trans y)
+                                                (-> self desty)
+                                                (* 24576.0 (-> self clock seconds-per-frame))
+                                                0.25
+                                                1.0
+                                                )
+            )
+      (suspend)
+      )
+    (set! (-> self flag) #f)
+    (send-event (ppointer->process (-> self parent)) 'clear-flag)
+    (go-virtual waiting)
+    (none)
+    )
+  :post (the-as (function none :behavior dig-stomp-block) transform-post)
+  )
+
+(defstate active (dig-stomp-block)
+  :virtual #t
+  :enter (behavior ()
+    (rigid-body-object-method-38 self)
+    (let ((s5-0 (new 'stack-no-clear 'vector))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> s5-0 x) (rand-vu-float-range -40960.0 40960.0))
+      (set! (-> s5-0 y) (rand-vu-float-range -40960.0 0.0))
+      (set! (-> s5-0 z) (rand-vu-float-range -40960.0 40960.0))
+      (vector-float*! (-> self rbody state lin-momentum) s5-0 (-> self info mass))
+      (set! (-> gp-0 x) (rand-vu-float-range -10000.0 10000.0))
+      (set! (-> gp-0 y) (rand-vu-float-range -10000.0 10000.0))
+      (set! (-> gp-0 z) (rand-vu-float-range -10000.0 10000.0))
+      (vector-float*! (-> self rbody state ang-momentum) gp-0 (-> self info mass))
+      )
+    (none)
+    )
+  )
+
+(defmethod rigid-body-object-method-37 dig-stomp-block ((obj dig-stomp-block))
+  (with-pp
+    (let ((a1-0 (new 'stack-no-clear 'collide-query)))
+      (set! (-> a1-0 start-pos quad) (-> obj rbody state position quad))
+      (vector-float*! (-> a1-0 move-dist) (-> obj rbody state lin-velocity) (-> pp clock seconds-per-frame))
+      (let ((v1-3 a1-0))
+        (set! (-> v1-3 radius) (+ 4096.0 (-> obj root-override-2 root-prim local-sphere w)))
+        (set! (-> v1-3 collide-with) (-> obj root-override-2 root-prim prim-core collide-with))
+        (set! (-> v1-3 ignore-process0) obj)
+        (set! (-> v1-3 ignore-process1) #f)
+        (set! (-> v1-3 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (set! (-> v1-3 action-mask) (collide-action solid))
+        )
+      (fill-using-line-sphere *collide-cache* a1-0)
+      )
+    (let* ((a0-15 *collide-cache*)
+           (v1-6 (the-as object (-> a0-15 tris)))
+           )
+      (countdown (a0-16 (-> a0-15 num-tris))
+        (when (= (-> (the-as collide-cache-tri v1-6) pat event) (pat-event endlessfall))
+          (set! (-> (the-as collide-cache-tri v1-6) vertex 0 y)
+                (+ 409600.0 (-> (the-as collide-cache-tri v1-6) vertex 0 y))
+                )
+          (set! (-> (the-as collide-cache-tri v1-6) vertex 1 y)
+                (+ 409600.0 (-> (the-as collide-cache-tri v1-6) vertex 1 y))
+                )
+          (set! (-> (the-as collide-cache-tri v1-6) vertex 2 y)
+                (+ 409600.0 (-> (the-as collide-cache-tri v1-6) vertex 2 y))
+                )
+          )
+        (set! v1-6 (-> (the-as (inline-array collide-cache-tri) v1-6) 1))
+        )
+      )
+    (if *display-collide-cache*
+        (debug-draw *collide-cache*)
+        )
+    (rigid-body-object-method-30 obj)
+    (set! (-> obj root-override-2 transv quad) (-> obj rbody state lin-velocity quad))
+    (quaternion-copy! (-> obj root-override-2 quat) (-> obj rbody state rotation))
+    (rigid-body-method-24 (-> obj rbody state))
+    (let ((v1-22 (-> obj rbody))
+          (a1-8 (-> obj root-override-2 trans))
+          )
+      (rigid-body-method-23 (-> v1-22 state) a1-8)
+      )
+    (set! (-> obj node-list data 0 bone transform trans quad) (-> obj root-override-2 trans quad))
+    (transform-post)
+    0
+    (none)
+    )
+  )
+
+(defmethod rigid-body-object-method-32 dig-stomp-block ((obj dig-stomp-block))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 9) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 10))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 -12288.0 0.0 22528.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 0)
+      (set-vector! (-> v1-14 local-sphere) -6144.0 -6144.0 -6144.0 6144.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid))
+      (set! (-> v1-16 transform-index) 0)
+      (set-vector! (-> v1-16 local-sphere) -6144.0 -6144.0 6144.0 6144.0)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-18 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-18 prim-core action) (collide-action solid))
+      (set! (-> v1-18 transform-index) 0)
+      (set-vector! (-> v1-18 local-sphere) 6144.0 -6144.0 -6144.0 6144.0)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-20 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-20 prim-core action) (collide-action solid))
+      (set! (-> v1-20 transform-index) 0)
+      (set-vector! (-> v1-20 local-sphere) 6144.0 -6144.0 6144.0 6144.0)
+      )
+    (let ((v1-22 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-22 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-22 prim-core action) (collide-action solid))
+      (set! (-> v1-22 transform-index) 0)
+      (set-vector! (-> v1-22 local-sphere) -6144.0 -18432.0 -6144.0 6144.0)
+      )
+    (let ((v1-24 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-24 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-24 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-24 prim-core action) (collide-action solid))
+      (set! (-> v1-24 transform-index) 0)
+      (set-vector! (-> v1-24 local-sphere) -6144.0 -18432.0 6144.0 6144.0)
+      )
+    (let ((v1-26 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-26 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-26 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-26 prim-core action) (collide-action solid))
+      (set! (-> v1-26 transform-index) 0)
+      (set-vector! (-> v1-26 local-sphere) 6144.0 -18432.0 -6144.0 6144.0)
+      )
+    (let ((v1-28 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-28 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-28 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-28 prim-core action) (collide-action solid))
+      (set! (-> v1-28 transform-index) 0)
+      (set-vector! (-> v1-28 local-sphere) 6144.0 -18432.0 6144.0 6144.0)
+      )
+    (let ((v1-30 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-30 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-30 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-30 prim-core action) (collide-action solid))
+      (set! (-> v1-30 transform-index) 3)
+      (set-vector! (-> v1-30 local-sphere) 0.0 -12288.0 0.0 22528.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-33 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-33 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-33 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod rigid-body-object-method-33 dig-stomp-block ((obj dig-stomp-block))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-stomp-block" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (rigid-body-object-method-31 obj *dig-stomp-block-constants*)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logior! (-> obj rbody state flags) (rigid-body-flag enable-collision))
+  (set! (-> obj draw light-index) (the-as uint 10))
+  (set! (-> obj flag) #f)
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-stomp-block-init-by-other dig-stomp-block ((arg0 vector))
+  (set! (-> self mask) (logior (process-mask platform) (-> self mask)))
+  (rigid-body-object-method-32 self)
+  (set! (-> self root-override-2 trans quad) (-> arg0 quad))
+  (set-vector! (-> self root-override-2 quat) 0.0 1.0 0.0 0.0)
+  (rigid-body-object-method-33 self)
+  (transform-post)
+  (go-virtual waiting)
+  (none)
+  )
+
+(deftype dig-stomp-block-controller (process-drawable)
+  ((stomp-blocks (pointer dig-stomp-block) 4 :offset-assert 200)
+   (played-fall? symbol                      :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 21
+  :size-assert         #xdc
+  :flag-assert         #x15006000dc
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(define *dig-stomp-block-table* (new 'static 'vector :x 36864.0 :y 12288.0 :z -12288.0 :w -36864.0))
+
+(defstate idle (dig-stomp-block-controller)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('set-flag)
+                      (dotimes (gp-0 4)
+                        (if (-> self stomp-blocks gp-0)
+                            (send-event (ppointer->process (-> self stomp-blocks gp-0)) 'set-flag)
+                            )
+                        )
+                      #f
+                      )
+                     (('clear-flag)
+                      (dotimes (gp-1 4)
+                        (if (-> self stomp-blocks gp-1)
+                            (send-event (ppointer->process (-> self stomp-blocks gp-1)) 'clear-flag)
+                            )
+                        )
+                      #f
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (change-parent self *pusher-pool*)
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (dotimes (s5-0 4)
+        (set! (-> gp-0 quad) (-> self root trans quad))
+        (+! (-> gp-0 x) (-> *dig-stomp-block-table* data s5-0))
+        (set! (-> self stomp-blocks s5-0) (process-spawn dig-stomp-block gp-0 :to self))
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-stomp-block-controller) sleep-code)
+  :post (behavior ()
+    (dotimes (v1-0 4)
+      (when (-> self stomp-blocks v1-0)
+        )
+      )
+    (let ((v1-3 #f))
+      (dotimes (a0-5 3)
+        (let ((a1-2 (-> self stomp-blocks a0-5))
+              (a2-3 (-> self stomp-blocks (+ a0-5 1)))
+              )
+          (when (and a1-2 a2-3)
+            (if (< 20480.0 (fabs (- (-> a1-2 0 root-override-2 trans y) (-> a2-3 0 root-override-2 trans y))))
+                (set! v1-3 #t)
+                )
+            )
+          )
+        )
+      (when v1-3
+        (when (not (-> self played-fall?))
+          (set! (-> self played-fall?) #t)
+          (sound-play "blocks-fall")
+          )
+        (dotimes (gp-1 4)
+          (if (-> self stomp-blocks gp-1)
+              (send-event (ppointer->process (-> self stomp-blocks gp-1)) 'broken)
+              )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-stomp-block-controller ((obj dig-stomp-block-controller) (arg0 entity-actor))
+  (set! (-> obj played-fall?) #f)
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype dig-totem (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-dig-totem-entity dig-totem 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 13 0 14.5))
+
+(defmethod run-logic? dig-totem ((obj dig-totem))
+  #t
+  )
+
+(defstate idle (dig-totem)
+  :virtual #t
+  :code (the-as (function none :behavior dig-totem) sleep-code)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-totem ((obj dig-totem) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 3)
+      (set-vector! (-> v1-2 local-sphere) 0.0 53248.0 0.0 59392.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-totem-entity" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-obs.gc b/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-obs.gc
index bc1b4fd529..340a8950d4 100644
--- a/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-obs.gc
+++ b/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-obs.gc
@@ -7,3 +7,575 @@
 
 ;; DECOMP BEGINS
 
+(deftype fort-elec-switch (process-drawable)
+  ((root-override      collide-shape          :offset        128)
+   (l-bolt             lightning-control      :offset-assert 200)
+   (notify-actor       entity-actor           :offset-assert 204)
+   (tank-actor         entity-actor           :offset-assert 208)
+   (switch-group       (pointer actor-group)  :offset-assert 212)
+   (switch-group-count int32                  :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xdc
+  :flag-assert         #x17006000dc
+  (:methods
+    (idle () _type_ :state 20)
+    (play-hint () _type_ :state 21)
+    (die () _type_ :state 22)
+    )
+  )
+
+
+(defskelgroup skel-fort-elec-switch fort-elec-switch 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 2 0 3)
+              )
+
+(defstate idle (fort-elec-switch)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (go-virtual die)
+       'push
+       )
+      (('hint)
+       (go-virtual play-hint)
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-elec-switch) sleep-code)
+  )
+
+(defstate play-hint (fort-elec-switch)
+  :virtual #t
+  :event (-> (method-of-type fort-elec-switch idle) event)
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 16))
+        (suspend)
+        )
+      )
+    (until (logtest? (-> self draw status) (draw-control-status on-screen))
+      (suspend)
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.4))
+        (suspend)
+        )
+      )
+    (talker-spawn-func (-> *talker-speech* 86) *entity-pool* (target-pos 0) (the-as region #f))
+    (sleep-code)
+    (none)
+    )
+  :post (-> (method-of-type fort-elec-switch idle) post)
+  )
+
+(defstate die (fort-elec-switch)
+  :virtual #t
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (let ((v1-0 (-> self l-bolt))
+          (v0-1 3)
+          )
+      (let ((a0-2 (!= v0-1 (-> v1-0 state mode))))
+        (case v0-1
+          ((3)
+           (if a0-2
+               (set! (-> v1-0 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-0 state start-color) (-> v1-0 spec start-color))
+           (set! (-> v1-0 state end-color) (-> v1-0 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-0 state mode) (the-as lightning-mode v0-1))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-1 (-> self root-override root-prim)))
+      (set! (-> v1-1 prim-core collide-as) (collide-spec))
+      (set! (-> v1-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (set! (-> gp-0 quad) (-> self root-override trans quad))
+      (set! (-> gp-0 y) (+ 8192.0 (-> gp-0 y)))
+      (let ((s5-0 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-0
+          (let ((t9-1 (method-of-type part-tracker activate)))
+            (t9-1
+              (the-as part-tracker s5-0)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-2 run-function-in-process)
+                (a0-6 s5-0)
+                (a1-2 part-tracker-init)
+                (a2-4 (-> *part-group-id-table* 125))
+                (a3-1 0)
+                (t0-0 #f)
+                (t1-0 #f)
+                (t2-0 #f)
+                (t3-0 *launch-matrix*)
+                )
+            (set! (-> t3-0 trans quad) (-> gp-0 quad))
+            ((the-as (function object object object object object object object object none) t9-2)
+             a0-6
+             a1-2
+             a2-4
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-0 ppointer)
+          )
+        )
+      )
+    (sound-play "elec-switch")
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (let ((v1-22 #t))
+      (when (-> self switch-group)
+        (dotimes (a0-11 (-> self switch-group-count))
+          (let ((a1-6 (-> self switch-group a0-11)))
+            (dotimes (a2-7 (-> a1-6 length))
+              (if (not (logtest? (-> a1-6 data a2-7 actor extra perm status) (entity-perm-status subtask-complete)))
+                  (set! v1-22 #f)
+                  )
+              )
+            )
+          )
+        )
+      (when v1-22
+        (set-setting! 'entity-name "camera-180" 0 0)
+        (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+        (process-grab? *target* #f)
+        (let ((a1-13 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-13 from) (process->ppointer self))
+          (set! (-> a1-13 num-params) 0)
+          (set! (-> a1-13 message) 'fire-suppress-on)
+          (let ((t9-8 send-event-function)
+                (v1-30 (-> self tank-actor))
+                )
+            (t9-8
+              (if v1-30
+                  (-> v1-30 extra process)
+                  )
+              a1-13
+              )
+            )
+          )
+        (let ((gp-3 (-> self clock frame-counter)))
+          (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.75))
+            (suspend)
+            )
+          )
+        (let ((a1-14 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-14 from) (process->ppointer self))
+          (set! (-> a1-14 num-params) 0)
+          (set! (-> a1-14 message) 'shutdown)
+          (let ((t9-9 send-event-function)
+                (v1-40 (-> self notify-actor))
+                )
+            (t9-9
+              (if v1-40
+                  (-> v1-40 extra process)
+                  )
+              a1-14
+              )
+            )
+          )
+        (let ((gp-4 (-> self clock frame-counter)))
+          (until (>= (- (-> self clock frame-counter) gp-4) (seconds 1.5))
+            (suspend)
+            )
+          )
+        (remove-setting! 'entity-name)
+        (remove-setting! 'process-mask)
+        (process-release? *target*)
+        (let ((a1-17 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-17 from) (process->ppointer self))
+          (set! (-> a1-17 num-params) 0)
+          (set! (-> a1-17 message) 'fire-suppress-off)
+          (let ((t9-13 send-event-function)
+                (v1-54 (-> self tank-actor))
+                )
+            (t9-13
+              (if v1-54
+                  (-> v1-54 extra process)
+                  )
+              a1-17
+              )
+            )
+          )
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch process-drawable vs fort-elec-switch.
+(defmethod relocate fort-elec-switch ((obj fort-elec-switch) (arg0 int))
+  (if (nonzero? (-> obj l-bolt))
+      (&+! (-> obj l-bolt) arg0)
+      )
+  (the-as fort-elec-switch ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-elec-switch ((obj fort-elec-switch) (arg0 entity-actor))
+  (local-vars (sv-16 res-tag))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 3)
+      (set-vector! (-> v1-2 local-sphere) 0.0 8192.0 0.0 12288.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-elec-switch" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj notify-actor) (entity-actor-lookup arg0 'alt-actor 0))
+  (set! (-> obj tank-actor) (entity-actor-lookup arg0 'alt-actor 1))
+  (set! sv-16 (new 'static 'res-tag))
+  (let ((v1-11 (res-lump-data (-> obj entity) 'actor-groups pointer :tag-ptr (& sv-16))))
+    (cond
+      ((and v1-11 (nonzero? (-> sv-16 elt-count)))
+       (set! (-> obj switch-group) (the-as (pointer actor-group) v1-11))
+       (set! (-> obj switch-group-count) (the-as int (-> sv-16 elt-count)))
+       )
+      (else
+        (set! (-> obj switch-group) (the-as (pointer actor-group) #f))
+        (set! (-> obj switch-group-count) 0)
+        0
+        )
+      )
+    )
+  (let ((a0-18 (-> obj skel root-channel 0)))
+    (set! (-> a0-18 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+    (set! (-> a0-18 frame-num) 0.0)
+    (joint-control-channel-group! a0-18 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-identity)
+    )
+  (transform-post)
+  (let ((a2-8 (new 'static 'lightning-spec
+                :name #f
+                :flags (lightning-spec-flags lsf2)
+                :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80)
+                :end-color (new 'static 'rgba :a #x80)
+                :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5)
+                :fade-start-factor 0.2
+                :fade-time 120.0
+                :texture (new 'static 'texture-id :index #x83 :page #xc)
+                :reduction 0.42
+                :num-points 8
+                :box-size 3072.0
+                :merge-factor 0.5
+                :merge-count 2
+                :radius 3072.0
+                :duration -1.0
+                :sound #f
+                )
+              )
+        )
+    (set! (-> obj l-bolt) (new 'process 'lightning-control a2-8 obj 0.0))
+    )
+  (let ((a0-20 (new 'stack-no-clear 'vector))
+        (v1-26 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a0-20 quad) (-> obj root-override trans quad))
+    (set! (-> v1-26 quad) (-> obj root-override trans quad))
+    (set! (-> a0-20 y) (+ 4915.2 (-> a0-20 y)))
+    (set! (-> v1-26 y) (+ 17203.2 (-> v1-26 y)))
+    (set! (-> obj l-bolt state meet data 0 quad) (-> a0-20 quad))
+    (let ((a0-22 (-> obj l-bolt)))
+      (set! (-> a0-22 state meet data (+ (-> a0-22 state points-to-draw) -1) quad) (-> v1-26 quad))
+      )
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype fort-fence (process-drawable)
+  ((root-override collide-shape  :offset        128)
+   (anim          spool-anim     :offset-assert 200)
+   (exit-anim     basic          :offset-assert 204)
+   (loading?      symbol         :offset-assert 208)
+   (tank          handle         :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 24
+  :size-assert         #xe0
+  :flag-assert         #x18006000e0
+  (:methods
+    (idle () _type_ :state 20)
+    (breaking () _type_ :state 21)
+    (fort-fence-method-22 (_type_) none 22)
+    (fort-fence-method-23 (_type_) none 23)
+    )
+  )
+
+
+(defskelgroup skel-fort-fence-a fort-fence 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 5.6 0 16))
+
+(defskelgroup skel-fort-fence-b fort-fence 5 7 ((6 (meters 999999))) :bounds (static-spherem 0 11 0 18))
+
+(defmethod fort-fence-method-22 fort-fence ((obj fort-fence))
+  0
+  (none)
+  )
+
+(defmethod fort-fence-method-23 fort-fence ((obj fort-fence))
+  0
+  (none)
+  )
+
+(defstate idle (fort-fence)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('break)
+       (go-virtual breaking)
+       )
+      (('start-loading)
+       (set! (-> self tank) (process->handle proc))
+       (let ((v0-0 (the-as object #t)))
+         (set! (-> self loading?) (the-as symbol v0-0))
+         v0-0
+         )
+       )
+      )
+    )
+  :trans (behavior ()
+    (when (-> self loading?)
+      (let ((a1-0 (new 'stack-no-clear 'event-message-block)))
+        (set! (-> a1-0 from) (process->ppointer self))
+        (set! (-> a1-0 num-params) 0)
+        (set! (-> a1-0 message) 'trans)
+        (let ((a1-1 (send-event-function (handle->process (-> self tank)) a1-0)))
+          (when a1-1
+            (let ((f0-0 (vector-vector-distance (-> self root-override trans) (the-as vector a1-1))))
+              (gui-control-method-12
+                *gui-control*
+                self
+                (gui-channel art-load)
+                (gui-action queue)
+                (-> self anim name)
+                0
+                (lerp-scale 1.0 100.0 f0-0 163840.0 327680.0)
+                (new 'static 'sound-id)
+                )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-fence) sleep-code)
+  )
+
+(defstate breaking (fort-fence)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 327680.0)
+    (let* ((a0-0 (the-as collide-shape-prim-group (-> self root-override root-prim)))
+           (v1-4 (-> a0-0 child 0))
+           )
+      (let ((a0-2 (-> a0-0 child 1)))
+        (set! (-> a0-2 prim-core collide-as) (-> v1-4 prim-core collide-as))
+        )
+      (set! (-> v1-4 prim-core collide-as) (collide-spec))
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((a0-0 (-> self anim)))
+      (when (and a0-0 (= (-> *setting-control* user-current spooling) (process->ppointer self)))
+        (ja-abort-spooled-anim a0-0 (the-as art-joint-anim #f) -1)
+        (ja-channel-set! 1)
+        (ja :group! (-> self exit-anim) :num! min)
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (ja-play-spooled-anim
+      (-> self anim)
+      (ja-group)
+      (the-as art-joint-anim (-> self exit-anim))
+      (the-as (function process-drawable symbol) false-func)
+      )
+    (logior! (-> self mask) (process-mask sleep))
+    (suspend)
+    0
+    (none)
+    )
+  :post (the-as (function none :behavior fort-fence) transform-post)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-fence ((obj fort-fence) (arg0 entity-actor))
+  (stack-size-set! (-> obj main-thread) 512)
+  (fort-fence-method-23 obj)
+  (process-drawable-from-entity! obj arg0)
+  (fort-fence-method-22 obj)
+  (process-entity-status! obj (entity-perm-status no-kill) #t)
+  (set! (-> obj loading?) #f)
+  (let ((a0-6 (-> obj skel root-channel 0)))
+    (set! (-> a0-6 frame-group) (if (> (-> obj skel active-channels) 0)
+                                    (-> obj skel root-channel 0 frame-group)
+                                    )
+          )
+    (set! (-> a0-6 frame-num) 0.0)
+    (joint-control-channel-group!
+      a0-6
+      (if (> (-> obj skel active-channels) 0)
+          (-> obj skel root-channel 0 frame-group)
+          )
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype fort-fence-a (fort-fence)
+  ()
+  :heap-base #x60
+  :method-count-assert 24
+  :size-assert         #xe0
+  :flag-assert         #x18006000e0
+  )
+
+
+(deftype fort-fence-b (fort-fence)
+  ()
+  :heap-base #x60
+  :method-count-assert 24
+  :size-assert         #xe0
+  :flag-assert         #x18006000e0
+  )
+
+
+(defmethod fort-fence-method-22 fort-fence-a ((obj fort-fence-a))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-fence-a" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj anim)
+        (new 'static 'spool-anim :name "fort-fence-a" :anim-name "a-break" :parts 2 :command-list '())
+        )
+  (set! (-> obj exit-anim) (-> obj draw art-group data 3))
+  0
+  (none)
+  )
+
+(defmethod fort-fence-method-22 fort-fence-b ((obj fort-fence-b))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-fence-b" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj anim)
+        (new 'static 'spool-anim :name "fort-fence-b" :anim-name "b-break" :parts 2 :command-list '())
+        )
+  (set! (-> obj exit-anim) (-> obj draw art-group data 8))
+  0
+  (none)
+  )
+
+(defmethod fort-fence-method-23 fort-fence-a ((obj fort-fence-a))
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 22937.6 0.0 65536.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-7 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set! (-> v1-7 transform-index) 3)
+      (set-vector! (-> v1-7 local-sphere) 0.0 22937.6 0.0 65536.0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 3)
+      (set-vector! (-> v1-9 local-sphere) 0.0 22937.6 0.0 65536.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+(defmethod fort-fence-method-23 fort-fence-b ((obj fort-fence-b))
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 22937.6 0.0 65536.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-7 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set! (-> v1-7 transform-index) 13)
+      (set-vector! (-> v1-7 local-sphere) 0.0 -16384.0 0.0 73728.0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 13)
+      (set-vector! (-> v1-9 local-sphere) 0.0 -16384.0 0.0 73728.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-texture.gc b/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-texture.gc
index b6820738cb..5bca129122 100644
--- a/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-texture.gc
+++ b/goal_src/jak2/levels/fortress/ammo_dump/fordumpa-texture.gc
@@ -5,5 +5,9 @@
 ;; name in dgo: fordumpa-texture
 ;; dgos: FORDUMPC, FDA
 
+;; TODO - temporary stub
+(defun set-roboscreen-alpha! ((arg0 float))
+  (none))
+
 ;; DECOMP BEGINS
 
diff --git a/goal_src/jak2/levels/fortress/ammo_dump/fordumpb-obs.gc b/goal_src/jak2/levels/fortress/ammo_dump/fordumpb-obs.gc
index dd1e4fcc72..df69a1cdfa 100644
--- a/goal_src/jak2/levels/fortress/ammo_dump/fordumpb-obs.gc
+++ b/goal_src/jak2/levels/fortress/ammo_dump/fordumpb-obs.gc
@@ -7,3 +7,433 @@
 
 ;; DECOMP BEGINS
 
+(deftype fort-plat-orbit (process-drawable)
+  ((sync sync-linear :inline :offset-assert 200)
+   )
+  :heap-base #x60
+  :method-count-assert 21
+  :size-assert         #xd8
+  :flag-assert         #x15006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-fort-plat-orbit fort-plat-orbit 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 16 0 22)
+              )
+
+(defstate idle (fort-plat-orbit)
+  :virtual #t
+  :trans (the-as (function none :behavior fort-plat-orbit) rider-trans)
+  :code (behavior ()
+    (until #f
+      (let ((f30-0 (the float (ja-num-frames 0))))
+        (cond
+          ((logtest? (actor-option user17) (-> self fact options))
+           (let ((gp-0 (-> self skel root-channel 0)))
+             (set! (-> gp-0 num-func) num-func-identity)
+             (let ((f0-4 (+ (- 0.5 (* (get-current-phase-no-mod (-> self sync)) f30-0)) f30-0)))
+               (set! (-> gp-0 frame-num) (- f0-4 (* (the float (the int (/ f0-4 f30-0))) f30-0)))
+               )
+             )
+           )
+          (else
+            (ja :num-func num-func-identity :frame-num (* (get-current-phase-no-mod (-> self sync)) f30-0))
+            )
+          )
+        )
+      (update! (-> self sound))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior fort-plat-orbit) rider-post)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-plat-orbit ((obj fort-plat-orbit) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s4-0 reaction) cshape-reaction-default)
+    (set! (-> s4-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 5) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 6))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid rideable))
+      (set-vector! (-> s3-0 local-sphere) 0.0 65536.0 0.0 90112.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-14 transform-index) 5)
+      (set-vector! (-> v1-14 local-sphere) 0.0 0.0 -16384.0 36864.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-16 transform-index) 6)
+      (set-vector! (-> v1-16 local-sphere) -16384.0 0.0 0.0 36864.0)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-18 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-18 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-18 transform-index) 7)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 16384.0 36864.0)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-20 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-20 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-20 transform-index) 8)
+      (set-vector! (-> v1-20 local-sphere) 16384.0 0.0 0.0 36864.0)
+      )
+    (let ((v1-22 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0))))
+      (set! (-> v1-22 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-22 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-22 transform-index) 4)
+      (set-vector! (-> v1-22 local-sphere) 0.0 36864.0 0.0 49152.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-25 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-25 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-25 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-plat-orbit" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj fact)
+        (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+        )
+  (let ((a1-23 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-34 0))
+      (if #t
+          (set! v1-34 (logior v1-34 1))
+          )
+      (set! (-> a1-23 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-23 sync-flags) (the-as sync-flags v1-34))
+      )
+    (set! (-> a1-23 entity) (-> obj entity))
+    (set! (-> a1-23 period) (the-as uint 6000))
+    (set! (-> a1-23 percent) 0.0)
+    (initialize! (-> obj sync) a1-23)
+    )
+  (let ((a0-48 (-> obj skel root-channel 0)))
+    (set! (-> a0-48 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+    (set! (-> a0-48 frame-num) 0.0)
+    (joint-control-channel-group! a0-48 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-identity)
+    )
+  (transform-post)
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "plat-orbit" :fo-max 70) (-> obj root trans))
+        )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype fort-plat-shuttle-plat (process-drawable)
+  ((path-pos   float  :offset-assert 200)
+   (path-speed float  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xd0
+  :flag-assert         #x15005000d0
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+
+(defskelgroup skel-fort-plat-shuttle fort-plat-shuttle 0 3
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 -0.5 0 7.6)
+              )
+
+(defstate idle (fort-plat-shuttle-plat)
+  :virtual #t
+  :trans (the-as (function none :behavior fort-plat-shuttle-plat) rider-trans)
+  :code (behavior ()
+    (until (< 1.0 (-> self path-pos))
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  :post (behavior ()
+    (+! (-> self path-pos) (* (-> self path-speed) (-> self clock seconds-per-frame)))
+    (let* ((f0-2 (-> self path-pos))
+           (f30-0 (if (< 0.5 f0-2)
+                      (- 1.0 f0-2)
+                      f0-2
+                      )
+                  )
+           (f0-4 (total-distance (-> self path)))
+           (f0-6 (fmin 40960.0 (* f30-0 f0-4)))
+           (f0-7 (lerp-scale 0.0 1.0 f0-6 0.0 40960.0))
+           )
+      (set-vector! (-> self draw color-mult) f0-7 f0-7 f0-7 1.0)
+      )
+    (get-point-in-path! (-> self path) (-> self root trans) (-> self path-pos) 'interp)
+    (update-trans! (-> self sound) (-> self root trans))
+    (update! (-> self sound))
+    (rider-post)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-plat-shuttle-plat-init-by-other fort-plat-shuttle-plat ((arg0 float))
+  (rlet ((vf0 :class vf))
+    (init-vf0-vector)
+    (let ((s5-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
+      (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+      (set! (-> s5-0 reaction) cshape-reaction-default)
+      (set! (-> s5-0 no-reaction)
+            (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+            )
+      (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+        (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle pusher))
+        (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot player-list))
+        (set! (-> s4-0 prim-core action) (collide-action solid rideable pull-rider-can-collide))
+        (set! (-> s4-0 transform-index) 3)
+        (set-vector! (-> s4-0 local-sphere) 0.0 -2048.0 0.0 31129.6)
+        (set! (-> s5-0 total-prims) (the-as uint 1))
+        (set! (-> s5-0 root-prim) s4-0)
+        )
+      (pusher-init s5-0)
+      (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+      (let ((v1-16 (-> s5-0 root-prim)))
+        (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+        (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+        )
+      (set! (-> self root) s5-0)
+      )
+    (initialize-skeleton
+      self
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-plat-shuttle" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (set! (-> self path) (new 'process 'path-control self 'path 0.0 (the-as entity #f) #f))
+    (set! (-> self path-pos) arg0)
+    (get-point-in-path! (-> self path) (-> self root trans) arg0 'interp)
+    (set! (-> self path-speed) (/ 24576.0 (total-distance (-> self path))))
+    (.svf (&-> (-> self draw color-mult) quad) vf0)
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (set! (-> self draw light-index) (the-as uint 1))
+    (set! (-> self sound)
+          (new 'process 'ambient-sound (static-sound-spec "plat-shuttle" :fo-max 70) (-> self root trans))
+          )
+    (go-virtual idle)
+    (none)
+    )
+  )
+
+(deftype fort-plat-shuttle (process-drawable)
+  ((next-spawn-time time-frame          :offset-assert 200)
+   (sync            sync-linear :inline :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xe0
+  :flag-assert         #x17006000e0
+  (:methods
+    (dormant () _type_ :state 20)
+    (idle () _type_ :state 21)
+    (fort-plat-shuttle-method-22 (_type_) symbol 22)
+    )
+  )
+
+
+(defstate dormant (fort-plat-shuttle)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('trigger)
+       (go-virtual idle)
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-plat-shuttle) sleep-code)
+  )
+
+(defstate idle (fort-plat-shuttle)
+  :virtual #t
+  :enter (behavior ()
+    (fort-plat-shuttle-method-22 self)
+    (set! (-> self next-spawn-time) (get-timeframe-offset! (-> self sync) 0))
+    (none)
+    )
+  :trans (behavior ()
+    (when (>= (-> self clock frame-counter) (-> self next-spawn-time))
+      (process-spawn fort-plat-shuttle-plat 0 :to self)
+      (set! (-> self next-spawn-time) (get-timeframe-offset! (-> self sync) 0))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-plat-shuttle) sleep-code)
+  )
+
+(defmethod fort-plat-shuttle-method-22 fort-plat-shuttle ((obj fort-plat-shuttle))
+  (with-pp
+    (let* ((f28-0 (total-distance (-> obj path)))
+           (s5-0 (-> obj sync))
+           (f26-0 81.92)
+           (a0-3 (- (-> pp clock frame-counter) (get-timeframe-offset! s5-0 0)))
+           (v1-6 (-> s5-0 period))
+           (f30-0 (/ (* f26-0 (the float a0-3)) f28-0))
+           (f28-1 (/ (* f26-0 (the float v1-6)) f28-0))
+           )
+      (while (>= 1.0 f30-0)
+        (if (>= f30-0 0.0)
+            (process-spawn fort-plat-shuttle-plat f30-0 :to obj)
+            )
+        (+! f30-0 f28-1)
+        )
+      )
+    #f
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-plat-shuttle ((obj fort-plat-shuttle) (arg0 entity-actor))
+  (local-vars (sv-64 int))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-plat-shuttle" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj fact)
+        (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+        )
+  (let ((s4-1 (new 'stack-no-clear 'sync-info-params)))
+    (let ((s3-1 1200))
+      0.0
+      (set! sv-64 0)
+      (let ((v1-7 (res-lump-data arg0 'sync (pointer float) :tag-ptr (the-as (pointer res-tag) (& sv-64)))))
+        (when v1-7
+          (set! s3-1 (the int (* 300.0 (-> v1-7 0))))
+          (-> v1-7 1)
+          )
+        )
+      (let ((v1-8 0))
+        (if #t
+            (set! v1-8 (logior v1-8 1))
+            )
+        (set! (-> s4-1 sync-type) (the-as basic 'sync-linear))
+        (set! (-> s4-1 sync-flags) (the-as sync-flags v1-8))
+        )
+      (set! (-> s4-1 entity) arg0)
+      (set! (-> s4-1 period) (the-as uint s3-1))
+      )
+    (set! (-> s4-1 percent) 0.0)
+    (initialize! (-> obj sync) s4-1)
+    )
+  (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 (the-as entity #f) #f))
+  (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (if (logtest? (actor-option user17) (-> obj fact options))
+      (go (method-of-object obj dormant))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+(deftype fort-conveyor (conveyor)
+  ()
+  :heap-base #x80
+  :method-count-assert 28
+  :size-assert         #x100
+  :flag-assert         #x1c00800100
+  )
+
+
+(defskelgroup skel-fort-conveyor fort-conveyor 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 36))
+
+(defmethod get-art-group fort-conveyor ((obj fort-conveyor))
+  "@returns The respective [[art-group]] for the [[conveyor]]"
+  (art-group-get-by-name *level* "skel-fort-conveyor" (the-as (pointer uint32) #f))
+  )
+
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod reset-root! fort-conveyor ((obj fort-conveyor))
+  "Re-initializes the `root` [[trsqv]]"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 0)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 69632.0 90112.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-15 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-15 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-15 prim-core collide-with))
+      )
+    (set! (-> s5-0 rider-max-momentum) 8192.0)
+    (set! (-> obj root) s5-0)
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch vector vs none.
+(defmethod init! fort-conveyor ((obj fort-conveyor))
+  "Initializes defaults for things like the `speed` and `belt-radius`"
+  (set! (-> obj belt-radius) 24576.0)
+  (set! (-> obj pull-y-threshold) 16384.0)
+  (cond
+    ((name= (-> obj name) "fort-conveyor-2")
+     (set! (-> obj speed) -21299.2)
+     (set-vector! (-> obj root scale) 1.0 1.0 0.9 1.0)
+     )
+    ((name= (-> obj name) "fort-conveyor-3")
+     (set! (-> obj speed) -18432.0)
+     (set-vector! (-> obj root scale) 1.0 1.0 0.79 1.0)
+     )
+    )
+  (none)
+  )
+
+(defmethod set-and-get-ambient-sound! fort-conveyor ((obj fort-conveyor))
+  "So long as [[actor-option::16]] is not set, fetch the [[ambient-sound]] for the [[conveyor]]
+       and return it as well.  Otherwise, set it to `0`"
+  (let* ((s5-0 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) 0.0 'interp))
+         (v1-2 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) 1.0 'interp))
+         (a3-3 (vector+! (new 'stack-no-clear 'vector) s5-0 v1-2))
+         )
+    (vector-float*! a3-3 a3-3 0.5)
+    (let ((v0-2 (new 'process 'ambient-sound (static-sound-spec "fort-conveyor" :fo-max 50) a3-3)))
+      (set! (-> obj sound) v0-2)
+      v0-2
+      )
+    )
+  )
diff --git a/goal_src/jak2/levels/fortress/ammo_dump/fordumpc-obs.gc b/goal_src/jak2/levels/fortress/ammo_dump/fordumpc-obs.gc
index 7098abfaed..923643f079 100644
--- a/goal_src/jak2/levels/fortress/ammo_dump/fordumpc-obs.gc
+++ b/goal_src/jak2/levels/fortress/ammo_dump/fordumpc-obs.gc
@@ -7,3 +7,1032 @@
 
 ;; DECOMP BEGINS
 
+(defmethod draw hud-rocketsensor ((obj hud-rocketsensor))
+  (set-hud-piece-position!
+    (the-as hud-sprite (-> obj sprites))
+    (the int (+ 457.0 (* 130.0 (-> obj offset))))
+    210
+    )
+  (format (clear (-> obj strings 0 text)) "~D" (-> obj values 0 current))
+  (set-as-offset-from! (the-as hud-sprite (-> obj strings 0 pos)) (the-as vector4w (-> obj sprites)) -17 25)
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+(defmethod update-values hud-rocketsensor ((obj hud-rocketsensor))
+  (set! (-> obj values 0 target) (the int (-> *game-info* counter)))
+  ((method-of-type hud update-values) obj)
+  0
+  (none)
+  )
+
+(defmethod init-callback hud-rocketsensor ((obj hud-rocketsensor))
+  (set! (-> obj level) (level-get *level* 'fordumpc))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :page #xb1f)))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 0 scale-x) 1.2)
+  (set! (-> obj sprites 0 scale-y) 1.2)
+  (alloc-string-if-needed obj 0)
+  (set! (-> obj strings 0 scale) 0.6)
+  (set! (-> obj strings 0 flags) (font-flags kerning middle large))
+  0
+  (none)
+  )
+
+(deftype fort-dump-bomb-a (process-drawable)
+  ((root-override collide-shape  :offset 128)
+   )
+  :heap-base #x50
+  :method-count-assert 22
+  :size-assert         #xc8
+  :flag-assert         #x16005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    (die () _type_ :state 21)
+    )
+  )
+
+
+(defskelgroup skel-fort-dump-bomb-a fort-dump-bomb-a 0 3
+              ((1 (meters 20)) (2 (meters 999999)))
+              :bounds (static-spherem 0 2.5 0 3.3)
+              )
+
+(defstate idle (fort-dump-bomb-a)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let* ((s5-0 (-> event param 0))
+              (gp-0 (the-as attack-info (-> event param 1)))
+              (s4-0 proc)
+              (v1-1 (if (type? s4-0 process-drawable)
+                        (the-as process-drawable s4-0)
+                        )
+                    )
+              )
+         (if (and s5-0 v1-1 (or (= (-> gp-0 mode) 'fort-robotank-shot) (= (-> gp-0 mode) 'explode)))
+             (go-virtual die)
+             )
+         )
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-dump-bomb-a) sleep-code)
+  :post (behavior ()
+    (spawn (-> self part) (-> self root-override trans))
+    (none)
+    )
+  )
+
+(defstate die (fort-dump-bomb-a)
+  :virtual #t
+  :code (behavior ()
+    (let ((v1-1 (-> self root-override root-prim)))
+      (set! (-> v1-1 prim-core collide-as) (collide-spec))
+      (set! (-> v1-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (sound-play "fort-bomb")
+    (let ((gp-1 (new 'stack-no-clear 'matrix)))
+      (set! (-> gp-1 quad 0) (-> self root-override trans quad))
+      (set! (-> gp-1 vector 0 y) (+ 8192.0 (-> gp-1 vector 0 y)))
+      (let ((s5-1 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-1
+          (let ((t9-3 (method-of-type part-tracker activate)))
+            (t9-3
+              (the-as part-tracker s5-1)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-4 run-function-in-process)
+                (a0-8 s5-1)
+                (a1-3 part-tracker-init)
+                (a2-5 (-> *part-group-id-table* 572))
+                (a3-2 0)
+                (t0-1 #f)
+                (t1-1 #f)
+                (t2-1 #f)
+                (t3-0 *launch-matrix*)
+                )
+            (set! (-> t3-0 trans quad) (-> gp-1 quad 0))
+            ((the-as (function object object object object object object object object none) t9-4)
+             a0-8
+             a1-3
+             a2-5
+             a3-2
+             t0-1
+             t1-1
+             t2-1
+             t3-0
+             )
+            )
+          (-> s5-1 ppointer)
+          )
+        )
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-dump-bomb-a ((obj fort-dump-bomb-a) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec bot))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 0)
+      (set-vector! (-> v1-2 local-sphere) 0.0 10240.0 0.0 13516.8)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-dump-bomb-a" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 573) obj))
+  (let ((a0-13 (-> obj skel root-channel 0)))
+    (set! (-> a0-13 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-13 frame-num) 0.0)
+    (joint-control-channel-group! a0-13 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-identity)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+(deftype fort-missile-target (process-drawable)
+  ((root-override collide-shape-moving           :offset        128)
+   (part-mat      matrix               2 :inline :offset-assert 208)
+   (sound-id      uint32                         :offset-assert 336)
+   )
+  :heap-base #xe0
+  :method-count-assert 22
+  :size-assert         #x154
+  :flag-assert         #x1600e00154
+  (:methods
+    (idle () _type_ :state 20)
+    (die () _type_ :state 21)
+    )
+  )
+
+
+(defskelgroup skel-fort-missile-target fort-missile-target 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 -0.5 -0.5 3.4)
+              )
+
+(defskelgroup skel-fort-missile-target-explode fort-missile-target 3 5
+              ((4 (meters 999999)))
+              :bounds (static-spherem 0 -0.5 -0.5 3.4)
+              )
+
+(define *fort-missile-target-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    :art-level #f
+    )
+  )
+
+(defstate idle (fort-missile-target)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack 'touch)
+       (let* ((gp-0 (-> event param 0))
+              (s5-0 (the-as attack-info (-> event param 1)))
+              (s4-0 proc)
+              (v1-1 (if (type? s4-0 projectile)
+                        (the-as projectile s4-0)
+                        )
+                    )
+              )
+         (if (and gp-0 v1-1 (= (-> s5-0 mode) 'fort-robotank-shot))
+             (go-virtual die)
+             )
+         )
+       )
+      (('trigger)
+       (go-virtual die)
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-missile-target) sleep-code)
+  )
+
+(defstate die (fort-missile-target)
+  :virtual #t
+  :enter (behavior ()
+    (let ((v1-1 (the-as collide-shape-prim-group (-> self root-override root-prim))))
+      (set! (-> v1-1 child 0 prim-core collide-as) (collide-spec))
+      (set! (-> v1-1 child 0 prim-core collide-with) (collide-spec))
+      )
+    0
+    (setup-masks (-> self draw) 2 0)
+    (setup-masks (-> self draw) 0 1)
+    (let ((s5-0 (-> self root-override trans))
+          (s1-0 (-> self root-override quat))
+          (s3-0 (new 'stack-no-clear 'vector))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> gp-0 x) 0.0)
+      (set! (-> gp-0 y) 2048.0)
+      (set! (-> gp-0 z) -8192.0)
+      (set! (-> gp-0 w) 0.0)
+      (let ((s2-0 (new 'stack-no-clear 'vector))
+            (s4-0 (new 'stack-no-clear 'vector))
+            )
+        (vector-orient-by-quat! gp-0 gp-0 (-> self root-override quat))
+        (vector+! gp-0 (-> self root-override trans) gp-0)
+        (let ((t9-3 vector-orient-by-quat!)
+              (a0-6 s3-0)
+              (a1-4 s3-0)
+              )
+          (set! (-> a1-4 x) 0.0)
+          (set! (-> a1-4 y) 2048.0)
+          (set! (-> a1-4 z) 5734.4)
+          (set! (-> a1-4 w) 0.0)
+          (t9-3 a0-6 a1-4 s1-0)
+          )
+        (vector+! s2-0 s5-0 s3-0)
+        (let ((t9-4 vector-orient-by-quat!)
+              (a0-8 s3-0)
+              (a1-7 s3-0)
+              )
+          (set! (-> a1-7 x) 0.0)
+          (set! (-> a1-7 y) -10649.6)
+          (set! (-> a1-7 z) -819.2)
+          (set! (-> a1-7 w) 0.0)
+          (t9-4 a0-8 a1-7 s1-0)
+          )
+        (vector+! s4-0 s5-0 s3-0)
+        (let ((s5-1 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) gp-0 s2-0) 1.0))
+              (gp-1 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) gp-0 s4-0) 1.0))
+              )
+          (forward-up->inv-matrix (the-as matrix (-> self part-mat)) s5-1 *up-vector*)
+          (set! (-> self part-mat 0 trans quad) (-> s2-0 quad))
+          (forward-up->inv-matrix (-> self part-mat 1) gp-1 *up-vector*)
+          )
+        (set! (-> self part-mat 1 trans quad) (-> s4-0 quad))
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-fort-missile-target-explode" (the-as (pointer uint32) #f))
+        5
+        gp-0
+        *fort-missile-target-exploder-params*
+        :to self
+        )
+      )
+    (activate! *camera-smush-control* 819.2 37 210 1.0 0.995 (-> self clock))
+    (sound-play "fort-target")
+    (suspend)
+    (let ((gp-2 (get-process *default-dead-pool* part-tracker #x4000)))
+      (when gp-2
+        (let ((t9-9 (method-of-type part-tracker activate)))
+          (t9-9
+            (the-as part-tracker gp-2)
+            *entity-pool*
+            (symbol->string (-> part-tracker symbol))
+            (the-as pointer #x70004000)
+            )
+          )
+        (let ((t9-10 run-function-in-process)
+              (a0-10 gp-2)
+              (a1-9 part-tracker-init)
+              (a2-13 (-> *part-group-id-table* 581))
+              (a3-5 0)
+              (t0-3 #f)
+              (t1-3 #f)
+              (t2-2 #f)
+              (t3-0 *launch-matrix*)
+              )
+          (set! (-> t3-0 trans quad) (-> self root-override trans quad))
+          ((the-as (function object object object object object object object object none) t9-10)
+           a0-10
+           a1-9
+           a2-13
+           a3-5
+           t0-3
+           t1-3
+           t2-2
+           t3-0
+           )
+          )
+        (-> gp-2 ppointer)
+        )
+      )
+    (let ((gp-3 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-3) (seconds 1))
+        (suspend)
+        )
+      )
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (sound-play "missile-steam" :id (the-as sound-id (-> self sound-id)))
+    (spawn-with-matrix (-> self part) (the-as matrix (-> self part-mat)))
+    (spawn-with-matrix (-> self part) (-> self part-mat 1))
+    (none)
+    )
+  )
+
+(defmethod deactivate fort-missile-target ((obj fort-missile-target))
+  (sound-stop (the-as sound-id (-> obj sound-id)))
+  ((the-as (function process-drawable none) (find-parent-method fort-missile-target 10)) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-missile-target-init-by-other fort-missile-target ((arg0 vector) (arg1 vector))
+  (stack-size-set! (-> self main-thread) 512)
+  (let ((s4-0 (new 'process 'collide-shape self (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 4) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 5))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 -2048.0 -2048.0 14745.6)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-11 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-11 prim-core action) (collide-action solid))
+      (set! (-> v1-11 transform-index) 3)
+      (set-vector! (-> v1-11 local-sphere) 0.0 -2048.0 -2048.0 13926.4)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-13 prim-core action) (collide-action solid))
+      (set! (-> v1-13 transform-index) 3)
+      (set-vector! (-> v1-13 local-sphere) 0.0 2048.0 4915.2 4915.2)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 -10649.6 -819.2 5734.4)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-17 prim-core action) (collide-action semi-solid))
+      (set! (-> v1-17 transform-index) 3)
+      (set-vector! (-> v1-17 local-sphere) 0.0 -2048.0 -2048.0 13107.2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-20 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-20 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-20 prim-core collide-with))
+      )
+    (set! (-> self root-override) (the-as collide-shape-moving s4-0))
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (forward-up-nopitch->quaternion (-> self root-override quat) arg1 *y-vector*)
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-fort-missile-target" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (set! (-> self draw light-index) (the-as uint 17))
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 582) self))
+  (setup-masks (-> self draw) -1 0)
+  (ja-no-eval :group! (-> self draw art-group data 2) :num! zero)
+  (transform-post)
+  (set! (-> self sound-id) (the-as uint (new-sound-id)))
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype fort-missile (process-drawable)
+  ((root-override      collide-shape              :offset        128)
+   (part-doom          sparticle-launch-control   :offset-assert 200)
+   (hud                handle                     :offset-assert 208)
+   (door-actor         entity-actor             2 :offset-assert 216)
+   (tank-actor         entity-actor               :offset-assert 224)
+   (bomb               handle                   4 :offset-assert 232)
+   (bomb-count         uint32                     :offset-assert 264)
+   (attack-id          uint32                     :offset-assert 268)
+   (explosion-sound-id uint32                     :offset-assert 272)
+   (alarm-sound-id     uint32                     :offset-assert 276)
+   )
+  :heap-base #xa0
+  :method-count-assert 25
+  :size-assert         #x118
+  :flag-assert         #x1900a00118
+  (:methods
+    (idle () _type_ :state 20)
+    (targets-active () _type_ :state 21)
+    (missile-countdown () _type_ :state 22)
+    (die () _type_ :state 23)
+    (dormant () _type_ :state 24)
+    )
+  )
+
+
+(defskelgroup skel-fort-missile fort-missile 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 -11 0 29))
+
+(defstate idle (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :trans (behavior ()
+    (if (and (task-node-closed? (game-task-node fortress-dump-deal)) *target*)
+        (go-virtual targets-active)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-missile) sleep-code)
+  )
+
+(defstate targets-active (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('die)
+       (go-virtual die)
+       )
+      (('died)
+       (+! (-> self bomb-count) -1)
+       (let ((v1-5 (-> self bomb-count)))
+         (cond
+           ((= v1-5 3)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv079" -99.0 0)
+            )
+           ((= v1-5 2)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv080" -99.0 0)
+            )
+           ((= v1-5 1)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv081" -99.0 0)
+            )
+           ((zero? v1-5)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv082" -99.0 0)
+            )
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (if *target*
+        (set! (-> self hud) (ppointer->handle (process-spawn hud-rocketsensor :init hud-init-by-other :to *target*)))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 8))
+        (suspend)
+        )
+      )
+    (until (logtest? (-> self draw status) (draw-control-status on-screen))
+      (suspend)
+      )
+    (when (= (-> self bomb-count) 4)
+      (let ((gp-1 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.4))
+          (suspend)
+          )
+        )
+      (add-process *gui-control* self (gui-channel daxter) (gui-action play) "ds017" -99.0 0)
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 20))
+        (suspend)
+        )
+      )
+    (if (= (-> self bomb-count) 4)
+        (add-process *gui-control* self (gui-channel daxter) (gui-action play) "ds018" -99.0 0)
+        )
+    (while (> (-> self bomb-count) 0)
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.2))
+          (suspend)
+          )
+        )
+      )
+    (let ((gp-4 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.8))
+        (suspend)
+        )
+      )
+    (go-virtual missile-countdown)
+    (none)
+    )
+  :post (behavior ()
+    (set! (-> *game-info* counter) (the float (-> self bomb-count)))
+    (none)
+    )
+  )
+
+(defstate missile-countdown (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('halt)
+       (go-virtual dormant)
+       )
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :exit (behavior ()
+    (set-fordumpc-light-flag! #f)
+    (send-event (handle->process (-> self hud)) 'hide-and-die)
+    (sound-stop (the-as sound-id (-> self alarm-sound-id)))
+    (none)
+    )
+  :code (behavior ()
+    (send-event (handle->process (-> self hud)) 'hide-and-die)
+    (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-1 from) (process->ppointer self))
+      (set! (-> a1-1 num-params) 0)
+      (set! (-> a1-1 message) 'fire-suppress-on)
+      (let ((t9-1 send-event-function)
+            (v1-8 (-> self tank-actor))
+            )
+        (t9-1
+          (if v1-8
+              (-> v1-8 extra process)
+              )
+          a1-1
+          )
+        )
+      )
+    (set-fordumpc-light-flag! #t)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.2))
+        (suspend)
+        )
+      )
+    (while (not (process-grab? *target* #f))
+      (suspend)
+      )
+    (set-setting! 'entity-name "camera-182" 0 0)
+    (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+    (task-node-close! (game-task-node fortress-dump-missile))
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.75))
+        (suspend)
+        )
+      )
+    (let ((a1-5 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-5 from) (process->ppointer self))
+      (set! (-> a1-5 num-params) 0)
+      (set! (-> a1-5 message) 'open)
+      (let ((t9-7 send-event-function)
+            (v1-28 (-> self door-actor 0))
+            )
+        (t9-7
+          (if v1-28
+              (-> v1-28 extra process)
+              )
+          a1-5
+          )
+        )
+      )
+    (let ((a1-6 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-6 from) (process->ppointer self))
+      (set! (-> a1-6 num-params) 0)
+      (set! (-> a1-6 message) 'open)
+      (let ((t9-8 send-event-function)
+            (v1-33 (-> self door-actor 1))
+            )
+        (t9-8
+          (if v1-33
+              (-> v1-33 extra process)
+              )
+          a1-6
+          )
+        )
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 1.5))
+        (suspend)
+        )
+      )
+    (remove-setting! 'entity-name)
+    (remove-setting! 'process-mask)
+    (process-release? *target*)
+    (let ((a1-9 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-9 from) (process->ppointer self))
+      (set! (-> a1-9 num-params) 0)
+      (set! (-> a1-9 message) 'fire-suppress-off)
+      (let ((t9-12 send-event-function)
+            (v1-47 (-> self tank-actor))
+            )
+        (t9-12
+          (if v1-47
+              (-> v1-47 extra process)
+              )
+          a1-9
+          )
+        )
+      )
+    (when *target*
+      (set! (-> *game-info* timer) 0)
+      (set! (-> self hud) (ppointer->handle (process-spawn hud-timer :init hud-init-by-other :to *target*)))
+      )
+    (let ((gp-4 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.4))
+        (suspend)
+        )
+      )
+    (set! (-> self explosion-sound-id)
+          (the-as uint (add-process *gui-control* self (gui-channel background) (gui-action queue) "big-xplo" -99.0 0))
+          )
+    (dotimes (gp-5 10)
+      (set! (-> *game-info* timer) (the-as time-frame (- 3000 (the int (* 300.0 (the float gp-5))))))
+      (let ((s5-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) s5-0) (seconds 1))
+          (suspend)
+          )
+        )
+      )
+    (go-virtual die)
+    (none)
+    )
+  :post (behavior ()
+    (sound-play "fort-alarm" :id (the-as sound-id (-> self alarm-sound-id)))
+    (none)
+    )
+  )
+
+(defstate die (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('halt)
+       (go-virtual dormant)
+       )
+      (('touched)
+       (let ((s4-0 proc))
+         (when (if (type? s4-0 process-drawable)
+                   s4-0
+                   )
+           (let ((a1-2 (new 'stack-no-clear 'event-message-block)))
+             (set! (-> a1-2 from) (process->ppointer self))
+             (set! (-> a1-2 num-params) 2)
+             (set! (-> a1-2 message) 'attack)
+             (set! (-> a1-2 param 0) (-> event param 0))
+             (let ((v1-8 (new 'static 'attack-info :mask (attack-info-mask mode id))))
+               (set! (-> v1-8 id) (-> self attack-id))
+               (set! (-> v1-8 mode) 'explode)
+               (set! (-> a1-2 param 1) (the-as uint v1-8))
+               )
+             (send-event-function proc a1-2)
+             )
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (set-setting! 'allow-pause #f 0 0)
+    (set-setting! 'allow-progress #f 0 0)
+    (none)
+    )
+  :exit (behavior ()
+    (remove-setting! 'allow-pause)
+    (remove-setting! 'allow-progress)
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.4))
+        (suspend)
+        )
+      )
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (when *scene-player*
+      (cleanup-for-death self)
+      (deactivate self)
+      )
+    (let ((gp-1 (new 'stack-no-clear 'matrix)))
+      (set! (-> gp-1 quad 0) (-> self root-override trans quad))
+      (let ((s5-0 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-0
+          (let ((t9-3 (method-of-type part-tracker activate)))
+            (t9-3
+              (the-as part-tracker s5-0)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-4 run-function-in-process)
+                (a0-8 s5-0)
+                (a1-2 part-tracker-init)
+                (a2-4 (-> *part-group-id-table* 125))
+                (a3-1 0)
+                (t0-0 #f)
+                (t1-0 #f)
+                (t2-0 #f)
+                (t3-0 *launch-matrix*)
+                )
+            (set! (-> t3-0 trans quad) (-> gp-1 quad 0))
+            ((the-as (function object object object object object object object object none) t9-4)
+             a0-8
+             a1-2
+             a2-4
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-0 ppointer)
+          )
+        )
+      )
+    (let ((gp-2 (new 'stack-no-clear 'vector))
+          (v1-24 (-> self root-override trans))
+          (a0-9 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> a0-9 x) 0.0)
+      (set! (-> a0-9 y) -87244.8)
+      (set! (-> a0-9 z) 0.0)
+      (set! (-> a0-9 w) 0.0)
+      (let* ((gp-3 (vector+! gp-2 v1-24 a0-9))
+             (s4-0 (get-process *default-dead-pool* manipy #x4000))
+             (s5-1 (when s4-0
+                     (let ((t9-6 (method-of-type manipy activate)))
+                       (t9-6 (the-as manipy s4-0) self (symbol->string (-> manipy symbol)) (the-as pointer #x70004000))
+                       )
+                     (run-now-in-process
+                       s4-0
+                       manipy-init
+                       gp-3
+                       (-> self entity)
+                       (art-group-get-by-name *level* "skel-bomb-blast" (the-as (pointer uint32) #f))
+                       #f
+                       0
+                       )
+                     (-> s4-0 ppointer)
+                     )
+                   )
+             (f30-0 1.4)
+             )
+        (when s5-1
+          (send-event (ppointer->process s5-1) 'anim-mode 'play1)
+          (send-event (ppointer->process s5-1) 'anim "idle")
+          (set-vector! (-> (the-as process-drawable (-> s5-1 0)) root scale) f30-0 1.0 f30-0 1.0)
+          )
+        )
+      )
+    (when *target*
+      (set-action!
+        *gui-control*
+        (gui-action play)
+        (the-as sound-id (-> self explosion-sound-id))
+        (gui-channel none)
+        (gui-action none)
+        (the-as string #f)
+        (the-as (function gui-connection symbol) #f)
+        (the-as process #f)
+        )
+      (while (let ((a1-13 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-13 from) (process->ppointer self))
+               (set! (-> a1-13 num-params) 2)
+               (set! (-> a1-13 message) 'attack-invinc)
+               (set! (-> a1-13 param 0) (the-as uint #f))
+               (let ((v1-56 (new 'static 'attack-info :mask (attack-info-mask mode id))))
+                 (let* ((a0-19 *game-info*)
+                        (a2-11 (+ (-> a0-19 attack-id) 1))
+                        )
+                   (set! (-> a0-19 attack-id) a2-11)
+                   (set! (-> v1-56 id) a2-11)
+                   )
+                 (set! (-> v1-56 mode) 'big-explosion)
+                 (set! (-> a1-13 param 1) (the-as uint v1-56))
+                 )
+               (not (send-event-function *target* a1-13))
+               )
+        (suspend)
+        )
+      (setup
+        *screen-filter*
+        (new 'static 'vector :x 255.0 :y 255.0 :z 255.0)
+        (new 'static 'vector :x 255.0 :y 255.0 :z 255.0 :w 128.0)
+        (* 0.3 (-> self clock seconds-per-frame))
+        (bucket-id tex-all-map)
+        )
+      )
+    (let* ((v1-63 *game-info*)
+           (a0-24 (+ (-> v1-63 attack-id) 1))
+           )
+      (set! (-> v1-63 attack-id) a0-24)
+      (set! (-> self attack-id) a0-24)
+      )
+    (let ((v1-65 (-> self root-override root-prim)))
+      (let ((a1-15 (-> (the-as collide-shape-prim-group v1-65) child 2))
+            (a0-27 (-> (the-as collide-shape-prim-group v1-65) child 1))
+            )
+        (set! (-> a1-15 prim-core action) (collide-action))
+        (set! (-> a1-15 prim-core collide-with) (collide-spec))
+        (set! (-> a0-27 prim-core action) (collide-action deadly))
+        (set! (-> a0-27 prim-core collide-as) (collide-spec obstacle))
+        (set! (-> a0-27 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list))
+        (set! (-> a0-27 local-sphere w) 131072.0)
+        (set! (-> a0-27 prim-core world-sphere w) 131072.0)
+        )
+      (set! (-> v1-65 local-sphere w) 155648.0)
+      (set! (-> v1-65 prim-core world-sphere w) 155648.0)
+      )
+    (update-transforms (-> self root-override))
+    (let ((a1-21 (new 'stack-no-clear 'overlaps-others-params)))
+      (set! (-> a1-21 options) (overlaps-others-options))
+      (set! (-> a1-21 collide-with-filter) (the-as collide-spec -1))
+      (set! (-> a1-21 tlist) *touching-list*)
+      (find-overlapping-shapes (-> self root-override) a1-21)
+      )
+    (suspend)
+    0
+    (let ((v1-74 (-> self root-override root-prim)))
+      (set! (-> v1-74 prim-core collide-as) (collide-spec))
+      (set! (-> v1-74 prim-core collide-with) (collide-spec))
+      )
+    0
+    (countdown (gp-4 5)
+      (let ((s5-3 (new 'stack-no-clear 'matrix)))
+        (position-in-front-of-camera! (-> s5-3 trans) (+ 28672.0 (* 20480.0 (the float gp-4))) 0.0)
+        (position-in-front-of-camera! (-> s5-3 vector 2) 4096.0 0.0)
+        (vector-! (-> s5-3 vector 2) (-> s5-3 vector 2) (-> s5-3 trans))
+        (vector-normalize! (-> s5-3 vector 2) 1.0)
+        (vector-cross! (the-as vector (-> s5-3 vector)) *up-vector* (-> s5-3 vector 2))
+        (vector-normalize! (the-as vector (-> s5-3 vector)) 1.0)
+        (vector-cross! (-> s5-3 vector 1) (-> s5-3 vector 2) (the-as vector (-> s5-3 vector)))
+        (vector-normalize! (-> s5-3 vector 1) 1.0)
+        (set! (-> s5-3 vector 0 w) 0.0)
+        (set! (-> s5-3 vector 1 w) 0.0)
+        (set! (-> s5-3 vector 2 w) 0.0)
+        (set! (-> s5-3 trans w) 1.0)
+        (spawn-with-matrix (-> self part-doom) s5-3)
+        )
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.2))
+        (suspend)
+        )
+      )
+    (let ((gp-5 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-5) (seconds 10))
+        (suspend)
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+(defstate dormant (fort-missile)
+  :virtual #t
+  :code (the-as (function none :behavior fort-missile) sleep-code)
+  )
+
+(defmethod deactivate fort-missile ((obj fort-missile))
+  (set-fordumpc-light-flag! #f)
+  (send-event (handle->process (-> obj hud)) 'hide-and-die)
+  (if (nonzero? (-> obj part-doom))
+      (kill-and-free-particles (-> obj part-doom))
+      )
+  (sound-stop (the-as sound-id (-> obj alarm-sound-id)))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs fort-missile.
+(defmethod relocate fort-missile ((obj fort-missile) (arg0 int))
+  (if (nonzero? (-> obj part-doom))
+      (&+! (-> obj part-doom) arg0)
+      )
+  (the-as
+    fort-missile
+    ((the-as (function process-drawable int process-drawable) (find-parent-method fort-missile 7)) obj arg0)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-missile ((obj fort-missile) (arg0 entity-actor))
+  (stack-size-set! (-> obj main-thread) 512)
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 2) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 3))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid deadly))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 -45056.0 0.0 118784.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-11 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-11 prim-core action) (collide-action solid))
+      (set! (-> v1-11 transform-index) 3)
+      (set-vector! (-> v1-11 local-sphere) 0.0 -45056.0 0.0 118784.0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-13 transform-index) 3)
+      (set-vector! (-> v1-13 local-sphere) 0.0 -81920.0 0.0 32768.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> s4-0 event-self) 'touched)
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-missile" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj door-actor 0) (entity-actor-lookup arg0 'alt-actor 0))
+  (set! (-> obj door-actor 1) (entity-actor-lookup arg0 'alt-actor 1))
+  (set! (-> obj tank-actor) (entity-actor-lookup arg0 'alt-actor 2))
+  (let ((s5-1 (new 'stack-no-clear 'vector)))
+    (set! (-> s5-1 x) 0.0)
+    (set! (-> s5-1 y) -36864.0)
+    (set! (-> s5-1 z) 34406.4)
+    (set! (-> s5-1 w) 1.0)
+    (let ((s4-2 (new 'stack-no-clear 'vector)))
+      (dotimes (s3-2 4)
+        (let ((s2-1 (vector+! (new 'stack-no-clear 'vector) (-> obj root-override trans) s5-1))
+              (s1-0 (new 'stack-no-clear 'vector))
+              )
+          (vector-normalize! (vector-! s4-2 s2-1 (-> obj root-override trans)) 1.0)
+          (vector-float*! s1-0 s4-2 -1.0)
+          (set! (-> obj bomb s3-2) (ppointer->handle (process-spawn fort-missile-target s2-1 s1-0 :to obj)))
+          )
+        (vector-rotate-y! s5-1 s5-1 16384.0)
+        )
+      )
+    )
+  (set! (-> obj bomb-count) (the-as uint 4))
+  (set! (-> obj hud) (the-as handle #f))
+  (set! (-> obj part-doom) (create-launch-control (-> *part-group-id-table* 583) obj))
+  (set! (-> obj alarm-sound-id) (the-as uint (new-sound-id)))
+  (let ((a0-36 (-> obj skel root-channel 0)))
+    (set! (-> a0-36 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+    (set! (-> a0-36 frame-num) 0.0)
+    (joint-control-channel-group! a0-36 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-identity)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank-turret.gc b/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank-turret.gc
index 2ce19d7926..349ed803a3 100644
--- a/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank-turret.gc
+++ b/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank-turret.gc
@@ -5,5 +5,1447 @@
 ;; name in dgo: fort-robotank-turret
 ;; dgos: FORDUMPC, FDA
 
+;; og:ignore-form:draw-2d-hud
+
 ;; DECOMP BEGINS
 
+(deftype fort-robotank-turret (process-focusable)
+  ((los                 los-control         :inline   :offset-assert 208)
+   (reticle             handle                        :offset-assert 360)
+   (screen              handle                        :offset-assert 368)
+   (tank-quat           quaternion          :inline   :offset-assert 384)
+   (tank-quat-vibe-only quaternion          :inline   :offset-assert 400)
+   (rotate-quat         quaternion          :inline   :offset-assert 416)
+   (rotate-rate         float                         :offset-assert 432)
+   (rotate-mult         float                         :offset-assert 436)
+   (shot-range          float                         :offset-assert 440)
+   (fov-mult            float                         :offset-assert 444)
+   (offset              vector              :inline   :offset-assert 448)
+   (sight-pos           vector              :inline   :offset-assert 464)
+   (firing-sight-pos    vector              :inline   :offset-assert 480)
+   (aim-pos             vector              3 :inline :offset-assert 496)
+   (aim-pos-2           vector              :inline   :offset        512)
+   (aim-pos-1           vector              :inline   :offset        528)
+   (gun-timer           time-frame                    :offset-assert 544)
+   (gun-elev-jmod       joint-mod-set-local           :offset-assert 552)
+   (gun-elev            float                         :offset-assert 556)
+   (gun-elev-cam        float                         :offset-assert 560)
+   (gun-joint-l         int32               2         :offset-assert 564)
+   (gun-joint-r         int32               2         :offset-assert 572)
+   (gun-spread          float                         :offset-assert 580)
+   (gun-index           int32                         :offset-assert 584)
+   (flags               uint16                        :offset-assert 588)
+   (turn-sound-id       uint32                        :offset-assert 592)
+   )
+  :heap-base #x1e0
+  :method-count-assert 35
+  :size-assert         #x254
+  :flag-assert         #x2301e00254
+  (:methods
+    (idle () _type_ :state 27)
+    (ready () _type_ :state 28)
+    (fire () _type_ :state 29)
+    (die () _type_ :state 30)
+    (fort-robotank-turret-method-31 (_type_ vector vector) none 31)
+    (fort-robotank-turret-method-32 (_type_ (inline-array vector)) (pointer process) 32)
+    (fort-robotank-turret-method-33 (_type_) none 33)
+    (fort-robotank-turret-method-34 (_type_ vector float) symbol 34)
+    )
+  )
+
+
+(deftype fort-robotank-reticle (process-drawable)
+  ((shadow-jmod  joint-mod          :offset-assert 200)
+   (sight-jmod   joint-mod          :offset-assert 204)
+   (ring-jmod    joint-mod  3       :offset-assert 208)
+   (ring-timer   time-frame         :offset-assert 224)
+   (sight-scale  vector     :inline :offset-assert 240)
+   (collide-dist float              :offset-assert 256)
+   )
+  :heap-base #x90
+  :method-count-assert 22
+  :size-assert         #x104
+  :flag-assert         #x1600900104
+  (:methods
+    (idle () _type_ :state 20)
+    (lock () _type_ :state 21)
+    )
+  )
+
+
+(deftype fort-roboscreen (process-drawable)
+  ((anim-frame float   :offset-assert 200)
+   (transition float   :offset-assert 204)
+   (gui-id-1   uint32  :offset-assert 208)
+   (gui-id-2   uint32  :offset-assert 212)
+   )
+  :heap-base #x60
+  :method-count-assert 25
+  :size-assert         #xd8
+  :flag-assert         #x19006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    (active () _type_ :state 21)
+    (deactive () _type_ :state 22)
+    (die () _type_ :state 23)
+    (fort-roboscreen-method-24 (_type_) none 24)
+    )
+  )
+
+
+(defskelgroup skel-fort-roboscreen fort-roboscreen 0 2 ((1 (meters 999999))) :bounds (static-spherem 0 0 0 8))
+
+(defstate idle (fort-roboscreen)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('trigger)
+       (set! (-> self state-time) (-> self clock frame-counter))
+       (go-virtual active)
+       )
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :enter (behavior ()
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (set! (-> self transition) 0.0)
+    (none)
+    )
+  :code (the-as (function none :behavior fort-roboscreen) sleep-code)
+  )
+
+(defstate active (fort-roboscreen)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('untrigger)
+       (go-virtual deactive)
+       )
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :enter (behavior ()
+    (logclear! (-> self draw status) (draw-control-status no-draw))
+    (set-action!
+      *gui-control*
+      (gui-action play)
+      (the-as sound-id (-> self gui-id-1))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (set-action!
+      *gui-control*
+      (gui-action play)
+      (the-as sound-id (-> self gui-id-2))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (set-action!
+      *gui-control*
+      (gui-action hidden)
+      (the-as sound-id (-> self gui-id-1))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (set-action!
+      *gui-control*
+      (gui-action hidden)
+      (the-as sound-id (-> self gui-id-2))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (when (and (not (paused?)) (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)))
+        (seek! (-> self anim-frame) 0.0 (* 0.2 (-> self clock time-adjust-ratio)))
+        (seek! (-> self transition) 1.0 (* 0.01 (-> self clock time-adjust-ratio)))
+        )
+      (set-roboscreen-alpha! (-> self transition))
+      (ja :num-func num-func-identity :frame-num (-> self anim-frame))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (fort-roboscreen-method-24 self)
+    (ja-post)
+    (none)
+    )
+  )
+
+(defstate deactive (fort-roboscreen)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :code (behavior ()
+    (until #f
+      (when (not (paused?))
+        (seek! (-> self anim-frame) 15.0 (* 0.2 (-> self clock time-adjust-ratio)))
+        (seek! (-> self transition) 0.0 (* 0.015 (-> self clock time-adjust-ratio)))
+        )
+      (set-roboscreen-alpha! (-> self transition))
+      (when (= (-> self anim-frame) 15.0)
+        (set-roboscreen-alpha! 0.0)
+        (go-virtual idle)
+        )
+      (ja :num-func num-func-identity :frame-num (-> self anim-frame))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (fort-roboscreen-method-24 self)
+    (ja-post)
+    (none)
+    )
+  )
+
+(defstate die (fort-roboscreen)
+  :virtual #t
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (seek! (-> self transition) 0.0 (-> self clock seconds-per-frame))
+        (set-roboscreen-alpha! (-> self transition))
+        (suspend)
+        )
+      )
+    (none)
+    )
+  )
+
+(defmethod fort-roboscreen-method-24 fort-roboscreen ((obj fort-roboscreen))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s3-0 (camera-matrix))
+          (s5-0 (new 'stack-no-clear 'vector))
+          (gp-0 (new 'stack-no-clear 'vector))
+          (f30-0 4096.0)
+          )
+      (let ((f0-4 (* 0.00013563369 (tan (* 0.5 (-> *math-camera* fov))) f30-0)))
+        (set-vector! (-> obj root scale) f0-4 f0-4 f0-4 1.0)
+        )
+      (set! (-> gp-0 quad) (-> (camera-pos) quad))
+      (vector-normalize-copy! s5-0 (-> s3-0 vector 2) 1.0)
+      (matrix->quaternion (-> obj root quat) s3-0)
+      (let ((v1-10 (-> obj root trans)))
+        (let ((a0-5 f30-0))
+          (.mov vf7 a0-5)
+          )
+        (.lvf vf5 (&-> s5-0 quad))
+        (.lvf vf4 (&-> gp-0 quad))
+        (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+        (.mul.x.vf acc vf5 vf7 :mask #b111)
+        (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+        (.svf (&-> v1-10 quad) vf6)
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-roboscreen-init-by-other fort-roboscreen ((arg0 vector) (arg1 quaternion) (arg2 entity-actor))
+  (process-entity-set! self arg2)
+  (set! (-> self root) (new 'process 'trsqv))
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (quaternion-copy! (-> self root quat) arg1)
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-roboscreen" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> self anim-frame) 15.0)
+  (set! (-> self transition) 0.0)
+  (set! (-> self gui-id-1)
+        (the-as
+          uint
+          (add-process *gui-control* self (gui-channel hud-center-left) (gui-action hidden) (-> self name) 81920.0 0)
+          )
+        )
+  (set! (-> self gui-id-2)
+        (the-as
+          uint
+          (add-process *gui-control* self (gui-channel hud-middle-left) (gui-action hidden) (-> self name) 81920.0 0)
+          )
+        )
+  (set-vector! (-> self draw color-emissive) 0.0 0.0 0.0 0.0)
+  (set-vector! (-> self draw color-emissive) 0.0 0.0 0.0 0.0)
+  (logior! (-> self skel status) (joint-control-status blend-shape))
+  (ja :group! (-> self draw art-group data 3))
+  (go-virtual idle)
+  (none)
+  )
+
+(defmethod deactivate fort-roboscreen ((obj fort-roboscreen))
+  (disable *screen-filter*)
+  (set-roboscreen-alpha! 0.0)
+  ((the-as (function process-drawable none) (find-parent-method fort-roboscreen 10)) obj)
+  (none)
+  )
+
+(defpartgroup group-robotank-steamescape
+  :id 561
+  :bounds (static-bspherem 0 0 0 6)
+  :parts ((sp-item 2471 :fade-after (meters 100) :falloff-to (meters 100) :flags (bit7)))
+  )
+
+(defpart 2471
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.5 1.0 1.0)
+    (sp-rnd-flt spt-x (meters -3) (meters 5) 1.0)
+    (sp-rnd-flt spt-y (meters -0.1) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-z (meters 0.2) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.25) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 64.0 128.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 0.0)
+    (sp-rnd-flt spt-vel-z (meters 0.005) (meters 0.0025) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0016666667) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a 0.64)
+    (sp-rnd-flt spt-accel-y 0.68266666 0.68266666 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-int-plain-rnd spt-next-time 25 24 1)
+    (sp-launcher-by-id spt-next-launcher 2472)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-y (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-rotate-y (degrees 0.0))
+    )
+  )
+
+(defpart 2472
+  :init-specs ((sp-rnd-flt spt-fade-a -0.064 -0.064 1.0))
+  )
+
+(defskelgroup skel-fort-robotank-reticle fort-robotank-sight 0 3
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 0 0.5 84)
+              :longest-edge (meters 80)
+              :shadow 2
+              :origin-joint-index 5
+              )
+
+(defbehavior fort-robotank-reticle-post fort-robotank-reticle ()
+  (let ((s5-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root quat)))
+        (s1-0 (new 'stack-no-clear 'vector))
+        (s3-0 (camera-pos))
+        (s4-0 (-> self draw shadow-ctrl settings shadow-dir))
+        (gp-0 (-> self draw shadow-ctrl settings bot-plane))
+        (s2-0 (-> self draw shadow-ctrl settings top-plane))
+        )
+    (-> self draw shadow-ctrl settings)
+    (vector-normalize! s5-0 1.0)
+    (vector-negate! s1-0 s5-0)
+    (set! (-> s4-0 x) (-> s5-0 x))
+    (set! (-> s4-0 y) (-> s5-0 y))
+    (set! (-> s4-0 z) (-> s5-0 z))
+    (set! (-> s4-0 w) -16384.0)
+    (set! (-> s2-0 quad) (-> s5-0 quad))
+    (set! (-> gp-0 quad) (-> s5-0 quad))
+    (let ((s4-1 (new 'stack-no-clear 'vector)))
+      (vector+float*! s4-1 (-> self root trans) s5-0 -4096.0)
+      (set! (-> s2-0 w) (- (vector-dot s4-1 s5-0)))
+      (vector+float*! s4-1 (-> self root trans) s5-0 (-> self collide-dist))
+      (let* ((a1-6 (vector-! (new 'stack-no-clear 'vector) s3-0 s4-1))
+             (f1-0 (vector-length a1-6))
+             (a2-2
+               (vector-normalize-copy! (new 'stack-no-clear 'vector) a1-6 (fmax -20480.0 (fmin 20480.0 (* 0.75 f1-0))))
+               )
+             (v1-26 (vector-float*! (new 'stack-no-clear 'vector) s5-0 (- (vector-dot a2-2 s5-0))))
+             )
+        (vector+! s4-1 s4-1 v1-26)
+        )
+      (set! (-> gp-0 w) (- (vector-dot s4-1 s5-0)))
+      )
+    )
+  0
+  (vector-seek! (-> self sight-jmod twist-max) (-> self sight-scale) (* 6.0 (-> self clock seconds-per-frame)))
+  (ja-post)
+  (none)
+  )
+
+(defbehavior fort-robotank-reticle-handler fort-robotank-reticle ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (case arg2
+    (('update-trans-only)
+     (set! v0-0 (-> self root trans))
+     (set! (-> (the-as vector v0-0) quad) (-> (the-as vector (-> arg3 param 0)) quad))
+     v0-0
+     )
+    (('update)
+     (let ((s5-0 (the-as object (-> arg3 param 0)))
+           (gp-0 (-> arg3 param 1))
+           )
+       (let ((a1-3 (vector-normalize-copy!
+                     (new 'stack-no-clear 'vector)
+                     (vector-! (new 'stack-no-clear 'vector) (the-as vector gp-0) (the-as vector s5-0))
+                     1.0
+                     )
+                   )
+             )
+         (set! (-> self root trans quad) (-> (the-as vector s5-0) quad))
+         (forward-up->quaternion (-> self root quat) a1-3 *up-vector*)
+         )
+       (let ((f0-0 (vector-length (vector-! (new 'stack-no-clear 'vector) (the-as vector gp-0) (the-as vector s5-0))))
+             (gp-1 (-> self sight-scale))
+             )
+         (set! (-> gp-1 z) (* 0.000024414063 f0-0))
+         (let ((f0-1 (lerp-scale 0.1 6.0 f0-0 61440.0 163840.0)))
+           (set! (-> gp-1 x) f0-1)
+           (set! (-> gp-1 y) f0-1)
+           f0-1
+           )
+         )
+       )
+     )
+    (('collide-dist)
+     (set! (-> self collide-dist) (the-as float (-> arg3 param 0)))
+     )
+    (('on)
+     (let ((v1-14 (-> self draw shadow-ctrl)))
+       (logclear! (-> v1-14 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     (set! v0-0 (logclear (-> self draw status) (draw-control-status no-draw)))
+     (set! (-> self draw status) (the-as draw-control-status v0-0))
+     v0-0
+     )
+    (('off)
+     (let ((v1-19 (-> self draw shadow-ctrl)))
+       (logior! (-> v1-19 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     (set! v0-0 (logior (-> self draw status) (draw-control-status no-draw)))
+     (set! (-> self draw status) (the-as draw-control-status v0-0))
+     v0-0
+     )
+    (('spotlight-on)
+     (let ((v1-25 (-> self draw shadow-ctrl)))
+       (logclear! (-> v1-25 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     )
+    (('spotlight-off)
+     (let ((v1-27 (-> self draw shadow-ctrl)))
+       (logior! (-> v1-27 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     )
+    (('lock)
+     (go-virtual lock)
+     )
+    (('unlock)
+     (go-virtual idle)
+     )
+    (('die)
+     (go empty-state)
+     )
+    )
+  )
+
+(defstate idle (fort-robotank-reticle)
+  :virtual #t
+  :event fort-robotank-reticle-handler
+  :enter (behavior ()
+    (set! (-> self ring-timer) 0)
+    (dotimes (v1-0 3)
+      (set! (-> self ring-jmod v1-0 twist z) (the-as float #t))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-no-eval :group! (-> self draw art-group data 3) :num! zero)
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (when (< (-> self ring-timer) (-> self clock frame-counter))
+      (let ((v1-2 (rand-vu-int-range 0 7)))
+        (dotimes (a0-3 3)
+          (if (logand (ash 1 a0-3) v1-2)
+              (set! (-> self ring-jmod a0-3 twist y) (* -1.0 (-> self ring-jmod a0-3 twist y)))
+              )
+          )
+        )
+      (set! (-> self ring-timer)
+            (+ (-> self clock frame-counter) (the int (* 300.0 (rand-vu-float-range 0.6 1.8))))
+            )
+      )
+    (fort-robotank-reticle-post)
+    (none)
+    )
+  )
+
+(defstate lock (fort-robotank-reticle)
+  :virtual #t
+  :event fort-robotank-reticle-handler
+  :enter (behavior ()
+    (dotimes (v1-0 3)
+      (set! (-> self ring-jmod v1-0 twist z) (the-as float #f))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.04))
+    (ja-no-eval :group! (-> self draw art-group data 4)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post fort-robotank-reticle-post
+  )
+
+;; WARN: Return type mismatch process-drawable vs fort-robotank-reticle.
+(defmethod relocate fort-robotank-reticle ((obj fort-robotank-reticle) (arg0 int))
+  (if (nonzero? (-> obj shadow-jmod))
+      (&+! (-> obj shadow-jmod) arg0)
+      )
+  (if (nonzero? (-> obj sight-jmod))
+      (&+! (-> obj sight-jmod) arg0)
+      )
+  (dotimes (v1-8 3)
+    (if (nonzero? (-> obj ring-jmod v1-8))
+        (&+! (-> obj ring-jmod v1-8) arg0)
+        )
+    )
+  (the-as fort-robotank-reticle ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-robotank-reticle-init-by-other fort-robotank-reticle ((arg0 vector))
+  (set! (-> self root) (new 'process 'trsqv))
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-fort-robotank-reticle" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (set-vector! (-> self root scale) 0.6 0.6 1.0 1.0)
+  (set! (-> self collide-dist) 491520.0)
+  (set! (-> self shadow-jmod) (the-as joint-mod (new 'process 'joint-mod-set-local self 4 #f #f #t)))
+  (set-vector! (-> self shadow-jmod twist-max) 0.3 0.3 1.0 1.0)
+  (set! (-> self sight-jmod) (the-as joint-mod (new 'process 'joint-mod-set-local self 5 #f #f #t)))
+  (set-vector! (-> self sight-jmod twist-max) 1.0 1.0 1.0 1.0)
+  (set! (-> self sight-scale quad) (-> self sight-jmod twist-max quad))
+  (set! (-> self ring-jmod 0) (the-as joint-mod (new 'process 'joint-mod-spinner self 6 *z-vector* 49152.0)))
+  (set! (-> self ring-jmod 1) (the-as joint-mod (new 'process 'joint-mod-spinner self 7 *z-vector* -32768.0)))
+  (set! (-> self ring-jmod 2) (the-as joint-mod (new 'process 'joint-mod-spinner self 8 *z-vector* 8192.0)))
+  (let ((v1-20 (new
+                 'process
+                 'shadow-control
+                 0.0
+                 0.0
+                 614400.0
+                 (shadow-flags disable-fade shdf02 shdf03 shdf04 shdf07)
+                 491520.0
+                 )
+               )
+        )
+    (set! (-> v1-20 settings shadow-type) 1)
+    (set! (-> self draw shadow-ctrl) v1-20)
+    )
+  (ja-no-eval :group! (-> self draw art-group data 3) :num! zero)
+  (ja-post)
+  (set-setting! 'spotlight-color #f 0 (the-as uint #x80a0a0ff))
+  (go-virtual idle)
+  (none)
+  )
+
+(deftype fort-robotank-shot (guard-shot)
+  ()
+  :heap-base #x170
+  :method-count-assert 40
+  :size-assert         #x1f0
+  :flag-assert         #x28017001f0
+  )
+
+
+;; WARN: Return type mismatch int vs sound-id.
+(defmethod play-impact-sound fort-robotank-shot ((obj fort-robotank-shot) (arg0 projectile-options))
+  (let ((v1-0 arg0))
+    (cond
+      ((zero? v1-0)
+       (sound-play "robotank-shot")
+       )
+      ((= v1-0 (projectile-options lose-altitude))
+       (sound-play "fort-robotank-s")
+       )
+      )
+    )
+  (the-as sound-id 0)
+  )
+
+(defmethod init-collision! fort-robotank-shot ((obj fort-robotank-shot))
+  "Init the [[projectile]]'s [[collide-shape]]"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction)
+          (the-as (function control-info collide-query vector vector collide-status) cshape-reaction-just-move)
+          )
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrate-using) (penetrate enemy-yellow-shot))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec projectile))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 2457.6)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec projectile))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid deadly))
+      (set-vector! (-> v1-13 local-sphere) 0.0 0.0 0.0 819.2)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec projectile))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot crate hit-by-others-list player-list))
+      (set! (-> v1-15 prim-core action) (collide-action deadly))
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 2457.6)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-18 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-18 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-18 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 1))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override) s5-0)
+    )
+  (set! (-> obj root-override pat-ignore-mask)
+        (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
+        )
+  0
+  (none)
+  )
+
+(defmethod init-proj-settings! fort-robotank-shot ((obj fort-robotank-shot))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+       :virtual"
+  (set! (-> obj tail-pos quad) (-> obj root-override trans quad))
+  (set! (-> obj attack-mode) 'fort-robotank-shot)
+  (set! (-> obj max-speed) 819200.0)
+  (set! (-> obj move) guard-shot-move)
+  (set! (-> obj update-velocity) projectile-update-velocity-space-wars)
+  (set! (-> obj timeout) (seconds 0.5))
+  (logior! (-> obj options) (projectile-options account-for-target-velocity))
+  (set-gravity-length (-> obj root-override dynam) 573440.0)
+  0
+  (none)
+  )
+
+(defskelgroup skel-fort-robotank-turret fort-robotank-top 0 3
+              ((1 (meters 20)) (2 (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              :origin-joint-index 3
+              )
+
+(defpart 2473
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbc :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1.5) (meters 0.1) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.0)
+    (sp-flt spt-g 0.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 96.0 64.0 1.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-flt spt-fade-g -1.0666667)
+    (sp-flt spt-fade-b -1.0666667)
+    (sp-flt spt-fade-a -8.533334)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 1.0)
+    )
+  )
+
+;; WARN: Return type mismatch pointer vs symbol.
+;; WARN: Failed store: (s.w! (+ t5-0 8) 0) at op 82
+;; WARN: Failed store: (s.w! (+ t5-0 12) t6-1) at op 84
+;; WARN: Failed store: (s.d! (+ t5-2 8) t1-0) at op 90
+;; WARN: Failed store: (s.q! (+ t5-4 16) t6-3) at op 98
+;; WARN: Failed store: (s.q! (+ t5-4 32) t6-4) at op 100
+;; WARN: Failed store: (s.q! (+ t5-4 48) t6-5) at op 102
+;; WARN: Failed store: (s.d! (+ t5-6 8) t1-0) at op 108
+;; WARN: Failed store: (s.q! (+ t5-8 16) t3-1) at op 116
+;; WARN: Failed store: (s.q! (+ t5-8 32) t3-2) at op 118
+;; WARN: Failed store: (s.q! (+ t5-8 48) t3-3) at op 120
+;; WARN: Failed store: (s.d! (+ t4-5 8) t1-0) at op 126
+;; WARN: Failed store: (s.q! (+ t4-7 16) t2-1) at op 134
+;; WARN: Failed store: (s.q! (+ t4-7 32) t2-2) at op 136
+;; WARN: Failed store: (s.q! (+ t4-7 48) t2-3) at op 138
+;; WARN: Failed store: (s.d! (+ t3-7 8) t1-0) at op 144
+;; WARN: Failed store: (s.q! (+ t1-1 16) a3-1) at op 152
+;; WARN: Failed store: (s.q! (+ t1-1 32) a3-2) at op 154
+;; WARN: Failed store: (s.q! (+ t1-1 48) a1-2) at op 156
+;; WARN: Failed load: (set! t0-6 (l.d (+ a0-28 8))) at op 170
+;; WARN: Failed store: (s.d! (+ a0-28 8) a3-10) at op 175
+;; WARN: Failed store: (s.w! (+ a0-29 8) 0) at op 183
+;; WARN: Failed store: (s.w! (+ a0-29 12) 0) at op 184
+
+(defmethod fort-robotank-turret-method-32 fort-robotank-turret ((obj fort-robotank-turret) (arg0 (inline-array vector)))
+  (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((v1-0 (-> arg0 0))
+          (a0-1 (-> arg0 1))
+          )
+      (set! (-> gp-0 ent) (-> obj entity))
+      (set! (-> gp-0 charge) 1.0)
+      (set! (-> gp-0 options) (projectile-options))
+      (set! (-> gp-0 pos quad) (-> v1-0 quad))
+      (set! (-> gp-0 notify-handle) (process->handle obj))
+      (set! (-> gp-0 owner-handle) (the-as handle #f))
+      (set! (-> gp-0 ignore-handle) (process->handle obj))
+      (let* ((a1-10 *game-info*)
+             (a2-11 (+ (-> a1-10 attack-id) 1))
+             )
+        (set! (-> a1-10 attack-id) a2-11)
+        (set! (-> gp-0 attack-id) a2-11)
+        )
+      (set! (-> gp-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-! (-> gp-0 vel) a0-1 v1-0)
+      )
+    (vector-normalize! (-> gp-0 vel) 512000.0)
+    (spawn-projectile fort-robotank-shot gp-0 obj *default-dead-pool*)
+    )
+  )
+
+;; WARN: Return type mismatch (pointer process) vs none.
+(defmethod fort-robotank-turret-method-33 fort-robotank-turret ((obj fort-robotank-turret))
+  (local-vars (sv-144 vector) (sv-160 vector))
+  (let ((s3-0 (new 'stack-no-clear 'inline-array 'vector 2))
+        (s5-0 (new 'stack-no-clear 'inline-array 'vector 4))
+        )
+    (-> obj node-list data 11)
+    (let ((s4-0 (new 'stack-no-clear 'vector))
+          (s1-0 (-> obj sight-pos))
+          (s2-0 (-> obj gun-index))
+          )
+      0.0
+      0.0
+      (vector<-cspace! (-> s3-0 0) (-> obj node-list data (-> obj gun-joint-l s2-0)))
+      (vector<-cspace! (-> s3-0 1) (-> obj node-list data (-> obj gun-joint-r s2-0)))
+      (let ((f30-0 (* 0.5 (vector-length (vector-! (new 'stack-no-clear 'vector) (-> s3-0 1) (-> s3-0 0))))))
+        (let ((f28-0 (fmax 81920.0 (+ 12288.0 (vector-length (vector-! (new 'stack-no-clear 'vector) s1-0 (-> s3-0 0)))))))
+          (vector-normalize-copy! s4-0 (-> obj node-list data (-> obj gun-joint-l s2-0) bone transform vector 2) 1.0)
+          (let ((s0-0 vector-rotate-y!))
+            (set! sv-144 s4-0)
+            (set! sv-160 s4-0)
+            (let ((a2-1 (- 16384.0 (acos (/ f30-0 f28-0)))))
+              (s0-0 sv-144 sv-160 a2-1)
+              )
+            )
+          (set! (-> s5-0 0 quad) (-> s3-0 0 quad))
+          (vector+float*! (-> s5-0 1) (-> s5-0 0) s4-0 512000.0)
+          (set! (-> obj shot-range) (fmin 204800.0 f28-0))
+          )
+        (fort-robotank-turret-method-32 obj s5-0)
+        (let ((f28-1 (fmax 81920.0 (+ 12288.0 (vector-length (vector-! (new 'stack-no-clear 'vector) s1-0 (-> s3-0 1)))))))
+          (vector-normalize-copy! s4-0 (-> obj node-list data (-> obj gun-joint-r s2-0) bone transform vector 2) 1.0)
+          (vector-rotate-y! s4-0 s4-0 (- (- 16384.0 (acos (/ f30-0 f28-1)))))
+          (set! (-> s5-0 0 quad) (-> s3-0 1 quad))
+          (vector+float*! (-> s5-0 1) (-> s5-0 0) s4-0 512000.0)
+          (set! (-> obj shot-range) (fmin 204800.0 f28-1))
+          )
+        )
+      )
+    (fort-robotank-turret-method-32 obj s5-0)
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod fort-robotank-turret-method-31 fort-robotank-turret ((obj fort-robotank-turret) (arg0 vector) (arg1 vector))
+  (let ((s3-0 (new 'stack-no-clear 'collide-query))
+        (f30-0 307200.0)
+        )
+    (set! (-> s3-0 start-pos quad) (-> arg0 quad))
+    (vector-float*! (-> s3-0 move-dist) arg1 f30-0)
+    (let ((v1-4 s3-0))
+      (set! (-> v1-4 radius) 4096.0)
+      (set! (-> v1-4 collide-with) (collide-spec backgnd jak bot enemy obstacle hit-by-others-list player-list))
+      (set! (-> v1-4 ignore-process0) (ppointer->process (-> obj parent)))
+      (set! (-> v1-4 ignore-process1) obj)
+      (set! (-> v1-4 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+      (set! (-> v1-4 action-mask) (collide-action solid semi-solid))
+      )
+    (let ((f28-0 (fill-and-probe-using-line-sphere *collide-cache* s3-0))
+          (s4-0 (-> obj sight-pos))
+          )
+      (cond
+        ((>= f28-0 0.0)
+         (let ((f0-3 (vector-length (-> s3-0 move-dist))))
+           (if (>= 20480.0 (* f0-3 f28-0))
+               (set! f28-0 (/ 20480.0 f0-3))
+               )
+           )
+         (vector+float*! s4-0 (-> s3-0 start-pos) (-> s3-0 move-dist) f28-0)
+         (let* ((s3-1 (-> s3-0 best-other-tri collide-ptr))
+                (s2-0 (if (type? s3-1 collide-shape-prim)
+                          (the-as collide-shape-prim s3-1)
+                          )
+                      )
+                (s3-2 (new 'stack-no-clear 'vector))
+                )
+           (set! (-> s3-2 quad) (-> s4-0 quad))
+           (vector+float*! s3-2 s3-2 (-> (math-camera-matrix) vector 2) -2048.0)
+           (cond
+             ((and s2-0
+                   (logtest? (process-mask target enemy) (-> s2-0 cshape process mask))
+                   (>= 307200.0 (vector-vector-distance s3-2 arg0))
+                   )
+              )
+             (else
+               (set! f30-0 (+ 12288.0 (* f30-0 f28-0)))
+               )
+             )
+           )
+         )
+        (else
+          (vector+! s4-0 (-> s3-0 start-pos) (-> s3-0 move-dist))
+          )
+        )
+      (send-event (handle->process (-> obj reticle)) 'update arg0 s4-0)
+      )
+    (send-event (handle->process (-> obj reticle)) 'collide-dist f30-0)
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch collide-prim-core vs vector.
+(defmethod get-trans fort-robotank-turret ((obj fort-robotank-turret) (arg0 int))
+  "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])"
+  (the-as vector (-> obj root-override root-prim prim-core))
+  )
+
+(defbehavior turret-post fort-robotank-turret ()
+  (let* ((s5-0 *target*)
+         (gp-0 (if (type? s5-0 process-focusable)
+                   s5-0
+                   )
+               )
+         )
+    (cond
+      ((and (logtest? (-> self flags) 1) gp-0)
+       (send-event (handle->process (-> self reticle)) 'on)
+       (if (logtest? (-> self flags) 512)
+           (los-control-method-9 (-> self los) gp-0 (the-as vector #f) 1638.4)
+           )
+       (if *target*
+           (look-at! (-> *target* neck) (the-as vector (-> self root-override root-prim prim-core)) 'attacking self)
+           )
+       (set! (-> self aim-pos 0 quad) (-> self aim-pos-2 quad))
+       (set! (-> self aim-pos-2 quad) (-> (get-trans gp-0 0) quad))
+       (let ((s5-2 (-> self aim-pos-1))
+             (s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data (-> self gun-joint-l 0))))
+             )
+         (let ((v1-31 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data (-> self gun-joint-r 0)))))
+           (vector-! s5-2 (-> self aim-pos-2) (the-as vector (-> self aim-pos)))
+           (vector-float*! s5-2 s5-2 (* 0.8 (-> self clock frames-per-second)))
+           (set! (-> s5-2 y) 0.0)
+           (vector+! s5-2 (-> self aim-pos-2) s5-2)
+           (set! (-> s5-2 y) (+ 8192.0 (-> s5-2 y)))
+           (vector+! s4-0 s4-0 v1-31)
+           )
+         (vector-float*! s4-0 s4-0 0.5)
+         (let ((gp-2 (vector-! (new 'stack-no-clear 'vector) s5-2 s4-0))
+               (s3-1 (vector-! (new 'stack-no-clear 'vector) (-> self firing-sight-pos) s4-0))
+               (s5-3 (new 'stack-no-clear 'vector))
+               )
+           (let ((f30-0 (vector-length gp-2)))
+             (vector-normalize! gp-2 1.0)
+             (vector-normalize! s3-1 1.0)
+             (if (logtest? (-> self flags) 8)
+                 (set! (-> s5-3 quad) (-> s3-1 quad))
+                 (set! (-> s5-3 quad) (-> gp-2 quad))
+                 )
+             (when (logtest? (-> self flags) 128)
+               (let ((f0-6 (lerp-scale 1.0 0.2 f30-0 8192.0 327680.0)))
+                 (seek! (-> self fov-mult) f0-6 (* 2.0 (-> self clock seconds-per-frame)))
+                 )
+               (set-setting! 'fov 'rel (-> self fov-mult) 0)
+               (send-event (handle->process (-> self screen)) 'set-fov-mult (-> self fov-mult))
+               )
+             )
+           (let* ((f30-1 (vector-y-angle s5-3))
+                  (f0-12 (quaternion-y-angle (-> self rotate-quat)))
+                  (f0-13 (deg-diff f0-12 f30-1))
+                  )
+             (* (-> self rotate-mult) f0-13)
+             (let ((f1-6 12743.111))
+               (set! (-> self rotate-rate) (fmax (fmin (* 4.0 f0-13) f1-6) (- f1-6)))
+               )
+             )
+           (let ((f30-3 (fmax -4551.1113 (fmin 4551.1113 (- 16384.0 (acos (- (vector-dot s5-3 *y-vector*))))))))
+             (let* ((f0-29 (fmax -4551.1113 (fmin 4551.1113 (- 16384.0 (acos (- (vector-dot gp-2 *y-vector*)))))))
+                    (f2-1 (- (-> self gun-elev-cam) f0-29))
+                    (f1-12 (if (< f2-1 0.0)
+                               (fmin 3640.889 (* (fabs (* 0.1 f2-1)) (-> self clock frames-per-second)))
+                               910.2222
+                               )
+                           )
+                    )
+               (seek! (-> self gun-elev-cam) f0-29 (* f1-12 (-> self clock seconds-per-frame)))
+               )
+             (let* ((f28-2 (quaternion-y-angle (-> self rotate-quat)))
+                    (f0-33 (quaternion-y-angle (-> self tank-quat)))
+                    (f0-35 (* 2.0 (deg-diff f0-33 f28-2)))
+                    (f0-36 (cos f0-35))
+                    )
+               0.0
+               (let ((f0-41 (fmin f30-3 (if (< 0.0 f0-36)
+                                            (* 182.04445 (lerp 4.0 14.0 f0-36))
+                                            (* 182.04445 (lerp 4.0 18.0 (- f0-36)))
+                                            )
+                                  )
+                            )
+                     )
+                 (seek! (-> self gun-elev) f0-41 (* 2730.6667 (-> self clock seconds-per-frame)))
+                 )
+               )
+             )
+           )
+         )
+       (when (logtest? (-> self flags) 1024)
+         (cond
+           ((< -1456.3556 (-> self gun-elev))
+            (send-event (handle->process (-> self reticle)) 'spotlight-on)
+            )
+           ((< (-> self gun-elev) -2184.5334)
+            (send-event (handle->process (-> self reticle)) 'spotlight-off)
+            )
+           )
+         )
+       (quaternion-axis-angle! (-> self gun-elev-jmod transform quat) 1.0 0.0 0.0 (-> self gun-elev))
+       )
+      (else
+        (send-event (handle->process (-> self reticle)) 'off)
+        (send-event (handle->process (-> self reticle)) 'update-trans-only (-> self root-override trans))
+        )
+      )
+    )
+  (when (and (logtest? (-> self flags) 1) (zero? (logand (-> self flags) 8)))
+    (let* ((a1-32 (-> self node-list data (-> self gun-joint-l 0)))
+           (s4-1 (-> self node-list data (-> self gun-joint-r 0)))
+           (gp-4
+             (vector+!
+               (new 'stack-no-clear 'vector)
+               (vector<-cspace! (new 'stack-no-clear 'vector) a1-32)
+               (vector<-cspace! (new 'stack-no-clear 'vector) s4-1)
+               )
+             )
+           (a2-23
+             (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> self node-list data 11 bone transform vector 2) 1.0)
+             )
+           )
+      (vector-float*! gp-4 gp-4 0.5)
+      (fort-robotank-turret-method-31 self gp-4 a2-23)
+      )
+    )
+  (cond
+    ((logtest? (-> self flags) 64)
+     (sound-play
+       "robotank-turret"
+       :id (the-as sound-id (-> self turn-sound-id))
+       :position (-> self root-override trans)
+       )
+     (when (< (fabs (-> self rotate-rate)) 728.1778)
+       (set! (-> self flags) (logand -65 (-> self flags)))
+       (sound-stop (the-as sound-id (-> self turn-sound-id)))
+       (sound-play "robo-turret-end")
+       )
+     )
+    (else
+      (if (< 2184.5334 (fabs (-> self rotate-rate)))
+          (logior! (-> self flags) 64)
+          )
+      )
+    )
+  (quaternion-rotate-y!
+    (-> self rotate-quat)
+    (-> self rotate-quat)
+    (* (-> self rotate-rate) (-> self clock seconds-per-frame))
+    )
+  (quaternion*! (-> self root-override quat) (-> self rotate-quat) (-> self tank-quat-vibe-only))
+  (quaternion-normalize! (-> self root-override quat))
+  (transform-post)
+  (none)
+  )
+
+(defbehavior robotank-turret-handler fort-robotank-turret ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (case arg2
+    (('trigger)
+     (when (and (-> self next-state) (= (-> self next-state name) 'idle))
+       (logior! (-> self flags) 1)
+       (go-virtual ready)
+       )
+     )
+    (('fire-suppress)
+     (cond
+       ((-> arg3 param 0)
+        (set! v0-0 (logior (-> self flags) 16))
+        (set! (-> self flags) (the-as uint v0-0))
+        )
+       (else
+         (set! v0-0 (logand -17 (-> self flags)))
+         (set! (-> self flags) (the-as uint v0-0))
+         )
+       )
+     v0-0
+     )
+    (('set-spread)
+     (set! (-> self gun-spread) (the-as float (-> arg3 param 0)))
+     )
+    (('use-los)
+     (cond
+       ((-> arg3 param 0)
+        (set! v0-0 (logior (-> self flags) 512))
+        (set! (-> self flags) (the-as uint v0-0))
+        )
+       (else
+         (set! v0-0 (logand -513 (-> self flags)))
+         (set! (-> self flags) (the-as uint v0-0))
+         )
+       )
+     v0-0
+     )
+    (('limit-reticle-elev)
+     (cond
+       ((-> arg3 param 0)
+        (set! v0-0 (logior (-> self flags) 1024))
+        (set! (-> self flags) (the-as uint v0-0))
+        )
+       (else
+         (set! v0-0 (logand -1025 (-> self flags)))
+         (set! (-> self flags) (the-as uint v0-0))
+         )
+       )
+     v0-0
+     )
+    (('pov-cam-on)
+     (let ((v1-22 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 3)))
+       (set! (-> v1-22 prim-core collide-as) (collide-spec obstacle pusher))
+       (set! (-> v1-22 prim-core collide-with) (collide-spec jak player-list))
+       )
+     (logior! (-> self flags) 128)
+     (send-event (handle->process (-> self screen)) 'trigger)
+     )
+    (('pov-cam-off)
+     (let ((v1-33 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 3)))
+       (set! (-> v1-33 prim-core collide-as) (collide-spec))
+       (set! (-> v1-33 prim-core collide-with) (collide-spec))
+       )
+     0
+     (set! (-> self flags) (logand -129 (-> self flags)))
+     (remove-setting! 'fov)
+     (send-event (handle->process (-> self screen)) 'untrigger)
+     )
+    (('get-rotate-quat)
+     (-> self rotate-quat)
+     )
+    (('get-gun-elevation-cam)
+     (-> self gun-elev-cam)
+     )
+    (('update)
+     (-> arg3 param 1)
+     (new 'stack-no-clear 'vector)
+     (let ((s5-0 (new 'stack-no-clear 'quaternion)))
+       (let ((s4-0 (the-as object (-> arg3 param 2))))
+         (vector<-cspace+vector! (-> self root-override trans) (the-as cspace s4-0) (-> self offset))
+         (matrix->quaternion s5-0 (-> (the-as cspace s4-0) bone transform))
+         )
+       (quaternion-copy! (-> self tank-quat) s5-0)
+       )
+     (quaternion-copy! (-> self tank-quat-vibe-only) (the-as quaternion (-> arg3 param 3)))
+     )
+    (('die)
+     (go-virtual die)
+     )
+    )
+  )
+
+(defmethod fort-robotank-turret-method-34 fort-robotank-turret ((obj fort-robotank-turret) (arg0 vector) (arg1 float))
+  (let ((s4-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj root-override trans)))
+        (s3-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override quat)))
+        (s5-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s5-0 quad) (-> s4-1 quad))
+    (set! (-> s3-0 y) 0.0)
+    (vector-normalize! s3-0 1.0)
+    (set! (-> s5-0 y) 0.0)
+    (vector-normalize! s5-0 1.0)
+    (>= (vector-dot s3-0 s5-0) (cos arg1))
+    )
+  )
+
+(defstate idle (fort-robotank-turret)
+  :virtual #t
+  :event robotank-turret-handler
+  :code (the-as (function none :behavior fort-robotank-turret) sleep-code)
+  :post turret-post
+  )
+
+(defstate ready (fort-robotank-turret)
+  :virtual #t
+  :event robotank-turret-handler
+  :enter (behavior ()
+    (set! (-> self gun-timer) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (logtest? (-> self flags) 16)
+        (set! (-> self gun-timer) (-> self clock frame-counter))
+        )
+    (let ((gp-0 *target*))
+      (if (and (if (type? gp-0 process-focusable)
+                   gp-0
+                   )
+               (or (not (logtest? (-> self flags) 512)) (check-los? (-> self los) 0))
+               (>= (- (-> self clock frame-counter) (-> self gun-timer)) (seconds 1))
+               )
+          (go-virtual fire)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post turret-post
+  )
+
+(defstate fire (fort-robotank-turret)
+  :virtual #t
+  :event robotank-turret-handler
+  :enter (behavior ()
+    (logior! (-> self flags) 256)
+    (let* ((gp-0 *target*)
+           (a0-1 (if (type? gp-0 process-focusable)
+                     gp-0
+                     )
+                 )
+           )
+      (when a0-1
+        (set! (-> self aim-pos 0 quad) (-> (get-trans a0-1 0) quad))
+        (set! (-> self aim-pos-2 quad) (-> self aim-pos 0 quad))
+        (set! (-> self aim-pos-1 quad) (-> self aim-pos 0 quad))
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 *target*))
+      (when (or (not (if (type? gp-0 process-focusable)
+                         gp-0
+                         )
+                     )
+                (and (logtest? (-> self flags) 512) (not (logtest? (-> self flags) 8)) (skip-check-los? (-> self los) 0))
+                (logtest? (-> self flags) 16)
+                )
+        (set! (-> self flags) (logand -257 (-> self flags)))
+        (go-virtual ready)
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (until (fort-robotank-turret-method-34 self (-> self aim-pos-1) 2730.6667)
+        (suspend)
+        )
+      (logior! (-> self flags) 8)
+      (set! (-> self firing-sight-pos quad) (-> self sight-pos quad))
+      (send-event (handle->process (-> self reticle)) 'lock)
+      (let ((gp-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.5))
+          (suspend)
+          )
+        )
+      (let ((gp-2 (max 2 (min 3 (rand-vu-int-range 0 3)))))
+        0
+        (dotimes (s5-2 gp-2)
+          (let ((s4-1 (max 2 (min 4 (rand-vu-int-range 1 8)))))
+            (dotimes (s3-2 s4-1)
+              (ja-no-eval :group! (-> self draw art-group data 4)
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek!))
+                )
+              (fort-robotank-turret-method-33 self)
+              (ja-no-eval :group! (-> self draw art-group data 5)
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek!))
+                )
+              (set! (-> self gun-index) (- 1 (-> self gun-index)))
+              (suspend)
+              (if (< (vector-length
+                       (vector-! (new 'stack-no-clear 'vector) (-> self firing-sight-pos) (-> self root-override trans))
+                       )
+                     73728.0
+                     )
+                  (goto cfg-26)
+                  )
+              )
+            )
+          (let ((f30-0 (rand-vu-float-range 0.05 0.43))
+                (s4-2 (-> self clock frame-counter))
+                )
+            (until (>= (- (-> self clock frame-counter) s4-2) (the int (* 300.0 f30-0)))
+              (suspend)
+              )
+            )
+          )
+        )
+      (label cfg-26)
+      (set! (-> self flags) (logand -9 (-> self flags)))
+      (send-event (handle->process (-> self reticle)) 'unlock)
+      (until (fort-robotank-turret-method-34 self (-> self aim-pos-1) 2730.6667)
+        (suspend)
+        )
+      (let ((f30-1 (rand-vu-float-range
+                     (if (< 2730.6667 (-> self rotate-rate))
+                         1.2
+                         0.32
+                         )
+                     2.11
+                     )
+                   )
+            (gp-3 (-> self clock frame-counter))
+            )
+        (until (>= (- (-> self clock frame-counter) gp-3) (the int (* 300.0 f30-1)))
+          (suspend)
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  :post turret-post
+  )
+
+(defstate die (fort-robotank-turret)
+  :virtual #t
+  :code (behavior ()
+    (send-event (handle->process (-> self reticle)) 'die)
+    (send-event (handle->process (-> self screen)) 'die)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (while (-> self child)
+      (suspend)
+      )
+    (none)
+    )
+  )
+
+(defmethod deactivate fort-robotank-turret ((obj fort-robotank-turret))
+  (set! (-> obj flags) (logand -65 (-> obj flags)))
+  (sound-stop (the-as sound-id (-> obj turn-sound-id)))
+  (let ((a0-4 (handle->process (-> obj screen))))
+    (if a0-4
+        (deactivate a0-4)
+        )
+    )
+  ((method-of-type process-focusable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-focusable vs fort-robotank-turret.
+(defmethod relocate fort-robotank-turret ((obj fort-robotank-turret) (arg0 int))
+  (if (nonzero? (-> obj gun-elev-jmod))
+      (&+! (-> obj gun-elev-jmod) arg0)
+      )
+  (the-as fort-robotank-turret ((method-of-type process-focusable relocate) obj arg0))
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-robotank-turret-init-by-other fort-robotank-turret ((arg0 vector) (arg1 quaternion) (arg2 vector) (arg3 float))
+  (let ((s2-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
+    (set! (-> s2-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s2-0 reaction) cshape-reaction-default)
+    (set! (-> s2-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s1-0 (new 'process 'collide-shape-prim-group s2-0 (the-as uint 4) 0)))
+      (set! (-> s2-0 total-prims) (the-as uint 5))
+      (set! (-> s1-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s1-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s1-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s1-0 local-sphere) 0.0 0.0 0.0 36864.0)
+      (set! (-> s2-0 root-prim) s1-0)
+      )
+    (pusher-init s2-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 3)
+      (set-vector! (-> v1-14 local-sphere) 0.0 0.0 0.0 16384.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid))
+      (set! (-> v1-16 transform-index) 8)
+      (set-vector! (-> v1-16 local-sphere) 0.0 0.0 4096.0 6553.6)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-18 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-18 prim-core action) (collide-action solid))
+      (set! (-> v1-18 transform-index) 5)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 4096.0 6553.6)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-20 prim-core action) (collide-action solid))
+      (set! (-> v1-20 transform-index) 3)
+      (set-vector! (-> v1-20 local-sphere) 0.0 20480.0 4096.0 31129.6)
+      )
+    (set! (-> s2-0 nav-radius) (* 0.75 (-> s2-0 root-prim local-sphere w)))
+    (let ((v1-23 (-> s2-0 root-prim)))
+      (set! (-> s2-0 backup-collide-as) (-> v1-23 prim-core collide-as))
+      (set! (-> s2-0 backup-collide-with) (-> v1-23 prim-core collide-with))
+      )
+    (set! (-> self root-override) s2-0)
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (quaternion-copy! (-> self root-override quat) arg1)
+  (set! (-> self offset quad) (-> arg2 quad))
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-fort-robotank-turret" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (new-source! (-> self los) self (seconds 1) (collide-spec backgnd))
+  (set! (-> self gun-elev-jmod) (new 'process 'joint-mod-set-local self 4 #f #f #f))
+  (set! (-> self gun-elev-jmod set-rotation) #t)
+  (set! (-> self gun-elev) 0.0)
+  (set! (-> self gun-elev-cam) 0.0)
+  (set! (-> self gun-spread) 728.1778)
+  (quaternion-axis-angle! (-> self gun-elev-jmod transform quat) 1.0 0.0 0.0 (-> self gun-elev))
+  (quaternion-zero! (-> self tank-quat))
+  (quaternion-copy! (-> self rotate-quat) arg1)
+  (set! (-> self rotate-rate) 0.0)
+  (set! (-> self rotate-mult) arg3)
+  (set! (-> self aim-pos 0 quad) (-> self root-override trans quad))
+  (set! (-> self aim-pos-2 quad) (-> self root-override trans quad))
+  (set! (-> self aim-pos-1 quad) (-> self root-override trans quad))
+  (set! (-> self gun-timer) (-> self clock frame-counter))
+  (set! (-> self flags) (the-as uint 0))
+  (set! (-> self fov-mult) 1.0)
+  (set! (-> self shot-range) 204800.0)
+  (set! (-> self gun-joint-l 0) 10)
+  (set! (-> self gun-joint-r 0) 7)
+  (set! (-> self gun-joint-l 1) 9)
+  (set! (-> self gun-joint-r 1) 6)
+  (set! (-> self gun-index) 0)
+  (let ((gp-1 (new 'stack-no-clear 'vector)))
+    (set! (-> gp-1 quad) (-> self root-override trans quad))
+    (set! (-> gp-1 z) (+ 40960.0 (-> gp-1 z)))
+    (set! (-> gp-1 y) (+ 32768.0 (-> gp-1 y)))
+    (set! (-> self reticle) (ppointer->handle (process-spawn fort-robotank-reticle gp-1 :to self)))
+    )
+  (let ((gp-2 (new 'stack-no-clear 'vector))
+        (s4-2 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s4-2 x) 0.0)
+    (set! (-> s4-2 y) 32768.0)
+    (set! (-> s4-2 z) 12288.0)
+    (set! (-> s4-2 w) 0.0)
+    (let ((s5-2 (-> self root-override quat)))
+      (vector-orient-by-quat! s4-2 s4-2 s5-2)
+      (vector+! gp-2 (-> self root-override trans) s4-2)
+      (set! (-> self screen)
+            (ppointer->handle (process-spawn fort-roboscreen gp-2 s5-2 (-> self entity) :to *display-pool*))
+            )
+      )
+    )
+  (ja-no-eval :group! (-> self draw art-group data 3) :num! zero)
+  (transform-post)
+  (set! (-> self turn-sound-id) (the-as uint (new-sound-id)))
+  (go-virtual idle)
+  (none)
+  )
diff --git a/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank.gc b/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank.gc
index 4355a16e16..d28c134b1a 100644
--- a/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank.gc
+++ b/goal_src/jak2/levels/fortress/ammo_dump/fort-robotank.gc
@@ -5,5 +5,1232 @@
 ;; name in dgo: fort-robotank
 ;; dgos: FORDUMPC, FDA
 
+(declare-type fort-robotank process-drawable)
+
 ;; DECOMP BEGINS
 
+(defpartgroup group-robotank-barrel-sparks
+  :id 562
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 2474 :fade-after (meters 120) :falloff-to (meters 120) :flags (bit7)))
+  )
+
+(defpart 2474
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-rnd-flt spt-num 1.0 6.0 1.0)
+    (sp-rnd-flt spt-x (meters -4) (meters 8) 1.0)
+    (sp-flt spt-scale-x (meters 1))
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.05) (meters 0.05) 1.0)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.033333335) 1.0)
+    (sp-flt spt-fade-r -0.85333335)
+    (sp-flt spt-fade-g -0.85333335)
+    (sp-rnd-flt spt-accel-y -10.922667 -4.096 1.0)
+    (sp-flt spt-friction 0.875)
+    (sp-int-plain-rnd spt-timer 25 99 1)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 5 294 1)
+    (sp-launcher-by-id spt-next-launcher 2475)
+    (sp-rnd-flt spt-conerot-x (degrees -45.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees -45.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-z (degrees -45.0) (degrees 90.0) 1.0)
+    (sp-flt spt-rotate-y (degrees 0.0))
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.2) 1.0)
+    )
+  )
+
+(defpart 2475
+  :init-specs ((sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b 0.0)
+    (sp-rnd-flt spt-fade-a -0.85333335 -1.7066667 1.0)
+    )
+  )
+
+(deftype fort-robotank-segment-event (structure)
+  ((source     handle                         :offset-assert   0)
+   (event-type symbol                         :offset-assert   8)
+   (actor      string                         :offset-assert  12)
+   (pos-norm   float                          :offset-assert  16)
+   (param-obj  object                         :offset-assert  20)
+   (param-func (function fort-robotank none)  :offset         20)
+   (param-sym  symbol                         :offset         20)
+   )
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
+
+
+(deftype fort-robotank-segment (structure)
+  ((flags              uint16                                      :offset-assert   0)
+   (max-speed          float                                       :offset-assert   4)
+   (next-segment       int32                                       :offset-assert   8)
+   (next-segment-start float                                       :offset-assert  12)
+   (event-count        int32                                       :offset-assert  16)
+   (event-tbl          (inline-array fort-robotank-segment-event)  :offset-assert  20)
+   )
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
+
+
+(deftype fort-robotank-path-info (structure)
+  ((path          path-control         :offset-assert   0)
+   (dir           vector       :inline :offset-assert  16)
+   (u             float                :offset-assert  32)
+   (du            float                :offset-assert  36)
+   (du-final      float                :offset-assert  40)
+   (prev-u        float                :offset-assert  44)
+   (max-speed     float                :offset-assert  48)
+   (dist          float                :offset-assert  52)
+   (dir-y-angle   float                :offset-assert  56)
+   (start-y-angle float                :offset-assert  60)
+   )
+  :method-count-assert 9
+  :size-assert         #x40
+  :flag-assert         #x900000040
+  )
+
+
+(deftype fort-robotank-path-info-array (inline-array-class)
+  ((data fort-robotank-path-info :inline :dynamic :offset-assert  16)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+
+(set! (-> fort-robotank-path-info-array heap-base) (the-as uint 64))
+
+(deftype fort-robotank-wheel-info (structure)
+  ((jmod   joint-mod-spinner  :offset-assert   0)
+   (radius float              :offset-assert   4)
+   )
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+
+(deftype fort-robotank-tread-info (structure)
+  ((wheel         fort-robotank-wheel-info 7 :inline :offset-assert   0)
+   (texture       texture-anim                       :offset-assert 112)
+   (locator-joint int32                              :offset-assert 116)
+   (pos           vector                   :inline   :offset-assert 128)
+   )
+  :method-count-assert 9
+  :size-assert         #x90
+  :flag-assert         #x900000090
+  )
+
+
+(deftype fort-robotank (process-drawable)
+  ((root-override      collide-shape-moving                           :offset        128)
+   (barrel-part        sparticle-launch-control                       :offset-assert 200)
+   (roller-jmod        joint-mod                                      :offset-assert 204)
+   (vibe-jmod          joint-mod                                      :offset-assert 208)
+   (tread              fort-robotank-tread-info             2 :inline :offset-assert 224)
+   (path-info          fort-robotank-path-info-array                  :offset-assert 512)
+   (segment-table      (inline-array fort-robotank-segment)           :offset-assert 516)
+   (flags              uint16                                         :offset-assert 520)
+   (pov-cam-offset     vector                               2 :inline :offset-assert 528)
+   (turret             handle                                         :offset-assert 560)
+   (no-collision-timer time-frame                                     :offset-assert 568)
+   (buzz-timer         time-frame                                     :offset-assert 576)
+   (player-u           float                                          :offset-assert 584)
+   (player-prev-u      float                                          :offset-assert 588)
+   (roller-spin-rate   float                                          :offset-assert 592)
+   (engine-vibe-rate   float                                          :offset-assert 596)
+   (engine-vibe-amp    float                                          :offset-assert 600)
+   (attack-id          uint32                                         :offset-assert 604)
+   (path-index         int32                                          :offset-assert 608)
+   (path-count         int32                                          :offset-assert 612)
+   (continue-index     int32                                          :offset-assert 616)
+   (idle-sound         ambient-sound                                  :offset-assert 620)
+   (barrel-sound       ambient-sound                                  :offset-assert 624)
+   )
+  :heap-base #x200
+  :method-count-assert 28
+  :size-assert         #x274
+  :flag-assert         #x1c02000274
+  (:methods
+    (idle () _type_ :state 20)
+    (turning () _type_ :state 21)
+    (moving () _type_ :state 22)
+    (pause () _type_ :state 23)
+    (die () _type_ :state 24)
+    (fort-robotank-method-25 (_type_) event-message-block 25)
+    (fort-robotank-method-26 (_type_ int float float) symbol 26)
+    (fort-robotank-method-27 (_type_) none 27)
+    )
+  )
+
+
+(define *fort-robotank-1-segment-table*
+  (new 'static 'inline-array fort-robotank-segment 4
+    (new 'static 'fort-robotank-segment
+      :flags #x17
+      :max-speed 6.0
+      :next-segment 1
+      :event-count 5
+      :event-tbl (new 'static 'inline-array fort-robotank-segment-event 5
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-on :actor "camera-229")
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-off :actor #f :pos-norm 0.3)
+        (new 'static 'fort-robotank-segment-event :event-type 'pov-cam-on :actor #f :pos-norm 0.3)
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-a-1"
+          :pos-norm 0.1
+          :param-obj 'start-loading
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-elec-gate-10"
+          :pos-norm 0.9375
+          :param-obj 'trigger
+          )
+        )
+      )
+    (new 'static 'fort-robotank-segment
+      :flags #x7
+      :max-speed 9.0
+      :next-segment 2
+      :event-count 4
+      :event-tbl (new 'static 'inline-array fort-robotank-segment-event 5
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'code
+          :pos-norm 0.01
+          :param-obj (lambda () (set-setting! 'target-height 'abs -981467136 0) (none))
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-a-1"
+          :pos-norm 0.0104
+          :param-obj 'break
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-b-1"
+          :pos-norm 0.66667
+          :param-obj 'start-loading
+          )
+        (new 'static 'fort-robotank-segment-event
+          :source (new 'static 'handle :process #x1 :u64 #x1)
+          :event-type 'pov-cam-off
+          :pos-norm 0.83
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'code
+          :pos-norm 0.83
+          :param-obj (lambda ((arg0 fort-robotank)) (send-event (handle->process (-> arg0 turret)) 'set-spread #x44e38e39) (none))
+          )
+        )
+      )
+    (new 'static 'fort-robotank-segment
+      :flags #x20
+      :max-speed 10.0
+      :next-segment 3
+      :event-count 4
+      :event-tbl (new 'static 'inline-array fort-robotank-segment-event 4
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'code
+          :param-obj (lambda ((arg0 fort-robotank)) (send-event (handle->process (-> arg0 turret)) 'set-spread #x43b60b61) (none))
+          )
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-on :actor "camera-176")
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-off :pos-norm 0.38)
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-b-1"
+          :pos-norm 0.0793
+          :param-obj 'break
+          )
+        )
+      )
+    (new 'static 'fort-robotank-segment :flags #x20 :max-speed 8.0 :next-segment 3)
+    )
+  )
+
+(define *fort-robotank-2-segment-table*
+  (new 'static 'inline-array fort-robotank-segment 1
+    (new 'static 'fort-robotank-segment :flags #x8 :max-speed 6.0 :next-segment-start 7.586)
+    )
+  )
+
+(defskelgroup skel-fort-robotank fort-robotank 0 3
+              ((1 (meters 20)) (2 (meters 999999)))
+              :bounds (static-spherem 0 0 0 9)
+              :origin-joint-index 3
+              )
+
+(defmethod fort-robotank-method-25 fort-robotank ((obj fort-robotank))
+  (with-pp
+    (let ((v1-0 (-> obj root-override)))
+      (when (< (-> *event-queue* length) (-> *event-queue* allocated-length))
+        (let ((v0-0 (-> *event-queue* data (-> *event-queue* length))))
+          (+! (-> *event-queue* length) 1)
+          (set! (-> v0-0 form-handle) (process->handle pp))
+          (set! (-> v0-0 to-handle) (process->handle (handle->process (-> obj turret))))
+          (set! (-> v0-0 num-params) 4)
+          (set! (-> v0-0 message) 'update)
+          (set! (-> v0-0 param 0) (the-as uint (-> v1-0 trans)))
+          (set! (-> v0-0 param 1) (the-as uint (-> v1-0 quat)))
+          (set! (-> v0-0 param 2) (the-as uint (-> obj node-list data 3)))
+          (set! (-> v0-0 param 3) (the-as uint (-> obj vibe-jmod twist)))
+          v0-0
+          )
+        )
+      )
+    )
+  )
+
+(defbehavior fort-robotank-post fort-robotank ()
+  (when (and (nonzero? (-> self no-collision-timer))
+             (>= (- (-> self clock frame-counter) (-> self no-collision-timer))
+                 (the-as time-frame (-> *TARGET-bank* hit-invulnerable-timeout))
+                 )
+             )
+    (let ((v1-7 (-> self root-override root-prim)))
+      (set! (-> v1-7 prim-core collide-as) (-> self root-override backup-collide-as))
+      (set! (-> v1-7 prim-core collide-with) (-> self root-override backup-collide-with))
+      )
+    (set! (-> self no-collision-timer) 0)
+    0
+    )
+  (fort-robotank-method-25 self)
+  (seek! (-> self roller-jmod twist y) (-> self roller-spin-rate) (* 16384.0 (-> self clock seconds-per-frame)))
+  (let ((gp-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 5)))
+        (s4-0 (get-field-spec-by-id (-> *part-id-table* 2474) (sp-field-id spt-num)))
+        (s5-0 (new 'stack-no-clear 'matrix))
+        )
+    (set! (-> s4-0 random-rangef) (lerp-scale 1.0 6.0 (-> self roller-jmod twist y) 8192.0 65536.0))
+    (set! (-> gp-0 y) (+ -6144.0 (-> gp-0 y)))
+    (quaternion->matrix s5-0 (-> self root-override quat))
+    (set! (-> s5-0 trans quad) (-> gp-0 quad))
+    (spawn-with-matrix (-> self barrel-part) s5-0)
+    )
+  (dotimes (gp-1 2)
+    (let* ((s5-1 (-> self tread gp-1))
+           (s4-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data (-> s5-1 locator-joint))))
+           )
+      (let ((s3-1 (vector-! (new 'stack-no-clear 'vector) s4-1 (-> s5-1 pos))))
+        (let ((s2-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root-override quat))))
+          (if (= gp-1 1)
+              (vector-float*! s2-0 s2-0 -1.0)
+              )
+          (let ((s1-0 (get-field-spec-by-id (-> *part-id-table* 2471) (sp-field-id spt-num)))
+                (f30-0 (vector-length s3-1))
+                (f28-0 (* 12288.0 (-> self clock seconds-per-frame)))
+                )
+            (set! (-> s1-0 initial-valuef) (lerp-scale 0.0 0.5 f30-0 0.0 f28-0))
+            (set! (-> s1-0 random-rangef) (lerp-scale 0.0 1.0 f30-0 0.0 f28-0))
+            )
+          (let ((a1-14 (forward-up-nopitch->inv-matrix (new 'stack-no-clear 'matrix) s2-0 *up-vector*)))
+            (set! (-> a1-14 trans quad) (-> s4-1 quad))
+            (set! (-> a1-14 trans y) (+ -2498.56 (-> a1-14 trans y)))
+            (spawn-with-matrix (-> self part) a1-14)
+            )
+          )
+        (vector-inv-orient-by-quat! s3-1 s3-1 (-> self root-override quat))
+        (let ((f30-1 (fabs (-> s3-1 z))))
+          (dotimes (s3-2 7)
+            (let ((s2-1 (-> s5-1 wheel s3-2)))
+              (set! (-> s2-1 jmod spin-rate) (* (atan f30-1 (-> s2-1 radius)) (-> self clock frames-per-second)))
+              )
+            )
+          (set! (-> s5-1 texture frame-delta) (* 0.00028388444 (-> self clock frames-per-second) f30-1))
+          )
+        )
+      (set! (-> s5-1 pos quad) (-> s4-1 quad))
+      )
+    )
+  (let ((v1-65 (-> self path-info data (-> self path-index))))
+    (cond
+      ((and (logtest? (-> self flags) 4) (!= (-> v1-65 u) (-> v1-65 prev-u)))
+       (seek! (-> self engine-vibe-rate) 3.0 (-> self clock seconds-per-frame))
+       (seek! (-> self engine-vibe-amp) 1.0 (-> self clock seconds-per-frame))
+       )
+      (else
+        (seek! (-> self engine-vibe-rate) 1.0 (-> self clock seconds-per-frame))
+        (seek! (-> self engine-vibe-amp) 0.4 (-> self clock seconds-per-frame))
+        )
+      )
+    )
+  (let* ((f0-35 30.0)
+         (f1-7 65536.0)
+         (f2-1 (the float (-> self clock frame-counter)))
+         (f0-36 (/ (* f1-7 (- f2-1 (* (the float (the int (/ f2-1 f0-35))) f0-35))) f0-35))
+         (f28-1 (sin f0-36))
+         (f30-2 (* 300.0 (/ 1.0 (-> self engine-vibe-rate))))
+         (f0-39 (the float (-> self clock frame-counter)))
+         (f24-0 (/ (- f0-39 (* (the float (the int (/ f0-39 f30-2))) f30-2)) f30-2))
+         (f28-2 (* f28-1 (sin (* 65536.0 f24-0))))
+         )
+    (let* ((f0-44 (sin 7281.778))
+           (f1-16 (- 1.0 f0-44))
+           (f26-0 0.0)
+           )
+      (when (and (or (< f0-44 f24-0) (< f24-0 f1-16))
+                 (>= (- (-> self clock frame-counter) (-> self buzz-timer)) (the int (* 0.5 f30-2)))
+                 )
+        (let* ((gp-2 *target*)
+               (a0-43 (if (type? gp-2 process-focusable)
+                          gp-2
+                          )
+                      )
+               )
+          (if a0-43
+              (set! f26-0
+                    (lerp-scale
+                      1.0
+                      0.0
+                      (vector-vector-distance (-> self root-override trans) (get-trans a0-43 0))
+                      81920.0
+                      327680.0
+                      )
+                    )
+              )
+          )
+        (cpad-set-buzz!
+          (-> *cpad-list* cpads 0)
+          1
+          (the int (* 255.0 (* 0.49 f26-0)))
+          (the-as time-frame (max 45 (the int (* 0.25 f30-2))))
+          )
+        (set! (-> self buzz-timer) (-> self clock frame-counter))
+        )
+      )
+    (quaternion-axis-angle!
+      (the-as quaternion (-> self vibe-jmod twist))
+      0.0
+      0.0
+      1.0
+      (* 182.04445 (* (-> self engine-vibe-amp) f28-2))
+      )
+    )
+  (dotimes (gp-4 (-> self path-count))
+    (debug-draw (-> self path-info data gp-4 path))
+    )
+  (when (logtest? (-> self flags) 128)
+    (let ((gp-5 (quaternion-inverse! (new 'stack-no-clear 'quaternion) (-> self root-override quat)))
+          (a1-28 (new 'stack-no-clear 'event-message-block))
+          )
+      (set! (-> a1-28 from) (process->ppointer self))
+      (set! (-> a1-28 num-params) 0)
+      (set! (-> a1-28 message) 'get-rotate-quat)
+      (let ((s5-3 (send-event-function (handle->process (-> self turret)) a1-28))
+            (s4-3 (new 'stack-no-clear 'quaternion))
+            (s2-3 (-> (the-as fort-robotank-turret (handle->process (-> self turret))) root-override trans))
+            (s1-1 (-> self root-override trans))
+            (s3-4 (new 'stack-no-clear 'vector))
+            )
+        (let ((a1-30 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-30 from) (process->ppointer self))
+          (set! (-> a1-30 num-params) 0)
+          (set! (-> a1-30 message) 'get-gun-elevation-cam)
+          (let ((f30-3 (the-as float (send-event-function (handle->process (-> self turret)) a1-30))))
+            (vector-! s3-4 s2-3 s1-1)
+            (vector-orient-by-quat! s3-4 s3-4 gp-5)
+            (quaternion*! s4-3 (the-as quaternion s5-3) gp-5)
+            (quaternion-normalize! s4-3)
+            (quaternion-rotate-local-x! s4-3 s4-3 f30-3)
+            )
+          )
+        (vector-orient-by-quat! (the-as vector (-> self pov-cam-offset)) (-> self pov-cam-offset 1) s4-3)
+        (vector+! (the-as vector (-> self pov-cam-offset)) (the-as vector (-> self pov-cam-offset)) s3-4)
+        )
+      )
+    )
+  (update-trans! (-> self sound) (-> self root-override trans))
+  (update! (-> self sound))
+  (update-trans! (-> self idle-sound) (-> self root-override trans))
+  (update! (-> self idle-sound))
+  (update-trans! (-> self barrel-sound) (-> self root-override trans))
+  (update! (-> self barrel-sound))
+  (pusher-post)
+  (none)
+  )
+
+(defbehavior fort-robotank-handler fort-robotank ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('trigger)
+     (when (and *target* (< (-> self continue-index) (the-as int (-> arg3 param 0))))
+       (if (< (-> self continue-index) 0)
+           (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv107" -99.0 0)
+           )
+       (when (< (-> *event-queue* length) (-> *event-queue* allocated-length))
+         (let ((v1-14 (-> *event-queue* data (-> *event-queue* length))))
+           (+! (-> *event-queue* length) 1)
+           (set! (-> v1-14 form-handle) (process->handle self))
+           (set! (-> v1-14 to-handle) (process->handle (handle->process (-> self turret))))
+           (set! (-> v1-14 num-params) 0)
+           (set! (-> v1-14 message) 'trigger)
+           )
+         )
+       (logior! (-> self flags) 32)
+       (set! (-> self continue-index) (the-as int (-> arg3 param 0)))
+       )
+     )
+    (('trans)
+     (-> self root-override trans)
+     )
+    (('die)
+     (go-virtual die)
+     )
+    (('fire-suppress-on)
+     (send-event (handle->process (-> self turret)) 'fire-suppress #t)
+     )
+    (('fire-suppress-off)
+     (send-event (handle->process (-> self turret)) 'fire-suppress #f)
+     )
+    (('touch 'attack)
+     (when ((method-of-type touching-shapes-entry prims-touching?)
+            (the-as touching-shapes-entry (-> arg3 param 0))
+            (-> self root-override)
+            (the-as uint 1)
+            )
+       (let ((s5-0 (if (type? arg0 process-focusable)
+                       (the-as process-focusable arg0)
+                       )
+                   )
+             )
+         (when s5-0
+           (let ((a0-48 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override quat)))
+                 (a1-19 (new 'stack-no-clear 'event-message-block))
+                 )
+             (set! (-> a1-19 from) (process->ppointer self))
+             (set! (-> a1-19 num-params) 2)
+             (set! (-> a1-19 message) 'attack-or-shove)
+             (set! (-> a1-19 param 0) (-> arg3 param 0))
+             (let ((v1-40 (new 'static 'attack-info :mask (attack-info-mask vector shove-back shove-up control id))))
+               (set! (-> v1-40 id) (-> self attack-id))
+               (set! (-> v1-40 vector quad) (-> a0-48 quad))
+               (set! (-> v1-40 shove-back) (if (and (-> self next-state) (= (-> self next-state name) 'idle))
+                                               16384.0
+                                               49152.0
+                                               )
+                     )
+               (set! (-> v1-40 shove-up) 24576.0)
+               (set! (-> v1-40 control) (if (logtest? (focus-status board) (-> s5-0 focus-status))
+                                            1.0
+                                            0.0
+                                            )
+                     )
+               (set! (-> a1-19 param 1) (the-as uint v1-40))
+               )
+             (when (send-event-function s5-0 a1-19)
+               (set! (-> self no-collision-timer) (-> self clock frame-counter))
+               (let ((v1-45 (-> self root-override root-prim)))
+                 (set! (-> v1-45 prim-core collide-as) (collide-spec))
+                 (set! (-> v1-45 prim-core collide-with) (collide-spec))
+                 )
+               0
+               )
+             )
+           )
+         )
+       )
+     )
+    (('stop-music)
+     (remove-setting! 'music)
+     (remove-setting! 'music-volume)
+     (remove-setting! 'sound-mode)
+     )
+    )
+  (none)
+  )
+
+(defmethod fort-robotank-method-26 fort-robotank ((obj fort-robotank) (arg0 int) (arg1 float) (arg2 float))
+  (local-vars
+    (sv-96 fort-robotank-segment-event)
+    (sv-112 (function process-tree event-message-block object))
+    (sv-128 event-message-block)
+    )
+  (with-pp
+    (let* ((s4-0 (* 0.00001 (the float (the int (+ 0.5 (* 100000.0 arg1))))))
+           (s3-0 (* 0.00001 (the float (the int (+ 0.5 (* 100000.0 arg2))))))
+           (s2-0 (-> obj segment-table (-> obj path-index)))
+           (s1-0 (-> s2-0 event-tbl))
+           )
+      (dotimes (s0-0 (-> s2-0 event-count))
+        (set! sv-96 (-> s1-0 s0-0))
+        (let ((f0-4 (-> sv-96 pos-norm)))
+          (when (and (= (-> sv-96 source) arg0) (>= s4-0 f0-4) (< s3-0 f0-4))
+            (case (-> sv-96 event-type)
+              (('send-event)
+               (set! sv-128 (new 'stack-no-clear 'event-message-block))
+               (set! (-> sv-128 from) (process->ppointer pp))
+               (set! (-> sv-128 num-params) 0)
+               (set! (-> sv-128 message) (the-as symbol (-> sv-96 param-obj)))
+               (set! sv-112 send-event-function)
+               (let ((a0-11 (process-by-ename (-> sv-96 actor))))
+                 (sv-112 a0-11 sv-128)
+                 )
+               )
+              (('code)
+               (let ((t9-2 (-> sv-96 param-obj)))
+                 (if t9-2
+                     ((the-as (function fort-robotank none) t9-2) obj)
+                     )
+                 )
+               )
+              (('pov-cam-on)
+               (set-setting! 'mode-name 'cam-pov-track 0 0)
+               (set-setting! 'allow-look-around #f 0 0)
+               (set-setting! 'target-height 'abs -968884224 0)
+               (let ((v1-27 (process->ppointer obj)))
+                 (set-setting! 'pov-handle v1-27 #x40400000 (-> v1-27 0 pid))
+                 )
+               (set-setting! 'pov-offset 'asdf (-> obj pov-cam-offset) 0)
+               (send-event (handle->process (-> obj turret)) 'pov-cam-on)
+               (logior! (-> obj flags) 128)
+               (let ((v1-41 (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 2)))
+                 (set! (-> v1-41 prim-core collide-as) (collide-spec enemy pusher))
+                 (set! (-> v1-41 prim-core collide-with) (collide-spec jak bot player-list))
+                 )
+               )
+              (('pov-cam-off)
+               (remove-setting! 'pov-handle)
+               (remove-setting! 'mode-name)
+               (remove-setting! 'allow-look-around)
+               (remove-setting! 'target-height)
+               (remove-setting! 'pov-offset)
+               (send-event (handle->process (-> obj turret)) 'pov-cam-off)
+               (set! (-> obj flags) (logand -129 (-> obj flags)))
+               (let ((v1-57 (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 2)))
+                 (set! (-> v1-57 prim-core collide-as) (collide-spec))
+                 (set! (-> v1-57 prim-core collide-with) (collide-spec))
+                 )
+               0
+               )
+              (('external-cam-on)
+               (hide-hud-quick #f)
+               (set-setting! 'entity-name (-> sv-96 actor) 0 0)
+               (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+               (remove-setting! 'target-height)
+               (process-grab? *target* #f)
+               (send-event (handle->process (-> obj turret)) 'fire-suppress #t)
+               )
+              (('external-cam-off)
+               (remove-setting! 'entity-name)
+               (remove-setting! 'process-mask)
+               (remove-setting! 'target-height)
+               (process-release? *target*)
+               (send-event (handle->process (-> obj turret)) 'fire-suppress #f)
+               )
+              )
+            )
+          )
+        )
+      )
+    #f
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod fort-robotank-method-27 fort-robotank ((obj fort-robotank))
+  (let ((s5-0 (-> obj segment-table (-> obj path-index) flags)))
+    (send-event (handle->process (-> obj turret)) 'use-los (if (logtest? s5-0 16)
+                                                               #t
+                                                               #f
+                                                               )
+                )
+    (send-event (handle->process (-> obj turret)) 'limit-reticle-elev (if (logtest? s5-0 32)
+                                                                          #t
+                                                                          #f
+                                                                          )
+                )
+    )
+  (none)
+  )
+
+(defstate idle (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (fort-robotank-method-25 self)
+    (set! (-> self roller-spin-rate) 2730.6667)
+    (none)
+    )
+  :trans (behavior ()
+    (when (and (name= (-> self name) "fort-robotank-6") (task-node-closed? (game-task-node fortress-dump-deal)))
+      (when (< (-> *event-queue* length) (-> *event-queue* allocated-length))
+        (let ((v1-8 (-> *event-queue* data (-> *event-queue* length))))
+          (+! (-> *event-queue* length) 1)
+          (set! (-> v1-8 form-handle) (process->handle self))
+          (set! (-> v1-8 to-handle) (process->handle (handle->process (-> self turret))))
+          (set! (-> v1-8 num-params) 0)
+          (set! (-> v1-8 message) 'trigger)
+          )
+        )
+      (logior! (-> self flags) 32)
+      )
+    (when (logtest? (-> self flags) 32)
+      (set! (-> self flags) (logand -33 (-> self flags)))
+      (set-setting! 'music 'danger11 0 0)
+      (set-setting! 'music-volume 'rel #x3f666666 0)
+      (go-virtual moving)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-robotank) sleep-code)
+  :post fort-robotank-post
+  )
+
+(defstate turning (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (set! (-> self path-info data (-> self path-index) start-y-angle)
+          (quaternion-y-angle (-> self root-override quat))
+          )
+    (set! (-> self roller-spin-rate) 32768.0)
+    (none)
+    )
+  :trans (behavior ()
+    (let* ((gp-0 (-> self path-info data (-> self path-index)))
+           (s5-0 (-> self root-override))
+           (f30-0 (quaternion-y-angle (-> s5-0 quat)))
+           (f28-0 (fabs (deg-diff f30-0 (-> gp-0 start-y-angle))))
+           (f30-1 (fabs (deg-diff f30-0 (vector-y-angle (-> gp-0 dir)))))
+           )
+      (let* ((f0-3 (fmin f28-0 f30-1))
+             (f0-6 (fmax 728.1778 (fmin 10012.444 (* 4.0 f0-3))))
+             )
+        (seek-toward-heading-vec! s5-0 (-> gp-0 dir) f0-6 (seconds 0.02))
+        )
+      (if (< f30-1 36.40889)
+          (go-virtual pause)
+          )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-robotank) sleep-code)
+  :post (behavior ()
+    (fort-robotank-post)
+    (none)
+    )
+  )
+
+(defstate moving (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (set! (-> self roller-spin-rate) 65536.0)
+    (let ((v1-4 (-> self path-info data (-> self path-index))))
+      (set! (-> v1-4 u) 0.0)
+      (set! (-> v1-4 prev-u) -1.0)
+      (set! (-> v1-4 du) 0.0)
+      (set! (-> v1-4 du-final) 0.01)
+      )
+    (fort-robotank-method-27 self)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self flags) (logand -5 (-> self flags)))
+    (none)
+    )
+  :trans (behavior ()
+    (if (not *target*)
+        (go-virtual die)
+        )
+    (let* ((gp-0 *target*)
+           (a0-1 (if (type? gp-0 process-focusable)
+                     gp-0
+                     )
+                 )
+           )
+      (when a0-1
+        (if (< (-> (get-trans a0-1 0) y) (+ -18432.0 (-> self root-override trans y)))
+            (go-virtual die)
+            )
+        )
+      )
+    (let* ((v1-14 (-> self path-index))
+           (s5-0 (-> self path-info data v1-14))
+           (gp-1 (-> self segment-table v1-14))
+           )
+      (fort-robotank-method-26 self 0 (-> s5-0 u) (-> s5-0 prev-u))
+      (let ((s4-0 *target*))
+        (if (if (type? s4-0 process-focusable)
+                s4-0
+                )
+            (fort-robotank-method-26 self 1 (-> self player-u) (-> self player-prev-u))
+            )
+        )
+      (when (= (-> s5-0 u) 1.0)
+        (cond
+          ((logtest? (-> gp-1 flags) 1)
+           (set! (-> self path-index) (-> gp-1 next-segment))
+           (go-virtual turning)
+           )
+          (else
+            (set! (-> self path-index) (-> gp-1 next-segment))
+            (let ((gp-2 (-> self path-info data (-> self path-index))))
+              (set! (-> gp-2 u)
+                    (/ (-> self segment-table (-> self path-index) next-segment-start) (get-num-segments (-> gp-2 path)))
+                    )
+              (set! (-> gp-2 prev-u) (+ -0.1 (-> gp-2 u)))
+              (set! (-> gp-2 du) 0.01)
+              (set! (-> gp-2 du-final) 0.01)
+              )
+            0
+            (fort-robotank-method-27 self)
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (set! (-> self flags) (logand -5 (-> self flags)))
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.1))
+        (suspend)
+        )
+      )
+    (logior! (-> self flags) 4)
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (when (logtest? (-> self flags) 4)
+      (let* ((gp-0 *target*)
+             (s3-0 (if (type? gp-0 process-focusable)
+                       gp-0
+                       )
+                   )
+             (s5-0 (if s3-0
+                       (get-trans s3-0 0)
+                       (the-as vector #f)
+                       )
+                   )
+             (gp-1 (-> self path-info data (-> self path-index)))
+             )
+        (-> self segment-table (-> self path-index))
+        (let ((s4-0 (-> gp-1 path))
+              (s2-0 (new 'stack-no-clear 'vector))
+              )
+          (let ((f30-0 (-> gp-1 u))
+                (s0-0 (new 'stack-no-clear 'vector))
+                (s1-0 (-> self root-override))
+                )
+            (get-point-at-percent-along-path! s4-0 (-> s1-0 trans) f30-0 'interp)
+            (set! (-> s1-0 trans y) (+ 1024.0 (-> s1-0 trans y)))
+            (displacement-between-points-at-percent-normalized! s4-0 s0-0 f30-0)
+            (displacement-between-points-at-percent-scaled! s4-0 s2-0 f30-0 (-> gp-1 du-final))
+            (seek-toward-heading-vec! s1-0 s0-0 16384.0 (seconds 0.02))
+            )
+          (set! (-> gp-1 prev-u) (-> gp-1 u))
+          (set! (-> self player-prev-u) (-> self player-u))
+          (if s3-0
+              (set! (-> self player-u) (get-path-percentage-at-furthest-point s4-0 s5-0))
+              )
+          (let ((f30-1 (* (-> gp-1 du) (/ (-> gp-1 max-speed) (vector-length s2-0))))
+                (f28-0 1.0)
+                )
+            (if (logtest? (-> self segment-table (-> self path-index) flags) 1)
+                (set! f28-0
+                      (fmin 1.0 (* 0.000048828126
+                                   (+ 2048.0 (vector-vector-distance
+                                               (-> self root-override trans)
+                                               (get-point-at-percent-along-path! s4-0 (new 'stack-no-clear 'vector) 1.0 'interp)
+                                               )
+                                      )
+                                   )
+                            )
+                      )
+                )
+            (when s3-0
+              (let* ((s2-2 (-> self segment-table (-> self path-index) flags))
+                     (f26-1 (-> self player-u))
+                     (s3-1 (method-of-type path-control get-point-in-path!))
+                     (s3-2 (s3-1 s4-0 (new 'stack-no-clear 'vector) (* f26-1 (get-num-segments s4-0)) 'interp))
+                     (f20-0 (vector-vector-distance s3-2 s5-0))
+                     (f24-1 (total-distance s4-0))
+                     (f22-0 (+ -20480.0 f24-1))
+                     )
+                (when (logtest? s2-2 2)
+                  (if (< (* f26-1 f24-1) (fmin (+ 61440.0 (* (-> gp-1 u) f24-1)) f22-0))
+                      (set! f28-0 (if (and (< f20-0 8192.0) (< (-> gp-1 u) f26-1))
+                                      1.0
+                                      (fmin f28-0 (lerp-scale
+                                                    0.0
+                                                    1.0
+                                                    (if (< f26-1 (-> gp-1 u))
+                                                        0.0
+                                                        (vector-vector-distance (-> self root-override trans) s3-2)
+                                                        )
+                                                    6144.0
+                                                    61440.0
+                                                    )
+                                            )
+                                      )
+                            )
+                      )
+                  )
+                (when (logtest? s2-2 4)
+                  (if (< (fmin (+ 102400.0 (* (-> gp-1 u) f24-1)) f22-0) (* f26-1 f24-1))
+                      (set! f28-0
+                            (fmax
+                              f28-0
+                              (lerp-scale 1.0 2.0 (vector-vector-distance (-> self root-override trans) s3-2) 102400.0 143360.0)
+                              )
+                            )
+                      )
+                  )
+                )
+              )
+            (set! (-> gp-1 u) (fmax 0.0 (fmin 1.0 (+ (-> gp-1 u) (* f28-0 f30-1 (-> self clock seconds-per-frame))))))
+            (seek! (-> gp-1 du) (-> gp-1 du-final) (* 0.5 (-> self clock seconds-per-frame) (-> gp-1 du-final)))
+            (update-vol! (-> self sound) (lerp-scale 0.0 1.0 (* f28-0 f30-1) 0.0 0.03))
+            (update-vol! (-> self barrel-sound) (lerp-scale 0.0 1.0 (* f28-0 f30-1) 0.0 0.01))
+            )
+          )
+        )
+      )
+    (fort-robotank-post)
+    (none)
+    )
+  )
+
+(defstate pause (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (set! (-> self roller-spin-rate) 16384.0)
+    (none)
+    )
+  :trans (behavior ()
+    (when (logtest? (-> self flags) 32)
+      (set! (-> self flags) (logand -33 (-> self flags)))
+      (go-virtual moving)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-robotank) sleep-code)
+  :post fort-robotank-post
+  )
+
+(defstate die (fort-robotank)
+  :virtual #t
+  :code (behavior ()
+    (remove-setting! 'pov-handle)
+    (remove-setting! 'pov-offset)
+    (remove-setting! 'mode-name)
+    (remove-setting! 'allow-look-around)
+    (remove-setting! 'entity-name)
+    (remove-setting! 'process-mask)
+    (remove-setting! 'target-height)
+    (send-event (handle->process (-> self turret)) 'die)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 2))
+        (suspend)
+        )
+      )
+    (while (-> self child)
+      (suspend)
+      )
+    (none)
+    )
+  :post (the-as (function none :behavior fort-robotank) pusher-post)
+  )
+
+(defmethod deactivate fort-robotank ((obj fort-robotank))
+  (stop! (-> obj idle-sound))
+  (stop! (-> obj barrel-sound))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; WARN: Return type mismatch process-drawable vs fort-robotank.
+(defmethod relocate fort-robotank ((obj fort-robotank) (arg0 int))
+  (if (nonzero? (-> obj barrel-part))
+      (&+! (-> obj barrel-part) arg0)
+      )
+  (if (nonzero? (-> obj roller-jmod))
+      (&+! (-> obj roller-jmod) arg0)
+      )
+  (if (nonzero? (-> obj vibe-jmod))
+      (&+! (-> obj vibe-jmod) arg0)
+      )
+  (if (nonzero? (-> obj idle-sound))
+      (&+! (-> obj idle-sound) arg0)
+      )
+  (if (nonzero? (-> obj barrel-sound))
+      (&+! (-> obj barrel-sound) arg0)
+      )
+  (let ((v1-20 (-> obj path-info)))
+    (when (nonzero? v1-20)
+      (dotimes (a0-2 (-> obj path-count))
+        (if (nonzero? (-> v1-20 data a0-2 path))
+            (&+! (-> v1-20 data a0-2 path) arg0)
+            )
+        )
+      (&+! (-> obj path-info) arg0)
+      )
+    )
+  (dotimes (v1-24 2)
+    (dotimes (a0-4 7)
+      (if (nonzero? (the-as
+                      joint-mod
+                      (-> (the-as (pointer uint32) (&+ (&+ (the-as (pointer uint32) obj) (* 144 v1-24)) (* a0-4 16))) 55)
+                      )
+                    )
+          (set! (-> (&+ (&+ (the-as (pointer uint32) obj) (* 144 v1-24)) (* a0-4 16)) 55)
+                (the-as
+                  uint
+                  (&+
+                    (the-as
+                      joint-mod
+                      (-> (the-as (pointer uint32) (&+ (&+ (the-as (pointer uint32) obj) (* 144 v1-24)) (* a0-4 16))) 55)
+                      )
+                    arg0
+                    )
+                  )
+                )
+          )
+      )
+    )
+  (the-as
+    fort-robotank
+    ((the-as (function process-drawable int process-drawable) (find-parent-method fort-robotank 7)) obj arg0)
+    )
+  )
+
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-robotank ((obj fort-robotank) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s4-0 reaction) cshape-reaction-default)
+    (set! (-> s4-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 3) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 4))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 47104.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 1))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 5)
+      (set-vector! (-> v1-14 local-sphere) 0.0 0.0 0.0 24576.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid))
+      (set! (-> v1-16 transform-index) 3)
+      (set-vector! (-> v1-16 local-sphere) 0.0 0.0 -8192.0 28672.0)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-18 prim-core action) (collide-action solid))
+      (set! (-> v1-18 transform-index) 3)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 -8192.0 36864.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-21 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-21 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-21 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-robotank" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (process-entity-status! obj (entity-perm-status no-kill) #t)
+  (set! (-> obj fact)
+        (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+        )
+  (set! (-> obj flags) (the-as uint 0))
+  (set! (-> obj no-collision-timer) 0)
+  (set! (-> obj engine-vibe-rate) 1.0)
+  (set! (-> obj buzz-timer) 0)
+  (let* ((v1-31 *game-info*)
+         (a0-30 (+ (-> v1-31 attack-id) 1))
+         )
+    (set! (-> v1-31 attack-id) a0-30)
+    (set! (-> obj attack-id) a0-30)
+    )
+  (cond
+    ((name= (-> obj name) "fort-robotank-2")
+     (set! (-> obj segment-table) *fort-robotank-1-segment-table*)
+     (set! (-> obj path-count) 4)
+     )
+    ((name= (-> obj name) "fort-robotank-6")
+     (set! (-> obj segment-table) *fort-robotank-2-segment-table*)
+     (set! (-> obj path-count) 1)
+     )
+    (else
+      (go process-drawable-art-error "unknown actor-node name")
+      )
+    )
+  (set! (-> obj path-info) (new 'process 'fort-robotank-path-info-array (-> obj path-count)))
+  (dotimes (s5-2 (-> obj path-count))
+    (let ((s4-2 (-> obj path-info data s5-2)))
+      (if (logtest? (-> obj segment-table s5-2 flags) 8)
+          (set! (-> s4-2 path) (new 'process 'curve-control obj 'path -1000000000.0))
+          (set! (-> s4-2 path) (new 'process 'curve-control obj 'path (the float s5-2)))
+          )
+      (logior! (-> s4-2 path flags) (path-control-flag display draw-line draw-point draw-text))
+      (set! (-> s4-2 u) 0.0)
+      (set! (-> s4-2 du) (-> s4-2 u))
+      (set! (-> s4-2 max-speed) (* 4096.0 (-> obj segment-table s5-2 max-speed)))
+      (set! (-> s4-2 dist) (total-distance (-> s4-2 path)))
+      (set! (-> s4-2 start-y-angle) 0.0)
+      (displacement-between-two-points-normalized! (-> s4-2 path) (-> s4-2 dir) 0.0)
+      )
+    )
+  (set! (-> obj path-index) 0)
+  (set! (-> obj continue-index) -1)
+  (let ((s5-3 (new 'stack-no-clear 'vector)))
+    (let ((s4-3 (-> obj path-info data 0 path)))
+      (get-point-in-path! s4-3 (-> obj root-override trans) 0.0 'interp)
+      (set! (-> obj root-override trans y) (+ 1024.0 (-> obj root-override trans y)))
+      (displacement-between-points-at-percent-normalized! s4-3 s5-3 0.0)
+      )
+    (set-heading-vec! (-> obj root-override) s5-3)
+    )
+  (let ((a0-46 (-> obj skel root-channel 0)))
+    (set! (-> a0-46 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-46 frame-num) 0.0)
+    (joint-control-channel-group! a0-46 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-identity)
+    )
+  (transform-post)
+  (let ((s5-4 (new 'stack-no-clear 'vector)))
+    (set-vector! s5-4 0.0 12541.952 -6778.88 1.0)
+    (set! (-> obj turret)
+          (ppointer->handle
+            (process-spawn
+              fort-robotank-turret
+              (-> obj root-override trans)
+              (-> obj root-override quat)
+              s5-4
+              #x42000000
+              :to obj
+              )
+            )
+          )
+    )
+  (set! (-> obj roller-jmod) (the-as joint-mod (new 'process 'joint-mod-spinner obj 5 *x-vector* 0.0)))
+  (set! (-> obj roller-spin-rate) 0.0)
+  (set! (-> obj vibe-jmod) (the-as joint-mod (new 'process 'joint-mod-blend-local obj 4 #t)))
+  (set! (-> obj vibe-jmod scale y) 0.5)
+  (quaternion-axis-angle! (the-as quaternion (-> obj vibe-jmod twist)) 0.0 0.0 1.0 0.0)
+  (let ((s5-5 (-> obj tread)))
+    (set! (-> s5-5 0 wheel 0 jmod) (new 'process 'joint-mod-spinner obj 6 *x-vector* 0.0))
+    (set! (-> s5-5 0 wheel 0 radius) 2048.0)
+    )
+  (let ((s5-6 (-> obj tread 0 wheel 1)))
+    (set! (-> s5-6 jmod) (new 'process 'joint-mod-spinner obj 7 *x-vector* 0.0))
+    (set! (-> s5-6 radius) 2048.0)
+    )
+  (let ((s5-7 (-> obj tread 0 wheel 2)))
+    (set! (-> s5-7 jmod) (new 'process 'joint-mod-spinner obj 8 *x-vector* 0.0))
+    (set! (-> s5-7 radius) 2048.0)
+    )
+  (let ((s5-8 (-> obj tread 0 wheel 3)))
+    (set! (-> s5-8 jmod) (new 'process 'joint-mod-spinner obj 9 *x-vector* 0.0))
+    (set! (-> s5-8 radius) 2048.0)
+    )
+  (let ((s5-9 (-> obj tread 0 wheel 4)))
+    (set! (-> s5-9 jmod) (new 'process 'joint-mod-spinner obj 10 *x-vector* 0.0))
+    (set! (-> s5-9 radius) 2048.0)
+    )
+  (let ((s5-10 (-> obj tread 0 wheel 5)))
+    (set! (-> s5-10 jmod) (new 'process 'joint-mod-spinner obj 11 *x-vector* 0.0))
+    (set! (-> s5-10 radius) 2048.0)
+    )
+  (let ((s5-11 (-> obj tread 0 wheel 6)))
+    (set! (-> s5-11 jmod) (new 'process 'joint-mod-spinner obj 12 *x-vector* 0.0))
+    (set! (-> s5-11 radius) 2048.0)
+    )
+  (let ((s5-12 (-> obj tread 1)))
+    (set! (-> s5-12 wheel 0 jmod) (new 'process 'joint-mod-spinner obj 13 *x-vector* 0.0))
+    (set! (-> s5-12 wheel 0 radius) 2048.0)
+    )
+  (let ((s5-13 (-> obj tread 1 wheel 1)))
+    (set! (-> s5-13 jmod) (new 'process 'joint-mod-spinner obj 14 *x-vector* 0.0))
+    (set! (-> s5-13 radius) 2048.0)
+    )
+  (let ((s5-14 (-> obj tread 1 wheel 2)))
+    (set! (-> s5-14 jmod) (new 'process 'joint-mod-spinner obj 15 *x-vector* 0.0))
+    (set! (-> s5-14 radius) 2048.0)
+    )
+  (let ((s5-15 (-> obj tread 1 wheel 3)))
+    (set! (-> s5-15 jmod) (new 'process 'joint-mod-spinner obj 16 *x-vector* 0.0))
+    (set! (-> s5-15 radius) 2048.0)
+    )
+  (let ((s5-16 (-> obj tread 1 wheel 4)))
+    (set! (-> s5-16 jmod) (new 'process 'joint-mod-spinner obj 17 *x-vector* 0.0))
+    (set! (-> s5-16 radius) 2048.0)
+    )
+  (let ((s5-17 (-> obj tread 1 wheel 5)))
+    (set! (-> s5-17 jmod) (new 'process 'joint-mod-spinner obj 18 *x-vector* 0.0))
+    (set! (-> s5-17 radius) 2048.0)
+    )
+  (let ((s5-18 (-> obj tread 1 wheel 6)))
+    (set! (-> s5-18 jmod) (new 'process 'joint-mod-spinner obj 19 *x-vector* 0.0))
+    (set! (-> s5-18 radius) 2048.0)
+    )
+  ;; (set! (-> obj tread 0 texture) (-> *fortress-pris-texture-anim-array* array-data 0))
+  ;; (set! (-> obj tread 0 texture frame-delta) 0.0)
+  (let ((v1-128 9))
+    (set! (-> obj tread 0 locator-joint) v1-128)
+    (vector<-cspace! (-> obj tread 0 pos) (-> obj node-list data v1-128))
+    )
+  ;; (set! (-> obj tread 1 texture) (-> *fortress-pris-texture-anim-array* array-data 1))
+  ;; (set! (-> obj tread 1 texture frame-delta) 0.0)
+  (let ((v1-135 16))
+    (set! (-> obj tread 1 locator-joint) v1-135)
+    (vector<-cspace! (-> obj tread 1 pos) (-> obj node-list data v1-135))
+    )
+  (set-vector! (-> obj pov-cam-offset 0) 0.0 13516.8 -13516.8 1.0)
+  (set-vector! (-> obj pov-cam-offset 1) 0.0 13516.8 -13516.8 1.0)
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 561) obj))
+  (set! (-> obj barrel-part) (create-launch-control (-> *part-group-id-table* 562) obj))
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "robotank-tread" :fo-max 70) (-> obj root-override trans))
+        )
+  (set! (-> obj idle-sound)
+        (new 'process 'ambient-sound (static-sound-spec "robotank-idle" :fo-max 50) (-> obj root-override trans))
+        )
+  (set! (-> obj barrel-sound)
+        (new 'process 'ambient-sound (static-sound-spec "robotank-barrel" :fo-max 50) (-> obj root-override trans))
+        )
+  (update-vol! (-> obj sound) 0.0)
+  (update-vol! (-> obj idle-sound) 1.0)
+  (update-vol! (-> obj barrel-sound) 0.25)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/goal_src/jak2/levels/fortress/fort-turret.gc b/goal_src/jak2/levels/fortress/fort-turret.gc
index 8bba29745c..f8e1028e8c 100644
--- a/goal_src/jak2/levels/fortress/fort-turret.gc
+++ b/goal_src/jak2/levels/fortress/fort-turret.gc
@@ -5,5 +5,1120 @@
 ;; name in dgo: fort-turret
 ;; dgos: FDA, FRB
 
+
 ;; DECOMP BEGINS
 
+(defpartgroup group-fort-turret-hit
+  :id 685
+  :duration (seconds 3)
+  :linger-duration (seconds 1)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 3049 :period 1500 :length 25 :offset -10)
+    (sp-item 3050 :fade-after (meters 60) :period 1500 :length 30)
+    (sp-item 3051 :fade-after (meters 60) :falloff-to (meters 60) :period 1500 :length 100)
+    (sp-item 3052 :fade-after (meters 200) :falloff-to (meters 200) :period 1500 :length 50)
+    (sp-item 3053 :period 1500 :length 5 :offset -10)
+    (sp-item 3054 :fade-after (meters 150) :falloff-to (meters 150) :period 1500 :length 50)
+    )
+  )
+
+(defpart 3052
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-rot-z)
+      :flags (sp-flag spflag7)
+      :random-rangef 65536.0
+      :random-multf 1.0
+      )
+    (sp-rnd-flt spt-scale-y (meters 0.8) (meters 0.2) 1.0)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.13333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.36)
+    (sp-flt spt-fade-b -4.24)
+    (sp-flt spt-fade-a -0.22068965)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 25 4 1)
+    (sp-launcher-by-id spt-next-launcher 3055)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-conerot-x)
+      :flags (sp-flag from-pointer)
+      :func '*sp-temp*
+      )
+    )
+  )
+
+(defpart 3054
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (sp-flt spt-rot-z (degrees 0.0))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 0.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.13333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.36)
+    (sp-flt spt-fade-b -4.24)
+    (sp-flt spt-fade-a 0.22068965)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 25 4 1)
+    (sp-launcher-by-id spt-next-launcher 3055)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 3055
+  :init-specs ((sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b 0.0)
+    (sp-int-plain-rnd spt-next-time 5 19 1)
+    (sp-launcher-by-id spt-next-launcher 3056)
+    )
+  )
+
+(defpart 3056
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.016666668) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.44)
+    (sp-flt spt-fade-g -2.36)
+    (sp-flt spt-fade-b -2.64)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 3057)
+    )
+  )
+
+(defpart 3057
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.008333334) (meters 0.008333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.2944444)
+    (sp-flt spt-fade-g -0.7111111)
+    (sp-flt spt-fade-b -0.094444446)
+    (sp-rnd-flt spt-fade-a -0.06545454 -0.06545454 1.0)
+    (sp-int-plain-rnd spt-next-time 150 29 1)
+    (sp-launcher-by-id spt-next-launcher 3058)
+    )
+  )
+
+(defpart 3058
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g 0.0) (sp-flt spt-fade-b 0.0))
+  )
+
+(defpart 3053
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x47 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 5))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 96.0)
+    (sp-flt spt-scalevel-x (meters 0.5))
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -1.28)
+    (sp-flt spt-fade-b -5.1)
+    (sp-flt spt-fade-a 0.0)
+    (sp-int spt-timer 100)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-int spt-next-time 50)
+    (sp-launcher-by-id spt-next-launcher 3059)
+    )
+  )
+
+(defpart 3059
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -2.56)
+    (sp-flt spt-fade-b 0.0)
+    (sp-flt spt-fade-a -1.92)
+    )
+  )
+
+(defpart 3051
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 5.0 3.0 1.0)
+    (sp-flt spt-x (meters 0.25))
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.25) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 16.0 48.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.083333336) (meters 0.083333336) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.18)
+    (sp-flt spt-fade-b -2.12)
+    (sp-rnd-flt spt-accel-y -0.68266666 -1.3653333 1.0)
+    (sp-flt spt-friction 0.87)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 3060)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 3060
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0016666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.02)
+    (sp-flt spt-fade-b 0.23555556)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 3061)
+    )
+  )
+
+(defpart 3061
+  :init-specs ((sp-flt spt-fade-r -0.5543478) (sp-flt spt-fade-g -0.5543478) (sp-flt spt-fade-a -0.13913043))
+  )
+
+(defpart 3049
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 3.0 1.0 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 0.6) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1.5) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 70.0 20.0 1.0)
+    (sp-rnd-flt spt-g 70.0 20.0 1.0)
+    (sp-rnd-flt spt-b 70.0 20.0 1.0)
+    (sp-rnd-flt spt-a 0.0 40.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.033333335) (meters 0.016666668) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 3.3)
+    (sp-flt spt-fade-g 3.12)
+    (sp-flt spt-fade-b 1.18)
+    (sp-flt spt-fade-a 1.76)
+    (sp-flt spt-friction 0.88)
+    (sp-int spt-timer 710)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 3062)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+(defpart 3062
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.53333336)
+    (sp-flt spt-fade-g -1.9666667)
+    (sp-flt spt-fade-b -2.2)
+    (sp-flt spt-fade-a -0.41666666)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 3063)
+    )
+  )
+
+(defpart 3063
+  :init-specs ((sp-flt spt-scalevel-x (meters 0))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.38833332)
+    (sp-flt spt-fade-g -0.21333334)
+    (sp-flt spt-fade-b -0.028333334)
+    (sp-flt spt-fade-a -0.38833332)
+    )
+  )
+
+(defpart 3050
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x31 :page #xc))
+    (sp-rnd-flt spt-num 4.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.25) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-r 128.0 128.0 1.0)
+    (sp-flt spt-g 96.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.13333334) (meters 0.02) 1.0)
+    (sp-flt spt-fade-g 1.6)
+    (sp-flt spt-fade-b 3.2)
+    (sp-flt spt-fade-a -1.6)
+    (sp-int spt-timer 80)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    )
+  )
+
+(defpart 3064
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x9b :page #xb))
+    (sp-func spt-birth-func 'birth-func-laser-pointer)
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.05) 1.0)
+    (sp-flt spt-scale-y (meters 40))
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 20.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14 left-multiply-quat)
+    )
+  )
+
+(defpart 3065
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbc :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.15) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 1.0)
+    )
+  )
+
+(defpart 3066
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.25) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 128.0 1.0)
+    (sp-flt spt-g 0.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 48.0 16.0 1.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 1.0)
+    )
+  )
+
+(defpart 3067
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbc :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.025) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 128.0 1.0)
+    (sp-flt spt-g 32.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-flt spt-fade-g -1.0666667)
+    (sp-flt spt-fade-b -1.0666667)
+    (sp-flt spt-fade-a -8.533334)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    )
+  )
+
+(defun fort-turret-draw-laser-spot ((arg0 vector) (arg1 object) (arg2 symbol))
+  (new 'stack-no-clear 'vector)
+  (cond
+    (arg2
+      (let ((t9-0 sp-launch-particles-var)
+            (a0-1 *sp-particle-system-2d*)
+            (a1-1 (-> *part-id-table* 3066))
+            (a2-1 *launch-matrix*)
+            )
+        (set! (-> a2-1 trans quad) (-> arg0 quad))
+        (t9-0 a0-1 a1-1 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      (let ((t9-1 sp-launch-particles-var)
+            (a0-2 *sp-particle-system-2d*)
+            (a1-2 (-> *part-id-table* 3065))
+            (a2-2 *launch-matrix*)
+            )
+        (set! (-> a2-2 trans quad) (-> arg0 quad))
+        (t9-1 a0-2 a1-2 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      )
+    (else
+      (let ((t9-2 sp-launch-particles-var)
+            (a0-3 *sp-particle-system-2d*)
+            (a1-3 (-> *part-id-table* 3067))
+            (a2-3 *launch-matrix*)
+            )
+        (set! (-> a2-3 trans quad) (-> arg0 quad))
+        (t9-2 a0-3 a1-3 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(defun fort-turret-draw-laser ((arg0 vector) (arg1 vector))
+  (let* ((s4-0 (-> *part-id-table* 3064))
+         (s3-0 (get-field-spec-by-id s4-0 (sp-field-id spt-scale-x)))
+         (f30-0 (-> s3-0 initial-valuef))
+         (f28-0 (-> s3-0 random-rangef))
+         )
+    (let ((f0-4 (fmin 1.0 (fmax 0.0 (* 0.000015287453 (+ -122.88 (vector-vector-distance (camera-pos) arg0)))))))
+      (set! (-> s3-0 initial-valuef) (* f30-0 f0-4))
+      (set! (-> s3-0 random-rangef) (* f28-0 f0-4))
+      )
+    (draw-beam s4-0 arg0 (vector-! (new 'stack-no-clear 'vector) arg1 arg0) #t #t)
+    (set! (-> s3-0 initial-valuef) f30-0)
+    (set! (-> s3-0 random-rangef) f28-0)
+    )
+  0
+  (none)
+  )
+
+(defskelgroup skel-fort-turret fort-turret 0 4
+              ((1 (meters 999999)))
+              :bounds (static-spherem 8 11.25 0 16.5)
+              :shadow 3
+              :origin-joint-index 3
+              :shadow-joint-index 3
+              )
+
+(defskelgroup skel-fort-turret-explode fort-turret 7 9
+              ((8 (meters 999999)))
+              :bounds (static-spherem 0 0 0 15)
+              )
+
+(define *fort-turret-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 13 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 14 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 15 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 16 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    )
+  )
+
+(deftype fort-turret (enemy)
+  ((gun-tilt-jm     joint-mod           :offset-assert 532)
+   (gun-shadow-jm   joint-mod           :offset-assert 536)
+   (aim-pos         vector      :inline :offset-assert 544)
+   (target-bullseye vector      :inline :offset-assert 560)
+   (gun-twist       float               :offset-assert 576)
+   (gun-tilt        float               :offset-assert 580)
+   (desired-twist   float               :offset-assert 584)
+   (desired-tilt    float               :offset-assert 588)
+   (los-clear       basic               :offset-assert 592)
+   (flash-state     basic               :offset-assert 596)
+   (flash-index     uint32              :offset-assert 600)
+   (can-shoot       symbol              :offset-assert 604)
+   (last-hit-time   time-frame          :offset-assert 608)
+   (init-mat        matrix      :inline :offset-assert 624)
+   (target-timeout  uint64              :offset-assert 688)
+   (beam-intersect  basic               :offset-assert 696)
+   (sync            sync-linear :inline :offset-assert 704)
+   (invincible      symbol              :offset-assert 720)
+   )
+  :heap-base #x260
+  :method-count-assert 143
+  :size-assert         #x2d4
+  :flag-assert         #x8f026002d4
+  (:methods
+    (attack () _type_ :state 137)
+    (sweep () _type_ :state 138)
+    (fort-turret-method-139 (_type_) none 139)
+    (fort-turret-method-140 (_type_ float float) quaternion 140)
+    (fort-turret-method-141 (_type_) vector 141)
+    (fort-turret-method-142 (_type_ symbol int) symbol 142)
+    )
+  )
+
+(defmethod coin-flip? fort-turret ((obj fort-turret))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+(define *fort-turret-enemy-info* (new 'static 'enemy-info
+                                   :use-die-falling #f
+                                   :use-victory #f
+                                   :use-jump-blocked #f
+                                   :debug-draw-neck #f
+                                   :jump-debug-draw #f
+                                   :move-to-ground #f
+                                   :hover-if-no-ground #f
+                                   :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+                                   :idle-anim 4
+                                   :notice-anim 4
+                                   :hostile-anim 4
+                                   :hit-anim 4
+                                   :knocked-anim -1
+                                   :knocked-land-anim -1
+                                   :die-anim 4
+                                   :die-falling-anim -1
+                                   :victory-anim -1
+                                   :jump-wind-up-anim -1
+                                   :jump-in-air-anim -1
+                                   :jump-land-anim -1
+                                   :neck-joint -1
+                                   :notice-distance (meters 150)
+                                   :notice-distance-delta (meters 10)
+                                   :proximity-notice-distance (meters 150)
+                                   :default-hit-points 1
+                                   :gnd-collide-with (collide-spec backgnd)
+                                   :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+                                   :movement-gravity (meters -100)
+                                   :friction 0.8
+                                   :attack-shove-back (meters 3)
+                                   :attack-shove-up (meters 2)
+                                   :attack-mode 'generic
+                                   :attack-damage 2
+                                   :jump-height-min (meters 3)
+                                   :jump-height-factor 0.5
+                                   :knocked-seek-ry-clamp 2730.6667
+                                   :knocked-soft-vxz-lo 72089.6
+                                   :knocked-soft-vxz-hi 108134.4
+                                   :knocked-soft-vy-lo 81920.0
+                                   :knocked-soft-vy-hi 122880.0
+                                   :knocked-medium-vxz-lo 147456.0
+                                   :knocked-medium-vxz-hi 196608.0
+                                   :knocked-medium-vy-lo 135168.0
+                                   :knocked-medium-vy-hi 151552.0
+                                   :knocked-hard-vxz-lo 78643.2
+                                   :knocked-hard-vxz-hi 117964.8
+                                   :knocked-hard-vy-lo 183500.8
+                                   :knocked-hard-vy-hi 209715.2
+                                   :knocked-huge-vxz-lo 164659.2
+                                   :knocked-huge-vxz-hi 249036.8
+                                   :knocked-huge-vy-lo 183500.8
+                                   :knocked-huge-vy-hi 217907.2
+                                   :knocked-yellow-vxz-lo 40960.0
+                                   :knocked-yellow-vxz-hi 49152.0
+                                   :knocked-yellow-vy-lo 57344.0
+                                   :knocked-yellow-vy-hi 81920.0
+                                   :knocked-red-vxz-lo 24576.0
+                                   :knocked-red-vxz-hi 196608.0
+                                   :knocked-red-vy-lo 94208.0
+                                   :knocked-red-vy-hi 151552.0
+                                   :knocked-blue-vxz-lo 40960.0
+                                   :knocked-blue-vxz-hi 49152.0
+                                   :knocked-blue-vy-lo 24576.0
+                                   :knocked-blue-vy-hi 81920.0
+                                   :shadow-size (meters 1)
+                                   :shadow-max-y (meters 1)
+                                   :shadow-min-y (meters -1)
+                                   :shadow-locus-dist (meters 150)
+                                   :gem-joint -1
+                                   :gem-offset (new 'static 'sphere :r 163840.0)
+                                   )
+        )
+
+(set! (-> *fort-turret-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+(defmethod enemy-method-55 fort-turret ((obj fort-turret))
+  (let ((t9-0 (method-of-type enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (let ((s5-0 (-> obj root-override2)))
+    (update-transforms s5-0)
+    (pull-riders! s5-0)
+    (do-push-aways s5-0)
+    )
+  (when (not (and (-> obj next-state) (= (-> obj next-state name) 'die)))
+    (let ((a0-7 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 12))))
+      (fort-turret-draw-laser a0-7 (-> obj target-bullseye))
+      )
+    (case (-> obj beam-intersect)
+      (('target)
+       (fort-turret-draw-laser-spot (-> obj target-bullseye) #f #t)
+       )
+      (('wall)
+       (fort-turret-draw-laser-spot (-> obj target-bullseye) #f #f)
+       )
+      )
+    )
+  (none)
+  )
+
+;; WARN: Return type mismatch quaternion vs none.
+(defmethod fort-turret-method-139 fort-turret ((obj fort-turret))
+  (let ((a0-2 (handle->process (-> obj focus handle))))
+    (if a0-2
+        (set! (-> obj aim-pos quad) (-> (get-trans (the-as process-focusable a0-2) 3) quad))
+        )
+    )
+  (let ((s4-0 (new 'stack-no-clear 'vector))
+        (s5-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 4)))
+        )
+    (let ((s3-0 (new 'stack-no-clear 'vector)))
+      (vector-! s4-0 (-> obj aim-pos) (-> obj root-override2 trans))
+      (vector-flatten! s4-0 s4-0 (-> obj init-mat vector 1))
+      (vector-normalize! s4-0 1.0)
+      (set! (-> obj desired-twist) (asin (vector-dot (the-as vector (-> obj init-mat)) s4-0)))
+      (set! (-> obj desired-twist) (fmin 9102.223 (fmax -9102.223 (-> obj desired-twist))))
+      (cond
+        ((< 0.0 (vector-dot (-> obj init-mat vector 2) s4-0))
+         )
+        ((< (-> obj desired-twist) 0.0)
+         (set! (-> obj desired-twist) -9102.223)
+         )
+        (else
+          (set! (-> obj desired-twist) 9102.223)
+          )
+        )
+      (set! (-> obj desired-tilt) 0.0)
+      (when (< (fabs (-> obj desired-twist)) 9102.223)
+        (vector-normalize-copy! s3-0 (-> obj node-list data 3 bone transform vector 1) 1.0)
+        (vector-! s4-0 (-> obj aim-pos) s5-2)
+        (set! (-> obj desired-tilt)
+              (- (atan 8192.0 (vector-normalize-ret-len! s4-0 1.0)) (asin (vector-dot s3-0 s4-0)))
+              )
+        (set! (-> obj desired-tilt) (fmin 8192.0 (fmax -8192.0 (-> obj desired-tilt))))
+        )
+      )
+    (vector-normalize-copy!
+      (-> obj aim-pos)
+      (-> obj node-list data 4 bone transform vector 2)
+      (vector-vector-distance s5-2 (-> obj aim-pos))
+      )
+    )
+  (vector+!
+    (-> obj aim-pos)
+    (-> obj aim-pos)
+    (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 7))
+    )
+  (fort-turret-method-140 obj 0.3 364.0889)
+  (none)
+  )
+
+(defmethod fort-turret-method-140 fort-turret ((obj fort-turret) (arg0 float) (arg1 float))
+  (rider-trans)
+  (let ((s3-0 (new 'stack-no-clear 'matrix)))
+    (+! (-> obj gun-twist) (fmax (- arg1) (fmin arg1 (* arg0 (- (-> obj desired-twist) (-> obj gun-twist))))))
+    (matrix-rotate-y! s3-0 (-> obj gun-twist))
+    (matrix*! s3-0 s3-0 (-> obj init-mat))
+    (matrix->quaternion (-> obj root-override2 quat) s3-0)
+    )
+  (+! (-> obj gun-tilt) (fmax (- arg1) (fmin arg1 (* arg0 (- (-> obj desired-tilt) (-> obj gun-tilt))))))
+  (quaternion-axis-angle! (-> obj gun-tilt-jm quat) 1.0 0.0 0.0 (-> obj gun-tilt))
+  )
+
+(defmethod fort-turret-method-141 fort-turret ((obj fort-turret))
+  (with-pp
+    (let* ((s5-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 12)))
+           (v1-3
+             (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> obj node-list data 12 bone transform vector 2) 1.0)
+             )
+           (s4-1 (vector-float*! (new 'stack-no-clear 'vector) v1-3 163840.0))
+           )
+      (let ((s3-0 (new 'stack-no-clear 'collide-query)))
+        (set! (-> s3-0 start-pos quad) (-> s5-0 quad))
+        (set! (-> s3-0 move-dist quad) (-> s4-1 quad))
+        (let ((v1-6 s3-0))
+          (set! (-> v1-6 radius) 409.6)
+          (set! (-> v1-6 collide-with)
+                (collide-spec backgnd jak crate obstacle hit-by-player-list hit-by-others-list player-list pusher)
+                )
+          (set! (-> v1-6 ignore-process0) obj)
+          (set! (-> v1-6 ignore-process1) #f)
+          (set! (-> v1-6 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-6 action-mask) (collide-action solid))
+          )
+        (let ((f30-0 (fill-and-probe-using-line-sphere *collide-cache* s3-0)))
+          (cond
+            ((>= f30-0 0.0)
+             (set! (-> obj beam-intersect) (the-as basic 'wall))
+             (when (-> s3-0 best-other-tri collide-ptr)
+               (let* ((s3-1 (-> s3-0 best-other-tri collide-ptr))
+                      (a0-14 (if (type? s3-1 collide-shape-prim)
+                                 (the-as collide-shape-prim s3-1)
+                                 )
+                             )
+                      )
+                 (when a0-14
+                   (when (= (-> a0-14 cshape process type) target)
+                     (set! (-> obj target-timeout) (the-as uint (-> pp clock frame-counter)))
+                     (set! (-> obj beam-intersect) (the-as basic 'target))
+                     )
+                   )
+                 )
+               )
+             (vector-float*! s4-1 s4-1 f30-0)
+             (let ((s3-3 (vector+! (new 'stack-no-clear 'vector) s5-0 s4-1))
+                   (a0-21 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 10)))
+                   (v1-23 (-> obj gun-shadow-jm twist-max))
+                   )
+               (set! (-> v1-23 z)
+                     (+ 2.0 (* 0.00024414062 (vector-length (vector-! (new 'stack-no-clear 'vector) s3-3 a0-21))))
+                     )
+               (if (= (-> obj beam-intersect) 'wall)
+                   (set! (-> v1-23 z) (+ -5.0 (-> v1-23 z)))
+                   )
+               )
+             )
+            (else
+              (set! (-> obj beam-intersect) (the-as basic 'nothing))
+              )
+            )
+          )
+        )
+      (vector+! (-> obj target-bullseye) s5-0 s4-1)
+      )
+    )
+  )
+
+(defmethod fort-turret-method-142 fort-turret ((obj fort-turret) (arg0 symbol) (arg1 int))
+  (let ((v1-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data arg1)))
+        (s4-0 (new 'stack-no-clear 'projectile-init-by-other-params))
+        )
+    (let* ((s2-1 (vector-! (new 'stack-no-clear 'vector) (-> obj aim-pos) v1-2))
+           (f30-0 (/ 2013265900.0 (vector-length s2-1)))
+           (s3-0 (new 'stack-no-clear 'vector))
+           )
+      (set! (-> s4-0 ent) (-> obj entity))
+      (set! (-> s4-0 charge) 1.0)
+      (set! (-> s4-0 options) (projectile-options))
+      (set! (-> s4-0 pos quad) (-> v1-2 quad))
+      (set! (-> s4-0 notify-handle) (process->handle obj))
+      (set! (-> s4-0 owner-handle) (the-as handle #f))
+      (set! (-> s4-0 ignore-handle) (process->handle obj))
+      (let* ((v1-10 *game-info*)
+             (a0-18 (+ (-> v1-10 attack-id) 1))
+             )
+        (set! (-> v1-10 attack-id) a0-18)
+        (set! (-> s4-0 attack-id) a0-18)
+        )
+      (set! (-> s4-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-normalize-copy! (-> s4-0 vel) s2-1 491520.0)
+      (let ((f30-1 (fmin 16384.0 f30-0)))
+        (set-vector! s3-0 (-> s2-1 z) (-> s2-1 y) (- (-> s2-1 x)) 1.0)
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        (vector+! (-> s4-0 vel) (-> s4-0 vel) s3-0)
+        (vector-cross! s3-0 s3-0 (-> s4-0 vel))
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        )
+      (vector+! (-> s4-0 vel) (-> s4-0 vel) s3-0)
+      )
+    (spawn-projectile guard-shot s4-0 obj *default-dead-pool*)
+    )
+  (sound-play "turret-shot")
+  (if arg0
+      (sound-play "gtur-shot-fire")
+      )
+  (let ((v0-11 #t))
+    (set! (-> obj flash-state) (the-as basic v0-11))
+    v0-11
+    )
+  )
+
+(defstate attack (fort-turret)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior fort-turret) enemy-event-handler)
+  :exit (behavior ()
+    (set! (-> self flash-state) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory))
+        (go-virtual victory)
+        )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+      (if (>= 2 (the-as int (-> self focus aware)))
+          (go-stare self)
+          )
+      )
+    (set! (-> self root-override2 penetrated-by) (enemy-method-59 self))
+    (fort-turret-method-141 self)
+    (if (or (>= (- (-> self clock frame-counter) (the-as int (-> self target-timeout))) (seconds 0.5))
+            (< (- (-> self clock frame-counter) (-> self last-hit-time)) (seconds 2))
+            )
+        (go-virtual hostile)
+        )
+    (fort-turret-method-139 self)
+    (none)
+    )
+  :code (behavior ()
+    (sound-play "turret-up")
+    (ja-no-eval :group! (-> self draw art-group data 6)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 6)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (until #f
+      (let ((gp-2 7))
+        (sound-play "gturret")
+        (dotimes (s5-2 3)
+          (cond
+            ((not (-> self can-shoot))
+             )
+            (else
+              (fort-turret-method-142 self #t gp-2)
+              )
+            )
+          (ja-no-eval :group! (-> self draw art-group data 5)
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          (let ((s4-1 (-> self clock frame-counter)))
+            (until (>= (- (-> self clock frame-counter) s4-1) (seconds 0.33))
+              (suspend)
+              )
+            )
+          (if (= gp-2 7)
+              (set! gp-2 8)
+              (set! gp-2 9)
+              )
+          )
+        )
+      (set! (-> self flash-state) #f)
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 1.5))
+          (suspend)
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (when (-> self flash-state)
+      (set-fordumpa-turret-flash! (the-as int (-> self flash-index)))
+      (set-forrescb-turret-flash! (the-as int (-> self flash-index)))
+      )
+    (enemy-simple-post)
+    (none)
+    )
+  )
+
+(defstate sweep (fort-turret)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior fort-turret) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory))
+        (go-virtual victory)
+        )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+      (if (>= 2 (the-as int (-> self focus aware)))
+          (go-stare self)
+          )
+      )
+    (set! (-> self root-override2 penetrated-by) (enemy-method-59 self))
+    (set! (-> self desired-twist) (* 8192.0 (cos (get-scaled-val! (-> self sync) 32768.0 0))))
+    (fort-turret-method-140 self 0.1 91.022224)
+    (fort-turret-method-141 self)
+    (if (and (< (- (-> self clock frame-counter) (the-as int (-> self target-timeout))) (seconds 0.5))
+             (>= (- (-> self clock frame-counter) (-> self last-hit-time)) (seconds 2))
+             )
+        (go-virtual attack)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (sleep-code)
+    (none)
+    )
+  :post (the-as (function none :behavior fort-turret) enemy-simple-post)
+  )
+
+(defstate hostile (fort-turret)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self desired-tilt) 0.0)
+    (set! (-> self desired-twist) 0.0)
+    (ja-channel-push! 1 (seconds 0.5))
+    (ja :group! (-> self draw art-group data 4))
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory))
+        (go-virtual victory)
+        )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+      (if (>= 2 (the-as int (-> self focus aware)))
+          (go-stare self)
+          )
+      )
+    (set! (-> self root-override2 penetrated-by) (enemy-method-59 self))
+    (fort-turret-method-141 self)
+    (if (and (< (- (-> self clock frame-counter) (the-as int (-> self target-timeout))) (seconds 0.5))
+             (>= (- (-> self clock frame-counter) (-> self last-hit-time)) (seconds 2))
+             )
+        (go-virtual attack)
+        )
+    (set! (-> self desired-twist) (* 8192.0 (cos (get-scaled-val! (-> self sync) 32768.0 0))))
+    (fort-turret-method-140 self 0.1 91.022224)
+    (if (and (< (fabs (-> self gun-twist)) 364.0889) (< (fabs (-> self gun-tilt)) 364.0889))
+        (go-virtual sweep)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (sleep-code)
+    (none)
+    )
+  )
+
+(defmethod enemy-method-74 fort-turret ((obj fort-turret) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (if (and (= arg2 'notify) (< 1 (the-as int arg1)) (= (-> arg3 param 0) 'attack) (= (-> arg3 param 1) *target*))
+        (set! (-> obj last-hit-time) (-> pp clock frame-counter))
+        )
+    (case arg2
+      (('start)
+       (let ((v0-0 (the-as object #t)))
+         (set! (-> obj can-shoot) (the-as symbol v0-0))
+         v0-0
+         )
+       )
+      (('stop)
+       (set! (-> obj can-shoot) #f)
+       #f
+       )
+      (('attack)
+       (cond
+         ((= (-> arg0 type) target)
+          #f
+          )
+         ((-> obj invincible)
+          #f
+          )
+         (else
+           ((method-of-type enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+           )
+         )
+       )
+      (else
+        ((method-of-type enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+(defstate die (fort-turret)
+  :virtual #t
+  :enter (behavior ()
+    (enemy-method-132 self)
+    (let ((v1-3 (-> self root-override2 root-prim)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec))
+      )
+    0
+    (set! (-> self hit-points) 0)
+    0
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-fort-turret-explode" (the-as (pointer uint32) #f))
+        9
+        gp-0
+        *fort-turret-exploder-params*
+        :to self
+        )
+      )
+    (activate! *camera-smush-control* 409.6 18 210 1.0 0.995 (-> self clock))
+    (sound-play "turret-explode")
+    (suspend)
+    (ja-channel-set! 0)
+    (let ((gp-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 4)))
+          (s5-2 (-> self clock frame-counter))
+          )
+      (until (>= (- (-> self clock frame-counter) s5-2) (seconds 2))
+        (spawn (-> self part) gp-2)
+        (suspend)
+        )
+      )
+    (let ((gp-3 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-3) (seconds 1))
+        (suspend)
+        )
+      )
+    (send-event self 'death-end)
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  :post (behavior ()
+    (enemy-method-55 self)
+    (none)
+    )
+  )
+
+
+;; WARN: Return type mismatch int vs penetrate.
+(defmethod enemy-method-59 fort-turret ((obj fort-turret))
+  (the-as penetrate 0)
+  )
+
+(defmethod enemy-method-114 fort-turret ((obj fort-turret))
+  "@abstract"
+  (stack-size-set! (-> obj main-thread) 512)
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 3) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 4))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 4)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 36864.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-17 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-17 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-17 transform-index) 6)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 5120.0 14336.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-19 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-19 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-19 transform-index) 5)
+      (set-vector! (-> v1-19 local-sphere) 0.0 6144.0 0.0 12288.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-21 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-21 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-21 transform-index) 3)
+      (set-vector! (-> v1-21 local-sphere) 0.0 24576.0 0.0 24576.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+
+;; WARN: Return type mismatch enemy vs fort-turret.
+(defmethod relocate fort-turret ((obj fort-turret) (arg0 int))
+  (if (nonzero? (-> obj gun-tilt-jm))
+      (&+! (-> obj gun-tilt-jm) arg0)
+      )
+  (if (nonzero? (-> obj gun-shadow-jm))
+      (&+! (-> obj gun-shadow-jm) arg0)
+      )
+  (the-as fort-turret ((method-of-type enemy relocate) obj arg0))
+  )
+
+(defmethod enemy-method-115 fort-turret ((obj fort-turret))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-turret" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *fort-turret-enemy-info*)
+  (set! (-> obj invincible) #f)
+  (if (logtest? (the-as int (res-lump-value (-> obj entity) 'enemy-options uint128 :time -1000000000.0)) 1)
+      (set! (-> obj invincible) #t)
+      )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logclear! (-> obj enemy-flags) (enemy-flag notice))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 685) obj))
+  (set! (-> obj gun-tilt-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 4))
+  (set! (-> obj gun-shadow-jm) (the-as joint-mod (new 'process 'joint-mod-set-local obj 10 #f #f #t)))
+  (set! (-> obj gun-shadow-jm twist-min-y) (the-as float #t))
+  (set! (-> obj los-clear) #f)
+  (set! (-> obj gun-twist) 0.0)
+  (set! (-> obj gun-tilt) 0.0)
+  (set! (-> obj desired-twist) 0.0)
+  (set! (-> obj desired-tilt) 0.0)
+  (set! (-> obj flash-state) #f)
+  (set! (-> obj can-shoot) #t)
+  (set! (-> obj last-hit-time) 0)
+  (set! (-> obj target-timeout) (the-as uint 0))
+  (let ((a1-7 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-21 0))
+      (if #t
+          (set! v1-21 (logior v1-21 1))
+          )
+      (set! (-> a1-7 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-7 sync-flags) (the-as sync-flags v1-21))
+      )
+    (set! (-> a1-7 entity) (-> obj entity))
+    (set! (-> a1-7 period) (the-as uint 3000))
+    (set! (-> a1-7 percent) 0.0)
+    (initialize! (-> obj sync) a1-7)
+    )
+  (set! (-> obj flash-index) (res-lump-value (-> obj entity) 'extra-id uint :time -1000000000.0))
+  (quaternion->matrix (-> obj init-mat) (-> obj root-override2 quat))
+  (set-vector! (-> obj gun-shadow-jm twist-max) 2.0 1.0 10.0 1.0)
+  (let ((v1-32 (new 'static 'shadow-control :settings (new 'static 'shadow-settings
+                                                        :flags (shadow-flags shdf02 shdf03 shdf04 shdf07)
+                                                        :shadow-dir (new 'static 'vector :y -1.0 :w -983040.0)
+                                                        :bot-plane (new 'static 'plane :y -1.0 :w 32358.4)
+                                                        :top-plane (new 'static 'plane :y -1.0 :w 49152.0)
+                                                        :fade-dist 409600.0
+                                                        )
+                                            )
+               )
+        )
+    (-> v1-32 settings)
+    (set! (-> v1-32 settings shadow-type) 1)
+    (set! (-> obj draw shadow-ctrl) v1-32)
+    )
+  0
+  (none)
+  )
diff --git a/goal_src/jak2/levels/hideout/hideout-obs.gc b/goal_src/jak2/levels/hideout/hideout-obs.gc
index 12417582a9..39778a79b9 100644
--- a/goal_src/jak2/levels/hideout/hideout-obs.gc
+++ b/goal_src/jak2/levels/hideout/hideout-obs.gc
@@ -117,7 +117,7 @@
       (lambda :behavior hide-light
         ()
         (let ((v0-0 (-> self node-list data)))
-          (set! (-> v0-0 0 param0) (the-as (function cspace matrix none) cspace<-parent-joint!))
+          (set! (-> v0-0 0 param0) (the-as (function cspace transformq none) cspace<-parent-joint!))
           (set! (-> v0-0 0 param1) (the-as basic (-> self parent)))
           (set! (-> v0-0 0 param2) (the-as basic 12))
           v0-0
diff --git a/test/decompiler/reference/jak2/engine/ai/enemy_REF.gc b/test/decompiler/reference/jak2/engine/ai/enemy_REF.gc
index 066e985f9f..856f3ad142 100644
--- a/test/decompiler/reference/jak2/engine/ai/enemy_REF.gc
+++ b/test/decompiler/reference/jak2/engine/ai/enemy_REF.gc
@@ -1102,7 +1102,7 @@
   (local-vars (sv-16 res-tag))
   (when (coin-flip? obj)
     (let ((a0-2 (-> obj node-list data 2)))
-      (set! (-> a0-2 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint-flip-z!))
+      (set! (-> a0-2 param0) (the-as (function cspace transformq none) cspace<-parented-matrix-joint-flip-z!))
       (set! (-> a0-2 param1) #f)
       (set! (-> a0-2 param2) #f)
       )
diff --git a/test/decompiler/reference/jak2/engine/anim/joint-mod-h_REF.gc b/test/decompiler/reference/jak2/engine/anim/joint-mod-h_REF.gc
index 26b97b0d13..35ed9a2159 100644
--- a/test/decompiler/reference/jak2/engine/anim/joint-mod-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/anim/joint-mod-h_REF.gc
@@ -248,7 +248,7 @@
     (set! (-> v0-0 angle) 0.0)
     (set-vector! (-> v0-0 last-position) 0.0 0.0 0.0 1.0)
     (let ((a0-3 (-> arg0 node-list data arg1)))
-      (set! (-> a0-3 param0) (the-as (function cspace matrix none) joint-mod-wheel-callback))
+      (set! (-> a0-3 param0) joint-mod-wheel-callback)
       (set! (-> a0-3 param1) v0-0)
       )
     v0-0
@@ -331,7 +331,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-set-local-callback))
+      (set! (-> a0-8 param0) joint-mod-set-local-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -408,7 +408,7 @@
     (quaternion-copy! (-> gp-0 transform quat) *unity-quaternion*)
     (set! (-> gp-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-7 (-> arg0 node-list data arg1)))
-      (set! (-> a0-7 param0) (the-as (function cspace matrix none) joint-mod-add-local-callback))
+      (set! (-> a0-7 param0) joint-mod-add-local-callback)
       (set! (-> a0-7 param1) gp-0)
       )
     gp-0
@@ -464,7 +464,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-set-world-callback))
+      (set! (-> a0-8 param0) joint-mod-set-world-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -537,7 +537,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-blend-local-callback))
+      (set! (-> a0-8 param0) joint-mod-blend-local-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -604,7 +604,7 @@
     (set! (-> v0-0 enable) #t)
     (set! (-> v0-0 angle) 0.0)
     (let ((a0-3 (-> arg0 node-list data arg1)))
-      (set! (-> a0-3 param0) (the-as (function cspace matrix none) joint-mod-spinner-callback))
+      (set! (-> a0-3 param0) joint-mod-spinner-callback)
       (set! (-> a0-3 param1) v0-0)
       )
     v0-0
@@ -734,7 +734,7 @@
     (set! (-> v0-0 transform quat quad) (-> *null-vector* quad))
     (set! (-> v0-0 transform scale quad) (-> *identity-vector* quad))
     (let ((a0-8 (-> arg0 node-list data arg1)))
-      (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-blend-world-callback))
+      (set! (-> a0-8 param0) joint-mod-blend-world-callback)
       (set! (-> a0-8 param1) v0-0)
       )
     v0-0
@@ -785,7 +785,7 @@
     (set! (-> gp-0 enable) arg2)
     (quaternion-set! (-> gp-0 rotation) 0.0 0.0 0.0 1.0)
     (let ((a0-3 (-> arg0 node-list data arg1)))
-      (set! (-> a0-3 param0) (the-as (function cspace matrix none) joint-mod-rotate-local-callback))
+      (set! (-> a0-3 param0) joint-mod-rotate-local-callback)
       (set! (-> a0-3 param1) gp-0)
       )
     gp-0
diff --git a/test/decompiler/reference/jak2/engine/anim/joint-mod_REF.gc b/test/decompiler/reference/jak2/engine/anim/joint-mod_REF.gc
index 6ac9d815f6..5dbbdeb6d6 100644
--- a/test/decompiler/reference/jak2/engine/anim/joint-mod_REF.gc
+++ b/test/decompiler/reference/jak2/engine/anim/joint-mod_REF.gc
@@ -297,7 +297,7 @@
     (set! (-> v0-0 blend) 0.0)
     (logclear! (-> v0-0 flags) (joint-mod-ik-flags enable))
     (let ((a0-5 (-> arg0 node-list data arg1)))
-      (set! (-> a0-5 param0) (the-as (function cspace matrix none) joint-mod-ik-callback))
+      (set! (-> a0-5 param0) joint-mod-ik-callback)
       (set! (-> a0-5 param1) v0-0)
       (set! (-> a0-5 param2) (the-as basic arg1))
       )
@@ -604,13 +604,13 @@
        )
       (((joint-mod-mode look-at))
        (let ((a0-4 v1-0))
-         (set! (-> a0-4 param0) (the-as (function cspace matrix none) joint-mod-look-at-handler))
+         (set! (-> a0-4 param0) joint-mod-look-at-handler)
          (set! (-> a0-4 param1) obj)
          )
        )
       (((joint-mod-mode gun-look-at))
        (let ((a0-5 v1-0))
-         (set! (-> a0-5 param0) (the-as (function cspace matrix none) joint-mod-gun-look-at-handler))
+         (set! (-> a0-5 param0) joint-mod-gun-look-at-handler)
          (set! (-> a0-5 param1) obj)
          )
        )
@@ -618,23 +618,20 @@
        (set-vector! (-> obj twist) 0.0 1.0 0.0 1.0)
        (let ((a0-7 v1-0))
          (set! (-> a0-7 param0)
-               (the-as
-                 (function cspace matrix none)
-                 (lambda ((arg0 cspace) (arg1 transformq)) (joint-mod-foot-rot-handler arg0 arg1) (none))
-                 )
+               (lambda ((arg0 cspace) (arg1 transformq)) (joint-mod-foot-rot-handler arg0 arg1) (none))
                )
          (set! (-> a0-7 param1) obj)
          )
        )
       (((joint-mod-mode world-look-at))
        (let ((a0-8 v1-0))
-         (set! (-> a0-8 param0) (the-as (function cspace matrix none) joint-mod-world-look-at-handler))
+         (set! (-> a0-8 param0) joint-mod-world-look-at-handler)
          (set! (-> a0-8 param1) obj)
          )
        )
       (((joint-mod-mode polar-look-at))
        (let ((a0-9 v1-0))
-         (set! (-> a0-9 param0) (the-as (function cspace matrix none) joint-mod-polar-look-at-handler))
+         (set! (-> a0-9 param0) joint-mod-polar-look-at-handler)
          (set! (-> a0-9 param1) obj)
          )
        (set! (-> obj polar-internal-tilt-max) 32768.0)
@@ -644,21 +641,21 @@
        )
       (((joint-mod-mode rotate))
        (let ((a0-11 v1-0))
-         (set! (-> a0-11 param0) (the-as (function cspace matrix none) joint-mod-rotate-handler))
+         (set! (-> a0-11 param0) joint-mod-rotate-handler)
          (set! (-> a0-11 param1) obj)
          )
        (set! (-> obj blend) 1.0)
        )
       (((joint-mod-mode rotate2))
        (let ((a0-13 v1-0))
-         (set! (-> a0-13 param0) (the-as (function cspace matrix none) joint-mod-rotate-handler))
+         (set! (-> a0-13 param0) joint-mod-rotate-handler)
          (set! (-> a0-13 param1) obj)
          )
        (set! (-> obj blend) 1.0)
        )
       (((joint-mod-mode joint-set))
        (let ((a0-15 v1-0))
-         (set! (-> a0-15 param0) (the-as (function cspace matrix none) joint-mod-joint-set-handler))
+         (set! (-> a0-15 param0) joint-mod-joint-set-handler)
          (set! (-> a0-15 param1) obj)
          )
        (vector-reset! (-> obj trans))
@@ -667,7 +664,7 @@
        )
       (((joint-mod-mode joint-set-world))
        (let ((a0-18 v1-0))
-         (set! (-> a0-18 param0) (the-as (function cspace matrix none) joint-mod-joint-set-world-handler))
+         (set! (-> a0-18 param0) joint-mod-joint-set-world-handler)
          (set! (-> a0-18 param1) obj)
          )
        (vector-reset! (-> obj trans))
@@ -677,7 +674,7 @@
        )
       (((joint-mod-mode joint-set*))
        (let ((a0-25 v1-0))
-         (set! (-> a0-25 param0) (the-as (function cspace matrix none) joint-mod-joint-set*-handler))
+         (set! (-> a0-25 param0) joint-mod-joint-set*-handler)
          (set! (-> a0-25 param1) obj)
          )
        (vector-reset! (-> obj trans))
@@ -686,7 +683,7 @@
        )
       (((joint-mod-mode joint-set*-world))
        (let ((a0-29 v1-0))
-         (set! (-> a0-29 param0) (the-as (function cspace matrix none) joint-mod-joint-set*-world-handler))
+         (set! (-> a0-29 param0) joint-mod-joint-set*-world-handler)
          (set! (-> a0-29 param1) obj)
          )
        (vector-reset! (-> obj trans))
diff --git a/test/decompiler/reference/jak2/engine/anim/mspace-h_REF.gc b/test/decompiler/reference/jak2/engine/anim/mspace-h_REF.gc
index 6c1f8807cd..22e0465011 100644
--- a/test/decompiler/reference/jak2/engine/anim/mspace-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/anim/mspace-h_REF.gc
@@ -108,14 +108,14 @@
 
 ;; definition of type cspace
 (deftype cspace (structure)
-  ((parent    cspace                         :offset-assert   0)
-   (joint     joint                          :offset-assert   4)
-   (joint-num int16                          :offset-assert   8)
-   (geo       drawable                       :offset-assert  12)
-   (bone      bone                           :offset-assert  16)
-   (param0    (function cspace matrix none)  :offset-assert  20)
-   (param1    basic                          :offset-assert  24)
-   (param2    basic                          :offset-assert  28)
+  ((parent    cspace                             :offset-assert   0)
+   (joint     joint                              :offset-assert   4)
+   (joint-num int16                              :offset-assert   8)
+   (geo       drawable                           :offset-assert  12)
+   (bone      bone                               :offset-assert  16)
+   (param0    (function cspace transformq none)  :offset-assert  20)
+   (param1    basic                              :offset-assert  24)
+   (param2    basic                              :offset-assert  28)
    )
   :method-count-assert 10
   :size-assert         #x20
diff --git a/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc b/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc
index 0b12944af9..9defa928ab 100644
--- a/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc
+++ b/test/decompiler/reference/jak2/engine/camera/cam-debug_REF.gc
@@ -1194,9 +1194,9 @@
           ((= (-> arg0 blend-to-type) (camera-blend-to-type unknown-2))
            (vector+float*! s5-1 s4-1 (the-as vector (-> *camera-combiner* tracking)) 2048.0)
            (camera-line s4-1 s5-1 (new 'static 'vector4w :x #xff :w #x80))
-           (vector+float*! s5-1 s4-1 (the-as vector (&-> *camera-combiner* stack 176)) 2048.0)
+           (vector+float*! s5-1 s4-1 (-> *camera-combiner* tracking inv-mat vector 1) 2048.0)
            (camera-line s4-1 s5-1 (new 'static 'vector4w :y #xff :w #x80))
-           (vector+float*! s5-1 s4-1 (the-as vector (&-> *camera-combiner* stack 192)) 2048.0)
+           (vector+float*! s5-1 s4-1 (-> *camera-combiner* tracking inv-mat vector 2) 2048.0)
            (camera-line s4-1 s5-1 (new 'static 'vector4w :z #xff :w #x80))
            )
           (else
diff --git a/test/decompiler/reference/jak2/engine/camera/cam-master_REF.gc b/test/decompiler/reference/jak2/engine/camera/cam-master_REF.gc
index 8801b6e6a9..1d4b86b5cd 100644
--- a/test/decompiler/reference/jak2/engine/camera/cam-master_REF.gc
+++ b/test/decompiler/reference/jak2/engine/camera/cam-master_REF.gc
@@ -185,7 +185,7 @@
                 (-> self local-down)
                 (-> self settings target-height)
                 )
-              (vector-float*! (-> s5-6 move-dist) (the-as vector (&-> self stack 256)) 4915.2)
+              (vector-float*! (-> s5-6 move-dist) (-> self tgt-rot-mat vector 2) 4915.2)
               (vector-! (-> s5-6 start-pos) (-> s5-6 start-pos) (-> s5-6 move-dist))
               (let ((s4-4 s5-6))
                 (set! (-> s4-4 radius) 4300.8)
diff --git a/test/decompiler/reference/jak2/engine/camera/cam-states_REF.gc b/test/decompiler/reference/jak2/engine/camera/cam-states_REF.gc
index 7814d47408..75f5480ca3 100644
--- a/test/decompiler/reference/jak2/engine/camera/cam-states_REF.gc
+++ b/test/decompiler/reference/jak2/engine/camera/cam-states_REF.gc
@@ -2726,7 +2726,7 @@
               (vector-flatten! s5-3 (-> self butt-vector) (-> *camera* local-down))
               )
              (else
-               (vector-flatten! s5-3 (the-as vector (&-> *camera* stack 256)) (-> *camera* local-down))
+               (vector-flatten! s5-3 (-> *camera* tgt-rot-mat vector 2) (-> *camera* local-down))
                )
              )
            )
@@ -2746,7 +2746,7 @@
         )
       (when (logtest? (-> *camera* settings slave-options) (cam-slave-options BIKE_MODE))
         (vector-normalize-copy! gp-3 (-> self view-flat) 1.0)
-        (vector-flatten! s5-3 (the-as vector (&-> *camera* stack 256)) (-> *camera* local-down))
+        (vector-flatten! s5-3 (-> *camera* tgt-rot-mat vector 2) (-> *camera* local-down))
         (vector-normalize! s5-3 -1.0)
         (let ((f0-97 (acos (vector-dot s5-3 gp-3))))
           (when (and (< (-> self max-angle-offset) f0-97) (< f0-97 32585.955))
@@ -3604,7 +3604,7 @@
             ((logtest? (-> self options) (cam-slave-options-u32 BUTT_CAM))
              (set-vector! s5-0 0.0 0.0 1.0 1.0)
              (vector-normalize-copy! s5-0 (-> self view-flat) 1.0)
-             (set! (-> s3-0 quad) (-> (the-as vector (&-> *camera* stack 256)) quad))
+             (set! (-> s3-0 quad) (-> (the-as vector (-> *camera* tgt-rot-mat vector 2)) quad))
              (vector-flatten! s3-0 s3-0 (-> *camera* local-down))
              (vector-negate! s3-0 s3-0)
              (set! (-> s4-0 quad) (-> s5-0 quad))
@@ -3670,7 +3670,7 @@
 
 ;; definition for function cam-calc-bike-follow!
 (defbehavior cam-calc-bike-follow! camera-slave ((arg0 cam-rotation-tracker) (arg1 vector) (arg2 symbol))
-  (vector-float*! (-> arg0 follow-off) (the-as vector (&-> *camera* stack 320)) 155648.0)
+  (vector-float*! (-> arg0 follow-off) (-> *camera* tgt-face-mat vector 2) 155648.0)
   (vector+! (-> arg0 follow-pt) (-> *camera* tpos-curr-adj) (-> arg0 follow-off))
   (vector--float*!
     (-> arg0 follow-pt)
@@ -3689,7 +3689,7 @@
           (s5-0 (new-stack-vector0))
           )
       (vector-normalize-copy! gp-0 (-> self view-flat) 1.0)
-      (vector-flatten! s5-0 (the-as vector (&-> *camera* stack 256)) (-> *camera* local-down))
+      (vector-flatten! s5-0 (-> *camera* tgt-rot-mat vector 2) (-> *camera* local-down))
       (vector-normalize! s5-0 -1.0)
       (matrix-from-two-vectors-partial-linear! s4-0 gp-0 s5-0 0.2)
       )
diff --git a/test/decompiler/reference/jak2/engine/camera/camera_REF.gc b/test/decompiler/reference/jak2/engine/camera/camera_REF.gc
index 0f46d7e067..8405f82682 100644
--- a/test/decompiler/reference/jak2/engine/camera/camera_REF.gc
+++ b/test/decompiler/reference/jak2/engine/camera/camera_REF.gc
@@ -1227,12 +1227,12 @@
                (f30-0 (vector-vector-distance (-> *camera* tpos-curr-adj) (-> *camera* tpos-old-adj)))
                (s2-0 (new 'stack-no-clear 'vector))
                )
-           (vector-flatten! s1-0 (the-as vector (&-> *camera* stack 320)) (-> *camera* local-down))
+           (vector-flatten! s1-0 (-> *camera* tgt-face-mat vector 2) (-> *camera* local-down))
            (vector-normalize! s1-0 1.0)
            (vector-! s0-0 (-> *camera* tpos-curr-adj) arg1)
            (vector-flatten! s0-0 s0-0 (-> *camera* local-down))
            (vector-normalize! s0-0 1.0)
-           (vector-float*! s2-0 (the-as vector (&-> *camera* stack 320)) 32768.0)
+           (vector-float*! s2-0 (-> *camera* tgt-face-mat vector 2) 32768.0)
            (set! sv-128 lerp-clamp)
            (set! sv-144 (the-as float 0.7))
            (set! sv-160 (the-as float 0.4))
@@ -1300,7 +1300,7 @@
               (else
                 (vector-! s2-1 (-> *camera* tpos-curr-adj) arg1)
                 (vector-normalize! s2-1 1.0)
-                (let* ((f0-32 (vector-dot (the-as vector (&-> *camera* stack 256)) s2-1))
+                (let* ((f0-32 (vector-dot (-> *camera* tgt-rot-mat vector 2) s2-1))
                        (f30-2 (cond
                                 ((< f0-32 0.0)
                                  1.0
@@ -1320,7 +1320,7 @@
                   (let* ((f1-15 (* 0.000022194603 (+ -20480.0 (vector-length s2-1))))
                          (f0-37 (fmax 0.0 (fmin 1.0 f1-15)))
                          )
-                    (vector-float*! s2-1 (the-as vector (&-> *camera* stack 256)) (* (lerp 2048.0 8192.0 f0-37) f30-2))
+                    (vector-float*! s2-1 (-> *camera* tgt-rot-mat vector 2) (* (lerp 2048.0 8192.0 f0-37) f30-2))
                     )
                   )
                 )
diff --git a/test/decompiler/reference/jak2/engine/collide/collide-shape-h_REF.gc b/test/decompiler/reference/jak2/engine/collide/collide-shape-h_REF.gc
index 99f016e404..8da9d1737d 100644
--- a/test/decompiler/reference/jak2/engine/collide/collide-shape-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/collide/collide-shape-h_REF.gc
@@ -1624,7 +1624,7 @@
     (move-to-ground (_type_ float float symbol collide-spec) none 60)
     (move-to-ground-point (_type_ vector vector vector) none 61)
     (compute-acc-due-to-gravity (_type_ vector float) vector 62)
-    (collide-shape-moving-method-63 () none 63)
+    (collide-shape-moving-method-63 (_type_ rigid-body float) none 63)
     (try-snap-to-surface (_type_ vector float float float) symbol 64)
     (fill-and-try-snap-to-surface (_type_ vector float float float collide-query) symbol 65)
     (step-collison! (_type_ vector vector float int) float 66)
@@ -1955,7 +1955,7 @@
   )
 
 ;; definition for method 4 of type collide-shape-prim-group
-;; WARN: Return type mismatch uint8 vs int.
+;; WARN: Return type mismatch uint vs int.
 (defmethod length collide-shape-prim-group ((obj collide-shape-prim-group))
   (the-as int (-> obj num-children))
   )
diff --git a/test/decompiler/reference/jak2/engine/common_objs/collectables_REF.gc b/test/decompiler/reference/jak2/engine/common_objs/collectables_REF.gc
index 61317d989c..bb09d964ce 100644
--- a/test/decompiler/reference/jak2/engine/common_objs/collectables_REF.gc
+++ b/test/decompiler/reference/jak2/engine/common_objs/collectables_REF.gc
@@ -2635,7 +2635,7 @@
      (set-vector! (-> obj root-override2 scale) 3.0 3.0 3.0 1.0)
      (logclear! (-> obj flags) (collectable-flag fadeout))
      (let ((v1-34 (-> obj node-list data)))
-       (set! (-> v1-34 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+       (set! (-> v1-34 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
        (set! (-> v1-34 0 param1) (the-as basic (-> obj root-override2 trans)))
        (set! (-> v1-34 0 param2) (the-as basic (-> obj extra-trans)))
        )
@@ -2663,7 +2663,7 @@
        )
      (set-vector! (-> obj root-override2 scale) 2.0 2.0 2.0 1.0)
      (let ((v1-52 (-> obj node-list data)))
-       (set! (-> v1-52 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+       (set! (-> v1-52 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
        (set! (-> v1-52 0 param1) (the-as basic (-> obj root-override2 trans)))
        (set! (-> v1-52 0 param2) (the-as basic (-> obj extra-trans)))
        )
diff --git a/test/decompiler/reference/jak2/engine/common_objs/generic-obs_REF.gc b/test/decompiler/reference/jak2/engine/common_objs/generic-obs_REF.gc
index b91eb3190e..b4235c18a1 100644
--- a/test/decompiler/reference/jak2/engine/common_objs/generic-obs_REF.gc
+++ b/test/decompiler/reference/jak2/engine/common_objs/generic-obs_REF.gc
@@ -1026,7 +1026,9 @@
            (cond
              ((-> event param 0)
               (set! s4-0 (-> self node-list data 2))
-              (set! (-> (the-as cspace s4-0) param0) (the-as (function cspace matrix none) cspace<-parented-matrix-mirror!))
+              (set! (-> (the-as cspace s4-0) param0)
+                    (the-as (function cspace transformq none) cspace<-parented-matrix-mirror!)
+                    )
               (set! (-> (the-as cspace s4-0) param1) (the-as basic (-> *math-camera* mirror-trans)))
               (set! (-> (the-as cspace s4-0) param2) (the-as basic (-> *math-camera* mirror-normal)))
               )
diff --git a/test/decompiler/reference/jak2/engine/nav/nav-enemy_REF.gc b/test/decompiler/reference/jak2/engine/nav/nav-enemy_REF.gc
index 719acb5f79..817216838a 100644
--- a/test/decompiler/reference/jak2/engine/nav/nav-enemy_REF.gc
+++ b/test/decompiler/reference/jak2/engine/nav/nav-enemy_REF.gc
@@ -1154,7 +1154,7 @@
   (local-vars (sv-16 res-tag))
   (when (coin-flip? obj)
     (let ((a0-2 (-> obj node-list data 2)))
-      (set! (-> a0-2 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint-flip-z!))
+      (set! (-> a0-2 param0) (the-as (function cspace transformq none) cspace<-parented-matrix-joint-flip-z!))
       (set! (-> a0-2 param1) #f)
       (set! (-> a0-2 param2) #f)
       )
diff --git a/test/decompiler/reference/jak2/engine/physics/rigid-body-h_REF.gc b/test/decompiler/reference/jak2/engine/physics/rigid-body-h_REF.gc
index d6dbaa912e..c6097f12ea 100644
--- a/test/decompiler/reference/jak2/engine/physics/rigid-body-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/physics/rigid-body-h_REF.gc
@@ -1,5 +1,7 @@
+;;-*-Lisp-*-
 (in-package goal)
 
+;; definition of type rigid-body-info
 (deftype rigid-body-info (structure)
   ((mass                float          :offset-assert   0)
    (inv-mass            float          :offset-assert   4)
@@ -21,6 +23,7 @@
     )
   )
 
+;; definition for method 3 of type rigid-body-info
 (defmethod inspect rigid-body-info ((obj rigid-body-info))
   (when (not obj)
     (set! obj obj)
@@ -42,6 +45,7 @@
   obj
   )
 
+;; definition of type rigid-body-object-extra-info
 (deftype rigid-body-object-extra-info (structure)
   ((max-time-step      float   :offset-assert   0)
    (gravity            meters  :offset-assert   4)
@@ -54,6 +58,7 @@
   :flag-assert         #x900000010
   )
 
+;; definition for method 3 of type rigid-body-object-extra-info
 (defmethod inspect rigid-body-object-extra-info ((obj rigid-body-object-extra-info))
   (when (not obj)
     (set! obj obj)
@@ -68,6 +73,7 @@
   obj
   )
 
+;; definition of type rigid-body-object-constants
 (deftype rigid-body-object-constants (structure)
   ((info               rigid-body-info              :inline :offset-assert   0)
    (mass               float                                :offset          0)
@@ -95,6 +101,7 @@
   :flag-assert         #x9000000d0
   )
 
+;; definition for method 3 of type rigid-body-object-constants
 (defmethod inspect rigid-body-object-constants ((obj rigid-body-object-constants))
   (when (not obj)
     (set! obj obj)
@@ -124,6 +131,7 @@
   obj
   )
 
+;; definition of type rigid-body-impact
 (deftype rigid-body-impact (structure)
   ((point    vector :inline :offset-assert   0)
    (normal   vector :inline :offset-assert  16)
@@ -138,6 +146,7 @@
   :flag-assert         #x900000040
   )
 
+;; definition for method 3 of type rigid-body-impact
 (defmethod inspect rigid-body-impact ((obj rigid-body-impact))
   (when (not obj)
     (set! obj obj)
@@ -155,6 +164,7 @@
   obj
   )
 
+;; definition of type rigid-body
 (deftype rigid-body (structure)
   ((work           rigid-body-work                      :offset-assert   0)
    (info           rigid-body-info                      :offset-assert   4)
@@ -205,6 +215,7 @@
     )
   )
 
+;; definition for method 3 of type rigid-body
 (defmethod inspect rigid-body ((obj rigid-body))
   (when (not obj)
     (set! obj obj)
@@ -254,6 +265,7 @@
   obj
   )
 
+;; definition of type rigid-body-control
 (deftype rigid-body-control (basic)
   ((process        process                 :offset-assert   4)
    (state          rigid-body      :inline :offset-assert  16)
@@ -301,6 +313,7 @@
     )
   )
 
+;; definition for method 3 of type rigid-body-control
 (defmethod inspect rigid-body-control ((obj rigid-body-control))
   (when (not obj)
     (set! obj obj)
@@ -352,88 +365,107 @@
   obj
   )
 
+;; definition for method 9 of type rigid-body-control
 (defmethod rigid-body-control-method-9 rigid-body-control ((obj rigid-body-control) (arg0 collide-shape-moving) (arg1 float))
   (rigid-body-method-9 (-> obj state) arg0 arg1)
   (none)
   )
 
+;; definition for method 10 of type rigid-body-control
+;; WARN: Return type mismatch none vs object.
 (defmethod rigid-body-control-method-10 rigid-body-control ((obj rigid-body-control) (arg0 rigid-body-object) (arg1 float) (arg2 float))
   (the-as object (rigid-body-method-10 (-> obj state)))
   )
 
+;; definition for method 11 of type rigid-body-control
 (defmethod rigid-body-control-method-11 rigid-body-control ((obj rigid-body-control) (arg0 collide-shape-moving))
   (rigid-body-method-11 (-> obj state) arg0)
   (none)
   )
 
+;; definition for method 12 of type rigid-body-control
 (defmethod rigid-body-control-method-12 rigid-body-control ((obj rigid-body-control) (arg0 float))
   (rigid-body-method-12 (-> obj state) arg0)
   (none)
   )
 
+;; definition for method 13 of type rigid-body-control
 (defmethod rigid-body-control-method-13 rigid-body-control ((obj rigid-body-control))
   (rigid-body-method-13 (-> obj state))
   (none)
   )
 
+;; definition for method 14 of type rigid-body-control
 (defmethod rigid-body-control-method-14 rigid-body-control ((obj rigid-body-control) (arg0 float))
   (rigid-body-method-14 (-> obj state) arg0)
   (none)
   )
 
+;; definition for method 15 of type rigid-body-control
 (defmethod clear-force-torque! rigid-body-control ((obj rigid-body-control))
   (clear-force-torque! (-> obj state))
   (none)
   )
 
+;; definition for method 16 of type rigid-body-control
 (defmethod clear-momentum! rigid-body-control ((obj rigid-body-control))
   (clear-momentum! (-> obj state))
   (none)
   )
 
+;; definition for method 17 of type rigid-body-control
 (defmethod rigid-body-control-method-17 rigid-body-control ((obj rigid-body-control) (arg0 vector) (arg1 vector))
   (rigid-body-method-18 (-> obj state) arg0 arg1)
   (none)
   )
 
+;; definition for method 18 of type rigid-body-control
 (defmethod rigid-body-control-method-18 rigid-body-control ((obj rigid-body-control) (arg0 vector) (arg1 vector))
   (rigid-body-method-19 (-> obj state) arg0 arg1)
   (none)
   )
 
+;; definition for method 19 of type rigid-body-control
 (defmethod rigid-body-control-method-19 rigid-body-control ((obj rigid-body-control) (arg0 vector))
   (rigid-body-method-20 (-> obj state) arg0)
   (none)
   )
 
+;; definition for method 20 of type rigid-body-control
 (defmethod rigid-body-control-method-20 rigid-body-control ((obj rigid-body-control) (arg0 vector) (arg1 vector) (arg2 float))
   (rigid-body-method-21 (-> obj state) arg0 arg1 arg2)
   (none)
   )
 
+;; definition for method 21 of type rigid-body-control
 (defmethod rigid-body-control-method-21 rigid-body-control ((obj rigid-body-control) (arg0 vector) (arg1 vector))
   (rigid-body-method-22 (-> obj state) arg0 arg1)
   )
 
+;; definition for method 22 of type rigid-body-control
 (defmethod rigid-body-control-method-22 rigid-body-control ((obj rigid-body-control) (arg0 vector))
   (rigid-body-method-23 (-> obj state) arg0)
   )
 
+;; definition for method 23 of type rigid-body-control
 (defmethod rigid-body-control-method-23 rigid-body-control ((obj rigid-body-control))
   (rigid-body-method-24 (-> obj state))
   (none)
   )
 
+;; definition for method 24 of type rigid-body-control
 (defmethod rigid-body-control-method-24 rigid-body-control ((obj rigid-body-control) (arg0 rigid-body-info) (arg1 vector) (arg2 quaternion) (arg3 basic))
   (rigid-body-method-25 (-> obj state) arg0 arg1 arg2 (the-as function arg3))
   (none)
   )
 
+;; definition for method 25 of type rigid-body-control
 (defmethod rigid-body-control-method-25 rigid-body-control ((obj rigid-body-control) (arg0 vector) (arg1 quaternion))
   (rigid-body-method-26 (-> obj state) arg0 arg1)
   (none)
   )
 
+;; definition of type rigid-body-object
 (deftype rigid-body-object (process-focusable)
   ((root-override-2       collide-shape-moving                :offset        128)
    (info                  rigid-body-object-constants         :offset-assert 204)
@@ -468,7 +500,7 @@
     (rigid-body-object-method-42 (_type_) none :behavior rigid-body-object 42)
     (rigid-body-object-method-43 (_type_) none 43)
     (rigid-body-object-method-44 (_type_ float) none 44)
-    (rigid-body-object-method-45 () none 45)
+    (rigid-body-object-method-45 (_type_ rigid-body-object-constants) sound-id 45)
     (rigid-body-object-method-46 (_type_ process-drawable int symbol event-message-block) none :behavior rigid-body-object 46)
     (rigid-body-object-method-47 (_type_ process-drawable attack-info object penetrate) symbol 47)
     (rigid-body-object-method-48 (_type_ object object) none 48)
@@ -479,6 +511,7 @@
     )
   )
 
+;; definition for method 3 of type rigid-body-object
 (defmethod inspect rigid-body-object ((obj rigid-body-object))
   (when (not obj)
     (set! obj obj)
@@ -529,6 +562,7 @@
   obj
   )
 
+;; definition of type rigid-body-queue
 (deftype rigid-body-queue (structure)
   ((count int8       :offset-assert   0)
    (array uint64 128 :offset          8)
@@ -548,6 +582,7 @@
     )
   )
 
+;; definition for method 3 of type rigid-body-queue
 (defmethod inspect rigid-body-queue ((obj rigid-body-queue))
   (when (not obj)
     (set! obj obj)
@@ -560,4 +595,5 @@
   obj
   )
 
+;; failed to figure out what this is:
 0
diff --git a/test/decompiler/reference/jak2/engine/physics/rigid-body_REF.gc b/test/decompiler/reference/jak2/engine/physics/rigid-body_REF.gc
index be82899d4b..392cf03624 100644
--- a/test/decompiler/reference/jak2/engine/physics/rigid-body_REF.gc
+++ b/test/decompiler/reference/jak2/engine/physics/rigid-body_REF.gc
@@ -347,7 +347,7 @@
     )
   (rigid-body-method-13 obj)
   (if (logtest? (-> obj flags) (rigid-body-flag enable-collision))
-      ((method-of-object arg0 collide-shape-moving-method-63))
+      (collide-shape-moving-method-63 arg0 obj arg1)
       (rigid-body-method-14 obj arg1)
       )
   0
@@ -397,10 +397,1333 @@
   )
 
 ;; definition for method 63 of type collide-shape-moving
-;; ERROR: function was not converted to expressions. Cannot decompile.
+;; INFO: Used lq/sq
+;; ERROR: failed type prop at 118: Could not figure out load: (set! v1 (l.wu v1))
+;; WARN: Return type mismatch int vs none.
+(defmethod collide-shape-moving-method-63 collide-shape-moving ((a0-0 collide-shape-moving) (a1-0 rigid-body) (a2-0 float))
+  (local-vars
+    (v0-0 quaternion)
+    (v0-1 none)
+    (v0-2 pointer)
+    (v0-3 quaternion)
+    (v0-4 none)
+    (v0-5 symbol)
+    (v0-6 none)
+    (v0-7 none)
+    (v0-8 none)
+    (v0-9 symbol)
+    (v0-10 none)
+    (v0-11 none)
+    (v0-12 none)
+    (v0-13 symbol)
+    (v0-14 pointer)
+    (v0-15 none)
+    (v0-16 none)
+    (v0-17 none)
+    (v0-18 none)
+    (v0-19 none)
+    (v0-20 none)
+    (v0-21 none)
+    (v0-22 none)
+    (v0-23 none)
+    (v0-24 none)
+    (v0-25 none)
+    (v0-26 none)
+    (v0-27 none)
+    (v0-28 none)
+    (v0-29 none)
+    (v0-30 none)
+    (v0-31 none)
+    (v0-32 none)
+    (v0-33 none)
+    (v0-34 none)
+    (v0-35 none)
+    (v0-36 int)
+    (v1-0 int)
+    (v1-1 int)
+    (v1-2 vector)
+    (v1-3 type)
+    (v1-5 vector)
+    (v1-6 type)
+    (v1-8 type)
+    (v1-10 symbol)
+    (v1-11 type)
+    (v1-13 type)
+    (v1-15 type)
+    (v1-17 type)
+    (v1-19 type)
+    (v1-21 float)
+    (v1-22 uint)
+    (v1-23 float)
+    (v1-24 none)
+    (v1-25 none)
+    (v1-26 none)
+    (v1-27 none)
+    (v1-28 none)
+    (v1-29 none)
+    (v1-30 none)
+    (v1-31 none)
+    (v1-32 none)
+    (v1-33 none)
+    (v1-34 none)
+    (v1-37 none)
+    (v1-38 none)
+    (v1-39 none)
+    (v1-41 none)
+    (v1-42 none)
+    (v1-44 none)
+    (v1-46 none)
+    (v1-47 none)
+    (v1-48 none)
+    (v1-49 none)
+    (v1-50 none)
+    (v1-51 none)
+    (v1-52 none)
+    (v1-53 none)
+    (v1-54 none)
+    (v1-55 none)
+    (v1-56 none)
+    (v1-57 none)
+    (v1-58 none)
+    (v1-59 none)
+    (v1-60 none)
+    (v1-61 none)
+    (v1-62 none)
+    (v1-63 none)
+    (v1-64 none)
+    (v1-65 none)
+    (v1-68 none)
+    (v1-70 none)
+    (v1-71 none)
+    (v1-72 none)
+    (v1-74 none)
+    (v1-76 none)
+    (v1-77 none)
+    (v1-78 none)
+    (v1-79 none)
+    (v1-80 none)
+    (v1-81 none)
+    (v1-82 none)
+    (v1-83 none)
+    (v1-84 none)
+    (v1-87 none)
+    (v1-88 none)
+    (v1-89 none)
+    (v1-91 none)
+    (v1-93 none)
+    (v1-95 none)
+    (v1-97 none)
+    (v1-98 none)
+    (v1-99 none)
+    (v1-102 none)
+    (v1-103 none)
+    (v1-104 none)
+    (v1-105 none)
+    (v1-106 none)
+    (v1-107 none)
+    (v1-109 none)
+    (v1-110 none)
+    (v1-112 none)
+    (v1-114 none)
+    (v1-115 none)
+    (v1-116 none)
+    (v1-117 none)
+    (v1-118 none)
+    (v1-119 none)
+    (v1-120 none)
+    (v1-121 none)
+    (v1-122 none)
+    (v1-124 none)
+    (v1-125 none)
+    (v1-126 none)
+    (v1-127 none)
+    (v1-128 none)
+    (v1-129 none)
+    (v1-131 none)
+    (v1-132 none)
+    (v1-133 none)
+    (v1-134 none)
+    (v1-135 none)
+    (v1-136 none)
+    (v1-137 none)
+    (v1-138 none)
+    (v1-140 none)
+    (v1-142 none)
+    (v1-144 none)
+    (v1-147 int)
+    (a0-1 vector)
+    (a0-2 uint128)
+    (a0-3 vector)
+    (a0-4 rigid-body)
+    (a0-5 vector)
+    (a0-6 vector)
+    (a0-7 uint128)
+    (a0-8 quaternion)
+    (a0-9 rigid-body)
+    (a0-10 collide-shape-prim)
+    (a0-11 collide-shape-moving)
+    (a0-12 rigid-body)
+    (a0-13 rigid-body)
+    (a0-14 collide-shape-prim)
+    (a0-15 touching-list)
+    (a0-16 rigid-body)
+    (a0-17 rigid-body)
+    (a0-18 collide-shape-prim)
+    (a0-19 vector)
+    (a0-20 none)
+    (a0-21 none)
+    (a0-25 none)
+    (a0-26 none)
+    (a0-27 none)
+    (a0-28 none)
+    (a0-29 none)
+    (a0-30 none)
+    (a0-31 none)
+    (a0-32 none)
+    (a0-33 none)
+    (a0-34 none)
+    (a0-35 none)
+    (a0-36 none)
+    (a0-37 none)
+    (a0-38 none)
+    (a0-39 none)
+    (a0-40 none)
+    (a0-41 none)
+    (a0-43 none)
+    (a0-47 none)
+    (a0-49 none)
+    (a0-50 none)
+    (a0-51 none)
+    (a0-54 none)
+    (a0-55 none)
+    (a0-56 none)
+    (a0-57 none)
+    (a0-58 none)
+    (a0-59 none)
+    (a0-60 none)
+    (a0-64 none)
+    (a1-1 quaternion)
+    (a1-2 float)
+    (a1-3 matrix)
+    (a1-4 vector)
+    (a1-5 matrix)
+    (a1-6 vector)
+    (a1-7 float)
+    (a1-8 matrix)
+    (a1-9 float)
+    (a1-10 float)
+    (a1-11 matrix)
+    (a1-12 matrix)
+    (a1-13 none)
+    (a1-14 none)
+    (a1-15 none)
+    (a1-16 none)
+    (a1-17 none)
+    (a1-18 none)
+    (a1-19 none)
+    (a1-20 none)
+    (a1-21 none)
+    (a1-22 none)
+    (a1-23 none)
+    (a1-24 none)
+    (a1-25 none)
+    (a1-26 none)
+    (a1-27 none)
+    (a1-28 none)
+    (a1-29 none)
+    (a1-30 none)
+    (a1-31 none)
+    (a1-32 none)
+    (a1-33 none)
+    (a1-34 none)
+    (a1-35 none)
+    (a1-36 none)
+    (a1-37 none)
+    (a1-38 none)
+    (a1-39 none)
+    (a1-42 none)
+    (a1-43 none)
+    (a1-44 none)
+    (a1-45 none)
+    (a1-46 none)
+    (a1-47 none)
+    (a1-48 none)
+    (a1-50 none)
+    (a2-1 int)
+    (a2-2 vector)
+    (a2-3 int)
+    (a2-4 none)
+    (a2-5 none)
+    (a2-6 none)
+    (a2-7 none)
+    (a2-8 none)
+    (a2-9 none)
+    (a2-10 none)
+    (a2-11 none)
+    (a2-12 none)
+    (s2-0 none)
+    (s3-0 symbol)
+    (s5-0 (inline-array vector))
+    (t9-0 (function quaternion quaternion quaternion))
+    (t9-1 (function rigid-body float none))
+    (t9-2 (function pointer pointer int pointer))
+    (t9-3 (function quaternion quaternion quaternion))
+    (t9-4 (function rigid-body none))
+    (t9-5 (function collide-shape-prim matrix symbol))
+    (t9-6 (function none))
+    (t9-7 (function rigid-body float none))
+    (t9-8 (function rigid-body none))
+    (t9-9 (function collide-shape-prim matrix symbol))
+    (t9-10 (function touching-list float none))
+    (t9-11 (function rigid-body float none))
+    (t9-12 (function rigid-body none))
+    (t9-13 (function collide-shape-prim matrix symbol))
+    (t9-14 (function pointer pointer int pointer))
+    (t9-15 none)
+    (t9-16 none)
+    (t9-17 none)
+    (t9-18 none)
+    (t9-19 none)
+    (t9-20 none)
+    (t9-21 none)
+    (t9-22 none)
+    (t9-23 none)
+    (t9-24 none)
+    (t9-25 none)
+    (t9-26 none)
+    (t9-27 none)
+    (t9-28 none)
+    (t9-29 none)
+    (t9-30 none)
+    (t9-31 none)
+    (t9-32 none)
+    (t9-33 none)
+    (t9-34 none)
+    (t9-35 none)
+    (sp-0 none)
+    (f0-0 float)
+    (f0-1 float)
+    (f0-2 float)
+    (f0-3 float)
+    (f0-4 float)
+    (f0-5 float)
+    (f0-6 float)
+    (f0-7 float)
+    (f0-8 float)
+    (f0-9 float)
+    (f0-10 float)
+    (f0-11 float)
+    (f0-12 none)
+    (f0-13 none)
+    (f0-14 none)
+    (f0-15 none)
+    (f0-16 none)
+    (f0-17 none)
+    (f0-18 none)
+    (f0-19 none)
+    (f0-20 none)
+    (f0-21 none)
+    (f0-22 none)
+    (f0-23 none)
+    (f0-24 none)
+    (f0-25 none)
+    (f0-26 none)
+    (f0-27 none)
+    (f0-28 none)
+    (f0-29 none)
+    (f0-30 none)
+    (f0-31 none)
+    (f0-32 none)
+    (f0-33 none)
+    (f0-34 none)
+    (f0-35 none)
+    (f0-36 none)
+    (f0-37 none)
+    (f0-38 none)
+    (f0-39 none)
+    (f0-40 none)
+    (f0-41 none)
+    (f0-42 none)
+    (f0-43 none)
+    (f0-44 none)
+    (f0-45 float)
+    (f0-46 float)
+    (f0-47 float)
+    (f0-48 float)
+    (f1-0 float)
+    (f1-1 float)
+    (f1-2 float)
+    (f1-3 none)
+    (f1-4 none)
+    (f1-5 none)
+    (f1-6 none)
+    (f1-7 none)
+    (f1-8 none)
+    (f1-9 none)
+    (f1-10 none)
+    (f1-11 none)
+    (f1-12 none)
+    (f1-13 none)
+    (f1-14 none)
+    (f1-15 none)
+    (f1-16 none)
+    (f1-17 none)
+    (f1-18 none)
+    (f1-19 none)
+    (f1-20 none)
+    (f1-21 none)
+    (f1-22 none)
+    (f1-23 none)
+    (f1-24 float)
+    (f1-25 float)
+    (f1-26 float)
+    (f2-0 none)
+    (f2-1 none)
+    (f2-2 none)
+    (f2-3 none)
+    (f2-4 none)
+    (f2-5 none)
+    (f3-0 none)
+    (f30-0 float)
+    (f30-1 none)
+    (f30-2 none)
+    (f30-3 none)
+    )
+  (with-pp
+    (rlet ((acc :class vf)
+           (Q :class vf)
+           (vf0 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           (vf8 :class vf)
+           (vf9 :class vf)
+           )
+      (init-vf0-vector)
+      (set! s5-0 (new 'stack-no-clear 'inline-array 'vector 51))
+      (set! f0-0 (gpr->fpr a2-0))
+      (set! (-> s5-0 49 z) f0-0)
+      (set! v1-0 #x3f800000)
+      (set! f0-1 (the-as float (gpr->fpr v1-0)))
+      (set! (-> s5-0 49 w) f0-1)
+      (s.b! (+ s5-0 800) 0)
+      (until (begin
+               (set! v1-1 -859915232)
+               (set! f0-2 (the-as float (gpr->fpr v1-1)))
+               (set! (-> s5-0 7 x) f0-2)
+               (set! (-> s5-0 7 z) (the-as float #f))
+               (set! (-> s5-0 7 y) (the-as float #f))
+               (set! v1-2 (-> s5-0 42))
+               (set! a0-1 (-> a1-0 position))
+               (set! a0-2 (-> a0-1 quad))
+               (set! (-> v1-2 quad) a0-2)
+               (set! t9-0 quaternion-copy!)
+               (set! a0-3 (-> s5-0 43))
+               (set! a1-1 (-> a1-0 rotation))
+               (call! a0-3 a1-1)
+               (set! a0-4 a1-0)
+               (set! v1-3 rigid-body)
+               (set! t9-1 (method-of-type v1-3 rigid-body-method-14))
+               (set! f0-3 (-> s5-0 49 w))
+               (set! f1-0 (-> s5-0 49 z))
+               (set! f0-4 (*.s f0-3 f1-0))
+               (set! a1-2 (fpr->gpr f0-4))
+               (call! a0-4 a1-2)
+               (set! v1-4 v0-1)
+               (set! t9-2 mem-copy!)
+               (set! a0-5 (-> s5-0 34))
+               (set! a1-3 (-> a1-0 matrix))
+               (set! a2-1 64)
+               (call! a0-5 a1-3 a2-1)
+               (set! v1-5 (-> a1-0 position))
+               (set! a0-6 (-> s5-0 42))
+               (set! a0-7 (-> a0-6 quad))
+               (set! (-> v1-5 quad) a0-7)
+               (set! t9-3 quaternion-copy!)
+               (set! a0-8 (-> a1-0 rotation))
+               (set! a1-4 (-> s5-0 43))
+               (call! a0-8 a1-4)
+               (set! a0-9 a1-0)
+               (set! v1-6 rigid-body)
+               (set! t9-4 (method-of-type v1-6 rigid-body-method-24))
+               (call! a0-9)
+               (set! v1-7 v0-4)
+               (set! t9-5 transform-rigid-body-prims)
+               (set! a0-10 (-> a0-0 root-prim))
+               (set! a1-5 (-> a1-0 matrix))
+               (call! a0-10 a1-5)
+               (set! a0-11 a0-0)
+               (set! v1-8 (-> a0-11 type))
+               (set! t9-6 (method-of-type v1-8 collide-shape-moving-method-67))
+               (set! a1-6 (-> s5-0 34))
+               (set! a2-2 (-> s5-0 0))
+               (call!)
+               (set! v1-9 v0-6)
+               (set! f30-0 (-> s5-0 7 x))
+               (set! f0-5 (the-as float 0))
+               (b! (>=.s f30-0 f0-5) L106 (set! v1-10 #f))
+               (set! a0-12 a1-0)
+               (set! v1-11 rigid-body)
+               (set! t9-7 (method-of-type v1-11 rigid-body-method-14))
+               (set! f0-6 (-> s5-0 49 w))
+               (set! f1-1 (-> s5-0 49 z))
+               (set! f0-7 (*.s f0-6 f1-1))
+               (set! a1-7 (fpr->gpr f0-7))
+               (call! a0-12 a1-7)
+               (set! v1-12 v0-7)
+               (set! a0-13 a1-0)
+               (set! v1-13 rigid-body)
+               (set! t9-8 (method-of-type v1-13 rigid-body-method-13))
+               (call! a0-13)
+               (set! v1-14 v0-8)
+               (set! t9-9 transform-rigid-body-prims)
+               (set! a0-14 (-> a0-0 root-prim))
+               (set! a1-8 (-> a1-0 matrix))
+               (call! a0-14 a1-8)
+               (set! f0-8 (the-as float 0))
+               (set! (-> s5-0 49 w) f0-8)
+               ((b! #t L126 (nop!)) (nop!))
+               (label cfg-3)
+               (set! a0-15 *touching-list*)
+               (set! v1-15 touching-list)
+               (set! t9-10 (method-of-type v1-15 update-from-step-size))
+               (set! a1-9 (fpr->gpr f30-0))
+               (call! a0-15 a1-9)
+               (set! v1-16 v0-10)
+               (set! a0-16 a1-0)
+               (set! v1-17 rigid-body)
+               (set! t9-11 (method-of-type v1-17 rigid-body-method-14))
+               (set! f0-9 (-> s5-0 49 w))
+               (set! f1-2 (-> s5-0 49 z))
+               (set! f0-10 (*.s f0-9 f1-2))
+               (set! f0-11 (*.s f0-10 f30-0))
+               (set! a1-10 (fpr->gpr f0-11))
+               (call! a0-16 a1-10)
+               (set! v1-18 v0-11)
+               (set! a0-17 a1-0)
+               (set! v1-19 rigid-body)
+               (set! t9-12 (method-of-type v1-19 rigid-body-method-13))
+               (call! a0-17)
+               (set! v1-20 v0-12)
+               (set! t9-13 transform-rigid-body-prims)
+               (set! a0-18 (-> a0-0 root-prim))
+               (set! a1-11 (-> a1-0 matrix))
+               (call! a0-18 a1-11)
+               (set! t9-14 mem-copy!)
+               (set! a0-19 (-> s5-0 34))
+               (set! a1-12 (-> a1-0 matrix))
+               (set! a2-3 64)
+               (call! a0-19 a1-12 a2-3)
+               (set! s3-0 #f)
+               (set! v1-21 (-> s5-0 7 y))
+               ((b! (not v1-21) L110 (set! v1-22 #f)) (empty-form))
+               (set! v1-23 (-> s5-0 7 y))
+               (set! v1-24 (the-as none (l.wu v1-23)))
+               (set! a0-20 (the-as none (l.wu (+ v1-24 136))))
+               (set! v1-25 (the-as none (l.wu (+ a0-20 180))))
+               ((b! (zero? v1-25) L110 (set! v1-26 #f)) (empty-form))
+               (set! v1-27 (the-as none (l.wu (+ a0-20 180))))
+               (set! s3-0 (the-as symbol (+ v1-27 12)))
+               (set! v1-28 (the-as none (l.wu (+ s3-0 8))))
+               (set! v1-29 (the-as none (logand v1-28 8)))
+               ((b! (zero? v1-29) L109 (nop!)) (nop!))
+               (set! v1-30 (the-as none (l.wu (+ s3-0 8))))
+               (set! v1-31 (the-as none (logand v1-30 2)))
+               ((b! (nonzero? v1-31) L108 (set! v1-32 #f)) (empty-form))
+               (if (begin (set! a1-13 (the-as none (+ sp-0 832))) (set! v1-33 (the-as none s6-0)) v1-33)
+                   (set! a2-4 (the-as none (l.wu (+ v1-33 24))))
+                   )
+               (s.w! (+ a1-13 8) a2-4)
+               (s.w! (+ a1-13 68) 0)
+               (set! v1-34 (the-as none 'enable-physics))
+               (s.w! (+ a1-13 64) v1-34)
+               (set! t9-15 (the-as none send-event-function))
+               (call!)
+               (set! v1-35 (the-as none v0-15))
+               (label cfg-10)
+               ((b! #t L110 (nop!)) (nop!))
+               (label cfg-11)
+               (set! s3-0 (the-as symbol #f))
+               (set! v1-36 (the-as none s3-0))
+               (label cfg-12)
+               (set! v1-37 (the-as none (-> s5-0 7 z)))
+               (set! a0-21 (the-as none (-> s5-0 0)))
+               (.lvf vf7 (+ a0-21 48))
+               (.lvf vf6 (+ v1-37 12))
+               (.sub.vf vf8 vf6 vf7)
+               (.mul.vf vf9 vf8 vf8 :mask #b111)
+               (.mul.x.vf acc vf0 vf9 :mask #b1000)
+               (.add.mul.y.vf acc vf0 vf9 acc :mask #b1000)
+               (.add.mul.z.vf vf9 vf0 vf9 acc :mask #b1000)
+               (.isqrt.vf Q vf0 vf9 :fsf #b11 :ftf #b11)
+               (.mov.vf vf8 vf0 :mask #b1000)
+               (.wait.vf)
+               (.mul.vf vf8 vf8 Q :mask #b111)
+               (.nop.vf)
+               (.nop.vf)
+               (.nop.vf)
+               (.svf (&-> s5-0 39 quad) vf8)
+               (.svf (&-> s5-0 38 quad) vf7)
+               (set! v1-38 (the-as none (l.wu (+ v1-37 4))))
+               (set! (-> s5-0 41 w) (the-as float v1-38))
+               (set! a0-22 (the-as none a1-0))
+               (set! v1-39 (the-as none rigid-body))
+               (set! t9-16 (the-as none (l.wu (+ v1-39 104))))
+               (set! a1-14 (the-as none (-> s5-0 38)))
+               (set! a2-5 (the-as none (-> s5-0 40)))
+               (call!)
+               (set! v1-40 (the-as none v0-16))
+               ((b! (not s3-0) L111 (set! v1-41 #f)) (empty-form))
+               (set! a0-23 (the-as none s3-0))
+               (set! v1-42 (the-as none rigid-body))
+               (set! t9-17 (the-as none (l.wu (+ v1-42 68))))
+               (call!)
+               (set! v1-43 (the-as none v0-17))
+               (set! a0-24 (the-as none s3-0))
+               (set! v1-44 (the-as none rigid-body))
+               (set! t9-18 (the-as none (l.wu (+ v1-44 104))))
+               (set! a1-15 (the-as none (+ s5-0 608)))
+               (set! a2-6 (the-as none (+ s5-0 720)))
+               (call!)
+               (set! v1-45 (the-as none v0-18))
+               (set! a1-16 (the-as none (+ s5-0 640)))
+               (set! v1-46 (the-as none (+ s5-0 640)))
+               (set! a0-25 (the-as none (+ s5-0 720)))
+               (set! a1-17 (the-as none (vector-!2 a1-16 v1-46 a0-25)))
+               (label cfg-14)
+               (set! f0-12 (the-as none 0))
+               (s.f! (+ s5-0 656) f0-12)
+               (set! v1-47 (the-as none -1009988403))
+               (set! f0-13 (the-as none (gpr->fpr v1-47)))
+               (set! a0-26 (the-as none (+ s5-0 640)))
+               (set! v1-48 (the-as none (+ s5-0 624)))
+               (set! f1-3 (the-as none (vec3dot a0-26 v1-48)))
+               (set! v1-49 (the-as none (fpr->gpr f1-3)))
+               (set! f1-4 (the-as none (gpr->fpr v1-49)))
+               (set! f0-14 (the-as none (+.s f0-13 f1-4)))
+               (s.f! (+ s5-0 784) f0-14)
+               (set! f0-15 (the-as none 0))
+               (s.f! (+ s5-0 788) f0-15)
+               (set! f0-16 (the-as none (l.f (+ s5-0 784))))
+               (set! f1-5 (the-as none 0))
+               (b! (>=.s f0-16 f1-5) L123 (nop!))
+               (if (begin
+                     (when (begin
+                             (when (begin
+                                     (cond
+                                       ((begin
+                                          (set! a1-18 (the-as none (+ s5-0 736)))
+                                          (set! v1-50 (the-as none (+ s5-0 608)))
+                                          (set! a0-27 (the-as none (+ a1-0 32)))
+                                          (set! a1-19 (the-as none (vector-!2 a1-18 v1-50 a0-27)))
+                                          (set! a1-20 (the-as none (+ s5-0 752)))
+                                          (set! v1-51 (the-as none (+ s5-0 736)))
+                                          (set! a0-28 (the-as none (+ s5-0 624)))
+                                          (set! a1-21 (the-as none (veccross a1-20 v1-51 a0-28)))
+                                          (set! t9-19 (the-as none vector-rotate*!))
+                                          (set! a0-29 (the-as none (+ s5-0 752)))
+                                          (set! a1-22 (the-as none (+ s5-0 752)))
+                                          (set! a2-7 (the-as none (+ a1-0 224)))
+                                          (call!)
+                                          (set! a1-23 (the-as none (+ s5-0 752)))
+                                          (set! v1-52 (the-as none (+ s5-0 752)))
+                                          (set! a0-30 (the-as none (+ s5-0 736)))
+                                          (set! a1-24 (the-as none (veccross a1-23 v1-52 a0-30)))
+                                          (set! v1-53 (the-as none (l.wu (+ a1-0 4))))
+                                          (set! f0-17 (the-as none (l.f (+ v1-53 4))))
+                                          (set! a0-31 (the-as none (+ s5-0 624)))
+                                          (set! v1-54 (the-as none (+ s5-0 752)))
+                                          (set! f1-6 (the-as none (vec3dot a0-31 v1-54)))
+                                          (set! v1-55 (the-as none (fpr->gpr f1-6)))
+                                          (set! f1-7 (the-as none (gpr->fpr v1-55)))
+                                          (set! f0-18 (the-as none (+.s f0-17 f1-7)))
+                                          (s.f! (+ s5-0 788) f0-18)
+                                          (set! v1-56 (the-as none (l.wu (+ a1-0 4))))
+                                          (set! f30-1 (the-as none (l.f (+ v1-56 16))))
+                                          s3-0
+                                          )
+                                        (set! a1-25 (the-as none (+ s5-0 736)))
+                                        (set! v1-57 (the-as none (+ s5-0 608)))
+                                        (set! a0-32 (the-as none (+ s3-0 32)))
+                                        (set! a1-26 (the-as none (vector-!2 a1-25 v1-57 a0-32)))
+                                        (set! a1-27 (the-as none (+ s5-0 752)))
+                                        (set! v1-58 (the-as none (+ s5-0 736)))
+                                        (set! a0-33 (the-as none (+ s5-0 624)))
+                                        (set! a1-28 (the-as none (veccross a1-27 v1-58 a0-33)))
+                                        (set! t9-20 (the-as none vector-rotate*!))
+                                        (set! a0-34 (the-as none (+ s5-0 752)))
+                                        (set! a1-29 (the-as none (+ s5-0 752)))
+                                        (set! a2-8 (the-as none (+ s3-0 224)))
+                                        (call!)
+                                        (set! a1-30 (the-as none (+ s5-0 752)))
+                                        (set! v1-59 (the-as none (+ s5-0 752)))
+                                        (set! a0-35 (the-as none (+ s5-0 736)))
+                                        (set! a1-31 (the-as none (veccross a1-30 v1-59 a0-35)))
+                                        (set! f0-19 (the-as none (l.f (+ s5-0 788))))
+                                        (set! v1-60 (the-as none (l.wu (+ s3-0 4))))
+                                        (set! f1-8 (the-as none (l.f (+ v1-60 4))))
+                                        (set! a0-36 (the-as none (+ s5-0 624)))
+                                        (set! v1-61 (the-as none (+ s5-0 752)))
+                                        (set! f2-0 (the-as none (vec3dot a0-36 v1-61)))
+                                        (set! v1-62 (the-as none (fpr->gpr f2-0)))
+                                        (set! f2-1 (the-as none (gpr->fpr v1-62)))
+                                        (set! f1-9 (the-as none (+.s f1-8 f2-1)))
+                                        (set! f0-20 (the-as none (+.s f0-19 f1-9)))
+                                        (s.f! (+ s5-0 788) f0-20)
+                                        (set! v1-63 (the-as none (l.wu (+ s3-0 4))))
+                                        (set! f0-21 (the-as none (l.f (+ v1-63 16))))
+                                        (set! f0-22 (the-as none (max.s f30-1 f0-21)))
+                                        (set! v1-64 (the-as none (l.wu (+ a1-0 4))))
+                                        (set! f1-10 (the-as none (l.f (+ v1-64 24))))
+                                        (set! v1-65 (the-as none (l.wu (+ s3-0 4))))
+                                        (set! f2-2 (the-as none (l.f (+ v1-65 24))))
+                                        (set! f1-11 (the-as none (*.s f1-10 f2-2)))
+                                        (set! f30-1 (the-as none (max.s f0-22 f1-11)))
+                                        (set! v1-66 (the-as none (fpr->gpr f30-1)))
+                                        )
+                                       (else
+                                         )
+                                       )
+                                     (set! v1-68 (the-as none #x3f800000))
+                                     (set! f0-23 (the-as none (gpr->fpr v1-68)))
+                                     (set! f0-24 (the-as none (+.s f0-23 f30-1)))
+                                     (set! f1-12 (the-as none (l.f (+ s5-0 784))))
+                                     (set! f1-13 (the-as none (neg.s f1-12)))
+                                     (set! f2-3 (the-as none (l.f (+ s5-0 788))))
+                                     (set! f1-14 (the-as none (/.s f1-13 f2-3)))
+                                     (set! f0-25 (the-as none (*.s f0-24 f1-14)))
+                                     (s.f! (+ s5-0 656) f0-25)
+                                     (set! v1-69 (the-as none (fpr->gpr f0-25)))
+                                     (set! v1-70 (the-as none (+ s5-0 704)))
+                                     (set! a0-37 (the-as none (+ s5-0 624)))
+                                     (set! f0-26 (the-as none (l.f (+ s5-0 656))))
+                                     (set! v1-71 (the-as none (vector-float*!2 v1-70 a0-37 f0-26)))
+                                     (set! v1-72 (the-as none (l.wu (+ a1-0 4))))
+                                     (set! f30-2 (the-as none (l.f v1-72)))
+                                     s3-0
+                                     )
+                               (set! v1-74 (the-as none (l.wu (+ s3-0 4))))
+                               (set! f0-27 (the-as none (l.f v1-74)))
+                               (set! f30-2 (the-as none (min.s f30-2 f0-27)))
+                               (set! v1-75 (the-as none (fpr->gpr f30-2)))
+                               )
+                             (when (begin
+                                     (set! v1-76 (the-as none (+ s5-0 768)))
+                                     (set! a0-38 (the-as none (+ s5-0 640)))
+                                     (set! a1-32 (the-as none (+ s5-0 624)))
+                                     (set! f0-28 (the-as none (l.f (+ s5-0 784))))
+                                     (set! f0-29 (the-as none (neg.s f0-28)))
+                                     (set! v1-77 (the-as none (vecplusfloattimes v1-76 a0-38 a1-32 f0-29)))
+                                     (set! t9-21 (the-as none vector-normalize!))
+                                     (set! a0-39 (the-as none (+ s5-0 768)))
+                                     (set! a1-33 (the-as none #x3f800000))
+                                     (call!)
+                                     (set! v1-78 (the-as none -1082130432))
+                                     (set! f0-30 (the-as none (gpr->fpr v1-78)))
+                                     (set! a0-40 (the-as none (+ s5-0 768)))
+                                     (set! v1-79 (the-as none (+ s5-0 640)))
+                                     (set! f1-15 (the-as none (vec3dot a0-40 v1-79)))
+                                     (set! v1-80 (the-as none (fpr->gpr f1-15)))
+                                     (set! f1-16 (the-as none (gpr->fpr v1-80)))
+                                     (set! f1-17 (the-as none (*.s f1-16 f30-2)))
+                                     (set! v1-81 (the-as none (l.wu (+ a1-0 4))))
+                                     (set! f2-4 (the-as none (l.f (+ v1-81 20))))
+                                     (set! f3-0 (the-as none (l.f (+ s5-0 656))))
+                                     (set! f2-5 (the-as none (*.s f2-4 f3-0)))
+                                     (set! f1-18 (the-as none (min.s f1-17 f2-5)))
+                                     (set! f0-31 (the-as none (*.s f0-30 f1-18)))
+                                     (set! v1-82 (the-as none (+ s5-0 704)))
+                                     (set! a0-41 (the-as none (+ s5-0 704)))
+                                     (set! a1-34 (the-as none (+ s5-0 768)))
+                                     (set! v1-83 (the-as none (vecplusfloattimes v1-82 a0-41 a1-34 f0-31)))
+                                     (set! a0-42 (the-as none a1-0))
+                                     (set! v1-84 (the-as none rigid-body))
+                                     (set! t9-22 (the-as none (l.wu (+ v1-84 88))))
+                                     (set! a1-35 (the-as none (+ s5-0 608)))
+                                     (set! a2-9 (the-as none (+ s5-0 704)))
+                                     (call!)
+                                     (set! v1-85 (the-as none v0-22))
+                                     s3-0
+                                     )
+                               (set! v1-87 (the-as none (+ s5-0 704)))
+                               (set! a0-43 (the-as none (+ s5-0 704)))
+                               (set! a1-36 (the-as none -1082130432))
+                               (set! f0-32 (the-as none (gpr->fpr a1-36)))
+                               (set! v1-88 (the-as none (vector-float*!2 v1-87 a0-43 f0-32)))
+                               (set! a0-44 (the-as none s3-0))
+                               (set! v1-89 (the-as none rigid-body))
+                               (set! t9-23 (the-as none (l.wu (+ v1-89 88))))
+                               (set! a1-37 (the-as none (+ s5-0 608)))
+                               (set! a2-10 (the-as none (+ s5-0 704)))
+                               (call!)
+                               (set! v1-90 (the-as none v0-23))
+                               )
+                             (set! a0-45 (the-as none a1-0))
+                             (set! v1-91 (the-as none rigid-body))
+                             (set! t9-24 (the-as none (l.wu (+ v1-91 64))))
+                             (set! a1-38 (the-as none #x3f800000))
+                             (call!)
+                             (set! v1-92 (the-as none v0-24))
+                             (set! a0-46 (the-as none a1-0))
+                             (set! v1-93 (the-as none rigid-body))
+                             (set! t9-25 (the-as none (l.wu (+ v1-93 68))))
+                             (call!)
+                             (set! v1-94 (the-as none v0-25))
+                             (set! f30-3 (the-as none (l.f (+ s5-0 112))))
+                             (set! v1-95 (the-as none #x38d1b717))
+                             (set! f0-33 (the-as none (gpr->fpr v1-95)))
+                             (<.s f30-3 f0-33)
+                             )
+                       (set! v1-97 (the-as none (+ a1-0 32)))
+                       (set! a0-47 (the-as none (+ a1-0 32)))
+                       (set! a1-39 (the-as none (+ s5-0 624)))
+                       (set! a2-11 (the-as none #x4223d70a))
+                       (set! f0-34 (the-as none (gpr->fpr a2-11)))
+                       (set! v1-98 (the-as none (vecplusfloattimes v1-97 a0-47 a1-39 f0-34)))
+                       (set! a0-48 (the-as none a1-0))
+                       (set! v1-99 (the-as none rigid-body))
+                       (set! t9-26 (the-as none (l.wu (+ v1-99 112))))
+                       (call!)
+                       (set! v1-100 (the-as none v0-26))
+                       )
+                     (when (begin
+                             (set! f0-35 (the-as none (l.f (+ s5-0 796))))
+                             (set! f1-19 (the-as none (l.f (+ s5-0 796))))
+                             (set! f1-20 (the-as none (*.s f30-3 f1-19)))
+                             (set! f0-36 (the-as none (-.s f0-35 f1-20)))
+                             (s.f! (+ s5-0 796) f0-36)
+                             (set! v1-101 (the-as none (fpr->gpr f0-36)))
+                             (set! v1-102 (the-as none (l.wu (+ s5-0 80))))
+                             (s.w! (+ s5-0 660) v1-102)
+                             (set! v1-103 (the-as none s6-0))
+                             (set! a0-49 (the-as none (l.wu (+ s5-0 116))))
+                             a0-49
+                             )
+                       (set! v1-104 (the-as none (l.wu a0-49)))
+                       (set! v1-103 (the-as none (l.wu (+ v1-104 136))))
+                       (set! a1-41 (the-as none v1-103))
+                       )
+                     (s.w! (+ s5-0 664) s3-0)
+                     (set! a1-42 (the-as none (+ sp-0 832)))
+                     v1-103
+                     )
+                   (set! a0-50 (the-as none (l.wu (+ v1-103 24))))
+                   )
+               (s.w! (+ a1-42 8) a0-50)
+               (set! v1-105 (the-as none 1))
+               (s.w! (+ a1-42 68) v1-105)
+               (set! v1-106 (the-as none 'impact-impulse))
+               (s.w! (+ a1-42 64) v1-106)
+               (set! v1-107 (the-as none (+ s5-0 608)))
+               (s.d! (+ a1-42 16) v1-107)
+               (set! t9-27 (the-as none send-event-function))
+               (set! a0-51 (the-as none (l.wu (+ a0-0 136))))
+               (call!)
+               (set! v1-108 (the-as none v0-27))
+               ((b! (not s3-0) L120 (set! v1-109 #f)) (empty-form))
+               (if (begin
+                     (set! a0-52 (the-as none s3-0))
+                     (set! v1-110 (the-as none rigid-body))
+                     (set! t9-28 (the-as none (l.wu (+ v1-110 64))))
+                     (set! a1-43 (the-as none #x3f800000))
+                     (call!)
+                     (set! v1-111 (the-as none v0-28))
+                     (set! a0-53 (the-as none s3-0))
+                     (set! v1-112 (the-as none rigid-body))
+                     (set! t9-29 (the-as none (l.wu (+ v1-112 68))))
+                     (call!)
+                     (set! v1-113 (the-as none v0-29))
+                     (set! v1-114 (the-as none (l.wu (+ s5-0 116))))
+                     (set! s2-0 (the-as none (l.wu v1-114)))
+                     (set! t9-30 (the-as none transform-rigid-body-prims))
+                     (set! a0-54 (the-as none (l.wu (+ s2-0 156))))
+                     (set! a1-44 (the-as none (+ s3-0 160)))
+                     (call!)
+                     (set! v1-115 (the-as none (+ s5-0 624)))
+                     (set! a0-55 (the-as none (+ s5-0 624)))
+                     (set! a1-45 (the-as none -1082130432))
+                     (set! f0-37 (the-as none (gpr->fpr a1-45)))
+                     (set! v1-116 (the-as none (vector-float*!2 v1-115 a0-55 f0-37)))
+                     (set! v1-117 (the-as none (+ s5-0 640)))
+                     (set! a0-56 (the-as none (+ s5-0 640)))
+                     (set! a1-46 (the-as none -1082130432))
+                     (set! f0-38 (the-as none (gpr->fpr a1-46)))
+                     (set! v1-118 (the-as none (vector-float*!2 v1-117 a0-56 f0-38)))
+                     (s.w! (+ s5-0 664) a1-0)
+                     (set! a1-47 (the-as none (+ sp-0 832)))
+                     (set! v1-119 (the-as none (l.wu (+ a0-0 136))))
+                     v1-119
+                     )
+                   (set! a0-57 (the-as none (l.wu (+ v1-119 24))))
+                   )
+               (s.w! (+ a1-47 8) a0-57)
+               (set! v1-120 (the-as none 1))
+               (s.w! (+ a1-47 68) v1-120)
+               (set! v1-121 (the-as none 'impact-impulse))
+               (s.w! (+ a1-47 64) v1-121)
+               (set! v1-122 (the-as none (+ s5-0 608)))
+               (s.d! (+ a1-47 16) v1-122)
+               (set! t9-31 (the-as none send-event-function))
+               (set! a0-58 (the-as none (l.wu (+ s2-0 136))))
+               (call!)
+               (set! v1-123 (the-as none v0-31))
+               (label cfg-32)
+               (set! v1-124 (the-as none (l.b (+ s5-0 800))))
+               (set! v1-125 (the-as none (+ v1-124 1)))
+               (s.b! (+ s5-0 800) v1-125)
+               (set! v1-126 (the-as none #x3d4ccccd))
+               (set! f0-39 (the-as none (gpr->fpr v1-126)))
+               (set! f1-21 (the-as none (l.f (+ s5-0 796))))
+               (set! v1-127 (the-as none (<.s f0-39 f1-21)))
+               (and v1-127 (begin
+                             (set! v1-129 (the-as none (l.b (+ s5-0 800))))
+                             (set! a0-59 (the-as none (l.bu (+ a0-0 140))))
+                             (set! v1-128 (the-as none (<.si v1-129 a0-59)))
+                             )
+                    )
+               (not v1-128)
+               )
+        (empty)
+        )
+      ((b! #t L125 (nop!)) (nop!))
+      (label cfg-39)
+      ((b! (not s3-0) L124 (set! v1-131 #f)) (empty-form))
+      (set! v1-132 (the-as none (l.wu (+ s5-0 116))))
+      (set! v1-133 (the-as none (l.wu v1-132)))
+      (set! v1-134 (the-as none (l.wu (+ v1-133 136))))
+      (s.w! (+ a1-0 16) v1-134)
+      (set! v1-135 (the-as none 0))
+      (label cfg-41)
+      (set! v1-136 (the-as none (+ a1-0 32)))
+      (set! a0-60 (the-as none (+ a1-0 32)))
+      (set! a1-48 (the-as none (+ s5-0 624)))
+      (set! a2-12 (the-as none #x4223d70a))
+      (set! f0-40 (the-as none (gpr->fpr a2-12)))
+      (set! v1-137 (the-as none (vecplusfloattimes v1-136 a0-60 a1-48 f0-40)))
+      (set! a0-61 (the-as none a1-0))
+      (set! v1-138 (the-as none rigid-body))
+      (set! t9-32 (the-as none (l.wu (+ v1-138 112))))
+      (call!)
+      (set! v1-139 (the-as none v0-32))
+      (set! v1-140 (the-as none 0))
+      (when (begin
+              (label cfg-42)
+              (set! f0-41 (the-as none 0))
+              (set! f1-22 (the-as none (l.f (+ s5-0 796))))
+              (<.s f0-41 f1-22)
+              )
+        (set! a0-62 (the-as none a1-0))
+        (set! v1-142 (the-as none rigid-body))
+        (set! t9-33 (the-as none (l.wu (+ v1-142 72))))
+        (set! f0-42 (the-as none (l.f (+ s5-0 796))))
+        (set! f1-23 (the-as none (l.f (+ s5-0 792))))
+        (set! f0-43 (the-as none (*.s f0-42 f1-23)))
+        (set! a1-49 (the-as none (fpr->gpr f0-43)))
+        (call!)
+        (set! v1-143 (the-as none v0-33))
+        (set! a0-63 (the-as none a1-0))
+        (set! v1-144 (the-as none rigid-body))
+        (set! t9-34 (the-as none (l.wu (+ v1-144 68))))
+        (call!)
+        (set! v1-145 (the-as none v0-34))
+        (set! t9-35 (the-as none transform-rigid-body-prims))
+        (set! a0-64 (the-as none (l.wu (+ a0-0 156))))
+        (set! a1-50 (the-as none (+ a1-0 160)))
+        (call!)
+        (set! f0-44 (the-as none 0))
+        (s.f! (+ s5-0 796) f0-44)
+        (set! v1-146 (the-as none (fpr->gpr f0-44)))
+        )
+      (label cfg-44)
+      (set! v1-147 #x3f800000)
+      (set! f0-45 (the-as float (gpr->fpr v1-147)))
+      (set! f1-24 (-> s5-0 49 w))
+      (set! f0-46 (-.s f0-45 f1-24))
+      (set! f1-25 (-> s5-0 49 z))
+      (set! f0-47 (*.s f0-46 f1-25))
+      (set! f1-26 (-> a1-0 time-remaining))
+      (set! f0-48 (-.s f1-26 f0-47))
+      (set! (-> a1-0 time-remaining) f0-48)
+      (set! v1-148 (fpr->gpr f0-48))
+      (set! v0-36 0)
+      (ret-none)
+      )
+    )
+  )
 
 ;; definition for method 15 of type rigid-body
-;; ERROR: function was not converted to expressions. Cannot decompile.
+;; INFO: Used lq/sq
+;; ERROR: failed type prop at 2: Could not figure out load: (set! v1 (l.wu gp))
+;; ERROR: Function may read a register that is not set: a0
+;; ERROR: Function may read a register that is not set: a1
+;; ERROR: Function may read a register that is not set: a2
+(defmethod rigid-body-method-15 rigid-body ()
+  (local-vars
+    (v0-0 none)
+    (v0-1 none)
+    (v0-2 none)
+    (v0-3 none)
+    (v0-4 none)
+    (v0-5 none)
+    (v0-6 none)
+    (v1-0 none)
+    (v1-1 none)
+    (v1-2 none)
+    (v1-3 none)
+    (v1-4 none)
+    (v1-5 none)
+    (v1-6 none)
+    (v1-7 none)
+    (v1-8 none)
+    (v1-10 none)
+    (v1-12 none)
+    (v1-13 none)
+    (v1-14 none)
+    (v1-15 none)
+    (v1-16 none)
+    (v1-17 none)
+    (v1-18 none)
+    (v1-20 none)
+    (v1-21 none)
+    (v1-22 none)
+    (v1-23 none)
+    (v1-24 none)
+    (v1-25 none)
+    (v1-26 none)
+    (v1-27 none)
+    (v1-28 none)
+    (v1-29 none)
+    (v1-30 none)
+    (v1-31 none)
+    (v1-32 none)
+    (v1-33 none)
+    (v1-34 none)
+    (v1-35 none)
+    (v1-36 none)
+    (v1-37 none)
+    (v1-38 none)
+    (v1-39 none)
+    (v1-41 none)
+    (v1-42 none)
+    (v1-43 none)
+    (v1-44 none)
+    (v1-45 none)
+    (v1-46 none)
+    (v1-48 none)
+    (v1-50 none)
+    (a0-0 none)
+    (a0-1 none)
+    (a0-2 none)
+    (a0-3 none)
+    (a0-4 none)
+    (a0-5 none)
+    (a0-6 none)
+    (a0-7 none)
+    (a0-8 none)
+    (a0-9 none)
+    (a0-12 none)
+    (a0-13 none)
+    (a0-14 none)
+    (a0-15 none)
+    (a0-16 none)
+    (a0-17 none)
+    (a0-18 none)
+    (a0-19 none)
+    (a0-20 none)
+    (a0-21 none)
+    (a0-22 none)
+    (a0-24 none)
+    (a0-25 none)
+    (a0-26 none)
+    (a0-27 none)
+    (a0-28 none)
+    (a1-0 none)
+    (a1-4 none)
+    (a1-5 none)
+    (a1-6 none)
+    (a1-7 none)
+    (a1-8 none)
+    (a1-9 none)
+    (a1-10 none)
+    (a1-11 none)
+    (a1-12 none)
+    (a1-13 none)
+    (a1-14 none)
+    (a1-15 none)
+    (a1-16 none)
+    (a1-17 none)
+    (a1-18 none)
+    (a1-19 none)
+    (a1-20 none)
+    (a1-21 none)
+    (a2-0 none)
+    (a2-1 none)
+    (a2-2 none)
+    (a2-3 none)
+    (a2-4 none)
+    (a2-5 none)
+    (a2-6 none)
+    (a2-7 none)
+    (a3-0 none)
+    (s2-0 none)
+    (s3-0 none)
+    (s4-0 none)
+    (t9-0 none)
+    (t9-1 none)
+    (t9-2 none)
+    (t9-3 none)
+    (t9-4 none)
+    (t9-5 none)
+    (sp-0 none)
+    (f0-0 none)
+    (f0-1 none)
+    (f0-2 none)
+    (f0-3 none)
+    (f0-4 none)
+    (f0-5 none)
+    (f0-6 none)
+    (f0-7 none)
+    (f0-8 none)
+    (f0-9 none)
+    (f0-10 none)
+    (f0-11 none)
+    (f0-12 none)
+    (f0-13 none)
+    (f0-14 none)
+    (f0-15 none)
+    (f0-16 none)
+    (f0-17 none)
+    (f0-18 none)
+    (f0-19 none)
+    (f0-20 none)
+    (f0-21 none)
+    (f0-22 none)
+    (f0-23 none)
+    (f0-24 none)
+    (f0-25 none)
+    (f0-26 none)
+    (f0-27 none)
+    (f0-28 none)
+    (f1-0 none)
+    (f1-1 none)
+    (f1-2 none)
+    (f1-3 none)
+    (f28-0 none)
+    (f30-0 none)
+    (sv-576 none)
+    (sv-624 none)
+    (sv-628 none)
+    (sv-632 none)
+    (sv-704 none)
+    (sv-708 none)
+    (sv-712 none)
+    (sv-716 none)
+    )
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (set! v1-0 (the-as none (l.wu a0-0)))
+    (set! s4-0 (the-as none (l.wu (+ a0-0 4))))
+    (set! s3-0 (the-as none (+ sp-0 16)))
+    (set! v1-1 (the-as none #x3f800000))
+    (set! f30-0 (the-as none (gpr->fpr v1-1)))
+    (set! s2-0 (the-as none 0))
+    (set! v1-2 (the-as none (+ s3-0 208)))
+    (set! a0-1 (the-as none (+ a0-0 32)))
+    (set! a0-2 (the-as none (l.q a0-1)))
+    (s.q! v1-2 a0-2)
+    (set! v1-3 (the-as none s3-0))
+    (set! a0-3 (the-as none (l.wu (+ a1-0 156))))
+    (set! f0-0 (the-as none (l.f (+ a0-3 24))))
+    (s.f! (+ v1-3 268) f0-0)
+    (set! a0-4 (the-as none (l.wu (+ a1-0 156))))
+    (set! a0-5 (the-as none (l.wu (+ a0-4 32))))
+    (s.w! (+ v1-3 100) a0-5)
+    (s.w! (+ v1-3 88) #f)
+    (s.w! (+ v1-3 92) #f)
+    (set! a0-6 (the-as none #x9000011))
+    (s.w! (+ v1-3 96) a0-6)
+    (set! a0-7 (the-as none 1))
+    (s.w! (+ v1-3 352) a0-7)
+    (until (begin
+             (set! v1-4 (the-as none (+ s3-0 224)))
+             (set! a0-8 (the-as none (+ a0-0 128)))
+             (set! f0-1 (the-as none (gpr->fpr a2-0)))
+             (set! f0-2 (the-as none (*.s f30-0 f0-1)))
+             (set! v1-5 (the-as none (vector-float*!2 v1-4 a0-8 f0-2)))
+             (set! a0-9 (the-as none *collide-cache*))
+             (set! v1-6 (the-as none (l.wu (+ a0-9 -4))))
+             (set! t9-0 (the-as none (l.wu (+ v1-6 80))))
+             (set! a1-1 (the-as none s3-0))
+             (set! v0-0 (the-as none (call!)))
+             (set! v1-7 (the-as none v0-0))
+             (set! f28-0 (the-as none (gpr->fpr v1-7)))
+             (set! f0-3 (the-as none 0))
+             (b! (>=.s f28-0 f0-3) L100 (nop!))
+             (set! v1-8 (the-as none rigid-body))
+             (set! t9-1 (the-as none (l.wu (+ v1-8 72))))
+             (set! f0-4 (the-as none (gpr->fpr a2-0)))
+             (set! f0-5 (the-as none (*.s f30-0 f0-4)))
+             (set! a1-2 (the-as none (fpr->gpr f0-5)))
+             (set! a0-10 (the-as none a0-0))
+             (call!)
+             (set! v1-9 (the-as none v0-1))
+             ((b! #t L103 (nop!)) (nop!))
+             (when (begin
+                     (label cfg-3)
+                     (set! a0-11 (the-as none a0-0))
+                     (set! v1-10 (the-as none rigid-body))
+                     (set! t9-2 (the-as none (l.wu (+ v1-10 72))))
+                     (set! f0-6 (the-as none (gpr->fpr a2-0)))
+                     (set! f0-7 (the-as none (*.s f30-0 f0-6)))
+                     (set! f0-8 (the-as none (*.s f0-7 f28-0)))
+                     (set! a1-3 (the-as none (fpr->gpr f0-8)))
+                     (call!)
+                     (set! v1-11 (the-as none v0-2))
+                     (set! v1-12 (the-as none (+ sp-0 560)))
+                     (set! sv-576 v1-12)
+                     (set! v1-13 (the-as none (+ sp-0 592)))
+                     (set! sv-624 v1-13)
+                     (set! v1-14 (the-as none (+ sp-0 608)))
+                     (set! sv-628 v1-14)
+                     (set! a1-4 sv-576)
+                     (set! v1-15 (the-as none (+ a0-0 32)))
+                     (set! a0-12 (the-as none (+ s3-0 48)))
+                     (set! a1-5 (the-as none (vector-!2 a1-4 v1-15 a0-12)))
+                     (set! t9-3 (the-as none vector-normalize!))
+                     (set! a0-13 sv-576)
+                     (set! a1-6 (the-as none #x3f800000))
+                     (call!)
+                     (set! a0-14 sv-576)
+                     (set! v1-16 (the-as none (+ a0-0 64)))
+                     (set! f0-9 (the-as none (vec3dot a0-14 v1-16)))
+                     (set! v1-17 (the-as none (fpr->gpr f0-9)))
+                     (set! f0-10 (the-as none (gpr->fpr v1-17)))
+                     (set! sv-632 f0-10)
+                     (set! v1-18 sv-632)
+                     (set! f0-11 (the-as none (gpr->fpr v1-18)))
+                     (set! f1-0 (the-as none 0))
+                     (<.s f0-11 f1-0)
+                     )
+               (set! v1-20 sv-624)
+               (set! a0-15 sv-576)
+               (set! f0-12 sv-632)
+               (set! v1-21 (the-as none (vector-float*!2 v1-20 a0-15 f0-12)))
+               (set! a1-7 sv-628)
+               (set! v1-22 (the-as none (+ a0-0 64)))
+               (set! a0-16 sv-624)
+               (set! a1-8 (the-as none (vector-!2 a1-7 v1-22 a0-16)))
+               (set! v1-23 sv-628)
+               (set! a0-17 sv-628)
+               (set! a1-9 (the-as none #x3f800000))
+               (set! f0-13 (the-as none (gpr->fpr a1-9)))
+               (set! f1-1 (the-as none (l.f (+ s4-0 20))))
+               (set! f0-14 (the-as none (-.s f0-13 f1-1)))
+               (set! v1-24 (the-as none (vector-float*!2 v1-23 a0-17 f0-14)))
+               (set! v1-25 sv-624)
+               (set! a0-18 sv-624)
+               (set! f0-15 (the-as none (l.f (+ s4-0 16))))
+               (set! f0-16 (the-as none (neg.s f0-15)))
+               (set! v1-26 (the-as none (vector-float*!2 v1-25 a0-18 f0-16)))
+               (set! a1-10 (the-as none (+ a0-0 64)))
+               (set! v1-27 sv-628)
+               (set! a0-19 sv-624)
+               (set! a1-11 (the-as none (vector+!2 a1-10 v1-27 a0-19)))
+               (set! v1-28 (the-as none (+ a0-0 128)))
+               (set! a0-20 (the-as none (+ a0-0 64)))
+               (set! f0-17 (the-as none (l.f (+ s4-0 4))))
+               (set! v1-29 (the-as none (vector-float*!2 v1-28 a0-20 f0-17)))
+               )
+             (set! v1-30 (the-as none #x38d1b717))
+             (set! f0-18 (the-as none (gpr->fpr v1-30)))
+             (b! (>=.s f28-0 f0-18) L102 (set! v1-31 #f))
+             (set! v1-32 (the-as none (+ a0-0 32)))
+             (set! a0-21 (the-as none (+ a0-0 32)))
+             (set! a1-12 sv-576)
+             (set! a2-1 (the-as none #x43cccccd))
+             (set! f0-19 (the-as none (gpr->fpr a2-1)))
+             (set! v1-33 (the-as none (vecplusfloattimes v1-32 a0-21 a1-12 f0-19)))
+             (label cfg-7)
+             (set! v1-34 (the-as none (+ sp-0 640)))
+             (set! sv-704 v1-34)
+             (set! v1-35 (the-as none (+ sp-0 656)))
+             (set! sv-708 v1-35)
+             (set! v1-36 (the-as none (+ sp-0 672)))
+             (set! sv-712 v1-36)
+             (set! v1-37 (the-as none (+ sp-0 688)))
+             (set! sv-716 v1-37)
+             (set! a1-13 sv-704)
+             (set! v1-38 (the-as none (+ s3-0 48)))
+             (set! a0-22 (the-as none (+ a0-0 32)))
+             (set! a1-14 (the-as none (vector-!2 a1-13 v1-38 a0-22)))
+             (set! a0-23 (the-as none a0-0))
+             (set! v1-39 (the-as none rigid-body))
+             (set! t9-4 (the-as none (l.wu (+ v1-39 104))))
+             (set! a1-15 (the-as none (+ s3-0 48)))
+             (set! a2-2 sv-708)
+             (call!)
+             (set! v1-40 (the-as none v0-4))
+             (set! v1-41 sv-708)
+             (set! a0-24 sv-708)
+             (set! a1-16 sv-576)
+             (set! a3-0 sv-708)
+             (set! a2-3 sv-576)
+             (set! f0-20 (the-as none (vec3dot a3-0 a2-3)))
+             (set! a2-4 (the-as none (fpr->gpr f0-20)))
+             (set! f0-21 (the-as none (gpr->fpr a2-4)))
+             (set! f0-22 (the-as none (neg.s f0-21)))
+             (set! v1-42 (the-as none (vecplusfloattimes v1-41 a0-24 a1-16 f0-22)))
+             (set! v1-43 sv-712)
+             (set! a0-25 sv-708)
+             (set! a1-17 (the-as none -1082130432))
+             (set! f0-23 (the-as none (gpr->fpr a1-17)))
+             (set! f1-2 (the-as none (l.f s4-0)))
+             (set! f0-24 (the-as none (*.s f0-23 f1-2)))
+             (set! f1-3 (the-as none (l.f (+ s4-0 20))))
+             (set! f0-25 (the-as none (*.s f0-24 f1-3)))
+             (set! v1-44 (the-as none (vector-float*!2 v1-43 a0-25 f0-25)))
+             (set! a1-18 sv-716)
+             (set! v1-45 sv-704)
+             (set! a0-26 sv-712)
+             (set! a1-19 (the-as none (veccross a1-18 v1-45 a0-26)))
+             (set! a1-20 (the-as none (+ a0-0 80)))
+             (set! v1-46 (the-as none (+ a0-0 80)))
+             (set! a0-27 sv-716)
+             (set! a2-5 (the-as none #x3f800000))
+             (set! f0-26 (the-as none (gpr->fpr a2-5)))
+             (set! a2-6 (the-as none (fpr->gpr f0-26)))
+             (.mov vf7 a2-6)
+             (.lvf vf5 a0-27)
+             (.lvf vf4 v1-46)
+             (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+             (.mul.x.vf acc vf5 vf7 :mask #b111)
+             (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+             (s.vf! a1-20 vf6)
+             (set! t9-5 (the-as none vector-rotate*!))
+             (set! a0-28 (the-as none (+ a0-0 144)))
+             (set! a1-21 (the-as none (+ a0-0 80)))
+             (set! a2-7 (the-as none (+ a0-0 224)))
+             (call!)
+             (set! v1-47 (the-as none v0-5))
+             (set! v1-48 (the-as none #x3f800000))
+             (set! f0-27 (the-as none (gpr->fpr v1-48)))
+             (set! f0-28 (the-as none (-.s f0-27 f28-0)))
+             (set! f30-0 (the-as none (*.s f30-0 f0-28)))
+             (set! s2-0 (the-as none (+ s2-0 1)))
+             (>=.si s2-0 4)
+             )
+      (empty)
+      )
+    (label cfg-9)
+    (set! v1-50 (the-as none 0))
+    (set! v0-6 (the-as none 0))
+    (ret-none)
+    )
+  )
 
 ;; definition for method 18 of type rigid-body
 ;; WARN: Return type mismatch int vs none.
@@ -829,10 +2152,9 @@
   )
 
 ;; definition for method 45 of type rigid-body-object
-;; WARN: Return type mismatch int vs none.
-(defmethod rigid-body-object-method-45 rigid-body-object ()
-  0
-  (none)
+;; WARN: Return type mismatch int vs sound-id.
+(defmethod rigid-body-object-method-45 rigid-body-object ((obj rigid-body-object) (arg0 rigid-body-object-constants))
+  (the-as sound-id 0)
   )
 
 ;; definition for method 49 of type rigid-body-object
@@ -945,8 +2267,8 @@
             )
           )
         )
+      (rigid-body-object-method-45 obj (the-as rigid-body-object-constants s5-0))
       )
-    ((method-of-object obj rigid-body-object-method-45))
     (if (and (-> obj next-state) (= (-> obj next-state name) 'idle))
         (rigid-body-object-method-43 obj)
         )
@@ -955,18 +2277,322 @@
   )
 
 ;; definition for method 48 of type rigid-body-object
-;; ERROR: function was not converted to expressions. Cannot decompile.
+;; INFO: Used lq/sq
+;; ERROR: failed type prop at 4: Could not figure out load: (set! a0 (l.wu (+ s3 4)))
+(defmethod rigid-body-object-method-48 rigid-body-object ((a0-0 rigid-body-object) (a1-0 object) (a2-0 object))
+  (local-vars
+    (v0-0 none)
+    (v0-1 none)
+    (v0-2 none)
+    (v0-3 none)
+    (v0-4 none)
+    (v0-5 none)
+    (v0-6 none)
+    (v0-7 none)
+    (v0-8 none)
+    (v0-9 none)
+    (v0-10 none)
+    (v0-11 none)
+    (v1-0 int)
+    (v1-1 none)
+    (v1-2 none)
+    (v1-3 none)
+    (v1-4 none)
+    (v1-5 none)
+    (v1-7 none)
+    (v1-8 none)
+    (v1-9 none)
+    (v1-11 none)
+    (v1-12 none)
+    (v1-13 none)
+    (v1-14 none)
+    (v1-15 none)
+    (v1-17 none)
+    (v1-18 none)
+    (v1-19 none)
+    (v1-20 none)
+    (v1-21 none)
+    (v1-23 none)
+    (v1-24 none)
+    (v1-25 none)
+    (v1-26 none)
+    (v1-27 none)
+    (v1-29 none)
+    (v1-30 none)
+    (v1-31 none)
+    (v1-32 none)
+    (v1-34 none)
+    (v1-35 none)
+    (v1-37 none)
+    (v1-38 none)
+    (v1-42 none)
+    (v1-44 none)
+    (v1-45 none)
+    (v1-46 none)
+    (v1-47 none)
+    (v1-49 none)
+    (a0-1 none)
+    (a0-2 none)
+    (a0-3 none)
+    (a0-4 none)
+    (a0-5 none)
+    (a0-6 none)
+    (a0-7 none)
+    (a0-8 none)
+    (a0-9 none)
+    (a0-10 none)
+    (a0-11 none)
+    (a0-12 none)
+    (a0-13 none)
+    (a0-14 none)
+    (a0-15 none)
+    (a0-16 none)
+    (a0-17 none)
+    (a0-18 none)
+    (a0-19 none)
+    (a0-20 none)
+    (a0-21 none)
+    (a0-22 none)
+    (a0-23 none)
+    (a0-24 none)
+    (a1-1 none)
+    (a1-3 none)
+    (a1-4 none)
+    (a1-5 none)
+    (a1-6 none)
+    (a1-7 none)
+    (a1-8 none)
+    (a1-10 none)
+    (a1-11 none)
+    (a2-2 none)
+    (a2-3 none)
+    (a2-4 none)
+    (a2-5 none)
+    (a2-6 none)
+    (a3-0 none)
+    (a3-1 none)
+    (t1-0 none)
+    (s4-0 none)
+    (s5-0 none)
+    (t9-0 none)
+    (t9-1 none)
+    (t9-2 none)
+    (t9-3 none)
+    (t9-4 none)
+    (t9-5 none)
+    (t9-6 none)
+    (t9-7 none)
+    (t9-8 none)
+    (t9-9 none)
+    (t9-10 none)
+    (sp-0 none)
+    (f0-0 none)
+    (f0-1 none)
+    (f0-2 none)
+    (f0-3 none)
+    (f0-4 none)
+    (f0-5 none)
+    (f0-6 none)
+    (f0-7 none)
+    (f0-8 none)
+    (f0-9 none)
+    (f0-10 none)
+    (f0-11 none)
+    (f0-12 none)
+    (f1-0 none)
+    (f1-1 none)
+    (f1-2 none)
+    (f1-3 none)
+    (f1-4 none)
+    (f30-0 none)
+    )
+  (set! v1-0 #xa8000)
+  (set! a0-1 (the-as none (l.wu (+ a1-0 4))))
+  (set! v1-1 (the-as none (logand v1-0 a0-1)))
+  ((bl! (zero? v1-1) L38) (set! v1-2 (the-as none #t)))
+  (set! v1-3 (the-as none (l.wu (+ a1-0 4))))
+  (set! v1-4 (the-as none (logand v1-3 #x8000)))
+  ((bl! (zero? v1-4) L38) (set! v1-2 (the-as none #f)))
+  (set! v1-5 (the-as none #t))
+  (set! a0-2 (the-as none #x100010))
+  (set! a1-1 (the-as none (l.wu (+ a1-0 196))))
+  (set! a0-3 (the-as none (logand a0-2 a1-1)))
+  (cmove-#f-zero v1-2 a0-3 v1-5)
+  (label cfg-5)
+  ((b! (truthy v1-2) L43 (nop!)) (nop!))
+  (when (begin
+          (cond
+            ((begin
+               (set! s5-0 (the-as none (+ sp-0 16)))
+               (set! s4-0 (the-as none (+ sp-0 80)))
+               (set! a0-4 (the-as none a1-0))
+               (set! v1-7 (the-as none (l.wu (+ a0-4 -4))))
+               (set! t9-0 (the-as none (l.wu (+ v1-7 120))))
+               (set! v0-0 (the-as none (call!)))
+               (set! v1-8 (the-as none v0-0))
+               (set! f30-0 (the-as none (gpr->fpr v1-8)))
+               (set! a0-5 (the-as none a0-0))
+               (set! v1-9 (the-as none (l.wu (+ a0-5 -4))))
+               (set! t9-1 (the-as none (l.wu (+ v1-9 212))))
+               (set! a1-2 (the-as none s5-0))
+               (set! a2-1 (the-as none a2-0))
+               (call!)
+               (set! v1-10 (the-as none v0-1))
+               (set! v1-11 (the-as none (l.wu (+ a0-0 180))))
+               (set! v1-12 (the-as none (l.wu (+ v1-11 20))))
+               (set! v1-13 (the-as none (logand v1-12 2)))
+               (nonzero? v1-13)
+               )
+             (set! v1-14 (the-as none (l.wu (+ a0-0 180))))
+             (set! a1-3 (the-as none (+ s5-0 0)))
+             (set! a2-2 (the-as none (+ s5-0 32)))
+             (set! a0-6 (the-as none (+ v1-14 12)))
+             (set! v1-15 (the-as none rigid-body))
+             (set! t9-2 (the-as none (l.wu (+ v1-15 104))))
+             (call!)
+             (set! v1-16 (the-as none v0-2))
+             )
+            (else
+              (set! v1-17 (the-as none (+ s5-0 32)))
+              (set! a0-7 (the-as none (l.wu (+ a0-0 124))))
+              (set! a0-8 (the-as none (+ a0-7 60)))
+              (set! a0-9 (the-as none (l.q a0-8)))
+              (s.q! v1-17 a0-9)
+              )
+            )
+          (set! v1-18 (the-as none (l.wu (+ a1-0 124))))
+          (set! a0-10 (the-as none s4-0))
+          (set! a1-4 (the-as none (+ v1-18 60)))
+          (set! a1-5 (the-as none (l.q a1-4)))
+          (s.q! a0-10 a1-5)
+          (set! a0-11 (the-as none (+ s5-0 32)))
+          (set! v1-19 (the-as none (+ v1-18 60)))
+          (set! a1-6 (the-as none (+ s5-0 32)))
+          (set! a0-12 (the-as none (vector-!2 a0-11 v1-19 a1-6)))
+          (set! a0-13 (the-as none (+ s5-0 32)))
+          (set! v1-20 (the-as none (+ s5-0 16)))
+          (set! f0-0 (the-as none (vec3dot a0-13 v1-20)))
+          (set! v1-21 (the-as none (fpr->gpr f0-0)))
+          (set! f0-1 (the-as none (gpr->fpr v1-21)))
+          (set! f1-0 (the-as none 0))
+          (<.s f0-1 f1-0)
+          )
+    (when (begin
+            (when (begin
+                    (set! v1-23 (the-as none (l.wu (+ a0-0 200))))
+                    (set! f1-1 (the-as none (l.f (+ v1-23 4))))
+                    (set! f1-2 (the-as none (+.s f30-0 f1-1)))
+                    (set! f0-2 (the-as none (/.s f0-1 f1-2)))
+                    (s.f! (+ s5-0 48) f0-2)
+                    (set! v1-24 (the-as none s4-0))
+                    (set! a0-14 (the-as none s4-0))
+                    (set! a1-7 (the-as none (+ s5-0 16)))
+                    (set! a2-3 (the-as none -1069128090))
+                    (set! f0-3 (the-as none (gpr->fpr a2-3)))
+                    (set! f0-4 (the-as none (*.s f0-3 f30-0)))
+                    (set! f1-3 (the-as none (l.f (+ s5-0 48))))
+                    (set! f0-5 (the-as none (*.s f0-4 f1-3)))
+                    (set! v1-25 (the-as none (vecplusfloattimes v1-24 a0-14 a1-7 f0-5)))
+                    (set! v1-26 (the-as none #x47400000))
+                    (set! f0-6 (the-as none (gpr->fpr v1-26)))
+                    (set! f0-7 (the-as none (*.s f0-6 f30-0)))
+                    (set! f1-4 (the-as none (l.f (+ s4-0 4))))
+                    (set! f0-8 (the-as none (max.s f0-7 f1-4)))
+                    (s.f! (+ s4-0 4) f0-8)
+                    (set! a0-15 (the-as none a0-0))
+                    (set! v1-27 (the-as none (l.wu (+ a0-15 -4))))
+                    (set! t9-3 (the-as none (l.wu (+ v1-27 184))))
+                    (call!)
+                    (set! v1-28 (the-as none v0-3))
+                    (set! a2-4 (the-as none (+ sp-0 96)))
+                    (set! v1-29 (the-as none a2-4))
+                    (set! a0-16 (the-as none (+ s5-0 16)))
+                    (set! f0-9 (the-as none (l.f (+ s5-0 48))))
+                    (set! v1-30 (the-as none (vector-float*!2 v1-29 a0-16 f0-9)))
+                    (set! v1-31 (the-as none (l.wu (+ a0-0 180))))
+                    (set! a1-8 (the-as none (+ s5-0 0)))
+                    (set! a0-17 (the-as none (+ v1-31 12)))
+                    (set! v1-32 (the-as none rigid-body))
+                    (set! t9-4 (the-as none (l.wu (+ v1-32 88))))
+                    (call!)
+                    (set! v1-33 (the-as none v0-4))
+                    (set! v1-34 (the-as none (l.wu (+ a0-0 180))))
+                    (set! a0-18 (the-as none #x3f800000))
+                    (set! f0-10 (the-as none (gpr->fpr a0-18)))
+                    (set! a0-19 (the-as none (+ v1-34 12)))
+                    (set! v1-35 (the-as none rigid-body))
+                    (set! t9-5 (the-as none (l.wu (+ v1-35 64))))
+                    (set! a1-9 (the-as none (fpr->gpr f0-10)))
+                    (call!)
+                    (set! v1-36 (the-as none v0-5))
+                    (set! v1-37 (the-as none (l.wu (+ a0-0 180))))
+                    (set! a0-20 (the-as none (+ v1-37 12)))
+                    (set! v1-38 (the-as none rigid-body))
+                    (set! t9-6 (the-as none (l.wu (+ v1-38 68))))
+                    (call!)
+                    (set! v1-39 (the-as none v0-6))
+                    #f
+                    )
+              (set! t9-7 (the-as none add-debug-x))
+              (set! a0-21 (the-as none #t))
+              (set! a1-10 (the-as none 318))
+              (set! a2-5 (the-as none (+ s5-0 0)))
+              (set! a3-0 (the-as none *color-blue*))
+              (call!)
+              (set! t9-8 (the-as none add-debug-vector))
+              (set! a0-22 (the-as none #t))
+              (set! a1-11 (the-as none 318))
+              (set! a2-6 (the-as none (+ s5-0 0)))
+              (set! a3-1 (the-as none (+ s5-0 16)))
+              (set! f0-11 (the-as none (l.f (+ s5-0 48))))
+              (set! f0-12 (the-as none (neg.s f0-11)))
+              (set! t0-0 (the-as none (fpr->gpr f0-12)))
+              (set! t1-0 (the-as none *color-blue*))
+              (call!)
+              (set! v1-41 (the-as none v0-8))
+              )
+            (and (begin
+                   (set! a0-23 (the-as none a0-0))
+                   (set! v1-42 (the-as none (l.wu (+ a0-23 -4))))
+                   (set! t9-9 (the-as none (l.wu (+ v1-42 196))))
+                   (set! a1-12 (the-as none s5-0))
+                   (call!)
+                   (set! v1-43 (the-as none v0-9))
+                   (set! v1-44 (the-as none (l.wu (+ a0-0 64))))
+                   v1-44
+                   )
+                 (begin
+                   (set! v1-46 (the-as none (l.wu (+ a0-0 64))))
+                   (set! v1-47 (the-as none (l.wu v1-46)))
+                   (set! a0-24 (the-as none 'idle))
+                   (set! v1-45 (the-as none (= v1-47 a0-24)))
+                   )
+                 )
+            v1-45
+            )
+      (set! v1-49 (the-as none (l.wu (+ a0-0 -4))))
+      (set! t9-10 (the-as none (l.wu (+ v1-49 188))))
+      (set! a0-25 (the-as none a0-0))
+      (call!)
+      (set! v1-50 (the-as none v0-10))
+      )
+    )
+  (label cfg-17)
+  (set! v0-11 (the-as none #t))
+  (ret-none)
+  )
 
 ;; definition for method 46 of type rigid-body-object
 ;; INFO: Used lq/sq
 (defmethod rigid-body-object-method-46 rigid-body-object ((obj rigid-body-object) (arg0 process-drawable) (arg1 int) (arg2 symbol) (arg3 event-message-block))
   (case arg2
     (('impact-impulse)
-     (-> arg3 param 0)
-     (if (!= obj arg0)
-         (rigid-body-object-method-42 obj)
-         )
-     ((method-of-object obj rigid-body-object-method-45))
+     (let ((s5-1 (-> arg3 param 0)))
+       (if (!= obj arg0)
+           (rigid-body-object-method-42 obj)
+           )
+       (rigid-body-object-method-45 obj (the-as rigid-body-object-constants s5-1))
+       )
      (if (and (-> obj next-state) (= (-> obj next-state name) 'idle))
          (rigid-body-object-method-43 obj)
          )
diff --git a/test/decompiler/reference/jak2/engine/process-drawable/process-drawable_REF.gc b/test/decompiler/reference/jak2/engine/process-drawable/process-drawable_REF.gc
index 33492b7d58..8d39714124 100644
--- a/test/decompiler/reference/jak2/engine/process-drawable/process-drawable_REF.gc
+++ b/test/decompiler/reference/jak2/engine/process-drawable/process-drawable_REF.gc
@@ -306,7 +306,7 @@
           (set! (-> v1-9 bone) (the-as bone (-> s3-1 bones)))
           )
         (let ((v1-10 (-> s5-0 data)))
-          (set! (-> v1-10 0 param0) (the-as (function cspace matrix none) cspace<-transformq!))
+          (set! (-> v1-10 0 param0) (the-as (function cspace transformq none) cspace<-transformq!))
           (set! (-> v1-10 0 param1) (the-as basic (-> (the-as process-drawable (-> obj process)) root trans)))
           )
         (let ((v1-12 (reset-and-assign-geo! (-> s5-0 data 1) (the-as drawable #f))))
@@ -318,7 +318,7 @@
           (set! (-> v1-14 joint) (-> arg0 data 1))
           (set! (-> v1-14 bone) (-> s3-1 bones 2))
           (set! (-> v1-14 parent) (the-as cspace (-> s5-0 data)))
-          (set! (-> v1-14 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint!))
+          (set! (-> v1-14 param0) (the-as (function cspace transformq none) cspace<-parented-matrix-joint!))
           (set! (-> v1-14 param1) (-> obj process))
           )
         (let ((s2-0 3))
@@ -396,7 +396,7 @@
               (let* ((v1-20 (-> arg0 data s1-1))
                      (t9-3 (the-as function (-> v1-20 param0)))
                      )
-                (if (the-as (function cspace matrix none) t9-3)
+                (if (the-as (function cspace transformq none) t9-3)
                     ((the-as (function object object object none) t9-3) v1-20 (-> v1-20 param1) (-> v1-20 param2))
                     )
                 )
@@ -407,7 +407,7 @@
                      (t9-4 (-> a0-11 param0))
                      )
                 (if t9-4
-                    (t9-4 a0-11 (the-as matrix a1-7))
+                    (t9-4 a0-11 (the-as transformq a1-7))
                     )
                 )
               )
@@ -417,7 +417,7 @@
                       (a1-9 (+ (* 48 s0-0) 2528 #x70000000))
                       )
                   (if (-> a0-12 param0)
-                      ((-> a0-12 param0) a0-12 (the-as matrix a1-9))
+                      ((-> a0-12 param0) a0-12 (the-as transformq a1-9))
                       (cspace<-parented-transformq-joint! a0-12 (the-as transformq a1-9))
                       )
                   )
diff --git a/test/decompiler/reference/jak2/engine/target/board/target-board_REF.gc b/test/decompiler/reference/jak2/engine/target/board/target-board_REF.gc
index 6a2fb602d6..523cb94284 100644
--- a/test/decompiler/reference/jak2/engine/target/board/target-board_REF.gc
+++ b/test/decompiler/reference/jak2/engine/target/board/target-board_REF.gc
@@ -746,7 +746,7 @@
   (logclear! (-> self control root-prim prim-core action) (collide-action can-ride))
   (set! (-> self control bend-target) 1.0)
   (let ((v1-82 (-> self node-list data)))
-    (set! (-> v1-82 0 param0) (the-as (function cspace matrix none) cspace<-transformq+world-trans!))
+    (set! (-> v1-82 0 param0) (the-as (function cspace transformq none) cspace<-transformq+world-trans!))
     (set! (-> v1-82 0 param1) (the-as basic (-> self control trans)))
     (set! (-> v1-82 0 param2) (the-as basic (-> self control cspace-offset)))
     )
@@ -825,7 +825,7 @@
     (remove-setting! 'string-spline-max-move-player)
     (remove-setting! 'string-spline-accel-player)
     (let ((v1-43 (-> self node-list data)))
-      (set! (-> v1-43 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+      (set! (-> v1-43 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
       (set! (-> v1-43 0 param1) (the-as basic (-> self control trans)))
       (set! (-> v1-43 0 param2) (the-as basic (-> self control cspace-offset)))
       )
@@ -3043,7 +3043,3 @@
     (none)
     )
   )
-
-
-
-
diff --git a/test/decompiler/reference/jak2/engine/target/logic-target_REF.gc b/test/decompiler/reference/jak2/engine/target/logic-target_REF.gc
index 9b7cd9de77..582a0d1dee 100644
--- a/test/decompiler/reference/jak2/engine/target/logic-target_REF.gc
+++ b/test/decompiler/reference/jak2/engine/target/logic-target_REF.gc
@@ -3291,7 +3291,7 @@
     )
   (logior! (-> obj skel effect flags) (effect-control-flag ecf0 ecf1))
   (let ((v1-94 (-> obj node-list data)))
-    (set! (-> v1-94 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+    (set! (-> v1-94 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
     (set! (-> v1-94 0 param1) (the-as basic (-> obj control trans)))
     (set! (-> v1-94 0 param2) (the-as basic (-> obj control cspace-offset)))
     )
diff --git a/test/decompiler/reference/jak2/engine/target/mech_suit/mech_REF.gc b/test/decompiler/reference/jak2/engine/target/mech_suit/mech_REF.gc
index b0a204d594..f884d90457 100644
--- a/test/decompiler/reference/jak2/engine/target/mech_suit/mech_REF.gc
+++ b/test/decompiler/reference/jak2/engine/target/mech_suit/mech_REF.gc
@@ -388,7 +388,7 @@
   (set! (-> self shadow-backup) (-> self draw shadow))
   (set! (-> self draw shadow-ctrl) *mech-shadow-control*)
   (let ((v1-27 (-> self node-list data)))
-    (set! (-> v1-27 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+    (set! (-> v1-27 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
     (set! (-> v1-27 0 param1) (the-as basic (-> self root-override trans)))
     (set! (-> v1-27 0 param2) (the-as basic (-> self extra-trans)))
     )
diff --git a/test/decompiler/reference/jak2/engine/target/mech_suit/target-mech_REF.gc b/test/decompiler/reference/jak2/engine/target/mech_suit/target-mech_REF.gc
index 10c788b74d..cb4d40e038 100644
--- a/test/decompiler/reference/jak2/engine/target/mech_suit/target-mech_REF.gc
+++ b/test/decompiler/reference/jak2/engine/target/mech_suit/target-mech_REF.gc
@@ -1161,7 +1161,7 @@
   (set! (-> self focus-status) (logior (focus-status mech) (-> self focus-status)))
   (set! (-> self control bend-target) 0.0)
   (let ((v1-40 (-> self node-list data)))
-    (set! (-> v1-40 0 param0) (the-as (function cspace matrix none) cspace<-transformq+world-trans!))
+    (set! (-> v1-40 0 param0) (the-as (function cspace transformq none) cspace<-transformq+world-trans!))
     (set! (-> v1-40 0 param1) (the-as basic (-> self control trans)))
     (set! (-> v1-40 0 param2) (the-as basic (-> self control cspace-offset)))
     )
@@ -1362,7 +1362,7 @@
     (set! (-> self control dynam gravity-max) (-> self control standard-dynamics gravity-max))
     (set! (-> self control dynam gravity-length) (-> self control standard-dynamics gravity-length))
     (let ((v1-39 (-> self node-list data)))
-      (set! (-> v1-39 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
+      (set! (-> v1-39 0 param0) (the-as (function cspace transformq none) cspace<-transformq+trans!))
       (set! (-> v1-39 0 param1) (the-as basic (-> self control trans)))
       (set! (-> v1-39 0 param2) (the-as basic (-> self control cspace-offset)))
       )
@@ -1787,7 +1787,3 @@
   (target-mech-real-post)
   (none)
   )
-
-
-
-
diff --git a/test/decompiler/reference/jak2/engine/target/sidekick_REF.gc b/test/decompiler/reference/jak2/engine/target/sidekick_REF.gc
index 67280e7928..56c0d10fac 100644
--- a/test/decompiler/reference/jak2/engine/target/sidekick_REF.gc
+++ b/test/decompiler/reference/jak2/engine/target/sidekick_REF.gc
@@ -180,7 +180,7 @@
          (('play-anim)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace+transformq!)
+                (the-as (function cspace transformq none) cspace<-cspace+transformq!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data))
@@ -190,7 +190,7 @@
          (('copy-parent)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace!)
+                (the-as (function cspace transformq none) cspace<-cspace!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data))
@@ -200,7 +200,7 @@
          (('root)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace-normalized!)
+                (the-as (function cspace transformq none) cspace<-cspace-normalized!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data))
@@ -210,7 +210,7 @@
          (('indax)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-transformq+trans!)
+                (the-as (function cspace transformq none) cspace<-transformq+trans!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 control trans))
@@ -222,7 +222,7 @@
          (('board)
           (set! v0-0 (-> self node-list data))
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                (the-as (function cspace matrix none) cspace<-cspace-normalized!)
+                (the-as (function cspace transformq none) cspace<-cspace-normalized!)
                 )
           (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                 (the-as basic (-> self parent-override 0 node-list data 25))
@@ -232,7 +232,7 @@
          (else
            (set! v0-0 (-> self node-list data))
            (set! (-> (the-as (inline-array cspace) v0-0) 0 param0)
-                 (the-as (function cspace matrix none) cspace<-cspace+transformq!)
+                 (the-as (function cspace transformq none) cspace<-cspace+transformq!)
                  )
            (set! (-> (the-as (inline-array cspace) v0-0) 0 param1)
                  (the-as basic (-> self parent-override 0 control sidekick-root parent))
@@ -483,7 +483,7 @@
             (send-event (ppointer->process gp-4) 'mirror #t)
             (set! (-> self mirror) gp-4)
             (let ((v0-29 (-> gp-4 0 node-list data)))
-              (set! (-> v0-29 0 param0) (the-as (function cspace matrix none) cspace<-cspace!))
+              (set! (-> v0-29 0 param0) (the-as (function cspace transformq none) cspace<-cspace!))
               (set! (-> v0-29 0 param1) (the-as basic (-> self node-list data)))
               (set! (-> v0-29 0 param2) #f)
               )
@@ -511,7 +511,7 @@
   (logior! (-> self skel status) (joint-control-status sync-math blend-shape eye-anim))
   (set! (-> self draw light-index) (the-as uint 30))
   (let ((v1-14 (-> self node-list data)))
-    (set! (-> v1-14 0 param0) (the-as (function cspace matrix none) cspace<-cspace+transformq!))
+    (set! (-> v1-14 0 param0) (the-as (function cspace transformq none) cspace<-cspace+transformq!))
     (set! (-> v1-14 0 param1) (the-as basic (-> self parent-override 0 control sidekick-root parent)))
     (set! (-> v1-14 0 param2) (the-as basic (-> self offset)))
     )
diff --git a/test/decompiler/reference/jak2/engine/util/sync-info-h_REF.gc b/test/decompiler/reference/jak2/engine/util/sync-info-h_REF.gc
index d9e91b3603..95139cd9e8 100644
--- a/test/decompiler/reference/jak2/engine/util/sync-info-h_REF.gc
+++ b/test/decompiler/reference/jak2/engine/util/sync-info-h_REF.gc
@@ -75,6 +75,7 @@
 ;; definition of type sync-linear
 (deftype sync-linear (sync-info)
   ()
+  :pack-me
   :method-count-assert 16
   :size-assert         #x10
   :flag-assert         #x1000000010
@@ -166,6 +167,7 @@
    (start-time time-frame  :offset-assert  16)
    (value      float       :offset-assert  24)
    )
+  :pack-me
   :method-count-assert 13
   :size-assert         #x1c
   :flag-assert         #xd0000001c
@@ -203,6 +205,7 @@
    (damping float  :offset-assert  16)
    (accel   float  :offset-assert  20)
    )
+  :allow-misaligned
   :method-count-assert 11
   :size-assert         #x18
   :flag-assert         #xb00000018
@@ -237,6 +240,7 @@
    (elasticity float                     :offset-assert  32)
    (state      int32                     :offset-assert  36)
    )
+  :allow-misaligned
   :method-count-assert 13
   :size-assert         #x28
   :flag-assert         #xd00000028
diff --git a/test/decompiler/reference/jak2/levels/castle/pad/caspad-obs_REF.gc b/test/decompiler/reference/jak2/levels/castle/pad/caspad-obs_REF.gc
new file mode 100644
index 0000000000..045dbbcb75
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/castle/pad/caspad-obs_REF.gc
@@ -0,0 +1,235 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type cpad-elevator
+(deftype cpad-elevator (elevator)
+  ((sound-id sound-id  :offset-assert 368)
+   )
+  :heap-base #x100
+  :method-count-assert 50
+  :size-assert         #x174
+  :flag-assert         #x3201000174
+  (:methods
+    (cpad-elevator-method-49 (_type_ symbol) none 49)
+    )
+  )
+
+;; definition for method 3 of type cpad-elevator
+(defmethod inspect cpad-elevator ((obj cpad-elevator))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type elevator inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tsound-id: ~D~%" (-> obj sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-cpad-elevator cpad-elevator cpad-elevator-lod0-jg cpad-elevator-idle-ja
+              ((cpad-elevator-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 18)
+              )
+
+;; definition for method 30 of type cpad-elevator
+(defmethod get-art-group cpad-elevator ((obj cpad-elevator))
+  "@returns The associated [[art-group]]"
+  (art-group-get-by-name *level* "skel-cpad-elevator" (the-as (pointer uint32) #f))
+  )
+
+;; definition for method 43 of type cpad-elevator
+(defmethod elevator-method-43 cpad-elevator ((obj cpad-elevator) (arg0 vector) (arg1 float) (arg2 float))
+  (let ((s4-0 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) arg1 'interp))
+        (a0-3 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) arg2 'interp))
+        (v1-3 (-> obj root-override trans))
+        )
+    (when (and (< (-> a0-3 y) (-> s4-0 y)) (< (-> arg0 y) (+ -8192.0 (-> v1-3 y))))
+      (let ((s4-2 (vector-! (new 'stack-no-clear 'vector) arg0 v1-3)))
+        (vector-inv-orient-by-quat! s4-2 s4-2 (-> obj root-override quat))
+        (and (< (fabs (-> s4-2 x)) 49152.0) (< (fabs (-> s4-2 z)) 49152.0))
+        )
+      )
+    )
+  )
+
+;; definition for method 45 of type cpad-elevator
+(defmethod elevator-method-45 cpad-elevator ((obj cpad-elevator))
+  "@returns Stub, or always returns [[#t]]"
+  (let* ((gp-0 *target*)
+         (a0-2 (if (type? gp-0 process-focusable)
+                   gp-0
+                   )
+               )
+         )
+    (when a0-2
+      (let* ((v1-1 (get-trans a0-2 0))
+             (gp-2 (vector-! (new 'stack-no-clear 'vector) v1-1 (-> obj root-override trans)))
+             )
+        (vector-inv-orient-by-quat! gp-2 gp-2 (-> obj root-override quat))
+        (and (< (fabs (-> gp-2 x)) 40960.0) (< (fabs (-> gp-2 z)) 40960.0))
+        )
+      )
+    )
+  )
+
+;; definition for method 49 of type cpad-elevator
+;; WARN: Return type mismatch int vs none.
+(defmethod cpad-elevator-method-49 cpad-elevator ((obj cpad-elevator) (arg0 symbol))
+  (let ((v1-3 (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 1)))
+    (cond
+      (arg0
+        (set! (-> v1-3 prim-core collide-as) (collide-spec obstacle pusher))
+        (set! (-> v1-3 prim-core collide-with) (collide-spec jak player-list))
+        )
+      (else
+        (set! (-> v1-3 prim-core collide-as) (collide-spec))
+        (set! (-> v1-3 prim-core collide-with) (collide-spec))
+        0
+        )
+      )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate running (cpad-elevator)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type elevator running) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (logtest? (-> self elevator-status) (elevator-status elevator-status-0))
+      (cpad-elevator-method-49 self #t)
+      (set-setting! 'jump #f 0 0)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (sound-stop (-> self sound-id))
+    (sound-play "dig-elevate-end")
+    (let ((t9-3 (-> (method-of-type elevator running) exit)))
+      (if t9-3
+          (t9-3)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (logior! (-> self elevator-status) (elevator-status elevator-status-1))
+    (until #f
+      (sound-play "dig-elevate" :id (-> self sound-id))
+      (suspend)
+      (if (= (-> self path-pos) 1.0)
+          (logclear! (-> self elevator-status) (elevator-status elevator-status-1))
+          )
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate arrived (cpad-elevator)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type elevator arrived) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (logtest? (-> self elevator-status) (elevator-status elevator-status-0))
+      (cpad-elevator-method-49 self #f)
+      (remove-setting! 'jump)
+      )
+    (none)
+    )
+  )
+
+;; definition for method 40 of type cpad-elevator
+(defmethod elevator-method-40 cpad-elevator ((obj cpad-elevator))
+  "TODO - need to figure out some flags to be confident about this"
+  (if (task-node-closed? (game-task-node dig-knock-down-introduction))
+      (go (method-of-object obj arrived))
+      (go (method-of-object obj dormant))
+      )
+  )
+
+;; definition for method 10 of type cpad-elevator
+(defmethod deactivate cpad-elevator ((obj cpad-elevator))
+  (sound-stop (-> obj sound-id))
+  ((the-as (function elevator none) (find-parent-method cpad-elevator 10)) obj)
+  (none)
+  )
+
+;; definition for method 42 of type cpad-elevator
+;; WARN: Return type mismatch ambient-sound vs none.
+(defmethod clear-ambient-sound! cpad-elevator ((obj cpad-elevator))
+  "Might be a virtual function, but clears the object's [[ambient-sound]]"
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "cpad-elevator-l" :fo-max 70) (-> obj root-override trans))
+        )
+  (none)
+  )
+
+;; definition for method 33 of type cpad-elevator
+;; WARN: Return type mismatch sound-id vs none.
+(defmethod base-plat-method-33 cpad-elevator ((obj cpad-elevator))
+  (let ((s5-0 (+ (-> obj path curve num-cverts) -1)))
+    (calc-dist-between-points! obj 0 s5-0)
+    (calc-dist-between-points! obj s5-0 0)
+    )
+  (set! (-> obj sound-id) (new-sound-id))
+  (none)
+  )
+
+;; definition for method 31 of type cpad-elevator
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod base-plat-method-31 cpad-elevator ((obj cpad-elevator))
+  "TODO - collision stuff"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 73728.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 73728.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 3)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 73728.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-20 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-20 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-20 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc b/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc
index 4741a6949c..c35bdf7e8b 100644
--- a/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc
+++ b/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc
@@ -940,10 +940,10 @@
     (set! (-> obj dividing-wall pos quad) (-> s5-3 quad))
     (set! (-> obj dividing-wall dir quad) (-> v1-28 quad))
     (vector+float*! (the-as vector (-> obj plane)) s5-3 v1-28 12288.0)
-    (set! (-> (the-as vector (&-> obj stack 320)) quad) (-> v1-28 quad))
+    (set! (-> (the-as vector (-> obj plane 0 dir)) quad) (-> v1-28 quad))
     (vector-float*! v1-28 v1-28 -1.0)
-    (vector+float*! (the-as vector (&-> obj stack 336)) s5-3 v1-28 12288.0)
-    (set! (-> (the-as vector (&-> obj stack 352)) quad) (-> v1-28 quad))
+    (vector+float*! (the-as vector (-> obj plane 1)) s5-3 v1-28 12288.0)
+    (set! (-> (the-as vector (-> obj plane 1 dir)) quad) (-> v1-28 quad))
     )
   (set! (-> obj wall-xz)
         (vector-vector-distance
diff --git a/test/decompiler/reference/jak2/levels/common/enemy/amphibian/amphibian_REF.gc b/test/decompiler/reference/jak2/levels/common/enemy/amphibian/amphibian_REF.gc
index 7fd4f7aa72..53a8e5e823 100644
--- a/test/decompiler/reference/jak2/levels/common/enemy/amphibian/amphibian_REF.gc
+++ b/test/decompiler/reference/jak2/levels/common/enemy/amphibian/amphibian_REF.gc
@@ -399,7 +399,7 @@
 ;; WARN: Return type mismatch amphibian-joint-mod vs none.
 (defmethod amphibian-joint-mod-method-9 amphibian-joint-mod ((obj amphibian-joint-mod))
   (let ((v1-3 (-> obj proc node-list data (-> obj joint-index))))
-    (set! (-> v1-3 param0) (the-as (function cspace matrix none) amphibian-joint-mod-callback))
+    (set! (-> v1-3 param0) amphibian-joint-mod-callback)
     (set! (-> v1-3 param1) obj)
     )
   (none)
diff --git a/test/decompiler/reference/jak2/levels/common/enemy/guards/crimson-guard-level_REF.gc b/test/decompiler/reference/jak2/levels/common/enemy/guards/crimson-guard-level_REF.gc
new file mode 100644
index 0000000000..6d6ac78a3b
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/common/enemy/guards/crimson-guard-level_REF.gc
@@ -0,0 +1,4485 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *crimson-guard-fact*, type fact-info-enemy-defaults
+(define *crimson-guard-fact* (new 'static 'fact-info-enemy-defaults :idle-distance (meters 200)))
+
+;; failed to figure out what this is:
+(defskelgroup skel-crimson-guard-level crimson-guard crimson-guard-lod0-jg crimson-guard-idle-ja
+              ((crimson-guard-lod0-mg (meters 20)) (crimson-guard-lod2-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 5)
+              :shadow crimson-guard-shadow-mg
+              :origin-joint-index 3
+              )
+
+;; definition of type guard-level-anim-info
+(deftype guard-level-anim-info (structure)
+  ((anim-index                int32  2 :offset-assert   0)
+   (anim-index-front          int32    :offset          0)
+   (anim-index-back           int32    :offset          4)
+   (unsigned-anim-index-front uint32   :offset          0)
+   (unsigned-anim-index-back  uint32   :offset          4)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+;; definition for method 3 of type guard-level-anim-info
+(defmethod inspect guard-level-anim-info ((obj guard-level-anim-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'guard-level-anim-info)
+  (format #t "~1Tanim-index[2] @ #x~X~%" (-> obj anim-index))
+  (format #t "~1Tanim-index-front: ~D~%" (-> obj anim-index-front))
+  (format #t "~1Tanim-index-back: ~D~%" (-> obj anim-index-back))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type guard-level-global-info
+(deftype guard-level-global-info (basic)
+  ((prev-yellow-hit         int8                            :offset-assert   4)
+   (prev-blue-hit           int8                            :offset-assert   5)
+   (knocked                 guard-level-anim-info :inline   :offset-assert   8)
+   (anim-knocked-front      int32                           :offset          8)
+   (anim-knocked-back       int32                           :offset         12)
+   (knocked-land            guard-level-anim-info :inline   :offset-assert  16)
+   (anim-knocked-front-land int32                           :offset         16)
+   (anim-knocked-back-land  int32                           :offset         20)
+   (yellow-hit-anim         guard-level-anim-info 2 :inline :offset-assert  24)
+   (yellow-land-anim        guard-level-anim-info 2 :inline :offset-assert  40)
+   (blue-hit-anim           guard-level-anim-info 1 :inline :offset-assert  56)
+   )
+  :method-count-assert 9
+  :size-assert         #x40
+  :flag-assert         #x900000040
+  )
+
+;; definition for method 3 of type guard-level-global-info
+(defmethod inspect guard-level-global-info ((obj guard-level-global-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj (-> obj type))
+  (format #t "~1Tprev-yellow-hit: ~D~%" (-> obj prev-yellow-hit))
+  (format #t "~1Tprev-blue-hit: ~D~%" (-> obj prev-blue-hit))
+  (format #t "~1Tknocked[2] @ #x~X~%" (-> obj knocked))
+  (format #t "~1Tknocked-land[2] @ #x~X~%" (-> obj knocked-land))
+  (format #t "~1Tanim-knocked-front: ~D~%" (-> obj knocked anim-index-front))
+  (format #t "~1Tanim-knocked-back: ~D~%" (-> obj knocked anim-index-back))
+  (format #t "~1Tanim-knocked-front-land: ~D~%" (-> obj knocked-land anim-index-front))
+  (format #t "~1Tanim-knocked-back-land: ~D~%" (-> obj knocked-land anim-index-back))
+  (format #t "~1Tyellow-hit-anim[2] @ #x~X~%" (-> obj yellow-hit-anim))
+  (format #t "~1Tyellow-land-anim[2] @ #x~X~%" (-> obj yellow-land-anim))
+  (format #t "~1Tblue-hit-anim[1] @ #x~X~%" (-> obj blue-hit-anim))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type guard-level-shoot-info
+(deftype guard-level-shoot-info (structure)
+  ((anim-index int32  :offset-assert   0)
+   (start      float  :offset-assert   4)
+   (end        float  :offset-assert   8)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #xc
+  :flag-assert         #x90000000c
+  )
+
+;; definition for method 3 of type guard-level-shoot-info
+(defmethod inspect guard-level-shoot-info ((obj guard-level-shoot-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'guard-level-shoot-info)
+  (format #t "~1Tanim-index: ~D~%" (-> obj anim-index))
+  (format #t "~1Tstart: ~f~%" (-> obj start))
+  (format #t "~1Tend: ~f~%" (-> obj end))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *crimson-guard-level-global-info*, type guard-level-global-info
+(define *crimson-guard-level-global-info*
+  (new 'static 'guard-level-global-info
+    :knocked (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 31 8))
+    :knocked-land (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 32 9))
+    :yellow-hit-anim (new 'static 'inline-array guard-level-anim-info 2
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 13 15))
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 15 13))
+      )
+    :yellow-land-anim (new 'static 'inline-array guard-level-anim-info 2
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 14 16))
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 16 14))
+      )
+    :blue-hit-anim (new 'static 'inline-array guard-level-anim-info 1
+      (new 'static 'guard-level-anim-info :anim-index (new 'static 'array int32 2 10 10))
+      )
+    )
+  )
+
+;; definition for symbol *crimson-guard-level-info*, type nav-enemy-info
+(define *crimson-guard-level-info* (new 'static 'nav-enemy-info
+                                     :use-die-falling #t
+                                     :use-victory #f
+                                     :use-jump-blocked #f
+                                     :debug-draw-neck #f
+                                     :jump-debug-draw #f
+                                     :move-to-ground #t
+                                     :hover-if-no-ground #f
+                                     :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+                                     :idle-anim 4
+                                     :notice-anim 7
+                                     :hostile-anim 6
+                                     :hit-anim 4
+                                     :knocked-anim 8
+                                     :knocked-land-anim 9
+                                     :die-anim 17
+                                     :die-falling-anim 39
+                                     :victory-anim 4
+                                     :jump-wind-up-anim 5
+                                     :jump-in-air-anim 5
+                                     :jump-land-anim 5
+                                     :neck-joint 6
+                                     :look-at-joint 6
+                                     :bullseye-joint 5
+                                     :sound-hit (static-sound-name "guard-hit")
+                                     :sound-die (static-sound-name "guard-die")
+                                     :notice-distance (meters 150)
+                                     :notice-distance-delta (meters 40)
+                                     :proximity-notice-distance (meters 4)
+                                     :default-hit-points 4
+                                     :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+                                     :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+                                     :penetrate-knocked #xffffffffffffffff
+                                     :movement-gravity (meters -100)
+                                     :friction 0.5
+                                     :attack-shove-back (meters 3)
+                                     :attack-shove-up (meters 2)
+                                     :attack-mode 'generic
+                                     :attack-damage 2
+                                     :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+                                     :jump-height-min (meters 3)
+                                     :jump-height-factor 0.5
+                                     :knocked-seek-ry-clamp 6371.5557
+                                     :knocked-soft-vxz-lo 32768.0
+                                     :knocked-soft-vxz-hi 53248.0
+                                     :knocked-soft-vy-lo 61440.0
+                                     :knocked-soft-vy-hi 61440.0
+                                     :knocked-medium-vxz-lo 147456.0
+                                     :knocked-medium-vxz-hi 196608.0
+                                     :knocked-medium-vy-lo 135168.0
+                                     :knocked-medium-vy-hi 151552.0
+                                     :knocked-hard-vxz-lo 40960.0
+                                     :knocked-hard-vxz-hi 61440.0
+                                     :knocked-hard-vy-lo 98304.0
+                                     :knocked-hard-vy-hi 106496.0
+                                     :knocked-huge-vxz-lo 164659.2
+                                     :knocked-huge-vxz-hi 249036.8
+                                     :knocked-huge-vy-lo 183500.8
+                                     :knocked-huge-vy-hi 217907.2
+                                     :knocked-yellow-vxz-lo 32768.0
+                                     :knocked-yellow-vxz-hi 49152.0
+                                     :knocked-yellow-vy-lo 32768.0
+                                     :knocked-yellow-vy-hi 49152.0
+                                     :knocked-red-vxz-lo 65536.0
+                                     :knocked-red-vxz-hi 81920.0
+                                     :knocked-red-vy-lo 61440.0
+                                     :knocked-red-vy-hi 61440.0
+                                     :knocked-blue-vxz-lo 32768.0
+                                     :knocked-blue-vxz-hi 65536.0
+                                     :knocked-blue-vy-lo 16384.0
+                                     :knocked-blue-vy-hi 32768.0
+                                     :shadow-size (meters 2)
+                                     :shadow-max-y (meters 1)
+                                     :shadow-min-y (meters -1)
+                                     :shadow-locus-dist (meters 150)
+                                     :gem-joint -1
+                                     :gem-offset (new 'static 'sphere :r 163840.0)
+                                     :callback-info #f
+                                     :use-momentum #f
+                                     :use-frustration #t
+                                     :use-stop-chase #f
+                                     :use-circling #f
+                                     :use-pacing #f
+                                     :walk-anim 5
+                                     :turn-anim 5
+                                     :run-anim 6
+                                     :taunt-anim -1
+                                     :run-travel-speed (meters 12)
+                                     :run-acceleration (meters 2)
+                                     :run-turning-acceleration (meters 50)
+                                     :walk-travel-speed (meters 3)
+                                     :walk-acceleration (meters 1)
+                                     :walk-turning-acceleration (meters 8)
+                                     :maximum-rotation-rate (degrees 720.0)
+                                     :notice-nav-radius (meters 5)
+                                     :frustration-distance (meters 8)
+                                     :frustration-time (seconds 2)
+                                     :blocked-time (seconds 0.3)
+                                     :circle-dist-lo 20480.0
+                                     :circle-dist-hi 61440.0
+                                     :nav-mesh #f
+                                     )
+        )
+
+;; failed to figure out what this is:
+(set! (-> *crimson-guard-level-info* fact-defaults) *crimson-guard-fact*)
+
+;; definition for symbol *crimson-guard-level-blast-info*, type nav-enemy-info
+(define *crimson-guard-level-blast-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 100)
+    :notice-distance-delta (meters 3)
+    :proximity-notice-distance (meters 100)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+;; failed to figure out what this is:
+(set! (-> *crimson-guard-level-blast-info* fact-defaults) *crimson-guard-fact*)
+
+;; definition for symbol *crimson-guard-level-grenade-info*, type nav-enemy-info
+(define *crimson-guard-level-grenade-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 300)
+    :notice-distance-delta (meters 300)
+    :proximity-notice-distance (meters 300)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+;; failed to figure out what this is:
+(set! (-> *crimson-guard-level-grenade-info* fact-defaults) *crimson-guard-fact*)
+
+;; definition for symbol *crimson-guard-level-sniper-info*, type nav-enemy-info
+(define *crimson-guard-level-sniper-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 150)
+    :notice-distance-delta (meters 40)
+    :proximity-notice-distance (meters 60)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+;; failed to figure out what this is:
+(set! (-> *crimson-guard-level-sniper-info* fact-defaults) *crimson-guard-fact*)
+
+;; definition for symbol *crimson-guard-level-tazer-info*, type nav-enemy-info
+(define *crimson-guard-level-tazer-info*
+  (new 'static 'nav-enemy-info
+    :use-die-falling #t
+    :use-victory #f
+    :use-jump-blocked #f
+    :debug-draw-neck #f
+    :jump-debug-draw #f
+    :move-to-ground #t
+    :hover-if-no-ground #f
+    :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+    :idle-anim 4
+    :notice-anim 7
+    :hostile-anim 6
+    :hit-anim 4
+    :knocked-anim 8
+    :knocked-land-anim 9
+    :die-anim 17
+    :die-falling-anim 39
+    :victory-anim 4
+    :jump-wind-up-anim 5
+    :jump-in-air-anim 5
+    :jump-land-anim 5
+    :neck-joint 6
+    :look-at-joint 6
+    :bullseye-joint 5
+    :sound-hit (static-sound-name "guard-hit")
+    :sound-die (static-sound-name "guard-die")
+    :notice-distance (meters 100)
+    :notice-distance-delta (meters 10)
+    :proximity-notice-distance (meters 100)
+    :default-hit-points 4
+    :gnd-collide-with (collide-spec backgnd obstacle hit-by-others-list pusher)
+    :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+    :penetrate-knocked #xffffffffffffffff
+    :movement-gravity (meters -100)
+    :friction 0.5
+    :attack-shove-back (meters 3)
+    :attack-shove-up (meters 2)
+    :attack-mode 'generic
+    :attack-damage 2
+    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
+    :jump-height-min (meters 3)
+    :jump-height-factor 0.5
+    :knocked-seek-ry-clamp 6371.5557
+    :knocked-soft-vxz-lo 32768.0
+    :knocked-soft-vxz-hi 53248.0
+    :knocked-soft-vy-lo 61440.0
+    :knocked-soft-vy-hi 61440.0
+    :knocked-medium-vxz-lo 147456.0
+    :knocked-medium-vxz-hi 196608.0
+    :knocked-medium-vy-lo 135168.0
+    :knocked-medium-vy-hi 151552.0
+    :knocked-hard-vxz-lo 40960.0
+    :knocked-hard-vxz-hi 61440.0
+    :knocked-hard-vy-lo 98304.0
+    :knocked-hard-vy-hi 106496.0
+    :knocked-huge-vxz-lo 164659.2
+    :knocked-huge-vxz-hi 249036.8
+    :knocked-huge-vy-lo 183500.8
+    :knocked-huge-vy-hi 217907.2
+    :knocked-yellow-vxz-lo 32768.0
+    :knocked-yellow-vxz-hi 49152.0
+    :knocked-yellow-vy-lo 32768.0
+    :knocked-yellow-vy-hi 49152.0
+    :knocked-red-vxz-lo 65536.0
+    :knocked-red-vxz-hi 81920.0
+    :knocked-red-vy-lo 61440.0
+    :knocked-red-vy-hi 61440.0
+    :knocked-blue-vxz-lo 32768.0
+    :knocked-blue-vxz-hi 65536.0
+    :knocked-blue-vy-lo 16384.0
+    :knocked-blue-vy-hi 32768.0
+    :shadow-size (meters 2)
+    :shadow-max-y (meters 1)
+    :shadow-min-y (meters -1)
+    :shadow-locus-dist (meters 150)
+    :gem-joint -1
+    :gem-offset (new 'static 'sphere :r 163840.0)
+    :callback-info #f
+    :use-momentum #f
+    :use-frustration #t
+    :use-stop-chase #f
+    :use-circling #f
+    :use-pacing #f
+    :walk-anim 5
+    :turn-anim 5
+    :run-anim 6
+    :taunt-anim -1
+    :run-travel-speed (meters 12)
+    :run-acceleration (meters 2)
+    :run-turning-acceleration (meters 50)
+    :walk-travel-speed (meters 3)
+    :walk-acceleration (meters 1)
+    :walk-turning-acceleration (meters 8)
+    :maximum-rotation-rate (degrees 720.0)
+    :notice-nav-radius (meters 3)
+    :frustration-distance (meters 8)
+    :frustration-time (seconds 2)
+    :blocked-time (seconds 0.3)
+    :circle-dist-lo 20480.0
+    :circle-dist-hi 61440.0
+    :nav-mesh #f
+    )
+  )
+
+;; failed to figure out what this is:
+(set! (-> *crimson-guard-level-tazer-info* fact-defaults) *crimson-guard-fact*)
+
+;; definition of type crimson-guard-level
+(deftype crimson-guard-level (nav-enemy)
+  ((info                    guard-level-global-info           :offset-assert 604)
+   (hit-face                uint32                            :offset-assert 608)
+   (anim-get-up-front       int32                             :offset-assert 612)
+   (anim-get-up-back        int32                             :offset-assert 616)
+   (small-hit               int32                             :offset-assert 620)
+   (yellow-anim             guard-level-anim-info   :inline   :offset-assert 624)
+   (flags                   int64                             :offset-assert 632)
+   (weapon                  int32                             :offset-assert 640)
+   (pad-kjh1n23             int32                             :offset-assert 644)
+   (last-time-see-target    int64                             :offset-assert 648)
+   (joint                   joint-mod                         :offset-assert 656)
+   (joint-enable            symbol                            :offset-assert 660)
+   (l-control               lightning-control                 :offset-assert 664)
+   (already-shot            uint32                            :offset-assert 668)
+   (miss-amount             float                             :offset-assert 672)
+   (pad-k1jh2n3             int32                             :offset-assert 676)
+   (next-shot               int64                             :offset-assert 680)
+   (anim-shoot              guard-level-shoot-info  3 :inline :offset-assert 688)
+   (target-pos              vector                  :inline   :offset-assert 736)
+   (target-pos-predict      vector                  :inline   :offset-assert 752)
+   (target-pos-predict-miss vector                  :inline   :offset-assert 768)
+   (target-vel-vec          vector                  :inline   :offset-assert 784)
+   (target-vel              float                             :offset-assert 800)
+   (target-self             vector                  :inline   :offset-assert 816)
+   (target-self-xz          vector                  :inline   :offset-assert 832)
+   (target-self-dist        float                             :offset-assert 848)
+   (target-self-xz-dist     float                             :offset-assert 852)
+   (target-y-angle          float                             :offset-assert 856)
+   (lazer-sound             sound-id                          :offset-assert 860)
+   (transport               handle                            :offset-assert 864)
+   (transport-side          uint32                            :offset-assert 872)
+   (other-side              uint32                            :offset-assert 876)
+   (start-target-pos        vector                  :inline   :offset-assert 880)
+   (start-target-vel        vector                  :inline   :offset-assert 896)
+   (trigger                 symbol                            :offset-assert 912)
+   (reachable-target-pos    vector                  :inline   :offset-assert 928)
+   )
+  :heap-base #x330
+  :method-count-assert 205
+  :size-assert         #x3b0
+  :flag-assert         #xcd033003b0
+  (:methods
+    (gun-shoot () _type_ :state 178)
+    (attack () _type_ :state 179)
+    (get-up-front () _type_ :state 180)
+    (get-up-back () _type_ :state 181)
+    (close-attack () _type_ :state 182)
+    (grenade-attack () _type_ :state 183)
+    (exit-transport () _type_ :state 184)
+    (blast-hostile () _type_ :state 185)
+    (grenade-hostile () _type_ :state 186)
+    (tazer-hostile () _type_ :state 187)
+    (roll-right () _type_ :state 188)
+    (roll-left () _type_ :state 189)
+    (arrest () _type_ :state 190)
+    (crimson-guard-level-method-191 (_type_) (pointer process) 191)
+    (crimson-guard-level-method-192 (_type_) none 192)
+    (crimson-guard-level-method-193 (_type_) symbol 193)
+    (crimson-guard-level-method-194 (_type_) symbol 194)
+    (crimson-guard-level-method-195 (_type_ vector vector vector) int 195)
+    (crimson-guard-level-method-196 (_type_ vector) none 196)
+    (crimson-guard-level-method-197 (_type_) quaternion 197)
+    (crimson-guard-level-method-198 (_type_) none 198)
+    (crimson-guard-level-method-199 (_type_ vector vector vector float) symbol 199)
+    (crimson-guard-level-method-200 (_type_) float 200)
+    (crimson-guard-level-method-201 (_type_ float) none 201)
+    (crimson-guard-level-method-202 (_type_ vector) float 202)
+    (crimson-guard-level-method-203 (_type_ int) none 203)
+    (crimson-guard-level-method-204 (_type_) none 204)
+    )
+  )
+
+;; definition for method 3 of type crimson-guard-level
+(defmethod inspect crimson-guard-level ((obj crimson-guard-level))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type nav-enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tinfo: ~A~%" (-> obj info))
+  (format #t "~2Thit-face: ~D~%" (-> obj hit-face))
+  (format #t "~2Tanim-get-up-front: ~D~%" (-> obj anim-get-up-front))
+  (format #t "~2Tanim-get-up-back: ~D~%" (-> obj anim-get-up-back))
+  (format #t "~2Tsmall-hit: ~D~%" (-> obj small-hit))
+  (format #t "~2Tyellow-anim: ~D~%" (-> obj yellow-anim unsigned-anim-index-front))
+  (format #t "~2Tflags: ~D~%" (-> obj flags))
+  (format #t "~2Tweapon: ~D~%" (-> obj weapon))
+  (format #t "~2Tlast-time-see-target: ~D~%" (-> obj last-time-see-target))
+  (format #t "~2Tjoint: ~A~%" (-> obj joint))
+  (format #t "~2Tjoint-enable: ~A~%" (-> obj joint-enable))
+  (format #t "~2Tl-control: ~A~%" (-> obj l-control))
+  (format #t "~2Talready-shot: ~A~%" (-> obj already-shot))
+  (format #t "~2Tmiss-amount: ~f~%" (-> obj miss-amount))
+  (format #t "~2Tnext-shot: ~D~%" (-> obj next-shot))
+  (format #t "~2Tanim-shoot[3] @ #x~X~%" (-> obj anim-shoot))
+  (format #t "~2Ttarget-pos: #<vector @ #x~X>~%" (-> obj target-pos))
+  (format #t "~2Ttarget-pos-predict: #<vector @ #x~X>~%" (-> obj target-pos-predict))
+  (format #t "~2Ttarget-pos-predict-miss: #<vector @ #x~X>~%" (-> obj target-pos-predict-miss))
+  (format #t "~2Ttarget-vel-vec: #<vector @ #x~X>~%" (-> obj target-vel-vec))
+  (format #t "~2Ttarget-vel: ~f~%" (-> obj target-vel))
+  (format #t "~2Ttarget-self: #<vector @ #x~X>~%" (-> obj target-self))
+  (format #t "~2Ttarget-self-xz: #<vector @ #x~X>~%" (-> obj target-self-xz))
+  (format #t "~2Ttarget-self-dist: ~f~%" (-> obj target-self-dist))
+  (format #t "~2Ttarget-self-xz-dist: ~f~%" (-> obj target-self-xz-dist))
+  (format #t "~2Ttarget-y-angle: ~f~%" (-> obj target-y-angle))
+  (format #t "~2Tlazer-sound: ~D~%" (-> obj lazer-sound))
+  (format #t "~2Ttransport: ~D~%" (-> obj transport))
+  (format #t "~2Ttransport-side: ~D~%" (-> obj transport-side))
+  (format #t "~2Tother-side: ~A~%" (-> obj other-side))
+  (format #t "~2Tstart-target-pos: #<vector @ #x~X>~%" (-> obj start-target-pos))
+  (format #t "~2Tstart-target-vel: #<vector @ #x~X>~%" (-> obj start-target-vel))
+  (format #t "~2Ttrigger: ~A~%" (-> obj trigger))
+  (format #t "~2Treachable-target-pos: #<vector @ #x~X>~%" (-> obj reachable-target-pos))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 72 of type crimson-guard-level
+(defmethod enemy-method-72 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (-> obj focus aware)))
+    (cond
+      ((and (= s5-0 (enemy-aware enemy-aware-3)) (enemy-method-107 obj))
+       (go-hostile obj)
+       )
+      ((and (= s5-0 (enemy-aware enemy-aware-2)) (enemy-method-107 obj))
+       (go-hostile obj)
+       )
+      ((<= (the-as int s5-0) 0)
+       (go (method-of-object obj idle))
+       )
+      ((>= 1 (the-as int s5-0))
+       (go (method-of-object obj active))
+       )
+      ((= s5-0 (enemy-aware enemy-aware-4))
+       (go-flee obj)
+       )
+      (else
+        (go-stare obj)
+        )
+      )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate active (crimson-guard-level)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (when (logtest? (-> self flags) 4)
+      (logior! (-> self nav state flags) (nav-state-flag at-target))
+      (let ((v1-9 self))
+        (set! (-> v1-9 enemy-flags) (the-as enemy-flag (logclear (-> v1-9 enemy-flags) (enemy-flag enemy-flag36))))
+        (set! (-> v1-9 nav callback-info) *nav-enemy-null-callback-info*)
+        )
+      0
+      (let ((v1-12 self))
+        (set! (-> v1-12 enemy-flags) (the-as enemy-flag (logclear (-> v1-12 enemy-flags) (enemy-flag enemy-flag37))))
+        )
+      0
+      )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate stare (crimson-guard-level)
+  :virtual #t
+  :trans (behavior ()
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (let ((gp-0 (-> self focus aware)))
+        (cond
+          ((>= 1 (the-as int gp-0))
+           (go-virtual active)
+           )
+          ((and (= gp-0 (enemy-aware enemy-aware-3)) (enemy-method-107 self))
+           (go-hostile self)
+           )
+          ((and (= gp-0 (enemy-aware enemy-aware-2)) (enemy-method-107 self))
+           (if (logtest? (-> self flags) 1)
+               (go-virtual arrest)
+               (go-hostile self)
+               )
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 74 of type crimson-guard-level
+;; WARN: Return type mismatch none vs object.
+(defmethod enemy-method-74 crimson-guard-level ((obj crimson-guard-level) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (let ((v1-0 arg2))
+    (the-as
+      object
+      (cond
+        ((= v1-0 'event-death)
+         (when (<= (-> obj hit-points) 0)
+           (set! (-> obj root-override2 penetrated-by) (the-as penetrate -1))
+           (the-as object (do-effect (-> obj skel effect) 'death-default 0.0 -1))
+           )
+         )
+        ((or (= v1-0 'hit) (= v1-0 'hit-flinch) (= v1-0 'hit-knocked))
+         (speech-control-method-13 *speech-control* (the-as handle obj))
+         (let* ((s1-0 (handle->process (-> obj incoming attacker-handle)))
+                (a0-13 (if (type? s1-0 process-focusable)
+                           s1-0
+                           )
+                       )
+                )
+           (if (and a0-13 (logtest? (-> a0-13 mask) (process-mask target)))
+               (speech-control-method-12 *speech-control* obj (speech-type speech-type-0 speech-type-1 speech-type-3))
+               )
+           )
+         ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+         )
+        ((= v1-0 'trigger)
+         (let ((v0-0 (the-as object #t)))
+           (set! (-> obj trigger) (the-as symbol v0-0))
+           v0-0
+           )
+         )
+        ((= v1-0 'untrigger)
+         (set! (-> obj trigger) #f)
+         #f
+         )
+        ((= v1-0 'notify)
+         (let ((a0-21 (-> arg3 param 0))
+               (v1-16 (the-as object (-> arg3 param 1)))
+               )
+           (when (= a0-21 'attack)
+             (when (logtest? (-> (the-as process-focusable v1-16) mask) (process-mask target))
+               (if (logtest? (-> (the-as process-focusable v1-16) focus-status) (focus-status dead))
+                   (speech-control-method-12 *speech-control* obj (speech-type speech-type-1 speech-type-3))
+                   )
+               )
+             )
+           )
+         ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+         )
+        (else
+          ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+          )
+        )
+      )
+    )
+  )
+
+;; definition for method 191 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod crimson-guard-level-method-191 crimson-guard-level ((obj crimson-guard-level))
+  (let* ((s4-0 (-> obj target-pos-predict-miss))
+         (s5-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14)))
+         (v1-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 15)))
+         (v1-3 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) s4-0 v1-2) 1.0))
+         (s4-1 (new 'stack-no-clear 'projectile-init-by-other-params))
+         )
+    (set! (-> s4-1 ent) (-> obj entity))
+    (set! (-> s4-1 charge) 1.0)
+    (set! (-> s4-1 options) (projectile-options))
+    (set! (-> s4-1 notify-handle) (process->handle obj))
+    (set! (-> s4-1 owner-handle) (the-as handle #f))
+    (set! (-> s4-1 ignore-handle) (process->handle obj))
+    (let* ((a0-13 *game-info*)
+           (a1-12 (+ (-> a0-13 attack-id) 1))
+           )
+      (set! (-> a0-13 attack-id) a1-12)
+      (set! (-> s4-1 attack-id) a1-12)
+      )
+    (set! (-> s4-1 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+    (set! (-> s4-1 pos quad) (-> s5-0 quad))
+    (set! (-> s4-1 vel quad) (-> v1-3 quad))
+    (vector-normalize! (-> s4-1 vel) 819200.0)
+    (spawn-projectile guard-shot s4-1 obj *default-dead-pool*)
+    )
+  )
+
+;; definition for method 195 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod crimson-guard-level-method-195 crimson-guard-level ((obj crimson-guard-level) (arg0 vector) (arg1 vector) (arg2 vector))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s5-0 (new 'stack-no-clear 'collide-query)))
+      (let ((f0-0 1228.8)
+            (f30-0 6144.0)
+            )
+        (set! (-> s5-0 start-pos quad) (-> arg0 quad))
+        (vector-! (-> s5-0 move-dist) arg1 arg0)
+        (let ((v1-4 s5-0))
+          (set! (-> v1-4 radius) f0-0)
+          (set! (-> v1-4 collide-with) (collide-spec backgnd))
+          (set! (-> v1-4 ignore-process0) obj)
+          (set! (-> v1-4 ignore-process1) (handle->process (-> obj focus handle)))
+          (set! (-> v1-4 ignore-pat)
+                (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
+                )
+          (set! (-> v1-4 action-mask) (collide-action solid))
+          )
+        (let ((f0-1 (fill-and-probe-using-line-sphere *collide-cache* s5-0)))
+          (cond
+            ((>= f0-1 0.0)
+             (vector-float*! (-> s5-0 move-dist) (-> s5-0 move-dist) f0-1)
+             (cond
+               ((< (vector-dot
+                     (-> s5-0 best-other-tri normal)
+                     (vector-! (new 'stack-no-clear 'vector) arg2 (the-as vector (-> s5-0 best-other-tri)))
+                     )
+                   0.0
+                   )
+                (return 1)
+                )
+               (else
+                 )
+               )
+             )
+            (else
+              (vector-! (-> s5-0 move-dist) arg1 arg0)
+              )
+            )
+          )
+        (set! (-> s5-0 start-pos quad) (-> arg0 quad))
+        (let ((a0-19 (-> s5-0 start-pos)))
+          (let ((v1-15 (-> s5-0 move-dist)))
+            (let ((a1-10 -0.1))
+              (.mov vf7 a1-10)
+              )
+            (.lvf vf5 (&-> v1-15 quad))
+            )
+          (.lvf vf4 (&-> arg0 quad))
+          (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+          (.mul.x.vf acc vf5 vf7 :mask #b111)
+          (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+          (.svf (&-> a0-19 quad) vf6)
+          )
+        (let ((a1-11 (-> s5-0 move-dist)))
+          (let ((v1-16 (-> s5-0 move-dist)))
+            (let ((a0-20 (-> s5-0 move-dist)))
+              (let ((a2-4 0.1))
+                (.mov vf7 a2-4)
+                )
+              (.lvf vf5 (&-> a0-20 quad))
+              )
+            (.lvf vf4 (&-> v1-16 quad))
+            )
+          (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+          (.mul.x.vf acc vf5 vf7 :mask #b111)
+          (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+          (.svf (&-> a1-11 quad) vf6)
+          )
+        (let ((v1-17 s5-0))
+          (set! (-> v1-17 radius) f30-0)
+          (set! (-> v1-17 collide-with) (collide-spec enemy obstacle hit-by-player-list hit-by-others-list))
+          (set! (-> v1-17 ignore-process0) obj)
+          (set! (-> v1-17 ignore-process1) (handle->process (-> obj focus handle)))
+          (set! (-> v1-17 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-17 action-mask) (collide-action solid))
+          )
+        )
+      (cond
+        ((< (fill-and-probe-using-line-sphere *collide-cache* s5-0) 0.0)
+         0
+         )
+        (else
+          (let ((s4-1 (-> s5-0 best-other-tri collide-ptr)))
+            (if (and (if (type? s4-1 collide-shape-prim)
+                         s4-1
+                         )
+                     (< (vector-dot
+                          (-> s5-0 best-other-tri normal)
+                          (vector-! (new 'stack-no-clear 'vector) arg2 (the-as vector (-> s5-0 best-other-tri)))
+                          )
+                        0.0
+                        )
+                     )
+                2
+                0
+                )
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for method 193 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod crimson-guard-level-method-193 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (get-trans obj 3))
+        (s4-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s4-0 quad) (-> obj target-pos quad))
+    (let ((s3-1 (vector-! (new 'stack-no-clear 'vector) s4-0 s5-0)))
+      (vector-normalize! s3-1 409600.0)
+      (zero? (crimson-guard-level-method-195 obj s5-0 (vector+! (new 'stack-no-clear 'vector) s5-0 s3-1) s4-0))
+      )
+    )
+  )
+
+;; definition for method 194 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod crimson-guard-level-method-194 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (new 'stack-no-clear 'vector)))
+    (set! (-> s5-0 quad) (-> obj target-pos-predict-miss quad))
+    (let* ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14)))
+           (a0-3 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 15)))
+           (s3-1 (vector-! (new 'stack-no-clear 'vector) s5-0 a0-3))
+           )
+      (vector-normalize! s3-1 409600.0)
+      (and (crimson-guard-level-method-193 obj)
+           (zero? (crimson-guard-level-method-195 obj s4-0 (vector+! (new 'stack-no-clear 'vector) s4-0 s3-1) s5-0))
+           )
+      )
+    )
+  )
+
+;; definition for method 196 of type crimson-guard-level
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod crimson-guard-level-method-196 crimson-guard-level ((obj crimson-guard-level) (arg0 vector))
+  (local-vars
+    (sv-240 vector)
+    (sv-256 (function vector vector vector))
+    (sv-272 vector)
+    (sv-288 vector)
+    (sv-304 vector)
+    (sv-320 vector)
+    )
+  (with-pp
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (set! sv-240 arg0)
+      (let ((s0-0 (new 'stack-no-clear 'vector)))
+        (let ((v1-1 (-> obj root-override2 trans)))
+          (let ((a0-1 *y-vector*))
+            (let ((a1-2 8192.0))
+              (.mov vf7 a1-2)
+              )
+            (.lvf vf5 (&-> a0-1 quad))
+            )
+          (.lvf vf4 (&-> v1-1 quad))
+          )
+        (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+        (.mul.x.vf acc vf5 vf7 :mask #b111)
+        (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+        (.svf (&-> s0-0 quad) vf6)
+        (set! sv-320 (new 'stack-no-clear 'vector))
+        (set! sv-304 (new 'stack-no-clear 'vector))
+        (let ((s1-0 (new 'stack-no-clear 'vector))
+              (s2-0 (new 'stack-no-clear 'vector))
+              (s5-0 (new 'stack-no-clear 'vector))
+              )
+          (-> obj node-list data 4 bone transform)
+          (let ((s4-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+                (s3-0 (vector-y-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+                )
+            (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat))
+            (set! (-> s0-0 quad) (-> obj root-override2 trans quad))
+            (cond
+              ((logtest? (enemy-flag dislike-combo) (-> obj enemy-flags))
+               (let ((a1-6 s0-0))
+                 (let ((v1-14 s0-0))
+                   (let ((a0-9 s4-0))
+                     (let ((a2-1 4096.0))
+                       (.mov vf7 a2-1)
+                       )
+                     (.lvf vf5 (&-> a0-9 quad))
+                     )
+                   (.lvf vf4 (&-> v1-14 quad))
+                   )
+                 (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                 (.mul.x.vf acc vf5 vf7 :mask #b111)
+                 (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                 (.svf (&-> a1-6 quad) vf6)
+                 )
+               )
+              (else
+                (let ((a1-7 s0-0))
+                  (let ((v1-15 s0-0))
+                    (let ((a0-10 s4-0))
+                      (let ((a2-3 2048.0))
+                        (.mov vf7 a2-3)
+                        )
+                      (.lvf vf5 (&-> a0-10 quad))
+                      )
+                    (.lvf vf4 (&-> v1-15 quad))
+                    )
+                  (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                  (.mul.x.vf acc vf5 vf7 :mask #b111)
+                  (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                  (.svf (&-> a1-7 quad) vf6)
+                  )
+                )
+              )
+            (let ((a1-8 s0-0))
+              (let ((v1-16 s0-0))
+                (let ((a0-11 s3-0))
+                  (let ((a2-5 8540.16))
+                    (.mov vf7 a2-5)
+                    )
+                  (.lvf vf5 (&-> a0-11 quad))
+                  )
+                (.lvf vf4 (&-> v1-16 quad))
+                )
+              (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+              (.mul.x.vf acc vf5 vf7 :mask #b111)
+              (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+              (.svf (&-> a1-8 quad) vf6)
+              )
+            (vector-normalize! (vector-! sv-320 sv-240 s0-0) 1.0)
+            (set! sv-288 (new 'stack-no-clear 'vector))
+            (let ((v1-20 (-> sv-240 quad)))
+              (set! (-> sv-288 quad) v1-20)
+              )
+            (set! sv-256 vector-rotate90-around-y!)
+            (set! sv-272 (new 'stack-no-clear 'vector))
+            (let* ((a1-13 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) sv-288 s0-0) -2998.272))
+                   (v0-5 (sv-256 sv-272 a1-13))
+                   )
+              (vector+! sv-288 sv-288 v0-5)
+              )
+            (vector-normalize! (vector-! sv-320 sv-288 s0-0) 1.0)
+            (vector-z-quaternion! sv-304 (-> obj root-override2 quat))
+            (rot-zxy-from-vector! s2-0 sv-304)
+            (rot-zxy-from-vector! s1-0 sv-320)
+            (set! (-> s5-0 x) (fmax -14563.556 (fmin 14563.556 (deg- (-> s1-0 x) (-> s2-0 x)))))
+            (set! (-> s5-0 y) (fmax -14563.556 (fmin 14563.556 (deg- (-> s1-0 y) (-> s2-0 y)))))
+            (set! (-> s5-0 z) 0.0)
+            (let ((s2-1 (new 'stack-no-clear 'quaternion)))
+              (let ((s1-1 (new 'stack-no-clear 'quaternion)))
+                (quaternion-vector-angle! s2-1 s4-0 (-> s5-0 x))
+                (quaternion-vector-angle! s1-1 s3-0 (-> s5-0 y))
+                (quaternion*! s2-1 s1-1 s2-1)
+                )
+              (quaternion-pseudo-seek (-> obj joint quat) (-> obj joint quat) s2-1 (-> pp clock seconds-per-frame))
+              )
+            )
+          )
+        )
+      0
+      (none)
+      )
+    )
+  )
+
+;; definition for method 197 of type crimson-guard-level
+(defmethod crimson-guard-level-method-197 crimson-guard-level ((obj crimson-guard-level))
+  (with-pp
+    (quaternion-pseudo-seek
+      (-> obj joint quat)
+      (-> obj joint quat)
+      *unity-quaternion*
+      (-> pp clock seconds-per-frame)
+      )
+    )
+  )
+
+;; definition for method 55 of type crimson-guard-level
+;; WARN: Return type mismatch object vs none.
+(defmethod enemy-method-55 crimson-guard-level ((obj crimson-guard-level))
+  (let ((t9-0 (method-of-type nav-enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (if (-> obj joint-enable)
+      (crimson-guard-level-method-196 obj (-> obj target-pos-predict-miss))
+      (crimson-guard-level-method-197 obj)
+      )
+  (case (-> obj root-override2 cur-pat event)
+    (((pat-event melt))
+     (if (not (and (-> obj next-state) (= (-> obj next-state name) 'die)))
+         (go (method-of-object obj die))
+         )
+     )
+    )
+  (none)
+  )
+
+;; definition for method 200 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod crimson-guard-level-method-200 crimson-guard-level ((obj crimson-guard-level))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s5-0 (handle->process (-> obj focus handle))))
+      (when s5-0
+        (set! (-> obj target-pos quad) (-> (get-trans (the-as process-focusable s5-0) 3) quad))
+        (if (= (-> obj focus aware) (enemy-aware enemy-aware-3))
+            (cloest-point-on-mesh (-> obj nav) (-> obj reachable-target-pos) (-> obj target-pos) (the-as nav-poly #f))
+            )
+        (set! (-> obj target-vel-vec quad) (-> (the-as process-focusable s5-0) root-override transv quad))
+        (set! (-> obj target-vel) (vector-length (-> obj target-vel-vec)))
+        (let ((s5-2 (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 trans) (-> obj target-pos))))
+          (let ((f0-2 (/ (vector-length s5-2) (if (= (-> obj weapon) 3)
+                                                  90112.0
+                                                  819200.0
+                                                  )
+                         )
+                      )
+                (a1-3 (-> obj target-pos-predict))
+                )
+            (let ((v1-20 (-> obj target-pos)))
+              (let ((a0-12 (-> obj target-vel-vec)))
+                (let ((a2-1 f0-2))
+                  (.mov vf7 a2-1)
+                  )
+                (.lvf vf5 (&-> a0-12 quad))
+                )
+              (.lvf vf4 (&-> v1-20 quad))
+              )
+            (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+            (.mul.x.vf acc vf5 vf7 :mask #b111)
+            (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+            (.svf (&-> a1-3 quad) vf6)
+            )
+          (set! (-> s5-2 y) 0.0)
+          (vector-rotate90-around-y! s5-2 s5-2)
+          (if (-> obj other-side)
+              (vector-negate! s5-2 s5-2)
+              )
+          (vector-normalize! s5-2 (-> obj miss-amount))
+          (vector+! (-> obj target-pos-predict-miss) (-> obj target-pos-predict) s5-2)
+          )
+        (vector-! (-> obj target-self) (-> obj target-pos) (-> obj root-override2 trans))
+        (set! (-> obj target-self-xz quad) (-> obj target-self quad))
+        (set! (-> obj target-self-xz y) 0.0)
+        (set! (-> obj target-self-dist) (vector-length (-> obj target-self)))
+        (set! (-> obj target-self-xz-dist) (vector-length (-> obj target-self-xz)))
+        (set! (-> obj target-y-angle)
+              (deg-diff (quaternion-y-angle (-> obj root-override2 quat)) (vector-y-angle (-> obj target-self)))
+              )
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate notice (crimson-guard-level)
+  :virtual #t
+  :enter (behavior ()
+    (talker-spawn-func (-> *talker-speech* 10) *entity-pool* (target-pos 0) (the-as region #f))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-4 (logior (-> self enemy-flags) (enemy-flag use-notice-distance))))
+      (set! (-> self enemy-flags) (logclear v1-4 (enemy-flag called-dying)))
+      )
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (enemy-method-109 self 1)
+    (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
+      (let ((gp-1 (-> self on-notice)))
+        (if gp-1
+            (eval!
+              (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
+              (the-as pair gp-1)
+              )
+            )
+        )
+      )
+    (let ((gp-2 (-> self focus aware)))
+      (when (logtest? (-> self enemy-flags) (enemy-flag chase-startup))
+        (cond
+          ((and (= gp-2 (enemy-aware enemy-aware-3)) (enemy-method-107 self))
+           (go-hostile self)
+           )
+          ((and (= gp-2 (enemy-aware enemy-aware-2)) (enemy-method-107 self))
+           (go-hostile self)
+           )
+          ((= gp-2 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          (else
+            (go-stare self)
+            )
+          )
+        )
+      )
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-1))
+    (logior! (-> self enemy-flags) (enemy-flag chase-startup))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.075))
+    (let ((f30-0 (get-rand-float-range self 0.8 1.2))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override notice-anim))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override notice-anim)))
+                                frames
+                                num-frames
+                                )
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (vector-! gp-0 (target-pos 0) (-> self root-override2 trans))
+        (seek-toward-heading-vec! (-> self root-override2) gp-0 131072.0 (seconds 0.05))
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (cond
+      ((logtest? (-> self flags) 2)
+       (go-virtual gun-shoot)
+       )
+      ((logtest? (-> self flags) 8)
+       (go-virtual grenade-attack)
+       )
+      (else
+        (enemy-method-72 self)
+        )
+      )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (if (logtest? (-> self flags) 4)
+        (go-virtual gun-shoot)
+        )
+    (set! (-> self reaction-time) (the-as uint (the int (* 300.0 (get-rand-float-range self 1.0 3.0)))))
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (< (the-as int gp-0) 2) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (when (handle->process (-> self focus handle))
+      (if (and (< (-> self target-self-xz-dist) 12288.0)
+               (enemy-method-96 self 3640.889 #t)
+               (nav-enemy-method-158 self (-> self target-pos))
+               )
+          (go-virtual close-attack)
+          )
+      (let ((v1-31 (-> self weapon)))
+        (cond
+          ((zero? v1-31)
+           )
+          ((= v1-31 1)
+           (if (< (-> self target-self-xz-dist) 28672.0)
+               (go-virtual attack)
+               )
+           )
+          ((= v1-31 3)
+           (if (and (< (-> self target-self-xz-dist) 12288.0)
+                    (enemy-method-96 self 3640.889 #t)
+                    (nav-enemy-method-158 self (-> self target-pos))
+                    )
+               (go-virtual close-attack)
+               )
+           (if (and (< (-> self target-self-xz-dist) 573440.0) (and (< 81920.0 (-> self target-self-xz-dist))
+                                                                    (enemy-method-96 self 1820.4445 #t)
+                                                                    (crimson-guard-level-method-193 self)
+                                                                    )
+                    )
+               (go-virtual grenade-attack)
+               )
+           )
+          )
+        )
+      )
+    (let ((a0-21 (-> self nav state))
+          (v1-62 (-> self target-pos))
+          )
+      (logclear! (-> a0-21 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-21 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-21 target-post quad) (-> v1-62 quad))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate tazer-hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    ((-> (method-of-type nav-enemy hostile) enter))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self reaction-time) (the-as uint (the int (* 300.0 (get-rand-float-range self 0.5 1.5)))))
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (>= 2 (the-as int gp-0)) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (when (handle->process (-> self focus handle))
+      (if (and (< (-> self target-self-xz-dist) 12288.0)
+               (enemy-method-96 self 3640.889 #t)
+               (nav-enemy-method-158 self (-> self target-pos))
+               )
+          (go-virtual close-attack)
+          )
+      (if (< (-> self target-self-xz-dist) 28672.0)
+          (go-virtual attack)
+          )
+      )
+    (let ((a0-13 (-> self nav state))
+          (v1-38 (-> self target-pos))
+          )
+      (logclear! (-> a0-13 flags) (nav-state-flag directional-mode))
+      (logior! (-> a0-13 flags) (nav-state-flag target-poly-dirty))
+      (set! (-> a0-13 target-post quad) (-> v1-38 quad))
+      )
+    0
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate blast-hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    ((-> (method-of-type nav-enemy hostile) enter))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (nav-enemy-method-156 self)
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (< (the-as int gp-0) 2) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (let ((a0-8 (handle->process (-> self focus handle))))
+      (when a0-8
+        (cond
+          ((and (< (-> self target-self-xz-dist) 81920.0) (= (-> self focus aware) (enemy-aware enemy-aware-3)))
+           (let ((gp-1 (-> self nav state))
+                 (v1-26 (get-trans (the-as process-focusable a0-8) 1))
+                 )
+             (logclear! (-> gp-1 flags) (nav-state-flag directional-mode))
+             (logior! (-> gp-1 flags) (nav-state-flag target-poly-dirty))
+             (set! (-> gp-1 target-post quad) (-> v1-26 quad))
+             )
+           0
+           (if (and (< (-> self target-self-xz-dist) 12288.0) (enemy-method-96 self 3640.889 #t))
+               (go-virtual close-attack)
+               )
+           )
+          (else
+            (if (logtest? (-> self nav state flags) (nav-state-flag at-target))
+                (nav-enemy-method-156 self)
+                )
+            (if (and (< (-> self target-self-xz-dist) 327680.0)
+                     (crimson-guard-level-method-193 self)
+                     (>= (- (-> self clock frame-counter) (-> self state-time)) (the int (* 300.0 (rand-vu-float-range 1.0 8.0))))
+                     )
+                (go-virtual gun-shoot)
+                )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-3))
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate grenade-hostile (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    ((-> (method-of-type nav-enemy hostile) enter))
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (nav-enemy-method-156 self)
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((or (< (the-as int gp-0) 2) (not (enemy-method-107 self)))
+           (go-stare self)
+           )
+          ((= gp-0 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (crimson-guard-level-method-200 self)
+    (let ((a0-8 (handle->process (-> self focus handle))))
+      (when a0-8
+        (cond
+          ((and (< (-> self target-self-xz-dist) 81920.0) (= (-> self focus aware) (enemy-aware enemy-aware-3)))
+           (let ((gp-1 (-> self nav state))
+                 (v1-26 (get-trans (the-as process-focusable a0-8) 1))
+                 )
+             (logclear! (-> gp-1 flags) (nav-state-flag directional-mode))
+             (logior! (-> gp-1 flags) (nav-state-flag target-poly-dirty))
+             (set! (-> gp-1 target-post quad) (-> v1-26 quad))
+             )
+           0
+           (if (and (< (-> self target-self-xz-dist) 12288.0) (enemy-method-96 self 3640.889 #t))
+               (go-virtual close-attack)
+               )
+           )
+          (else
+            (if (or (and (logtest? (-> self nav state flags) (nav-state-flag at-target))
+                         (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+                         )
+                    (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+                    )
+                (go-virtual grenade-attack)
+                )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-3))
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja :group! (-> self draw art-group data (-> self enemy-info-override hostile-anim)))
+    (ja :num-func num-func-identity :frame-num 0.0)
+    (let ((f30-1 (* 2.0 (get-rand-float-range self 0.9 1.1))))
+      (until #f
+        (suspend)
+        (ja :num! (loop! f30-1))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate arrest (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (nav-enemy-method-167 self)
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-4 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-7 self))
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (vector-reset! (-> self root-override2 transv))
+    (let ((a0-9 (-> self nav state))
+          (v1-12 *null-vector*)
+          )
+      (set! (-> a0-9 velocity quad) (-> v1-12 quad))
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self last-time-see-target) (the-as int (-> self clock frame-counter)))
+    (set! (-> self miss-amount) 0.0)
+    (set! (-> self next-shot) (the-as int (-> self clock frame-counter)))
+    (set! (-> self joint-enable) #t)
+    (set! (-> self reaction-time) (the-as uint (the int (* 300.0 (get-rand-float-range self 3.0 5.0)))))
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self joint-enable) #f)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (let ((v1-2 (-> self focus aware)))
+      (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+        (cond
+          ((< (the-as int v1-2) 2)
+           (go-stare self)
+           )
+          ((= v1-2 (enemy-aware enemy-aware-3))
+           (go-hostile self)
+           )
+          ((= v1-2 (enemy-aware enemy-aware-4))
+           (go-flee self)
+           )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-2 speech-type-3))
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (ja-no-eval :group! (-> self draw art-group data 19)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 19)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (until #f
+      (if (or (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+              (< 10922.667 (fabs (-> self target-y-angle)))
+              )
+          (goto cfg-13)
+          )
+      (ja-no-eval :group! (-> self draw art-group data 20)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 20)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (label cfg-13)
+    (let ((f30-1 (get-rand-float-range self 0.9 1.1)))
+      (ja-channel-push! 1 (seconds 0.2))
+      (ja-no-eval :group! (-> self draw art-group data 24)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 24)) frames num-frames) -1))
+                    f30-1
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-1))
+        )
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate gun-shoot (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self other-side) (the-as uint (if (< (rand-vu) 0.5)
+                                                #t
+                                                #f
+                                                )
+                                       )
+          )
+    (nav-enemy-method-166 self)
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-4 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-7 self))
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (let ((v1-10 (-> self nav state)))
+      (set! (-> v1-10 speed) 0.0)
+      )
+    0
+    (let ((a0-8 (-> self nav state))
+          (v1-13 *null-vector*)
+          )
+      (set! (-> a0-8 velocity quad) (-> v1-13 quad))
+      )
+    0
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self last-time-see-target) (the-as int (-> self clock frame-counter)))
+    (crimson-guard-level-method-200 self)
+    (if (logtest? (-> self flags) 4)
+        (set! (-> self miss-amount) 16384.0)
+        (set! (-> self miss-amount) (lerp-scale 0.0 16384.0 (-> self target-self-dist) 40960.0 122880.0))
+        )
+    (set! (-> self next-shot) (the-as int (-> self clock frame-counter)))
+    (set! (-> self joint-enable) #t)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self joint-enable) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (let ((v1-4 (handle->process (-> self focus handle))))
+      (when v1-4
+        (when (not (and v1-4
+                        (zero? (logand (-> (the-as process-focusable v1-4) focus-status) (focus-status disable dead ignore grabbed)))
+                        )
+                   )
+          (if (logtest? (-> self flags) 4)
+              (set! (-> self miss-amount) 16384.0)
+              (set! (-> self miss-amount) (lerp-scale 0.0 16384.0 (-> self target-self-dist) 40960.0 122880.0))
+              )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-48 object))
+    (ja-channel-push! 1 (seconds 0.2))
+    (let ((f30-0 (get-rand-float-range self 0.9 1.1)))
+      (ja-no-eval :group! (-> self draw art-group data (-> self anim-shoot 0 anim-index))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-shoot 0 anim-index))) frames num-frames)
+                            -1
+                            )
+                         )
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (let ((v1-31 (handle->process (-> self focus handle))))
+      (when v1-31
+        (set! (-> self start-target-pos quad) (-> (the-as process-drawable v1-31) root trans quad))
+        (set! (-> self start-target-vel quad) (-> (the-as process-drawable v1-31) root transv quad))
+        )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (label cfg-10)
+    (when (crimson-guard-level-method-194 self)
+      (when (or (not (logtest? (-> self flags) 256)) (and (logtest? (-> self flags) 256) (-> self trigger)))
+        (set! v1-48 #t)
+        (goto cfg-23)
+        )
+      )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+      (set! v1-48 #f)
+      (goto cfg-23)
+      )
+    (suspend)
+    (b! (not #f) cfg-10 :delay (set! v1-48 #f))
+    (label cfg-23)
+    (when v1-48
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (let ((gp-0 3))
+        (until #f
+          (ja-channel-push! 1 (seconds 0.1))
+          (ja-no-eval :group! (-> self draw art-group data (-> self anim-shoot 1 anim-index)) :num! min)
+          (set! (-> self already-shot) (the-as uint #t))
+          (let ((f0-7 (lerp-scale 1.0 0.2 (-> self target-self-dist) 81920.0 327680.0)))
+            (cond
+              ((logtest? (-> self flags) 4)
+               (if (< (-> self target-vel) 40.96)
+                   (set! (-> self miss-amount) (+ -12288.0 (-> self miss-amount)))
+                   )
+               )
+              ((logtest? (-> self draw status) (draw-control-status on-screen))
+               (when (handle->process (-> self focus handle))
+                 (if (< (-> self target-vel) 40.96)
+                     (set! (-> self miss-amount) (- (-> self miss-amount) (* 12288.0 f0-7)))
+                     (set! (-> self miss-amount) (- (-> self miss-amount) (* 4096.0 f0-7)))
+                     )
+                 )
+               )
+              (else
+                (set! (-> self miss-amount) (- (-> self miss-amount) (* 3276.8 f0-7)))
+                )
+              )
+            )
+          (if (< (-> self miss-amount) 0.0)
+              (set! (-> self miss-amount) 0.0)
+              )
+          (if (= gp-0 3)
+              (speech-control-method-12 *speech-control* self (speech-type speech-type-0 speech-type-3))
+              )
+          (crimson-guard-level-method-191 self)
+          (until (ja-done? 0)
+            (ja :num! (seek!))
+            (suspend)
+            )
+          (when (logtest? (-> self flags) 4)
+            (let ((s5-1 (-> self clock frame-counter)))
+              (until (>= (- (-> self clock frame-counter) s5-1) (seconds 1))
+                (suspend)
+                )
+              )
+            (until (crimson-guard-level-method-194 self)
+              (suspend)
+              )
+            )
+          (+! gp-0 -1)
+          (if (< gp-0 0)
+              (goto cfg-57)
+              )
+          )
+        )
+      #f
+      )
+    (label cfg-57)
+    (let ((f30-1 (get-rand-float-range self 0.9 1.1)))
+      (ja-channel-push! 1 (seconds 0.2))
+      (ja-no-eval :group! (-> self draw art-group data (-> self anim-shoot 2 anim-index))
+                  :num! (seek!
+                    (the float
+                         (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-shoot 2 anim-index))) frames num-frames)
+                            -1
+                            )
+                         )
+                    f30-1
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+        (suspend)
+        (ja :num! (seek! max f30-1))
+        )
+      )
+    (if (logtest? (-> self flags) 2)
+        (crimson-guard-level-method-204 self)
+        )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+;; definition for method 199 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod crimson-guard-level-method-199 crimson-guard-level ((obj crimson-guard-level) (arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
+  (local-vars (sv-672 vector) (sv-688 vector) (sv-704 vector) (sv-720 vector))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s4-0 (new 'stack-no-clear 'vector)))
+      (set! (-> s4-0 quad) (-> arg0 quad))
+      (let ((s3-0 (new 'stack-no-clear 'vector)))
+        (set! (-> s3-0 quad) (-> arg1 quad))
+        (vector-length arg1)
+        (let ((s2-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s2-0 quad) (-> arg2 quad))
+          (let ((s1-0 (new 'stack-no-clear 'collide-query)))
+            (dotimes (s0-0 6)
+              (cond
+                (arg3
+                  (let ((v1-5 s1-0))
+                    (set! (-> v1-5 radius) 4096.0)
+                    (set! (-> v1-5 collide-with) (collide-spec backgnd obstacle))
+                    (set! (-> v1-5 ignore-process0) #f)
+                    (set! (-> v1-5 ignore-process1) #f)
+                    (set! (-> v1-5 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                    (set! (-> v1-5 action-mask) (collide-action solid))
+                    )
+                  )
+                (else
+                  (let ((v1-6 s1-0))
+                    (set! (-> v1-6 radius) 4096.0)
+                    (set! (-> v1-6 collide-with) (collide-spec jak hit-by-others-list player-list))
+                    (set! (-> v1-6 ignore-process0) #f)
+                    (set! (-> v1-6 ignore-process1) #f)
+                    (set! (-> v1-6 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+                    (set! (-> v1-6 action-mask) (collide-action solid))
+                    )
+                  )
+                )
+              (set! (-> s1-0 start-pos quad) (-> s4-0 quad))
+              (set! (-> s1-0 move-dist quad) (-> s3-0 quad))
+              (set-from-point-offset-pad! (-> s1-0 bbox) (-> s1-0 start-pos) (-> s1-0 move-dist) (-> s1-0 radius))
+              (fill-using-bounding-box *collide-cache* s1-0)
+              (set! (-> s1-0 start-pos quad) (-> s4-0 quad))
+              (set! (-> s1-0 move-dist quad) (-> s3-0 quad))
+              (set! (-> s1-0 radius) 409.6)
+              (let ((f0-5 (probe-using-line-sphere *collide-cache* s1-0)))
+                (cond
+                  ((>= f0-5 0.0)
+                   (set! sv-672 (new 'stack-no-clear 'vector))
+                   (let ((v1-16 (-> s1-0 start-pos)))
+                     (let ((a0-20 (-> s1-0 move-dist)))
+                       (let ((a1-4 f0-5))
+                         (.mov vf7 a1-4)
+                         )
+                       (.lvf vf5 (&-> a0-20 quad))
+                       )
+                     (.lvf vf4 (&-> v1-16 quad))
+                     )
+                   (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                   (.mul.x.vf acc vf5 vf7 :mask #b111)
+                   (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                   (.svf (&-> sv-672 quad) vf6)
+                   (set! sv-688 (new 'stack-no-clear 'vector))
+                   (set! (-> s4-0 quad) (-> sv-672 quad))
+                   (+! (-> sv-672 x) (rand-vu-float-range -819.2 819.2))
+                   (+! (-> sv-672 y) (rand-vu-float-range -819.2 819.2))
+                   (+! (-> sv-672 z) (rand-vu-float-range -819.2 819.2))
+                   (set-point! (-> obj l-control) (-> obj l-control state points-to-draw) sv-672)
+                   (+! (-> obj l-control state points-to-draw) 1)
+                   (quaternion-from-two-vectors! (the-as quaternion sv-688) s2-0 (-> s1-0 best-other-tri normal))
+                   (vector-orient-by-quat! s3-0 s3-0 (the-as quaternion sv-688))
+                   (set! (-> s2-0 quad) (-> s1-0 best-other-tri normal quad))
+                   (vector-flatten! s3-0 s3-0 (-> s1-0 best-other-tri normal))
+                   )
+                  (else
+                    (vector+! (-> s1-0 start-pos) s4-0 s3-0)
+                    (let ((a1-14 (-> s1-0 start-pos)))
+                      (let ((v1-33 (-> s1-0 start-pos)))
+                        (let ((a0-35 s2-0))
+                          (let ((a2-7 -2048.0))
+                            (.mov vf7 a2-7)
+                            )
+                          (.lvf vf5 (&-> a0-35 quad))
+                          )
+                        (.lvf vf4 (&-> v1-33 quad))
+                        )
+                      (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                      (.mul.x.vf acc vf5 vf7 :mask #b111)
+                      (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                      (.svf (&-> a1-14 quad) vf6)
+                      )
+                    (vector-negate! (-> s1-0 move-dist) s3-0)
+                    (set! (-> s1-0 radius) 409.6)
+                    (let ((f0-14 (probe-using-line-sphere *collide-cache* s1-0)))
+                      (cond
+                        ((>= f0-14 0.0)
+                         (set! sv-704 (new 'stack-no-clear 'vector))
+                         (let ((v1-37 (-> s1-0 start-pos)))
+                           (let ((a0-38 (-> s1-0 move-dist)))
+                             (let ((a1-17 f0-14))
+                               (.mov vf7 a1-17)
+                               )
+                             (.lvf vf5 (&-> a0-38 quad))
+                             )
+                           (.lvf vf4 (&-> v1-37 quad))
+                           )
+                         (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                         (.mul.x.vf acc vf5 vf7 :mask #b111)
+                         (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                         (.svf (&-> sv-704 quad) vf6)
+                         (set! sv-720 (new 'stack-no-clear 'vector))
+                         (let ((a1-18 sv-704))
+                           (let ((v1-40 sv-704))
+                             (let ((a0-39 s2-0))
+                               (let ((a2-9 2048.0))
+                                 (.mov vf7 a2-9)
+                                 )
+                               (.lvf vf5 (&-> a0-39 quad))
+                               )
+                             (.lvf vf4 (&-> v1-40 quad))
+                             )
+                           (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+                           (.mul.x.vf acc vf5 vf7 :mask #b111)
+                           (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+                           (.svf (&-> a1-18 quad) vf6)
+                           )
+                         (set! (-> s4-0 quad) (-> sv-704 quad))
+                         (+! (-> sv-704 x) (rand-vu-float-range -819.2 819.2))
+                         (+! (-> sv-704 y) (rand-vu-float-range -819.2 819.2))
+                         (+! (-> sv-704 z) (rand-vu-float-range -819.2 819.2))
+                         (set-point! (-> obj l-control) (-> obj l-control state points-to-draw) sv-704)
+                         (+! (-> obj l-control state points-to-draw) 1)
+                         (quaternion-from-two-vectors! (the-as quaternion sv-720) s2-0 (-> s1-0 best-other-tri normal))
+                         (vector-orient-by-quat! s3-0 s3-0 (the-as quaternion sv-720))
+                         (set! (-> s2-0 quad) (-> s1-0 best-other-tri normal quad))
+                         (vector-flatten! s3-0 s3-0 (-> s1-0 best-other-tri normal))
+                         )
+                        (else
+                          (vector+! s4-0 s4-0 s3-0)
+                          (when (< s0-0 6)
+                            (set-point! (-> obj l-control) (-> obj l-control state points-to-draw) s4-0)
+                            (+! (-> obj l-control state points-to-draw) 1)
+                            )
+                          )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    #f
+    )
+  )
+
+;; definition for method 198 of type crimson-guard-level
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod crimson-guard-level-method-198 crimson-guard-level ((obj crimson-guard-level))
+  (local-vars (sv-784 vector))
+  (with-pp
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (let* ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14)))
+             (v0-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 15)))
+             (s2-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) s4-0 v0-1) 16384.0))
+             (s1-0
+               (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> obj target-pos-predict-miss) s4-0) 16384.0)
+               )
+             (s5-0 (new 'stack-no-clear 'vector))
+             (s3-0 (new 'stack-no-clear 'collide-query))
+             )
+        (when (< 1820.4445 (vector-vector-angle-safe s2-0 s1-0))
+          (let* ((a1-9 (vector-normalize! (vector-cross! (new 'stack-no-clear 'vector) s2-0 s1-0) 1.0))
+                 (a2-1 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) a1-9 1820.4445))
+                 )
+            (vector-orient-by-quat! s1-0 s2-0 a2-1)
+            )
+          )
+        (let ((a0-12 s4-0))
+          (let ((v1-8 s4-0))
+            (let ((a1-12 0.2))
+              (.mov vf7 a1-12)
+              )
+            (.lvf vf5 (&-> s2-0 quad))
+            (.lvf vf4 (&-> v1-8 quad))
+            )
+          (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+          (.mul.x.vf acc vf5 vf7 :mask #b111)
+          (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+          (.svf (&-> a0-12 quad) vf6)
+          )
+        (vector+! s5-0 s4-0 s1-0)
+        (let ((v1-10 s3-0))
+          (set! (-> v1-10 radius) 409.6)
+          (set! (-> v1-10 collide-with) (collide-spec backgnd jak bot obstacle hit-by-others-list player-list))
+          (set! (-> v1-10 ignore-process0) #f)
+          (set! (-> v1-10 ignore-process1) #f)
+          (set! (-> v1-10 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-10 action-mask) (collide-action solid))
+          )
+        (set! (-> s3-0 start-pos quad) (-> s4-0 quad))
+        (set! (-> s3-0 move-dist quad) (-> s1-0 quad))
+        (set! (-> s3-0 ignore-process0) #f)
+        (set! (-> s3-0 ignore-process1) #f)
+        (set! (-> s3-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (fill-using-line-sphere *collide-cache* s3-0)
+        (set! (-> obj l-control state points-to-draw) 0)
+        (let ((f0-3 (probe-using-line-sphere *collide-cache* s3-0))
+              (s2-1 (new 'stack-no-clear 'vector))
+              )
+          (cond
+            ((>= f0-3 0.0)
+             (vector-float*! s1-0 (-> s3-0 move-dist) f0-3)
+             (vector+! s5-0 s4-0 s1-0)
+             (point-in-plane-<-point+normal! s2-1 s5-0 (-> s3-0 best-other-tri normal))
+             (vector-! s2-1 s2-1 s5-0)
+             (let ((s1-1 quaternion-vector-angle!)
+                   (s0-0 (new 'stack-no-clear 'quaternion))
+                   )
+               (set! sv-784 (-> s3-0 best-other-tri normal))
+               (let* ((a2-3 (rand-vu-float-range 0.0 65536.0))
+                      (a2-4 (s1-1 s0-0 sv-784 a2-3))
+                      )
+                 (vector-orient-by-quat! s2-1 s2-1 a2-4)
+                 )
+               )
+             (let ((s1-2 (get-process *default-dead-pool* part-tracker #x4000)))
+               (when s1-2
+                 (let ((t9-15 (method-of-type part-tracker activate)))
+                   (t9-15 (the-as part-tracker s1-2) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                   )
+                 (let ((t9-16 run-function-in-process)
+                       (a0-34 s1-2)
+                       (a1-25 part-tracker-init)
+                       (a2-9 (-> *part-group-id-table* 140))
+                       (a3-1 0)
+                       (t0-0 #f)
+                       (t1-0 #f)
+                       (t2-0 #f)
+                       (t3-0 *launch-matrix*)
+                       )
+                   (set! (-> t3-0 trans quad) (-> s4-0 quad))
+                   ((the-as (function object object object object object object object object none) t9-16)
+                    a0-34
+                    a1-25
+                    a2-9
+                    a3-1
+                    t0-0
+                    t1-0
+                    t2-0
+                    t3-0
+                    )
+                   )
+                 (-> s1-2 ppointer)
+                 )
+               )
+             (let ((s1-3 (get-process *default-dead-pool* part-tracker #x4000)))
+               (when s1-3
+                 (let ((t9-18 (method-of-type part-tracker activate)))
+                   (t9-18 (the-as part-tracker s1-3) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                   )
+                 (let ((t9-19 run-function-in-process)
+                       (a0-37 s1-3)
+                       (a1-28 part-tracker-init)
+                       (a2-14 (-> *part-group-id-table* 140))
+                       (a3-3 0)
+                       (t0-1 #f)
+                       (t1-1 #f)
+                       (t2-1 #f)
+                       (t3-1 *launch-matrix*)
+                       )
+                   (set! (-> t3-1 trans quad) (-> s5-0 quad))
+                   ((the-as (function object object object object object object object object none) t9-19)
+                    a0-37
+                    a1-28
+                    a2-14
+                    a3-3
+                    t0-1
+                    t1-1
+                    t2-1
+                    t3-1
+                    )
+                   )
+                 (-> s1-3 ppointer)
+                 )
+               )
+             (set-point! (-> obj l-control) 0 s4-0)
+             (set-point! (-> obj l-control) 1 s5-0)
+             (set! (-> obj l-control spec) (-> *lightning-spec-id-table* 13))
+             (+! (-> obj l-control state points-to-draw) 2)
+             (let* ((s4-1 (-> s3-0 best-other-tri collide-ptr))
+                    (v1-45 (if (type? s4-1 collide-shape-prim)
+                               (the-as collide-shape-prim s4-1)
+                               )
+                           )
+                    (s4-2 #t)
+                    )
+               (when v1-45
+                 (set! s4-2 #f)
+                 (when (logtest? (-> v1-45 prim-core collide-as) (collide-spec jak bot))
+                   (let ((a1-32 (new 'stack-no-clear 'event-message-block)))
+                     (set! (-> a1-32 from) (process->ppointer pp))
+                     (set! (-> a1-32 num-params) 2)
+                     (set! (-> a1-32 message) 'attack)
+                     (set! (-> a1-32 param 0) (the-as uint #f))
+                     (let ((a0-50 (new 'static 'attack-info :mask (attack-info-mask mode id))))
+                       (let* ((a2-18 *game-info*)
+                              (a3-5 (+ (-> a2-18 attack-id) 1))
+                              )
+                         (set! (-> a2-18 attack-id) a3-5)
+                         (set! (-> a0-50 id) a3-5)
+                         )
+                       (set! (-> a0-50 mode) 'shock)
+                       (set! (-> a1-32 param 1) (the-as uint a0-50))
+                       )
+                     (send-event-function (-> v1-45 cshape process) a1-32)
+                     )
+                   )
+                 )
+               (crimson-guard-level-method-199 obj s5-0 s2-1 (-> s3-0 best-other-tri normal) (the-as float s4-2))
+               )
+             )
+            (else
+              (let ((s3-1 (get-process *default-dead-pool* part-tracker #x4000)))
+                (when s3-1
+                  (let ((t9-26 (method-of-type part-tracker activate)))
+                    (t9-26 (the-as part-tracker s3-1) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                    )
+                  (let ((t9-27 run-function-in-process)
+                        (a0-56 s3-1)
+                        (a1-36 part-tracker-init)
+                        (a2-25 (-> *part-group-id-table* 140))
+                        (a3-8 0)
+                        (t0-3 #f)
+                        (t1-2 #f)
+                        (t2-2 #f)
+                        (t3-2 *launch-matrix*)
+                        )
+                    (set! (-> t3-2 trans quad) (-> s4-0 quad))
+                    ((the-as (function object object object object object object object object none) t9-27)
+                     a0-56
+                     a1-36
+                     a2-25
+                     a3-8
+                     t0-3
+                     t1-2
+                     t2-2
+                     t3-2
+                     )
+                    )
+                  (-> s3-1 ppointer)
+                  )
+                )
+              (let ((s3-2 (get-process *default-dead-pool* part-tracker #x4000)))
+                (when s3-2
+                  (let ((t9-29 (method-of-type part-tracker activate)))
+                    (t9-29 (the-as part-tracker s3-2) obj (symbol->string (-> part-tracker symbol)) (the-as pointer #x70004000))
+                    )
+                  (let ((t9-30 run-function-in-process)
+                        (a0-59 s3-2)
+                        (a1-39 part-tracker-init)
+                        (a2-30 (-> *part-group-id-table* 140))
+                        (a3-10 0)
+                        (t0-4 #f)
+                        (t1-3 #f)
+                        (t2-3 #f)
+                        (t3-3 *launch-matrix*)
+                        )
+                    (set! (-> t3-3 trans quad) (-> s5-0 quad))
+                    ((the-as (function object object object object object object object object none) t9-30)
+                     a0-59
+                     a1-39
+                     a2-30
+                     a3-10
+                     t0-4
+                     t1-3
+                     t2-3
+                     t3-3
+                     )
+                    )
+                  (-> s3-2 ppointer)
+                  )
+                )
+              (set! (-> obj l-control state points-to-draw) 9)
+              (set! (-> obj l-control spec) (-> *lightning-spec-id-table* 14))
+              (let ((v1-67 s4-0))
+                (set! (-> obj l-control state meet data 0 quad) (-> v1-67 quad))
+                )
+              (let ((a0-65 (-> obj l-control))
+                    (v1-69 s5-0)
+                    )
+                (set! (-> a0-65 state meet data (+ (-> a0-65 state points-to-draw) -1) quad) (-> v1-69 quad))
+                )
+              )
+            )
+          )
+        )
+      (none)
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate close-attack (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 3)))
+      (logior! (-> v1-3 prim-core action) (collide-action deadly))
+      )
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-8 *game-info*)
+           (a0-4 (+ (-> v1-8 attack-id) 1))
+           )
+      (set! (-> v1-8 attack-id) a0-4)
+      (set! (-> self attack-id) a0-4)
+      )
+    (let ((v1-9 (-> self nav)))
+      (set! (-> v1-9 target-speed) 0.0)
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 3)))
+      (logclear! (-> v1-3 prim-core action) (collide-action deadly))
+      )
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data 18)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 18)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+;; definition for method 192 of type crimson-guard-level
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod crimson-guard-level-method-192 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 14))))
+    (new 'stack-no-clear 'vector)
+    (let ((s5-0 (new 'stack-no-clear 'traj3d-params)))
+      (let ((s3-1 (vector-! (new 'stack-no-clear 'vector) (-> obj target-pos-predict) s4-0)))
+        (set! (-> s3-1 y) 0.0)
+        (vector-rotate-around-y! s3-1 s3-1 (* 182.04445 (+ (if (zero? (rand-vu-int-count 2))
+                                                               90.0
+                                                               -90.0
+                                                               )
+                                                           (rand-vu-float-range -45.0 45.0)
+                                                           )
+                                              )
+                                 )
+        (if (logtest? (-> obj draw status) (draw-control-status on-screen))
+            (vector-normalize! s3-1 (* 4096.0 (rand-vu-float-range 1.0 4.0)))
+            (vector-normalize! s3-1 (* 4096.0 (rand-vu-float-range 4.0 15.0)))
+            )
+        (set! (-> s5-0 dest quad) (-> (vector+! (new 'stack-no-clear 'vector) s3-1 (-> obj target-pos-predict)) quad))
+        )
+      (set! (-> s5-0 src quad) (-> s4-0 quad))
+      (set! (-> s5-0 initial-tilt) 8192.0)
+      (set! (-> s5-0 gravity) 184320.0)
+      (when (traj3d-calc-initial-velocity-using-tilt s5-0)
+        (let ((a1-9 (new 'stack-no-clear 'projectile-init-by-other-params)))
+          (set! (-> a1-9 ent) (-> obj entity))
+          (set! (-> a1-9 charge) 1.0)
+          (set! (-> a1-9 options) (projectile-options))
+          (set! (-> a1-9 pos quad) (-> s5-0 src quad))
+          (set! (-> a1-9 vel quad) (-> s5-0 initial-velocity quad))
+          (set! (-> a1-9 notify-handle) (the-as handle #f))
+          (set! (-> a1-9 owner-handle) (the-as handle #f))
+          (set! (-> a1-9 ignore-handle) (process->handle obj))
+          (let* ((v1-24 *game-info*)
+                 (a0-23 (+ (-> v1-24 attack-id) 1))
+                 )
+            (set! (-> v1-24 attack-id) a0-23)
+            (set! (-> a1-9 attack-id) a0-23)
+            )
+          (set! (-> a1-9 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+          (spawn-projectile vehicle-grenade a1-9 obj *default-dead-pool*)
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate grenade-attack (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let ((v1-4 self))
+      (set! (-> v1-4 enemy-flags) (the-as enemy-flag (logclear (-> v1-4 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (let ((v1-6 self))
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logclear (-> v1-6 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-6 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-9 (-> self nav)))
+      (set! (-> v1-9 target-speed) 0.0)
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data 37)
+                :num! (seek! (ja-aframe 12.0 0))
+                :frame-num (ja-aframe 1.0 0)
+                )
+    (until (ja-done? 0)
+      (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+      (suspend)
+      (ja :num! (seek! (ja-aframe 12.0 0)))
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (the int (* 900.0 (you-suck-scale *game-info* #f))))
+        (ja-no-eval :group! (-> self draw art-group data 37)
+                    :num! (seek! (ja-aframe 12.0 0))
+                    :frame-num (ja-aframe 12.0 0)
+                    )
+        (until (ja-done? 0)
+          (seek-toward-heading-vec! (-> self root-override2) (-> self target-self-xz) 65536.0 (seconds 0.02))
+          (suspend)
+          (ja :num! (seek! (ja-aframe 12.0 0)))
+          )
+        (if (and (< (-> self target-self-xz-dist) 81920.0) (= (-> self focus aware) (enemy-aware enemy-aware-3)))
+            (go-hostile self)
+            )
+        (suspend)
+        )
+      )
+    (crimson-guard-level-method-192 self)
+    (ja-no-eval :group! (-> self draw art-group data 37)
+                :num! (seek! (ja-aframe 32.0 0))
+                :frame-num (ja-aframe 22.0 0)
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! (ja-aframe 32.0 0)))
+      )
+    (ja-no-eval :group! (-> self draw art-group data 37)
+                :num! (seek! (ja-aframe 37.0 0))
+                :frame-num (ja-aframe 33.0 0)
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! (ja-aframe 37.0 0)))
+      )
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate attack (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self joint-enable) #t)
+    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
+    (logior! (-> self focus-status) (focus-status dangerous))
+    (let* ((v1-5 *game-info*)
+           (a0-2 (+ (-> v1-5 attack-id) 1))
+           )
+      (set! (-> v1-5 attack-id) a0-2)
+      (set! (-> self attack-id) a0-2)
+      )
+    (let ((v1-6 self))
+      (set! (-> v1-6 enemy-flags) (the-as enemy-flag (logclear (-> v1-6 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-6 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-9 self))
+      (set! (-> v1-9 enemy-flags) (the-as enemy-flag (logclear (-> v1-9 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (set! (-> self miss-amount) 0.0)
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self next-shot) (the-as int (-> self clock frame-counter)))
+    (set! (-> self lazer-sound) (new 'static 'sound-id))
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (if (nonzero? (-> self lazer-sound))
+        (sound-stop (-> self lazer-sound))
+        )
+    (let ((v1-6 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 2)))
+      (logclear! (-> v1-6 prim-core action) (collide-action deadly))
+      )
+    (let ((v1-10 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 3)))
+      (logclear! (-> v1-10 prim-core action) (collide-action deadly))
+      )
+    (let ((v1-11 (-> self l-control))
+          (a0-5 0)
+          )
+      (let ((a1-3 (!= a0-5 (-> v1-11 state mode))))
+        (case a0-5
+          ((3)
+           (if a1-3
+               (set! (-> v1-11 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-11 state start-color) (-> v1-11 spec start-color))
+           (set! (-> v1-11 state end-color) (-> v1-11 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-11 state mode) (the-as lightning-mode a0-5))
+      )
+    (set! (-> self joint-enable) #f)
+    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
+    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
+        (logior! (-> self focus-status) (focus-status dangerous))
+        (logclear! (-> self focus-status) (focus-status dangerous))
+        )
+    (none)
+    )
+  :trans (behavior ()
+    (crimson-guard-level-method-200 self)
+    (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+             (< 32768.0 (-> self target-self-xz-dist))
+             )
+        (go-hostile self)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-69 symbol))
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data 19) :num! (seek! (ja-aframe 7.0 0)) :frame-num 0.0)
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! (ja-aframe 7.0 0)))
+      )
+    (until #f
+      (let ((gp-2 #t))
+        (while (or (< 5461.3335 (fabs (-> self target-y-angle))) (>= (-> self next-shot) (-> self clock frame-counter)))
+          (when gp-2
+            (ja-channel-push! 1 (seconds 0.1))
+            (set! gp-2 #f)
+            )
+          (cond
+            ((< 5461.3335 (fabs (-> self target-y-angle)))
+             (ja-no-eval :group! (-> self draw art-group data 25)
+                         :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 25)) frames num-frames) -1)))
+                         :frame-num 0.0
+                         )
+             (until (ja-done? 0)
+               (if (< 5461.3335 (fabs (-> self target-y-angle)))
+                   (seek-to-point-toward-point!
+                     (-> self root-override2)
+                     (-> self target-pos)
+                     (-> self nav max-rotation-rate)
+                     (seconds 0.2)
+                     )
+                   )
+               (suspend)
+               (ja :num! (seek!))
+               )
+             )
+            (else
+              (ja-no-eval :group! (-> self draw art-group data 20)
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 20)) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until v1-69
+                (suspend)
+                (ja :num! (seek!))
+                (set! v1-69
+                      (or (ja-done? 0) (< (-> self target-self-xz-dist) 16384.0) (< 5461.3335 (fabs (-> self target-y-angle))))
+                      )
+                )
+              )
+            )
+          (when (< (-> self target-self-xz-dist) 16384.0)
+            (set! (-> self next-shot) 0)
+            0
+            )
+          )
+        )
+      (cond
+        ((and (crimson-guard-level-method-193 self)
+              (handle->process (-> self focus handle))
+              (zero? (logand (-> (the-as process-focusable (handle->process (-> self focus handle))) focus-status)
+                             (focus-status disable dead ignore grabbed)
+                             )
+                     )
+              )
+         (cond
+           ((< (-> self target-self-xz-dist) 16384.0)
+            (go-virtual close-attack)
+            )
+           (else
+             (ja-channel-push! 1 (seconds 0.1))
+             (ja-no-eval :group! (-> self draw art-group data 21)
+                         :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 21)) frames num-frames) -1)))
+                         :frame-num 0.0
+                         )
+             (until (ja-done? 0)
+               (suspend)
+               (ja :num! (seek!))
+               )
+             (set! (-> self next-shot) (the-as int (+ (-> self clock frame-counter) (seconds 1))))
+             (let ((v1-124 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 2)))
+               (logior! (-> v1-124 prim-core action) (collide-action deadly))
+               )
+             (let* ((v1-125 *game-info*)
+                    (a0-34 (+ (-> v1-125 attack-id) 1))
+                    )
+               (set! (-> v1-125 attack-id) a0-34)
+               (set! (-> self attack-id) a0-34)
+               )
+             (set! (-> self lazer-sound) (sound-play "guard-zap"))
+             (let ((v1-127 (-> self l-control))
+                   (a0-38 1)
+                   )
+               (let ((a1-21 (!= a0-38 (-> v1-127 state mode))))
+                 (case a0-38
+                   ((3)
+                    (if a1-21
+                        (set! (-> v1-127 state counter) 0.0)
+                        )
+                    )
+                   ((1)
+                    (set! (-> v1-127 state start-color) (-> v1-127 spec start-color))
+                    (set! (-> v1-127 state end-color) (-> v1-127 spec end-color))
+                    )
+                   )
+                 )
+               (set! (-> v1-127 state mode) (the-as lightning-mode a0-38))
+               )
+             (let ((gp-4 (-> self clock frame-counter))
+                   (s5-1 150)
+                   (f30-0 1.0)
+                   )
+               (ja-no-eval :group! (-> self draw art-group data 22) :num! (loop! f30-0) :frame-num 0.0)
+               (until (>= (- (-> self clock frame-counter) gp-4) s5-1)
+                 (crimson-guard-level-method-198 self)
+                 (suspend)
+                 (ja :num! (loop! f30-0))
+                 )
+               )
+             (let ((v1-150 (-> (the-as collide-shape-prim-group (-> self root-override2 root-prim)) child 2)))
+               (logclear! (-> v1-150 prim-core action) (collide-action deadly))
+               )
+             (let ((v1-151 (-> self l-control))
+                   (a0-44 3)
+                   )
+               (let ((a1-34 (!= a0-44 (-> v1-151 state mode))))
+                 (case a0-44
+                   ((3)
+                    (if a1-34
+                        (set! (-> v1-151 state counter) 0.0)
+                        )
+                    )
+                   ((1)
+                    (set! (-> v1-151 state start-color) (-> v1-151 spec start-color))
+                    (set! (-> v1-151 state end-color) (-> v1-151 spec end-color))
+                    )
+                   )
+                 )
+               (set! (-> v1-151 state mode) (the-as lightning-mode a0-44))
+               )
+             (ja-no-eval :group! (-> self draw art-group data 23)
+                         :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 23)) frames num-frames) -1)))
+                         :frame-num 0.0
+                         )
+             (until (ja-done? 0)
+               (suspend)
+               (ja :num! (seek!))
+               )
+             )
+           )
+         )
+        (else
+          (set! (-> self next-shot) (the-as int (+ (-> self clock frame-counter) (seconds 1))))
+          (suspend)
+          0
+          )
+        )
+      (when (not (handle->process (-> self focus handle)))
+        (ja-no-eval :group! (-> self draw art-group data 24)
+                    :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 24)) frames num-frames) -1)))
+                    :frame-num 0.0
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek!))
+          )
+        #t
+        (goto cfg-81)
+        )
+      )
+    #f
+    (label cfg-81)
+    (go-virtual active)
+    (none)
+    )
+  :post (behavior ()
+    (nav-enemy-method-176 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate get-up-front (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logclear (-> v1-2 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-2 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logclear (-> v1-5 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-1 (-> self root-override2 root-prim)))
+      (logclear! (-> (the-as collide-shape-prim-group v1-1) child 0 prim-core action) (collide-action no-standon))
+      (logior! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core action) (collide-action no-standon))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-as) (collide-spec enemy))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-with)
+            (collide-spec backgnd jak obstacle hit-by-others-list player-list pusher)
+            )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data (-> self anim-get-up-front))
+                :num! (seek!
+                  (the float
+                       (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-get-up-front))) frames num-frames)
+                          -1
+                          )
+                       )
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (set! (-> self hit-face) (the-as uint -1))
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 *null-vector*)
+          )
+      (logior! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (set! (-> a0-0 travel quad) (-> v1-1 quad))
+      )
+    0
+    (enemy-method-55 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate get-up-back (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (let ((v1-2 self))
+      (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logclear (-> v1-2 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-2 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (let ((v1-5 self))
+      (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logclear (-> v1-5 enemy-flags) (enemy-flag enemy-flag37))))
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((v1-1 (-> self root-override2 root-prim)))
+      (logclear! (-> (the-as collide-shape-prim-group v1-1) child 0 prim-core action) (collide-action no-standon))
+      (logior! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core action) (collide-action no-standon))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-as) (collide-spec enemy))
+      (set! (-> (the-as collide-shape-prim-group v1-1) child 1 prim-core collide-with)
+            (collide-spec backgnd jak obstacle hit-by-others-list player-list pusher)
+            )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.2))
+    (ja-no-eval :group! (-> self draw art-group data (-> self anim-get-up-back))
+                :num! (seek!
+                  (the float
+                       (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self anim-get-up-back))) frames num-frames) -1)
+                       )
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (set! (-> self hit-face) (the-as uint -1))
+    (go-hostile self)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 (-> self nav state))
+          (v1-1 *null-vector*)
+          )
+      (logior! (-> a0-0 flags) (nav-state-flag directional-mode))
+      (set! (-> a0-0 travel quad) (-> v1-1 quad))
+      )
+    0
+    (enemy-method-55 self)
+    (none)
+    )
+  )
+
+;; definition for method 204 of type crimson-guard-level
+;; WARN: Return type mismatch object vs none.
+(defmethod crimson-guard-level-method-204 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s4-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+        (s5-0 (-> obj root-override2))
+        (s3-0 (lambda ((arg0 crimson-guard-level) (arg1 collide-shape-moving) (arg2 vector))
+                (let ((s4-0 (new 'stack-no-clear 'vector))
+                      (s3-0 (new 'stack-no-clear 'vector))
+                      )
+                  (vector+! s3-0 (-> arg1 trans) arg2)
+                  (cloest-point-on-mesh (-> arg0 nav) s4-0 s3-0 (the-as nav-poly #f))
+                  (cond
+                    ((< 409.6 (vector-vector-distance s3-0 s4-0))
+                     #f
+                     )
+                    ((let ((a1-4 (new 'stack-no-clear 'vector)))
+                       (set! (-> a1-4 quad) (-> s4-0 quad))
+                       (set! (-> a1-4 w) (-> arg0 root-override2 nav-radius))
+                       (add-root-sphere-to-hash! (-> arg0 nav) a1-4 #x8046e)
+                       )
+                     #f
+                     )
+                    (else
+                      (let ((a1-5 (new 'stack-no-clear 'collide-query)))
+                        (set! (-> a1-5 start-pos quad) (-> arg1 trans quad))
+                        (vector-! (-> a1-5 move-dist) s4-0 (-> a1-5 start-pos))
+                        (let ((v1-10 a1-5))
+                          (set! (-> v1-10 radius) 2048.0)
+                          (set! (-> v1-10 collide-with) (-> arg1 root-prim prim-core collide-with))
+                          (set! (-> v1-10 ignore-process0) arg0)
+                          (set! (-> v1-10 ignore-process1) #f)
+                          (set! (-> v1-10 ignore-pat) (-> arg1 pat-ignore-mask))
+                          (set! (-> v1-10 action-mask) (collide-action solid))
+                          )
+                        (if (>= (fill-and-probe-using-line-sphere *collide-cache* a1-5) 0.0)
+                            #f
+                            #t
+                            )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+        )
+    (cond
+      ((s3-0 obj s5-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s4-0 24576.0))
+       (go (method-of-object obj roll-right))
+       )
+      ((s3-0 obj s5-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s4-0 -24576.0))
+       (go (method-of-object obj roll-left))
+       )
+      )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate roll-right (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :code (behavior ()
+    (vector-reset! (-> self root-override2 transv))
+    (vector-x-quaternion! (-> self root-override2 transv) (-> self root-override2 quat))
+    (set! (-> self root-override2 transv y) 24576.0)
+    (vector-xz-normalize! (-> self root-override2 transv) 40960.0)
+    (let ((v1-7 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-7 enemy-flags)))
+          (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-7 enemy-flags))))
+          )
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-7 enemy-flags))))
+      (set! (-> v1-7 nav callback-info) (-> v1-7 enemy-info-override callback-info))
+      )
+    0
+    (ja-channel-push! 1 (seconds 0.1))
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 40)
+                   :num! (seek! (ja-aframe 6.0 0))
+                   :frame-num (ja-aframe 0.0 0)
+                   )
+       (until (ja-done? 0)
+         (let ((a0-20 (handle->process (-> self focus handle))))
+           (if a0-20
+               (seek-toward-heading-vec!
+                 (-> self root-override2)
+                 (vector-!
+                   (new 'stack-no-clear 'vector)
+                   (get-trans (the-as process-focusable a0-20) 0)
+                   (-> self root-override2 trans)
+                   )
+                 32768.0
+                 (seconds 0.05)
+                 )
+               )
+           )
+         (suspend)
+         (ja :num! (seek! (ja-aframe 6.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 41)
+                    :num! (seek! (ja-aframe 9.0 0))
+                    :frame-num (ja-aframe 0.0 0)
+                    )
+        (until (ja-done? 0)
+          (let ((a0-33 (handle->process (-> self focus handle))))
+            (if a0-33
+                (seek-toward-heading-vec!
+                  (-> self root-override2)
+                  (vector-!
+                    (new 'stack-no-clear 'vector)
+                    (get-trans (the-as process-focusable a0-33) 0)
+                    (-> self root-override2 trans)
+                    )
+                  32768.0
+                  (seconds 0.05)
+                  )
+                )
+            )
+          (suspend)
+          (ja :num! (seek! (ja-aframe 9.0 0)))
+          )
+        )
+      )
+    (let ((v1-59 self))
+      (set! (-> v1-59 enemy-flags) (the-as enemy-flag (logclear (-> v1-59 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-59 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 40)
+                   :num! (seek! (ja-aframe 11.0 0))
+                   :frame-num (ja-aframe 6.0 0)
+                   )
+       (until (ja-done? 0)
+         (suspend)
+         (ja :num! (seek! (ja-aframe 11.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 41)
+                    :num! (seek! (ja-aframe 11.0 0))
+                    :frame-num (ja-aframe 9.0 0)
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! (ja-aframe 11.0 0)))
+          )
+        )
+      )
+    (go-virtual gun-shoot)
+    (none)
+    )
+  :post (behavior ()
+    (let ((a0-0 self))
+      (when (logtest? (enemy-flag enemy-flag36) (-> a0-0 enemy-flags))
+        (vector-v++!
+          (-> self root-override2 transv)
+          (compute-acc-due-to-gravity (-> self root-override2) (new 'stack-no-clear 'vector) 0.0)
+          )
+        (let ((a2-1 (new 'stack-no-clear 'collide-query))
+              (a0-5 (-> self root-override2))
+              )
+          (set! (-> a2-1 collide-with) (-> a0-5 root-prim prim-core collide-with))
+          (set! (-> a2-1 ignore-process0) self)
+          (set! (-> a2-1 ignore-process1) #f)
+          (set! (-> a2-1 ignore-pat) (-> a0-5 pat-ignore-mask))
+          (set! (-> a2-1 action-mask) (collide-action solid))
+          (fill-cache-integrate-and-collide a0-5 (-> self root-override2 transv) a2-1 (meters 0))
+          )
+        )
+      )
+    (nav-enemy-simple-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate roll-left (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :code (behavior ()
+    (vector-reset! (-> self root-override2 transv))
+    (vector-x-quaternion! (-> self root-override2 transv) (-> self root-override2 quat))
+    (set! (-> self root-override2 transv y) 24576.0)
+    (vector-xz-normalize! (-> self root-override2 transv) -40960.0)
+    (let ((v1-7 self))
+      (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-7 enemy-flags)))
+          (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-7 enemy-flags))))
+          )
+      (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-7 enemy-flags))))
+      (set! (-> v1-7 nav callback-info) (-> v1-7 enemy-info-override callback-info))
+      )
+    0
+    (ja-channel-push! 1 (seconds 0.1))
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 41)
+                   :num! (seek! (ja-aframe 9.0 0))
+                   :frame-num (ja-aframe 0.0 0)
+                   )
+       (until (ja-done? 0)
+         (let ((a0-20 (handle->process (-> self focus handle))))
+           (if a0-20
+               (seek-toward-heading-vec!
+                 (-> self root-override2)
+                 (vector-!
+                   (new 'stack-no-clear 'vector)
+                   (get-trans (the-as process-focusable a0-20) 0)
+                   (-> self root-override2 trans)
+                   )
+                 32768.0
+                 (seconds 0.05)
+                 )
+               )
+           )
+         (suspend)
+         (ja :num! (seek! (ja-aframe 9.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 40)
+                    :num! (seek! (ja-aframe 6.0 0))
+                    :frame-num (ja-aframe 0.0 0)
+                    )
+        (until (ja-done? 0)
+          (let ((a0-33 (handle->process (-> self focus handle))))
+            (if a0-33
+                (seek-toward-heading-vec!
+                  (-> self root-override2)
+                  (vector-!
+                    (new 'stack-no-clear 'vector)
+                    (get-trans (the-as process-focusable a0-33) 0)
+                    (-> self root-override2 trans)
+                    )
+                  32768.0
+                  (seconds 0.05)
+                  )
+                )
+            )
+          (suspend)
+          (ja :num! (seek! (ja-aframe 6.0 0)))
+          )
+        )
+      )
+    (let ((v1-59 self))
+      (set! (-> v1-59 enemy-flags) (the-as enemy-flag (logclear (-> v1-59 enemy-flags) (enemy-flag enemy-flag36))))
+      (set! (-> v1-59 nav callback-info) *nav-enemy-null-callback-info*)
+      )
+    0
+    (cond
+      ((logtest? (enemy-flag dislike-combo) (-> self enemy-flags))
+       (ja-no-eval :group! (-> self draw art-group data 41)
+                   :num! (seek! (ja-aframe 11.0 0))
+                   :frame-num (ja-aframe 9.0 0)
+                   )
+       (until (ja-done? 0)
+         (suspend)
+         (ja :num! (seek! (ja-aframe 11.0 0)))
+         )
+       )
+      (else
+        (ja-no-eval :group! (-> self draw art-group data 40)
+                    :num! (seek! (ja-aframe 11.0 0))
+                    :frame-num (ja-aframe 6.0 0)
+                    )
+        (until (ja-done? 0)
+          (suspend)
+          (ja :num! (seek! (ja-aframe 11.0 0)))
+          )
+        )
+      )
+    (go-virtual gun-shoot)
+    (none)
+    )
+  :post (-> (method-of-type crimson-guard-level roll-right) post)
+  )
+
+;; failed to figure out what this is:
+(defstate knocked (crimson-guard-level)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (let ((v1-5 (the-as collide-shape-prim-group (-> self root-override2 root-prim))))
+      (logior! (-> v1-5 child 0 prim-core action) (collide-action no-standon))
+      (logclear! (-> v1-5 child 1 prim-core action) (collide-action no-standon))
+      (set! (-> v1-5 child 1 prim-core collide-as) (collide-spec))
+      (set! (-> v1-5 child 1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (if (zero? (-> self hit-points))
+        (set! (-> self root-override2 penetrated-by) (the-as penetrate -1))
+        )
+    (set! (-> self hit-face)
+          (the-as uint (if (< (vector-dot
+                                (-> self root-override2 transv)
+                                (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat))
+                                )
+                              0.0
+                              )
+                           1
+                           0
+                           )
+                  )
+          )
+    (none)
+    )
+  :trans (behavior ()
+    (let ((t9-0 (-> (method-of-type nav-enemy knocked) trans)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 77 of type crimson-guard-level
+(defmethod enemy-method-77 crimson-guard-level ((obj crimson-guard-level) (arg0 (pointer float)))
+  (let ((v1-1 (-> obj root-override2 transv)))
+    (cond
+      ((< (sqrtf (+ (* (-> v1-1 x) (-> v1-1 x)) (* (-> v1-1 z) (-> v1-1 z)))) 57344.0)
+       (set! (-> obj small-hit) 1)
+       )
+      (else
+        (set! (-> obj small-hit) 0)
+        0
+        )
+      )
+    )
+  (cond
+    ((<= (-> obj hit-points) 0)
+     (ja-channel-push! 1 (seconds 0.01))
+     (let ((a1-2 (-> obj draw art-group data (-> obj info knocked anim-index (-> obj hit-face))))
+           (a0-5 (-> obj skel root-channel 0))
+           )
+       (set! (-> a0-5 frame-group) (the-as art-joint-anim a1-2))
+       (set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
+       (set! (-> a0-5 param 1) (-> arg0 0))
+       (set! (-> a0-5 frame-num) 0.0)
+       (joint-control-channel-group! a0-5 (the-as art-joint-anim a1-2) num-func-seek!)
+       )
+     )
+    (else
+      (case (-> obj incoming knocked-type)
+        (((knocked-type knocked-type-4) (knocked-type knocked-type-5) (knocked-type knocked-type-7))
+         (ja-channel-push! 1 (seconds 0.01))
+         (cond
+           ((= (-> obj small-hit) 1)
+            (set! (-> obj yellow-anim anim-index-front) (get-rand-int obj 2))
+            (let ((a1-8
+                    (-> obj
+                        draw
+                        art-group
+                        data
+                        (-> (the-as (array int32) (+ (+ (* (-> obj hit-face) 4) (* (-> obj yellow-anim unsigned-anim-index-front) 8))
+                                                     (the-as uint (-> obj info))
+                                                     )
+                                    )
+                            2
+                            )
+                        )
+                    )
+                  (a0-17 (-> obj skel root-channel 0))
+                  )
+              (set! (-> a0-17 frame-group) (the-as art-joint-anim a1-8))
+              (set! (-> a0-17 param 0) (the float (+ (-> (the-as art-joint-anim a1-8) frames num-frames) -1)))
+              (set! (-> a0-17 param 1) (-> arg0 0))
+              (set! (-> a0-17 frame-num) 0.0)
+              (joint-control-channel-group! a0-17 (the-as art-joint-anim a1-8) num-func-seek!)
+              )
+            )
+           (else
+             (let ((a1-9 (-> obj draw art-group data (-> obj info knocked anim-index (-> obj hit-face))))
+                   (a0-21 (-> obj skel root-channel 0))
+                   )
+               (set! (-> a0-21 frame-group) (the-as art-joint-anim a1-9))
+               (set! (-> a0-21 param 0) (the float (+ (-> (the-as art-joint-anim a1-9) frames num-frames) -1)))
+               (set! (-> a0-21 param 1) (-> arg0 0))
+               (set! (-> a0-21 frame-num) 0.0)
+               (joint-control-channel-group! a0-21 (the-as art-joint-anim a1-9) num-func-seek!)
+               )
+             )
+           )
+         )
+        (((knocked-type knocked-type-6))
+         (ja-channel-push! 1 (seconds 0.01))
+         (let ((a0-24 (-> obj skel root-channel 0)))
+           (set! (-> a0-24 frame-group) (the-as art-joint-anim (-> obj draw art-group data 10)))
+           (set! (-> a0-24 param 0)
+                 (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 10)) frames num-frames) -1))
+                 )
+           (set! (-> a0-24 param 1) (-> arg0 0))
+           (set! (-> a0-24 frame-num) 0.0)
+           (joint-control-channel-group! a0-24 (the-as art-joint-anim (-> obj draw art-group data 10)) num-func-seek!)
+           )
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.1))
+          (let ((a1-13 (-> obj draw art-group data (-> obj info knocked anim-index (-> obj hit-face))))
+                (a0-29 (-> obj skel root-channel 0))
+                )
+            (set! (-> a0-29 frame-group) (the-as art-joint-anim a1-13))
+            (set! (-> a0-29 param 0) (the float (+ (-> (the-as art-joint-anim a1-13) frames num-frames) -1)))
+            (set! (-> a0-29 param 1) (-> arg0 0))
+            (set! (-> a0-29 frame-num) 0.0)
+            (joint-control-channel-group! a0-29 (the-as art-joint-anim a1-13) num-func-seek!)
+            )
+          )
+        )
+      )
+    )
+  #t
+  )
+
+;; definition for method 70 of type crimson-guard-level
+;; WARN: Return type mismatch object vs none.
+(defmethod go-hostile crimson-guard-level ((obj crimson-guard-level))
+  (let ((v1-0 (-> obj hit-face)))
+    (cond
+      ((zero? v1-0)
+       (go (method-of-object obj get-up-front))
+       )
+      ((= v1-0 1)
+       (go (method-of-object obj get-up-back))
+       )
+      ((logtest? (-> obj flags) 1)
+       (go (method-of-object obj tazer-hostile))
+       )
+      ((logtest? (-> obj flags) 2)
+       (go (method-of-object obj blast-hostile))
+       )
+      ((logtest? (-> obj flags) 8)
+       (go (method-of-object obj grenade-hostile))
+       )
+      (else
+        (go (method-of-object obj hostile))
+        )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 78 of type crimson-guard-level
+(defmethod enemy-method-78 crimson-guard-level ((obj crimson-guard-level) (arg0 (pointer float)))
+  (cond
+    ((<= (-> obj hit-points) 0)
+     (let ((a1-1 (-> obj draw art-group data (-> obj info knocked-land anim-index (-> obj hit-face))))
+           (a0-4 (-> obj skel root-channel 0))
+           )
+       (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-1))
+       (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-1) frames num-frames) -1)))
+       (set! (-> a0-4 param 1) (-> arg0 0))
+       (set! (-> a0-4 frame-num) 0.0)
+       (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-1) num-func-seek!)
+       )
+     (set! (-> obj hit-face) (the-as uint -1))
+     #t
+     )
+    (else
+      (case (-> obj incoming knocked-type)
+        (((knocked-type knocked-type-4) (knocked-type knocked-type-5) (knocked-type knocked-type-7))
+         (ja-channel-push! 1 (seconds 0.1))
+         (cond
+           ((= (-> obj small-hit) 1)
+            (let ((a1-6
+                    (-> obj
+                        draw
+                        art-group
+                        data
+                        (-> (the-as (array int32) (+ (+ (* (-> obj hit-face) 4) (* (-> obj yellow-anim unsigned-anim-index-front) 8))
+                                                     (the-as uint (-> obj info))
+                                                     )
+                                    )
+                            6
+                            )
+                        )
+                    )
+                  (a0-15 (-> obj skel root-channel 0))
+                  )
+              (set! (-> a0-15 frame-group) (the-as art-joint-anim a1-6))
+              (set! (-> a0-15 param 0) (the float (+ (-> (the-as art-joint-anim a1-6) frames num-frames) -1)))
+              (set! (-> a0-15 param 1) (-> arg0 0))
+              (set! (-> a0-15 frame-num) 0.0)
+              (joint-control-channel-group! a0-15 (the-as art-joint-anim a1-6) num-func-seek!)
+              )
+            (set! (-> obj hit-face) (the-as uint -1))
+            #t
+            )
+           (else
+             (let ((a1-7 (-> obj draw art-group data (-> obj info knocked-land anim-index (-> obj hit-face))))
+                   (a0-19 (-> obj skel root-channel 0))
+                   )
+               (set! (-> a0-19 frame-group) (the-as art-joint-anim a1-7))
+               (set! (-> a0-19 param 0) (the float (+ (-> (the-as art-joint-anim a1-7) frames num-frames) -1)))
+               (set! (-> a0-19 param 1) (-> arg0 0))
+               (set! (-> a0-19 frame-num) 0.0)
+               (joint-control-channel-group! a0-19 (the-as art-joint-anim a1-7) num-func-seek!)
+               )
+             #t
+             )
+           )
+         )
+        (((knocked-type knocked-type-6))
+         (ja-channel-push! 1 (seconds 0.01))
+         (let ((a0-22 (-> obj skel root-channel 0)))
+           (set! (-> a0-22 frame-group) (the-as art-joint-anim (-> obj draw art-group data 11)))
+           (set! (-> a0-22 param 0)
+                 (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 11)) frames num-frames) -1))
+                 )
+           (set! (-> a0-22 param 1) (-> arg0 0))
+           (set! (-> a0-22 frame-num) 0.0)
+           (joint-control-channel-group! a0-22 (the-as art-joint-anim (-> obj draw art-group data 11)) num-func-seek!)
+           )
+         (set! (-> obj hit-face) (the-as uint -1))
+         #t
+         )
+        (else
+          (ja-channel-push! 1 (seconds 0.1))
+          (let ((a1-11 (-> obj draw art-group data (-> obj info knocked-land anim-index (-> obj hit-face))))
+                (a0-27 (-> obj skel root-channel 0))
+                )
+            (set! (-> a0-27 frame-group) (the-as art-joint-anim a1-11))
+            (set! (-> a0-27 param 0) (the float (+ (-> (the-as art-joint-anim a1-11) frames num-frames) -1)))
+            (set! (-> a0-27 param 1) (-> arg0 0))
+            (set! (-> a0-27 frame-num) 0.0)
+            (joint-control-channel-group! a0-27 (the-as art-joint-anim a1-11) num-func-seek!)
+            )
+          #t
+          )
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die-falling (crimson-guard-level)
+  :virtual #t
+  :code (behavior ()
+    (cond
+      ((enemy-method-133 self)
+       (ja-channel-push! 1 (seconds 0.2))
+       (let ((gp-0 (-> self draw art-group data (-> self enemy-info-override die-falling-anim)))
+             (f30-0 (get-rand-float-range self 0.8 1.2))
+             )
+         (ja-no-eval :group! gp-0
+                     :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0)
+                     :frame-num 0.0
+                     )
+         (until (ja-done? 0)
+           (suspend)
+           (ja :num! (seek! max f30-0))
+           )
+         )
+       )
+      (else
+        (let ((gp-1 #t))
+          (let ((v1-24 (ja-group)))
+            (cond
+              ((and v1-24 (or (= v1-24 (-> self draw art-group data 33)) (= v1-24 (-> self draw art-group data 34))))
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               )
+              ((let ((v1-39 (ja-group)))
+                 (and v1-39 (= v1-39 (-> self draw art-group data 8)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 9)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 9)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               (set! gp-1 #f)
+               )
+              ((let ((v1-79 (ja-group)))
+                 (and v1-79 (= v1-79 (-> self draw art-group data 31)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 32)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 32)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               (set! gp-1 #f)
+               )
+              ((let ((v1-119 (ja-group)))
+                 (and v1-119 (= v1-119 (-> self draw art-group data 9)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 34)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 34)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               )
+              ((let ((v1-158 (ja-group)))
+                 (and v1-158 (= v1-158 (-> self draw art-group data 32)))
+                 )
+               (ja-no-eval :num! (seek!))
+               (while (not (ja-done? 0))
+                 (suspend)
+                 (ja-eval)
+                 )
+               (ja-channel-push! 1 (seconds 0.07))
+               (ja-no-eval :group! (-> self draw art-group data 33)
+                           :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 33)) frames num-frames) -1)))
+                           :frame-num 0.0
+                           )
+               (until (ja-done? 0)
+                 (suspend)
+                 (ja :num! (seek!))
+                 )
+               )
+              )
+            )
+          (when gp-1
+            (ja-channel-push! 1 (seconds 0.1))
+            (ja-no-eval :group! (-> self draw art-group data 17)
+                        :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 17)) frames num-frames) -1)))
+                        :frame-num 0.0
+                        )
+            (until (ja-done? 0)
+              (suspend)
+              (ja :num! (seek!))
+              )
+            )
+          )
+        )
+      )
+    (send-event self 'death-end)
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; definition for method 201 of type crimson-guard-level
+;; WARN: Return type mismatch int vs none.
+(defmethod crimson-guard-level-method-201 crimson-guard-level ((obj crimson-guard-level) (arg0 float))
+  (let* ((s3-0 (handle->process (-> obj transport)))
+         (s4-0 (if (type? s3-0 process-focusable)
+                   (the-as process-focusable s3-0)
+                   )
+               )
+         )
+    (when s4-0
+      (let ((s2-0 (matrix<-transformq! (new 'stack-no-clear 'matrix) (the-as transformq (-> s4-0 root-override trans))))
+            (s3-1 (new 'stack-no-clear 'vector))
+            )
+        (set! (-> s3-1 x) (if (zero? (-> obj transport-side))
+                              -8192.0
+                              8192.0
+                              )
+              )
+        (set! (-> s3-1 y) 12288.0)
+        (set! (-> s3-1 z) (lerp-scale -16384.0 -49152.0 arg0 0.0 1.0))
+        (set! (-> s3-1 w) 1.0)
+        (quaternion-rotate-local-y! (-> obj root-override2 quat) (-> s4-0 root-override quat) 32768.0)
+        (vector-matrix*! (-> obj root-override2 trans) s3-1 s2-0)
+        )
+      )
+    )
+  (let ((f0-5 (fmax 0.0 (fmin 1.0 (* 3.3333333 arg0)))))
+    (set-vector! (-> obj draw color-mult) f0-5 f0-5 f0-5 1.0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 202 of type crimson-guard-level
+;; INFO: Used lq/sq
+;; ERROR: Unsupported inline assembly instruction kind - [mula.s f0, f3]
+;; ERROR: Unsupported inline assembly instruction kind - [madda.s f1, f4]
+;; ERROR: Unsupported inline assembly instruction kind - [madd.s f0, f2, f5]
+(defmethod crimson-guard-level-method-202 crimson-guard-level ((obj crimson-guard-level) (arg0 vector))
+  (local-vars
+    (f0-8 float)
+    (sv-768 vector)
+    (sv-784 vector)
+    (sv-800 nav-control)
+    (sv-816 nav-poly)
+    (sv-832 vector)
+    )
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+          (f30-0 0.0)
+          )
+      (dotimes (s3-0 2)
+        (vector-normalize! s4-0 (* 4096.0 (+ 4.0 (* 2.0 (the float s3-0)))))
+        (dotimes (s2-0 6)
+          (set! sv-768 (new 'stack-no-clear 'vector))
+          (let ((s1-0 (new 'stack-no-clear 'vector))
+                (s0-0 (new 'stack 'collide-query))
+                )
+            (vector-rotate-around-y! sv-768 s4-0 (* 182.04445 (the float (+ (* 23 s2-0) -70))))
+            (let ((v1-10 s1-0))
+              (let ((a0-6 (-> obj root-override2 trans)))
+                (let ((a1-5 sv-768))
+                  (let ((a2-2 1.0))
+                    (.mov vf7 a2-2)
+                    )
+                  (.lvf vf5 (&-> a1-5 quad))
+                  )
+                (.lvf vf4 (&-> a0-6 quad))
+                )
+              (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+              (.mul.x.vf acc vf5 vf7 :mask #b111)
+              (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+              (.svf (&-> v1-10 quad) vf6)
+              )
+            (if (enemy-method-126 obj s0-0 s1-0 (collide-spec backgnd) 8192.0 81920.0 1024.0)
+                (set! (-> s1-0 y) (-> s0-0 best-other-tri intersect y))
+                )
+            (let ((v1-14 (-> obj nav))
+                  (a0-8 s1-0)
+                  (a1-7 (new 'stack-no-clear 'nav-find-poly-parms))
+                  )
+              (vector-! (-> a1-7 point) a0-8 (-> v1-14 state mesh bounds))
+              (set! (-> a1-7 y-threshold) (-> v1-14 nearest-y-threshold))
+              (set! (-> a1-7 ignore) (the-as uint 2))
+              (set! sv-816 (find-poly-containing-point-local (-> v1-14 state mesh) a1-7))
+              )
+            (when sv-816
+              (let* ((v1-18 s4-0)
+                     (f0-7 (-> sv-768 x))
+                     (f1-4 (-> sv-768 y))
+                     (f2-2 (-> sv-768 z))
+                     (f3-2 (-> v1-18 x))
+                     (f4-0 (-> v1-18 y))
+                     (f5-0 (-> v1-18 z))
+                     )
+                (.mula.s f0-7 f3-2)
+                (.madda.s f1-4 f4-0)
+                (.madd.s f0-8 f2-2 f5-0)
+                )
+              (let ((f28-0 f0-8))
+                #t
+                (new 'stack-no-clear 'vector)
+                (let ((a1-8 (new 'stack-no-clear 'vector)))
+                  (set! (-> a1-8 quad) (-> s1-0 quad))
+                  (set! (-> a1-8 w) 8192.0)
+                  (when (not (add-root-sphere-to-hash! (-> obj nav) a1-8 32))
+                    (when (< f30-0 f28-0)
+                      (set! f30-0 f28-0)
+                      (set! sv-784 (new 'stack-no-clear 'vector))
+                      (let ((a3-3 (new 'stack-no-clear 'vector)))
+                        (set! sv-800 (-> obj nav))
+                        (set! sv-832 sv-784)
+                        (let* ((v1-30 s1-0)
+                               (a0-18 (-> sv-800 state mesh))
+                               (t9-7 (method-of-object a0-18 project-point-onto-plane-of-poly-local))
+                               (a2-7 sv-832)
+                               (t0-2 (vector-! (new 'stack-no-clear 'vector) v1-30 (-> sv-800 state mesh bounds)))
+                               )
+                          (t9-7 a0-18 sv-816 a2-7 a3-3 t0-2)
+                          )
+                        )
+                      (let ((v1-31 sv-832))
+                        (let ((a0-21 (-> sv-800 state mesh bounds)))
+                          (.mov.vf vf6 vf0 :mask #b1000)
+                          (.lvf vf4 (&-> sv-832 quad))
+                          (.lvf vf5 (&-> a0-21 quad))
+                          )
+                        (.add.vf vf6 vf4 vf5 :mask #b111)
+                        (.svf (&-> v1-31 quad) vf6)
+                        )
+                      0
+                      (set! (-> s1-0 y) (-> sv-784 y))
+                      (if (enemy-method-126 obj s0-0 s1-0 (collide-spec backgnd) 8192.0 81920.0 1024.0)
+                          (set! (-> s1-0 y) (-> s0-0 best-other-tri intersect y))
+                          )
+                      (set! (-> arg0 quad) (-> s1-0 quad))
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      f30-0
+      )
+    )
+  )
+
+;; definition for method 93 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod enemy-method-93 crimson-guard-level ((obj crimson-guard-level))
+  (let ((s5-0 (-> obj nav state))
+        (v1-2 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
+        )
+    (set! (-> s5-0 heading quad) (-> v1-2 quad))
+    )
+  0
+  (let ((s5-1 (-> obj nav state)))
+    (set! (-> (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)) quad)
+          (-> s5-1 travel quad)
+          )
+    )
+  (let ((a0-5 (-> obj nav state))
+        (v1-9 *null-vector*)
+        )
+    (set! (-> a0-5 velocity quad) (-> v1-9 quad))
+    )
+  0
+  ((method-of-type nav-enemy enemy-method-93) obj)
+  (none)
+  )
+
+;; definition for method 89 of type crimson-guard-level
+(defmethod enemy-method-89 crimson-guard-level ((obj crimson-guard-level) (arg0 enemy-jump-info))
+  #f
+  )
+
+;; definition for method 87 of type crimson-guard-level
+(defmethod enemy-method-87 crimson-guard-level ((obj crimson-guard-level) (arg0 enemy-jump-info))
+  (let ((a0-1 (-> obj skel root-channel 0)))
+    (set! (-> a0-1 param 0) 1.0)
+    (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!)
+    )
+  (ja-channel-push! 1 (seconds 0.1))
+  (let ((s4-0 (-> obj skel root-channel 0)))
+    (set! (-> s4-0 frame-group) (the-as art-joint-anim (-> obj draw art-group data 38)))
+    (set! (-> s4-0 param 0) (ja-aframe 3.0 0))
+    (set! (-> s4-0 param 1) (-> arg0 anim-speed))
+    (set! (-> s4-0 frame-num) (ja-aframe 0.0 0))
+    (joint-control-channel-group! s4-0 (the-as art-joint-anim (-> obj draw art-group data 38)) num-func-seek!)
+    )
+  #t
+  )
+
+;; definition for method 88 of type crimson-guard-level
+(defmethod enemy-method-88 crimson-guard-level ((obj crimson-guard-level) (arg0 enemy-jump-info))
+  (let ((a0-1 (-> obj skel root-channel 0)))
+    (set! (-> a0-1 param 0) 1.0)
+    (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!)
+    )
+  (ja-channel-push! 1 (seconds 0.01))
+  (let ((s4-0 (-> obj skel root-channel 0)))
+    (set! (-> s4-0 frame-group) (the-as art-joint-anim (-> obj draw art-group data 38)))
+    (set! (-> s4-0 param 0) (ja-aframe 9.0 0))
+    (set! (-> s4-0 param 1) (-> arg0 anim-speed))
+    (set! (-> s4-0 frame-num) (ja-aframe 4.0 0))
+    (joint-control-channel-group! s4-0 (the-as art-joint-anim (-> obj draw art-group data 38)) num-func-seek!)
+    )
+  #t
+  )
+
+;; definition for method 90 of type crimson-guard-level
+(defmethod enemy-method-90 crimson-guard-level ((obj crimson-guard-level) (arg0 int) (arg1 enemy-jump-info))
+  (local-vars (s5-0 symbol))
+  (let ((v1-0 arg0))
+    (cond
+      ((zero? v1-0)
+       (not (enemy-method-89 obj arg1))
+       )
+      ((= v1-0 1)
+       (set! s5-0 (ja-done? 0))
+       (let ((s4-1 (-> obj skel root-channel 0)))
+         (set! (-> s4-1 param 0) (ja-aframe 3.0 0))
+         (set! (-> s4-1 param 1) (-> arg1 anim-speed))
+         (joint-control-channel-group-eval! s4-1 (the-as art-joint-anim #f) num-func-seek!)
+         )
+       (ja-blend-eval)
+       s5-0
+       )
+      ((= v1-0 2)
+       (enemy-method-87 obj arg1)
+       #f
+       )
+      ((= v1-0 3)
+       (set! s5-0 (ja-done? 0))
+       (let ((s4-2 (-> obj skel root-channel 0)))
+         (set! (-> s4-2 param 0) (ja-aframe 3.0 0))
+         (set! (-> s4-2 param 1) (-> arg1 anim-speed))
+         (joint-control-channel-group-eval! s4-2 (the-as art-joint-anim #f) num-func-seek!)
+         )
+       (ja-blend-eval)
+       s5-0
+       )
+      ((= v1-0 4)
+       (not (enemy-method-88 obj arg1))
+       )
+      ((= v1-0 5)
+       (set! s5-0 (ja-done? 0))
+       (let ((s4-3 (-> obj skel root-channel 0)))
+         (set! (-> s4-3 param 0) (ja-aframe 9.0 0))
+         (set! (-> s4-3 param 1) (-> arg1 anim-speed))
+         (joint-control-channel-group-eval! s4-3 (the-as art-joint-anim #f) num-func-seek!)
+         )
+       (ja-blend-eval)
+       s5-0
+       )
+      (else
+        #t
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate exit-transport (crimson-guard-level)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior crimson-guard-level)
+    enemy-event-handler
+    )
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (logior! (-> self nav flags) (nav-control-flag output-sphere-hash))
+    (nav-enemy-method-166 self)
+    (let ((v1-7 (-> self nav)))
+      (set! (-> v1-7 target-speed) (-> self enemy-info-override run-travel-speed))
+      )
+    0
+    (set! (-> self already-shot) (the-as uint #f))
+    (none)
+    )
+  :exit (behavior ()
+    (set-vector! (-> self draw color-mult) 1.0 1.0 1.0 1.0)
+    (logclear! (-> self nav flags) (nav-control-flag output-sphere-hash))
+    (none)
+    )
+  :trans (behavior ()
+    (rlet ((acc :class vf)
+           (vf0 :class vf)
+           (vf4 :class vf)
+           (vf5 :class vf)
+           (vf6 :class vf)
+           (vf7 :class vf)
+           )
+      (init-vf0-vector)
+      (when (not (-> self already-shot))
+        (crimson-guard-level-method-201 self 1.0)
+        (let ((gp-0 (new 'stack-no-clear 'vector)))
+          (set! (-> gp-0 quad) (-> self root-override2 trans quad))
+          (let ((s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override2 quat)))
+                (s5-0 (new 'stack 'collide-query))
+                )
+            (let ((a0-3 gp-0))
+              (let ((v1-8 gp-0))
+                (let ((a1-4 20480.0))
+                  (.mov vf7 a1-4)
+                  )
+                (.lvf vf5 (&-> s4-0 quad))
+                (.lvf vf4 (&-> v1-8 quad))
+                )
+              (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+              (.mul.x.vf acc vf5 vf7 :mask #b111)
+              (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+              (.svf (&-> a0-3 quad) vf6)
+              )
+            (if (enemy-method-126 self s5-0 gp-0 (collide-spec backgnd) 8192.0 81920.0 1024.0)
+                (set! (-> gp-0 y) (-> s5-0 best-other-tri intersect y))
+                )
+            )
+          )
+        (when (!= (crimson-guard-level-method-202 self (-> self event-param-point)) 0.0)
+          (let* ((v1-16 (-> self nav))
+                 (a1-7 (-> self event-param-point))
+                 (f0-3 (-> v1-16 extra-nav-sphere w))
+                 )
+            (set! (-> v1-16 extra-nav-sphere quad) (-> a1-7 quad))
+            (set! (-> v1-16 extra-nav-sphere w) f0-3)
+            )
+          0
+          (let ((v1-19 (-> self nav)))
+            (set! (-> v1-19 extra-nav-sphere w) (-> self nav-radius-backup))
+            )
+          0
+          (let ((v1-21 (-> self nav)))
+            (logior! (-> v1-21 shape nav-flags) (nav-flags has-extra-sphere))
+            )
+          0
+          (set! (-> self already-shot) (the-as uint #t))
+          )
+        (crimson-guard-level-method-201 self 0.0)
+        )
+      (none)
+      )
+    )
+  :code (behavior ()
+    (while (not (-> self already-shot))
+      (suspend)
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (ja-channel-set! 1)
+    (let ((gp-0 (-> self clock frame-counter))
+          (s5-0 150)
+          (f30-0 2.0)
+          )
+      (ja-no-eval :group! (-> self draw art-group data 6) :num! (loop! f30-0) :frame-num 0.0)
+      (until (>= (- (-> self clock frame-counter) gp-0) s5-0)
+        (crimson-guard-level-method-201
+          self
+          (* 0.006666667 (the float (- (-> self clock frame-counter) (-> self state-time))))
+          )
+        (suspend)
+        (ja :num! (loop! f30-0))
+        )
+      )
+    (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable))))
+    (send-event self 'jump 0 (-> self event-param-point))
+    (until #f
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (ja-post)
+    (none)
+    )
+  )
+
+;; definition for method 114 of type crimson-guard-level
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 crimson-guard-level ((obj crimson-guard-level))
+  "@abstract"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate
+                                    generic-attack
+                                    lunge
+                                    flop
+                                    punch
+                                    spin
+                                    roll
+                                    uppercut
+                                    bonk
+                                    tube
+                                    vehicle
+                                    flut-attack
+                                    board
+                                    mech-punch
+                                    dark-punch
+                                    dark-giant
+                                    )
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 4) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 5))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak bot obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 8192.0 0.0 24576.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak bot obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid))
+      (set-vector! (-> v1-13 local-sphere) 0.0 6144.0 0.0 6144.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-15 prim-core collide-with)
+            (collide-spec backgnd jak bot obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-15 prim-core action) (collide-action solid no-standon))
+      (set-vector! (-> v1-15 local-sphere) 0.0 9830.4 0.0 6144.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-17 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list pusher))
+      (set! (-> v1-17 prim-core action) (collide-action semi-solid))
+      (set! (-> v1-17 transform-index) 14)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 2048.0 4096.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-19 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list pusher))
+      (set! (-> v1-19 prim-core action) (collide-action semi-solid))
+      (set! (-> v1-19 transform-index) 14)
+      (set-vector! (-> v1-19 local-sphere) 0.0 0.0 -12288.0 6144.0)
+      )
+    (set! (-> s5-0 nav-radius) 6144.0)
+    (let ((v1-21 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-21 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-21 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 3))
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 7 of type crimson-guard-level
+;; WARN: Return type mismatch nav-enemy vs crimson-guard-level.
+(defmethod relocate crimson-guard-level ((obj crimson-guard-level) (arg0 int))
+  (if (nonzero? (-> obj joint))
+      (&+! (-> obj joint) arg0)
+      )
+  (if (nonzero? (-> obj l-control))
+      (&+! (-> obj l-control) arg0)
+      )
+  (the-as
+    crimson-guard-level
+    ((the-as (function nav-enemy int nav-enemy) (find-parent-method crimson-guard-level 7)) obj arg0)
+    )
+  )
+
+;; definition for method 203 of type crimson-guard-level
+;; WARN: Return type mismatch float vs none.
+(defmethod crimson-guard-level-method-203 crimson-guard-level ((obj crimson-guard-level) (arg0 int))
+  "TODO - probably a flag"
+  (cond
+    ((= arg0 1)
+     (setup-masks (-> obj draw) 16 0)
+     (set! (-> obj weapon) 1)
+     (set! (-> obj root-override2 nav-radius) 10240.0)
+     )
+    ((= arg0 3)
+     (setup-masks (-> obj draw) 16 0)
+     (set! (-> obj weapon) 3)
+     (set! (-> obj root-override2 nav-radius) 10240.0)
+     )
+    ((zero? arg0)
+     (setup-masks (-> obj draw) 8 0)
+     (set! (-> obj weapon) 0)
+     (set! (-> obj root-override2 nav-radius) 6144.0)
+     )
+    )
+  (none)
+  )
+
+;; definition for method 156 of type crimson-guard-level
+;; INFO: Used lq/sq
+(defmethod nav-enemy-method-156 crimson-guard-level ((obj crimson-guard-level))
+  (cond
+    ((logtest? (-> obj flags) 36)
+     (let ((v1-3 (-> obj nav state))
+           (a0-2 (-> obj root-override2 trans))
+           )
+       (logclear! (-> v1-3 flags) (nav-state-flag directional-mode))
+       (logior! (-> v1-3 flags) (nav-state-flag target-poly-dirty))
+       (set! (-> v1-3 target-post quad) (-> a0-2 quad))
+       )
+     0
+     )
+    (else
+      ((method-of-type nav-enemy nav-enemy-method-156) obj)
+      )
+    )
+  (none)
+  )
+
+;; definition for method 115 of type crimson-guard-level
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 crimson-guard-level ((obj crimson-guard-level))
+  "@abstract"
+  (local-vars (sv-16 int))
+  (let ((f0-0 (res-lump-float (-> obj entity) 'rotoffset)))
+    (if (!= f0-0 0.0)
+        (quaternion-rotate-y! (-> obj root-override2 quat) (-> obj root-override2 quat) f0-0)
+        )
+    )
+  (set! sv-16 0)
+  (let ((v1-6 (res-lump-data (-> obj entity) 'trans-offset vector :tag-ptr (the-as (pointer res-tag) (& sv-16)))))
+    (when v1-6
+      (+! (-> obj root-override2 trans x) (-> v1-6 x))
+      (+! (-> obj root-override2 trans y) (-> v1-6 y))
+      (+! (-> obj root-override2 trans z) (-> v1-6 z))
+      )
+    )
+  (initialize-skeleton
+    obj
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-crimson-guard-level" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (let ((a0-13 (-> obj entity)))
+    (set! (-> obj flags) (the-as int ((method-of-object a0-13 get-property-value)
+                                      a0-13
+                                      'crimson-guard-level-flags
+                                      'interp
+                                      -1000000000.0
+                                      (the-as uint128 1)
+                                      (the-as (pointer res-tag) #f)
+                                      *res-static-buf*
+                                      )
+                                 )
+          )
+    )
+  (set! (-> obj info) *crimson-guard-level-global-info*)
+  (enemy-method-113 obj *crimson-guard-level-info*)
+  (cond
+    ((logtest? (-> obj flags) 1)
+     (enemy-method-113 obj *crimson-guard-level-tazer-info*)
+     )
+    ((logtest? (-> obj flags) 4)
+     (enemy-method-113 obj *crimson-guard-level-sniper-info*)
+     )
+    ((logtest? (-> obj flags) 2)
+     (enemy-method-113 obj *crimson-guard-level-blast-info*)
+     )
+    ((logtest? (-> obj flags) 8)
+     (enemy-method-113 obj *crimson-guard-level-grenade-info*)
+     )
+    (else
+      (enemy-method-113 obj *crimson-guard-level-info*)
+      )
+    )
+  (let ((v1-34 (-> obj nav)))
+    (set! (-> v1-34 speed-scale) 1.0)
+    )
+  0
+  (set! (-> obj draw lod-set lod 0 dist) 143360.0)
+  (set! (-> obj draw lod-set lod 1 dist) 491520.0)
+  (set! (-> obj joint) (new 'process 'joint-mod (joint-mod-mode joint-set*-world) obj 4))
+  (set! (-> obj l-control) (new 'process 'lightning-control (-> *lightning-spec-id-table* 13) obj 0.0))
+  (set! (-> obj l-control state points-to-draw) 0)
+  (let ((v1-45 (get-rand-int obj 2)))
+    (if (logtest? (-> obj flags) 4)
+        (set! v1-45 0)
+        )
+    (cond
+      ((zero? v1-45)
+       (set! (-> obj anim-shoot 0 anim-index) 19)
+       (set! (-> obj anim-shoot 0 start) 1.0)
+       (set! (-> obj anim-shoot 0 end) 12.0)
+       (set! (-> obj anim-shoot 1 anim-index) 26)
+       (set! (-> obj anim-shoot 1 start) 12.0)
+       (set! (-> obj anim-shoot 1 end) 22.0)
+       (set! (-> obj anim-shoot 2 anim-index) 24)
+       (set! (-> obj anim-shoot 2 start) 20.0)
+       (set! (-> obj anim-shoot 2 end) 30.0)
+       )
+      ((= v1-45 1)
+       (set! (-> obj anim-shoot 0 anim-index) 27)
+       (set! (-> obj anim-shoot 0 start) 2.0)
+       (set! (-> obj anim-shoot 0 end) 9.0)
+       (set! (-> obj anim-shoot 1 anim-index) 29)
+       (set! (-> obj anim-shoot 1 start) 18.0)
+       (set! (-> obj anim-shoot 1 end) 26.0)
+       (set! (-> obj anim-shoot 2 anim-index) 30)
+       (set! (-> obj anim-shoot 2 start) 26.0)
+       (set! (-> obj anim-shoot 2 end) 35.0)
+       )
+      )
+    )
+  (setup-masks (-> obj draw) 0 -1)
+  (cond
+    ((logtest? (-> obj flags) 1)
+     (crimson-guard-level-method-203 obj 1)
+     )
+    ((logtest? (-> obj flags) 2)
+     (set! (-> obj fact-info-override trig-dist) 409600.0)
+     (crimson-guard-level-method-203 obj 0)
+     )
+    ((logtest? (-> obj flags) 4)
+     (crimson-guard-level-method-203 obj 0)
+     )
+    ((logtest? (-> obj flags) 8)
+     (set! (-> obj fact-info-override trig-dist) 819200.0)
+     (crimson-guard-level-method-203 obj 3)
+     )
+    ((logtest? (-> obj flags) 16)
+     (crimson-guard-level-method-203 obj 0)
+     )
+    )
+  (cond
+    ((logtest? (-> obj flags) 128)
+     (setup-masks (-> obj draw) 5 0)
+     (set-vector! (-> obj root-override2 scale) 1.1 1.1 1.1 1.0)
+     (set! (-> obj hit-points) (* (-> obj hit-points) 2))
+     (set-vector! (-> obj joint scale) 1.1 1.0 1.1 1.0)
+     (let* ((a0-45 (-> obj neck))
+            (t9-22 (method-of-object a0-45 trs-set!))
+            (a1-22 #f)
+            (a2-10 #f)
+            (a3-5 (new 'stack-no-clear 'vector))
+            )
+       (set! (-> a3-5 x) 0.9090909)
+       (set! (-> a3-5 y) 1.0)
+       (set! (-> a3-5 z) 0.9090909)
+       (set! (-> a3-5 w) 1.0)
+       (t9-22 a0-45 (the-as vector a1-22) (the-as quaternion a2-10) a3-5)
+       )
+     (mode-set! (-> obj neck) (joint-mod-mode rotate2))
+     (set! (-> obj joint parented-scale?) #t)
+     (set! (-> obj neck parented-scale?) #t)
+     )
+    (else
+      (setup-masks (-> obj draw) 3 0)
+      )
+    )
+  (set! (-> obj hit-face) (the-as uint -1))
+  (set! (-> obj anim-get-up-front) 33)
+  (set! (-> obj anim-get-up-back) 34)
+  (set! (-> obj joint-enable) #f)
+  (set! (-> obj fact-info-override pickup-type) (pickup-type ammo-random))
+  (set! (-> obj fact-info-override pickup-amount) 10.0)
+  (set! (-> obj fact-info-override pickup-spawn-amount) 1.0)
+  (set! (-> obj trigger) #f)
+  (set! (-> obj root-override2 pause-adjust-distance) 409600.0)
+  (transform-post)
+  0
+  (none)
+  )
+
+;; definition of type crimson-guard-level-params
+(deftype crimson-guard-level-params (structure)
+  ((pos            vector     :inline :offset-assert   0)
+   (quat           quaternion :inline :offset-assert  16)
+   (nav-mesh       nav-mesh           :offset-assert  32)
+   (handle         uint64             :offset-assert  40)
+   (transport-side uint32             :offset-assert  48)
+   (weapon         int32              :offset-assert  52)
+   (proc           process            :offset-assert  56)
+   )
+  :method-count-assert 9
+  :size-assert         #x3c
+  :flag-assert         #x90000003c
+  )
+
+;; definition for method 3 of type crimson-guard-level-params
+(defmethod inspect crimson-guard-level-params ((obj crimson-guard-level-params))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'crimson-guard-level-params)
+  (format #t "~1Tpos: #<vector @ #x~X>~%" (-> obj pos))
+  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> obj quat))
+  (format #t "~1Tnav-mesh: ~A~%" (-> obj nav-mesh))
+  (format #t "~1Thandle: ~D~%" (-> obj handle))
+  (format #t "~1Ttransport-side: ~D~%" (-> obj transport-side))
+  (format #t "~1Tweapon: ~D~%" (-> obj weapon))
+  (format #t "~1Tproc: ~A~%" (-> obj proc))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for function crimson-guard-level-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior crimson-guard-level-init-by-other crimson-guard-level ((arg0 crimson-guard-level-params))
+  (enemy-method-114 self)
+  (set! (-> self root-override2 trans quad) (-> arg0 pos quad))
+  (quaternion-copy! (-> self root-override2 quat) (-> arg0 quat))
+  (vector-identity! (-> self root-override2 scale))
+  (set! (-> self transport-side) (-> arg0 transport-side))
+  (add-process-drawable-to-navmesh (-> arg0 nav-mesh) self #t)
+  (set! (-> arg0 proc) self)
+  (set! (-> self transport) (the-as handle (-> arg0 handle)))
+  (enemy-method-115 self)
+  (crimson-guard-level-method-203 self (-> arg0 weapon))
+  (logior! (-> self flags) 96)
+  (go-virtual exit-transport)
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/common/enemy/guards/transport-level_REF.gc b/test/decompiler/reference/jak2/levels/common/enemy/guards/transport-level_REF.gc
new file mode 100644
index 0000000000..c28c0e53e2
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/common/enemy/guards/transport-level_REF.gc
@@ -0,0 +1,405 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type transport-level
+(deftype transport-level (process-focusable)
+  ((y-dest                float        :offset-assert 204)
+   (last-guard-spawn-time time-frame   :offset-assert 208)
+   (nav-mesh              nav-mesh     :offset-assert 216)
+   (spawn-side            uint32       :offset-assert 220)
+   (spawn?                symbol       :offset-assert 224)
+   (leave-time            time-frame   :offset-assert 232)
+   (max-guard             uint32       :offset-assert 240)
+   (count-guard           uint32       :offset-assert 244)
+   (max-time              float        :offset-assert 248)
+   (spawn-time            time-frame   :offset-assert 256)
+   (ambient-sound-id      uint32       :offset-assert 264)
+   (num-wanted-guards     uint32       :offset-assert 268)
+   (guards                handle     8 :offset-assert 272)
+   )
+  :heap-base #xd0
+  :method-count-assert 35
+  :size-assert         #x150
+  :flag-assert         #x2300d00150
+  (:methods
+    (come-down () _type_ :state 27)
+    (idle () _type_ :state 28)
+    (leave () _type_ :state 29)
+    (die-fast () _type_ :state 30)
+    (transport-level-method-31 (_type_) none 31)
+    (transport-level-method-32 (_type_) none 32)
+    (transport-level-method-33 (_type_) uint 33)
+    (transport-level-method-34 (_type_) none 34)
+    )
+  )
+
+;; definition for method 3 of type transport-level
+(defmethod inspect transport-level ((obj transport-level))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Ty-dest: ~f~%" (-> obj y-dest))
+  (format #t "~2Tlast-guard-spawn-time: ~D~%" (-> obj last-guard-spawn-time))
+  (format #t "~2Tnav-mesh: ~A~%" (-> obj nav-mesh))
+  (format #t "~2Tspawn-side: ~D~%" (-> obj spawn-side))
+  (format #t "~2Tspawn?: ~A~%" (-> obj spawn?))
+  (format #t "~2Tleave-time: ~D~%" (-> obj leave-time))
+  (format #t "~2Tmax-guard: ~D~%" (-> obj max-guard))
+  (format #t "~2Tcount-guard: ~D~%" (-> obj count-guard))
+  (format #t "~2Tmax-time: ~f~%" (-> obj max-time))
+  (format #t "~2Tspawn-time: ~D~%" (-> obj spawn-time))
+  (format #t "~2Tambient-sound-id: ~D~%" (-> obj ambient-sound-id))
+  (format #t "~2Tnum-wanted-guards: ~D~%" (-> obj num-wanted-guards))
+  (format #t "~2Tguards[8] @ #x~X~%" (-> obj guards))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-transport-level transport transport-lod0-jg transport-idle-ja
+              ((transport-lod0-mg (meters 20)) (transport-lod1-mg (meters 40)) (transport-lod2-mg (meters 999999)))
+              :bounds (static-spherem 0 5 0 17)
+              )
+
+;; definition for function transport-level-event-handler
+;; WARN: Return type mismatch object vs transport-level.
+(defbehavior transport-level-event-handler transport-level ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (the-as transport-level (case arg2
+                            (('die-fast)
+                             (go-virtual die-fast)
+                             )
+                            (('leave)
+                             (if (not (and (-> self next-state) (let ((v1-6 (-> self next-state name)))
+                                                                  (or (= v1-6 'leave) (= v1-6 'die-fast))
+                                                                  )
+                                           )
+                                      )
+                                 (go-virtual leave)
+                                 )
+                             )
+                            (('guards-left)
+                             (- (-> self max-guard) (-> self count-guard))
+                             )
+                            (('guards-alive)
+                             (set! v0-0 (-> arg3 param 0))
+                             (set! (-> self num-wanted-guards) (the-as uint v0-0))
+                             v0-0
+                             )
+                            (('guards-alive-count)
+                             (set! v0-0 0)
+                             (dotimes (v1-10 (the-as int (-> self num-wanted-guards)))
+                               (if (handle->process (-> self guards v1-10))
+                                   (set! v0-0 (+ (the-as int v0-0) 1))
+                                   )
+                               )
+                             v0-0
+                             )
+                            (('spawn-time)
+                             (set! v0-0 (-> arg3 param 0))
+                             (set! (-> self spawn-time) (the-as time-frame v0-0))
+                             v0-0
+                             )
+                            (('stop-spawning)
+                             (set! (-> self spawn?) #f)
+                             #f
+                             )
+                            )
+          )
+  )
+
+;; definition for method 34 of type transport-level
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-level-method-34 transport-level ((obj transport-level))
+  (let ((f30-0 (lerp-scale 0.0 2.0 (fabs (-> obj root-override transv y)) 0.0 122880.0))
+        (f0-4 (lerp-scale 0.0 1.0 (- (-> obj root-override trans y) (-> obj y-dest)) 143360.0 20480.0))
+        (a0-3 (static-sound-spec "transport" :volume 0.0 :mask (pitch reg0)))
+        )
+    (set! (-> a0-3 volume) (the int (* 1024.0 f0-4)))
+    (set! (-> a0-3 pitch-mod) (the int (* 1524.0 f30-0)))
+    (sound-play-by-spec a0-3 (the-as sound-id (-> obj ambient-sound-id)) (-> obj root-override trans))
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate come-down (transport-level)
+  :virtual #t
+  :event transport-level-event-handler
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self last-guard-spawn-time) (-> self clock frame-counter))
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (ja-no-eval :group! (-> self draw art-group data 4)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (set! (-> self root-override transv y) (* 2.0 (- (-> self y-dest) (-> self root-override trans y))))
+    (set! (-> self root-override transv y) (fmax -122880.0 (fmin 122880.0 (-> self root-override transv y))))
+    (+! (-> self root-override trans y) (* (-> self root-override transv y) (-> self clock seconds-per-frame)))
+    (if (< (fabs (- (-> self root-override trans y) (-> self y-dest))) 409.6)
+        (go-virtual idle)
+        )
+    (transport-level-method-34 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (transport-level)
+  :virtual #t
+  :event transport-level-event-handler
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self root-override transv y) 0.0)
+    (set! (-> self last-guard-spawn-time) 0)
+    0
+    (none)
+    )
+  :exit (behavior ()
+    '()
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (sound-play "tran-door-open")
+    (ja-no-eval :group! (-> self draw art-group data 5)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames) -1)) 0.5)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.5))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (local-vars (gp-0 symbol))
+    (if (-> self spawn?)
+        (transport-level-method-33 self)
+        )
+    (if (and (zero? (-> self leave-time))
+             (begin
+               (let ((gp-1 #t)
+                     (a1-0 (new 'stack-no-clear 'event-message-block))
+                     )
+                 (set! (-> a1-0 from) (process->ppointer self))
+                 (set! (-> a1-0 num-params) 1)
+                 (set! (-> a1-0 message) 'get-object-reserve-count)
+                 (set! (-> a1-0 param 0) (the-as uint 6))
+                 (let ((v1-9 (the-as object (send-event-function *traffic-manager* a1-0))))
+                   (cmove-#f-nonzero gp-0 v1-9 gp-1)
+                   )
+                 )
+               gp-0
+               )
+             )
+        (set! (-> self leave-time) (+ (-> self clock frame-counter) (seconds 3)))
+        )
+    (if (and (nonzero? (-> self leave-time)) (< (-> self leave-time) (-> self clock frame-counter)))
+        (go-virtual leave)
+        )
+    (when (and (zero? (-> self leave-time))
+               (nonzero? (-> self max-guard))
+               (>= (-> self count-guard) (-> self max-guard))
+               )
+      (set! (-> self leave-time) (+ (-> self clock frame-counter) (seconds 3)))
+      (send-event self 'stop-spawning)
+      )
+    (transport-level-method-34 self)
+    (transform-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die-fast (transport-level)
+  :virtual #t
+  :code (behavior ()
+    (sound-stop (the-as sound-id (-> self ambient-sound-id)))
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate leave (transport-level)
+  :virtual #t
+  :event transport-level-event-handler
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (set! (-> self root-override transv y) 0.0)
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 0)
+    (sound-play "tran-thrust")
+    (sound-play "tran-door-close")
+    (ja-no-eval :group! (-> self draw art-group data 6)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 6)) frames num-frames) -1)) 0.2)
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.2))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (transport-level-method-34 self)
+    (+! (-> self root-override transv y) (* 40960.0 (-> self clock seconds-per-frame)))
+    (set! (-> self root-override transv y) (fmax -122880.0 (fmin 122880.0 (-> self root-override transv y))))
+    (+! (-> self root-override trans y) (* (-> self root-override transv y) (-> self clock seconds-per-frame)))
+    (if (and (not (logtest? (-> self draw status) (draw-control-status on-screen)))
+             (< 163840.0 (- (-> self root-override trans y) (-> self y-dest)))
+             )
+        (go-virtual die-fast)
+        )
+    (transform-post)
+    (none)
+    )
+  )
+
+;; definition for method 33 of type transport-level
+;; INFO: Used lq/sq
+(defmethod transport-level-method-33 transport-level ((obj transport-level))
+  (with-pp
+    (let ((v1-0 0))
+      (dotimes (a0-1 8)
+        (if (handle->process (-> obj guards a0-1))
+            (+! v1-0 1)
+            )
+        )
+      (when (zero? (-> obj count-guard))
+        (set! (-> obj last-guard-spawn-time) 0)
+        0
+        )
+      (when (and (>= (- (-> pp clock frame-counter) (-> obj last-guard-spawn-time)) (-> obj spawn-time))
+                 (< v1-0 (the-as int (-> obj num-wanted-guards)))
+                 )
+        (let ((s5-0 (new 'stack-no-clear 'crimson-guard-level-params)))
+          (set! (-> s5-0 transport-side) (-> obj spawn-side))
+          (set! (-> s5-0 nav-mesh) (-> obj nav-mesh))
+          (set! (-> s5-0 pos quad) (-> obj root-override trans quad))
+          (set! (-> s5-0 pos y) (+ 8192.0 (-> s5-0 pos y)))
+          (quaternion-rotate-local-y! (-> s5-0 quat) (-> obj root-override quat) 32768.0)
+          (set! (-> s5-0 handle) (the-as uint (process->handle obj)))
+          (set! (-> s5-0 weapon) 1)
+          (dotimes (s4-0 (the-as int (-> obj num-wanted-guards)))
+            (when (not (handle->process (-> obj guards s4-0)))
+              (set! (-> obj guards s4-0) (ppointer->handle (process-spawn crimson-guard-level s5-0 :to obj)))
+              #t
+              (goto cfg-38)
+              )
+            )
+          (label cfg-38)
+          (when (-> s5-0 proc)
+            (set! (-> obj spawn-side) (- 1 (the-as int (-> obj spawn-side))))
+            (set! (-> obj last-guard-spawn-time) (-> pp clock frame-counter))
+            (let ((v0-0 (+ (-> obj count-guard) 1)))
+              (set! (-> obj count-guard) v0-0)
+              v0-0
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for method 31 of type transport-level
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-level-method-31 transport-level ((obj transport-level))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 20480.0 0.0 69632.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 4)
+      (set-vector! (-> v1-12 local-sphere) 0.0 0.0 0.0 40960.0)
+      )
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 3)
+      (set-vector! (-> v1-14 local-sphere) 0.0 20480.0 0.0 69632.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-17 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-17 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-17 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 32 of type transport-level
+;; WARN: Return type mismatch int vs none.
+(defmethod transport-level-method-32 transport-level ((obj transport-level))
+  (set! (-> obj spawn-side) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; definition for method 11 of type transport-level
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! transport-level ((obj transport-level) (arg0 entity-actor))
+  (transport-level-method-31 obj)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-transport-level" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transport-level-method-32 obj)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (process-entity-status! obj (entity-perm-status no-kill) #t)
+  (set! (-> obj spawn?) #t)
+  (set! (-> obj nav-mesh) (nav-mesh-from-res-tag arg0 'nav-mesh-actor 0))
+  (set! (-> obj num-wanted-guards) (the-as uint 4))
+  (dotimes (v1-11 8)
+    (set! (-> obj guards v1-11) (the-as handle #f))
+    )
+  (set! (-> obj spawn-time) (seconds 4))
+  (set! (-> obj root-override trans y) (+ 40960.0 (-> obj root-override trans y)))
+  (set! (-> obj y-dest) (-> obj root-override trans y))
+  (set! (-> obj root-override trans y) (+ 163840.0 (-> obj root-override trans y)))
+  (go (method-of-object obj come-down))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/common/entities/fort-floor-spike_REF.gc b/test/decompiler/reference/jak2/levels/common/entities/fort-floor-spike_REF.gc
new file mode 100644
index 0000000000..54cf764877
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/common/entities/fort-floor-spike_REF.gc
@@ -0,0 +1,779 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type spike-row-info
+(deftype spike-row-info (structure)
+  ((sync      sync-linear           :inline :offset-assert   0)
+   (table-ptr (inline-array vector)         :offset-assert  16)
+   (on-ratio  float                         :offset-assert  20)
+   (state     int32                         :offset-assert  24)
+   )
+  :method-count-assert 9
+  :size-assert         #x1c
+  :flag-assert         #x90000001c
+  )
+
+;; definition for method 3 of type spike-row-info
+(defmethod inspect spike-row-info ((obj spike-row-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'spike-row-info)
+  (format #t "~1Tsync: #<sync-linear @ #x~X>~%" (-> obj sync))
+  (format #t "~1Ttable-ptr: #x~X~%" (-> obj table-ptr))
+  (format #t "~1Ton-ratio: ~f~%" (-> obj on-ratio))
+  (format #t "~1Tstate: ~D~%" (-> obj state))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type spike-row-info-array
+(deftype spike-row-info-array (inline-array-class)
+  ((data spike-row-info :inline :dynamic :offset-assert  16)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+;; definition for method 3 of type spike-row-info-array
+(defmethod inspect spike-row-info-array ((obj spike-row-info-array))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj (-> obj type))
+  (format #t "~1Tlength: ~D~%" (-> obj length))
+  (format #t "~1Tallocated-length: ~D~%" (-> obj allocated-length))
+  (format #t "~1Tdata[0] @ #x~X~%" (-> obj data))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(set! (-> spike-row-info-array heap-base) (the-as uint 32))
+
+;; definition of type fort-floor-spike
+(deftype fort-floor-spike (process-drawable)
+  ((pos-table        (inline-array vector)   :offset-assert 200)
+   (spike-row        spike-row-info-array    :offset-assert 204)
+   (spike-dim        basic                 2 :offset-assert 208)
+   (attack-id        int32                   :offset-assert 216)
+   (no-overlap-timer uint64                  :offset-assert 224)
+   )
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  (:methods
+    (idle () _type_ :state 20)
+    (fort-floor-spike-method-21 (_type_) none 21)
+    (fort-floor-spike-method-22 (_type_) collide-shape-moving 22)
+    (fort-floor-spike-method-23 (_type_) symbol 23)
+    )
+  )
+
+;; definition for method 3 of type fort-floor-spike
+(defmethod inspect fort-floor-spike ((obj fort-floor-spike))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tpos-table: #x~X~%" (-> obj pos-table))
+  (format #t "~2Tspike-row: ~A~%" (-> obj spike-row))
+  (format #t "~2Tspike-dim[2] @ #x~X~%" (-> obj spike-dim))
+  (format #t "~2Tattack-id: ~D~%" (-> obj attack-id))
+  (format #t "~2Tno-overlap-timer: ~D~%" (-> obj no-overlap-timer))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for function joint-mod-set-y-callback
+;; INFO: Used lq/sq
+(defun joint-mod-set-y-callback ((arg0 cspace) (arg1 transformq))
+  "TODO - investigate weird casting"
+  (let ((a2-0 (-> arg0 param1))
+        (a3-0 (the-as object (-> arg0 param2)))
+        (v1-0 (new 'stack-no-clear 'transformq))
+        )
+    (set! (-> v1-0 trans quad) (-> arg1 trans quad))
+    (set! (-> v1-0 quat quad) (-> arg1 quat quad))
+    (set! (-> v1-0 scale quad) (-> arg1 scale quad))
+    (set! (-> v1-0 trans y) (fmin -4096.0 (-> (the-as vector (+ (* (the-as int a3-0) 16) (the-as int a2-0))) y)))
+    (cspace<-parented-transformq-joint! arg0 v1-0)
+    )
+  (none)
+  )
+
+;; definition for method 21 of type fort-floor-spike
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-floor-spike-method-21 fort-floor-spike ((obj fort-floor-spike))
+  0
+  (none)
+  )
+
+;; definition for method 22 of type fort-floor-spike
+;; WARN: Return type mismatch int vs collide-shape-moving.
+(defmethod fort-floor-spike-method-22 fort-floor-spike ((obj fort-floor-spike))
+  (the-as collide-shape-moving 0)
+  )
+
+;; definition for method 23 of type fort-floor-spike
+;; WARN: Return type mismatch int vs symbol.
+(defmethod fort-floor-spike-method-23 fort-floor-spike ((obj fort-floor-spike))
+  (the-as symbol 0)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (fort-floor-spike)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as
+      object
+      (case event-type
+        (('touched)
+         (when (+ (-> self clock frame-counter) (seconds -2))
+           (let* ((s3-0 proc)
+                  (s4-0 (if (type? s3-0 process-drawable)
+                            (the-as process-drawable s3-0)
+                            )
+                        )
+                  )
+             (when s4-0
+               (let ((s3-1 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root quat)))
+                     (s4-1
+                       (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> s4-0 root trans) (-> self root trans)) 1.0)
+                       )
+                     )
+                 (vector-flatten! s4-1 s4-1 s3-1)
+                 (set! (-> s4-1 y) 0.0)
+                 (vector-normalize! s4-1 1.0)
+                 (let ((a1-8 (new 'stack-no-clear 'event-message-block)))
+                   (set! (-> a1-8 from) (process->ppointer self))
+                   (set! (-> a1-8 num-params) 2)
+                   (set! (-> a1-8 message) 'attack)
+                   (set! (-> a1-8 param 0) (-> event param 0))
+                   (let ((v1-11 (new 'static 'attack-info :mask (attack-info-mask vector mode shove-back shove-up id))))
+                     (set! (-> v1-11 id) (the-as uint (-> self attack-id)))
+                     (set! (-> v1-11 mode) 'deadly)
+                     (set! (-> v1-11 shove-up) 24576.0)
+                     (set! (-> v1-11 shove-back) 16384.0)
+                     (set! (-> v1-11 vector quad) (-> s4-1 quad))
+                     (set! (-> a1-8 param 1) (the-as uint v1-11))
+                     )
+                   (send-event-function proc a1-8)
+                   )
+                 )
+               (let ((v0-0 (-> self clock frame-counter)))
+                 (set! (-> self no-overlap-timer) (the-as uint v0-0))
+                 v0-0
+                 )
+               )
+             )
+           )
+         )
+        )
+      )
+    )
+  :enter (behavior ()
+    (set! (-> self no-overlap-timer) (the-as uint 0))
+    0
+    (none)
+    )
+  :code (the-as (function none :behavior fort-floor-spike) sleep-code)
+  :post (behavior ()
+    (dotimes (gp-0 (the-as int (-> self spike-dim 0)))
+      (let ((s5-0 (-> self spike-row data gp-0)))
+        (let ((f0-0 (get-norm! (-> s5-0 sync) 0)))
+          (cond
+            ((< (-> s5-0 on-ratio) f0-0)
+             (set! (-> s5-0 state) 0)
+             0
+             )
+            (else
+              (set! (-> s5-0 state) 1)
+              )
+            )
+          )
+        (dotimes (s4-0 (the-as int (-> self spike-dim 1)))
+          (cond
+            ((zero? (-> s5-0 state))
+             (seek!
+               (-> s5-0 table-ptr s4-0 y)
+               (* 4096.0 (- -4.0 (the float s4-0)))
+               (* 131072.0 (-> self clock seconds-per-frame))
+               )
+             )
+            (else
+              (let ((f30-0 (-> s5-0 table-ptr s4-0 y))
+                    (f28-0 (* 4096.0 (+ -1.0 (the float s4-0))))
+                    )
+                (seek! (-> s5-0 table-ptr s4-0 y) f28-0 (* 131072.0 (-> self clock seconds-per-frame)))
+                (if (and (< f30-0 f28-0) (= (-> s5-0 table-ptr gp-0 y) f28-0))
+                    (sound-play "floor-spike" :position (-> s5-0 table-ptr gp-0))
+                    )
+                )
+              )
+            )
+          )
+        )
+      )
+    (transform-post)
+    (none)
+    )
+  )
+
+;; definition for method 7 of type fort-floor-spike
+;; WARN: Return type mismatch process-drawable vs fort-floor-spike.
+(defmethod relocate fort-floor-spike ((obj fort-floor-spike) (arg0 int))
+  (if (nonzero? (-> obj spike-row))
+      (&+! (-> obj spike-row) arg0)
+      )
+  (the-as fort-floor-spike ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; definition for method 11 of type fort-floor-spike
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-floor-spike ((obj fort-floor-spike) (arg0 entity-actor))
+  (fort-floor-spike-method-22 obj)
+  (process-drawable-from-entity! obj arg0)
+  (fort-floor-spike-method-21 obj)
+  (fort-floor-spike-method-23 obj)
+  (let* ((v1-6 *game-info*)
+         (a0-6 (+ (-> v1-6 attack-id) 1))
+         )
+    (set! (-> v1-6 attack-id) a0-6)
+    (set! (-> obj attack-id) (the-as int a0-6))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-floor-spike-a fort-floor-spike-a 0 4
+              ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999)))
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-floor-spike-b fort-floor-spike-b fort-floor-spike-b-lod0-jg fort-floor-spike-b-idle-ja
+              ((fort-floor-spike-b-lod0-mg (meters 20))
+               (fort-floor-spike-b-lod1-mg (meters 40))
+               (fort-floor-spike-b-lod2-mg (meters 999999))
+               )
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-floor-spike-c fort-floor-spike-c fort-floor-spike-c-lod0-jg fort-floor-spike-c-idle-ja
+              ((fort-floor-spike-c-lod0-mg (meters 20))
+               (fort-floor-spike-c-lod1-mg (meters 40))
+               (fort-floor-spike-c-lod2-mg (meters 999999))
+               )
+              :bounds (static-spherem 0 0 0 12)
+              )
+
+;; definition of type fort-floor-spike-a
+(deftype fort-floor-spike-a (fort-floor-spike)
+  ()
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  )
+
+;; definition for method 3 of type fort-floor-spike-a
+(defmethod inspect fort-floor-spike-a ((obj fort-floor-spike-a))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type fort-floor-spike inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 21 of type fort-floor-spike-a
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-floor-spike-method-21 fort-floor-spike-a ((obj fort-floor-spike-a))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-floor-spike-a" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a0-3 (-> obj skel root-channel 0)))
+    (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 4)))
+    (set! (-> a0-3 frame-num) 0.0)
+    (joint-control-channel-group-eval!
+      a0-3
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (none)
+  )
+
+;; definition for method 22 of type fort-floor-spike-a
+;; INFO: Used lq/sq
+(defmethod fort-floor-spike-method-22 fort-floor-spike-a ((obj fort-floor-spike-a))
+  (local-vars (sv-16 collide-shape-prim-mesh) (sv-32 type) (sv-48 collide-shape-moving))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 8) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 9))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 49152.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      (let* ((s3-0 '((0 4 17203) (1 5 17203) (2 6 17203) (3 7 17203) (4 8 17203) (5 9 17203) (6 10 17203) (7 11 17203)))
+             (s2-0 (car s3-0))
+             )
+        (while (not (null? s3-0))
+          (let ((s1-0 (method-of-type collide-shape-prim-mesh new))
+                (s0-0 'process)
+                )
+            (set! sv-32 collide-shape-prim-mesh)
+            (set! sv-48 s5-0)
+            (let ((a3-2 (command-get-int (car s2-0) 0))
+                  (t0-1 0)
+                  )
+              (set! sv-16 (s1-0 s0-0 sv-32 sv-48 (the-as uint a3-2) (the-as uint t0-1)))
+              )
+            )
+          (let ((s1-1 sv-16))
+            (set! (-> s1-1 prim-core collide-as) (-> s4-0 prim-core collide-as))
+            (set! (-> s1-1 prim-core collide-with) (-> s4-0 prim-core collide-with))
+            (set! (-> s1-1 prim-core action) (-> s4-0 prim-core action))
+            (set! (-> s1-1 transform-index) (command-get-int (car (cdr s2-0)) 0))
+            )
+          (set-vector! (-> sv-16 local-sphere) 0.0 0.0 0.0 (command-get-float (car (cdr (cdr s2-0))) 0.0))
+          (set! s3-0 (cdr s3-0))
+          (set! s2-0 (car s3-0))
+          )
+        )
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root) s5-0)
+    s5-0
+    )
+  )
+
+;; definition for method 23 of type fort-floor-spike-a
+;; INFO: Used lq/sq
+(defmethod fort-floor-spike-method-23 fort-floor-spike-a ((obj fort-floor-spike-a))
+  (local-vars (sv-64 cspace))
+  (let ((s5-0 2)
+        (s4-0 4)
+        )
+    (set! (-> obj spike-dim 0) (the-as basic s5-0))
+    (set! (-> obj spike-dim 1) (the-as basic s4-0))
+    (set! (-> obj spike-row) (new 'process 'spike-row-info-array s5-0))
+    (set! (-> obj pos-table) (new 'static 'inline-array vector 8
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               )
+          )
+    (let ((s3-0 (-> obj pos-table))
+          (s2-0 4)
+          (s1-0 11)
+          )
+      (dotimes (s0-0 (+ (- 1 s2-0) s1-0))
+        (set! sv-64 (-> obj node-list data (+ s2-0 s0-0)))
+        (vector<-cspace! (-> s3-0 s0-0) sv-64)
+        (set! (-> s3-0 s0-0 y) 0.0)
+        (set! (-> sv-64 param0) joint-mod-set-y-callback)
+        (set! (-> sv-64 param1) (the-as basic s3-0))
+        (set! (-> sv-64 param2) (the-as basic s0-0))
+        )
+      )
+    (dotimes (s3-1 s5-0)
+      (let ((s2-1 (-> obj spike-row data s3-1)))
+        (let ((a1-2 (new 'stack-no-clear 'sync-info-params)))
+          (let ((v1-19 0))
+            (if #t
+                (set! v1-19 (logior v1-19 1))
+                )
+            (set! (-> a1-2 sync-type) (the-as basic 'sync-linear))
+            (set! (-> a1-2 sync-flags) (the-as sync-flags v1-19))
+            )
+          (set! (-> a1-2 entity) #f)
+          (set! (-> a1-2 period) (the-as uint 1200))
+          (let ((f0-2 (* 0.25 (the float s3-1))))
+            (set! (-> a1-2 percent) (- f0-2 (* (the float (the int (/ f0-2 1.0))) 1.0)))
+            )
+          (initialize! (-> s2-1 sync) a1-2)
+          )
+        (set! (-> s2-1 on-ratio) 0.375)
+        (set! (-> s2-1 state) 0)
+        (set! (-> s2-1 table-ptr) (the-as (inline-array vector) (-> obj pos-table (* s3-1 s4-0))))
+        )
+      )
+    )
+  #f
+  )
+
+;; definition of type fort-floor-spike-b
+(deftype fort-floor-spike-b (fort-floor-spike)
+  ()
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  )
+
+;; definition for method 3 of type fort-floor-spike-b
+(defmethod inspect fort-floor-spike-b ((obj fort-floor-spike-b))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type fort-floor-spike inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 21 of type fort-floor-spike-b
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-floor-spike-method-21 fort-floor-spike-b ((obj fort-floor-spike-b))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-floor-spike-b" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a0-3 (-> obj skel root-channel 0)))
+    (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 4)))
+    (set! (-> a0-3 frame-num) 0.0)
+    (joint-control-channel-group-eval!
+      a0-3
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (none)
+  )
+
+;; definition for method 22 of type fort-floor-spike-b
+;; INFO: Used lq/sq
+(defmethod fort-floor-spike-method-22 fort-floor-spike-b ((obj fort-floor-spike-b))
+  (local-vars (sv-16 collide-shape-prim-mesh) (sv-32 type) (sv-48 collide-shape-moving))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 10) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 11))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 49152.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      (let* ((s3-0 '((0 4 16384)
+                     (1 5 16384)
+                     (2 6 16384)
+                     (3 7 16384)
+                     (4 8 16384)
+                     (5 9 16384)
+                     (6 10 16384)
+                     (7 11 16384)
+                     (8 12 16384)
+                     (9 13 16384)
+                     )
+                   )
+             (s2-0 (car s3-0))
+             )
+        (while (not (null? s3-0))
+          (let ((s1-0 (method-of-type collide-shape-prim-mesh new))
+                (s0-0 'process)
+                )
+            (set! sv-32 collide-shape-prim-mesh)
+            (set! sv-48 s5-0)
+            (let ((a3-2 (command-get-int (car s2-0) 0))
+                  (t0-1 0)
+                  )
+              (set! sv-16 (s1-0 s0-0 sv-32 sv-48 (the-as uint a3-2) (the-as uint t0-1)))
+              )
+            )
+          (let ((s1-1 sv-16))
+            (set! (-> s1-1 prim-core collide-as) (-> s4-0 prim-core collide-as))
+            (set! (-> s1-1 prim-core collide-with) (-> s4-0 prim-core collide-with))
+            (set! (-> s1-1 prim-core action) (-> s4-0 prim-core action))
+            (set! (-> s1-1 transform-index) (command-get-int (car (cdr s2-0)) 0))
+            )
+          (set-vector! (-> sv-16 local-sphere) 0.0 0.0 0.0 (command-get-float (car (cdr (cdr s2-0))) 0.0))
+          (set! s3-0 (cdr s3-0))
+          (set! s2-0 (car s3-0))
+          )
+        )
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root) s5-0)
+    s5-0
+    )
+  )
+
+;; definition for method 23 of type fort-floor-spike-b
+;; INFO: Used lq/sq
+(defmethod fort-floor-spike-method-23 fort-floor-spike-b ((obj fort-floor-spike-b))
+  (local-vars (sv-64 cspace))
+  (let ((s5-0 2)
+        (s4-0 5)
+        )
+    (set! (-> obj spike-dim 0) (the-as basic s5-0))
+    (set! (-> obj spike-dim 1) (the-as basic s4-0))
+    (set! (-> obj spike-row) (new 'process 'spike-row-info-array s5-0))
+    (set! (-> obj pos-table) (new 'static 'inline-array vector 8
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               )
+          )
+    (let ((s3-0 (-> obj pos-table))
+          (s2-0 4)
+          (s1-0 13)
+          )
+      (dotimes (s0-0 (+ (- 1 s2-0) s1-0))
+        (set! sv-64 (-> obj node-list data (+ s2-0 s0-0)))
+        (vector<-cspace! (-> s3-0 s0-0) sv-64)
+        (set! (-> s3-0 s0-0 y) 0.0)
+        (set! (-> sv-64 param0) joint-mod-set-y-callback)
+        (set! (-> sv-64 param1) (the-as basic s3-0))
+        (set! (-> sv-64 param2) (the-as basic s0-0))
+        )
+      )
+    (dotimes (s3-1 s5-0)
+      (let ((s2-1 (-> obj spike-row data s3-1)))
+        (let ((a1-2 (new 'stack-no-clear 'sync-info-params)))
+          (let ((v1-19 0))
+            (if #t
+                (set! v1-19 (logior v1-19 1))
+                )
+            (set! (-> a1-2 sync-type) (the-as basic 'sync-linear))
+            (set! (-> a1-2 sync-flags) (the-as sync-flags v1-19))
+            )
+          (set! (-> a1-2 entity) #f)
+          (set! (-> a1-2 period) (the-as uint 1200))
+          (let ((f0-2 (* 0.25 (the float s3-1))))
+            (set! (-> a1-2 percent) (- f0-2 (* (the float (the int (/ f0-2 1.0))) 1.0)))
+            )
+          (initialize! (-> s2-1 sync) a1-2)
+          )
+        (set! (-> s2-1 on-ratio) 0.375)
+        (set! (-> s2-1 state) 0)
+        (set! (-> s2-1 table-ptr) (the-as (inline-array vector) (-> obj pos-table (* s3-1 s4-0))))
+        )
+      )
+    )
+  #f
+  )
+
+;; definition of type fort-floor-spike-c
+(deftype fort-floor-spike-c (fort-floor-spike)
+  ()
+  :heap-base #x70
+  :method-count-assert 24
+  :size-assert         #xe8
+  :flag-assert         #x18007000e8
+  )
+
+;; definition for method 3 of type fort-floor-spike-c
+(defmethod inspect fort-floor-spike-c ((obj fort-floor-spike-c))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type fort-floor-spike inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 21 of type fort-floor-spike-c
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-floor-spike-method-21 fort-floor-spike-c ((obj fort-floor-spike-c))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-floor-spike-c" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (let ((a0-3 (-> obj skel root-channel 0)))
+    (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> obj draw art-group data 4)))
+    (set! (-> a0-3 frame-num) 0.0)
+    (joint-control-channel-group-eval!
+      a0-3
+      (the-as art-joint-anim (-> obj draw art-group data 4))
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (none)
+  )
+
+;; definition for method 22 of type fort-floor-spike-c
+;; INFO: Used lq/sq
+(defmethod fort-floor-spike-method-22 fort-floor-spike-c ((obj fort-floor-spike-c))
+  (local-vars (sv-16 collide-shape-prim-mesh) (sv-32 type) (sv-48 collide-shape-moving))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 15) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 16))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot enemy hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 49152.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      (let* ((s3-0 '((0 4 16384)
+                     (1 5 16384)
+                     (2 6 16384)
+                     (3 7 16384)
+                     (4 8 16384)
+                     (5 9 16384)
+                     (6 10 16384)
+                     (7 11 16384)
+                     (8 12 16384)
+                     (9 13 16384)
+                     (10 15 16384)
+                     (11 16 16384)
+                     (12 14 16384)
+                     (13 15 16384)
+                     (14 16 16384)
+                     )
+                   )
+             (s2-0 (car s3-0))
+             )
+        (while (not (null? s3-0))
+          (let ((s1-0 (method-of-type collide-shape-prim-mesh new))
+                (s0-0 'process)
+                )
+            (set! sv-32 collide-shape-prim-mesh)
+            (set! sv-48 s5-0)
+            (let ((a3-2 (command-get-int (car s2-0) 0))
+                  (t0-1 0)
+                  )
+              (set! sv-16 (s1-0 s0-0 sv-32 sv-48 (the-as uint a3-2) (the-as uint t0-1)))
+              )
+            )
+          (let ((s1-1 sv-16))
+            (set! (-> s1-1 prim-core collide-as) (-> s4-0 prim-core collide-as))
+            (set! (-> s1-1 prim-core collide-with) (-> s4-0 prim-core collide-with))
+            (set! (-> s1-1 prim-core action) (-> s4-0 prim-core action))
+            (set! (-> s1-1 transform-index) (command-get-int (car (cdr s2-0)) 0))
+            )
+          (set-vector! (-> sv-16 local-sphere) 0.0 0.0 0.0 (command-get-float (car (cdr (cdr s2-0))) 0.0))
+          (set! s3-0 (cdr s3-0))
+          (set! s2-0 (car s3-0))
+          )
+        )
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root) s5-0)
+    s5-0
+    )
+  )
+
+;; definition for method 23 of type fort-floor-spike-c
+;; INFO: Used lq/sq
+(defmethod fort-floor-spike-method-23 fort-floor-spike-c ((obj fort-floor-spike-c))
+  (local-vars (sv-64 cspace))
+  (let ((s5-0 3)
+        (s4-0 5)
+        )
+    (set! (-> obj spike-dim 0) (the-as basic s5-0))
+    (set! (-> obj spike-dim 1) (the-as basic s4-0))
+    (set! (-> obj spike-row) (new 'process 'spike-row-info-array s5-0))
+    (set! (-> obj pos-table) (new 'static 'inline-array vector 8
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               (new 'static 'vector)
+                               )
+          )
+    (let ((s3-0 (-> obj pos-table))
+          (s2-0 4)
+          (s1-0 18)
+          )
+      (dotimes (s0-0 (+ (- 1 s2-0) s1-0))
+        (set! sv-64 (-> obj node-list data (+ s2-0 s0-0)))
+        (vector<-cspace! (-> s3-0 s0-0) sv-64)
+        (set! (-> s3-0 s0-0 y) 0.0)
+        (set! (-> sv-64 param0) joint-mod-set-y-callback)
+        (set! (-> sv-64 param1) (the-as basic s3-0))
+        (set! (-> sv-64 param2) (the-as basic s0-0))
+        )
+      )
+    (dotimes (s3-1 s5-0)
+      (let ((s2-1 (-> obj spike-row data s3-1)))
+        (let ((a1-2 (new 'stack-no-clear 'sync-info-params)))
+          (let ((v1-19 0))
+            (if #t
+                (set! v1-19 (logior v1-19 1))
+                )
+            (set! (-> a1-2 sync-type) (the-as basic 'sync-linear))
+            (set! (-> a1-2 sync-flags) (the-as sync-flags v1-19))
+            )
+          (set! (-> a1-2 entity) #f)
+          (set! (-> a1-2 period) (the-as uint 1200))
+          (let ((f0-2 (* 0.25 (the float s3-1))))
+            (set! (-> a1-2 percent) (- f0-2 (* (the float (the int (/ f0-2 1.0))) 1.0)))
+            )
+          (initialize! (-> s2-1 sync) a1-2)
+          )
+        (set! (-> s2-1 on-ratio) 0.375)
+        (set! (-> s2-1 state) 0)
+        (set! (-> s2-1 table-ptr) (the-as (inline-array vector) (-> obj pos-table (* s3-1 s4-0))))
+        )
+      )
+    )
+  #f
+  )
diff --git a/test/decompiler/reference/jak2/levels/dig/dig-digger_REF.gc b/test/decompiler/reference/jak2/levels/dig/dig-digger_REF.gc
new file mode 100644
index 0000000000..4a5ce51fab
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/dig/dig-digger_REF.gc
@@ -0,0 +1,1895 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-dig-clasp-break
+  :id 1142
+  :duration (seconds 0.05)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 4937 :fade-after (meters 50) :falloff-to (meters 100) :period 600 :length 10)
+    (sp-item 4938 :fade-after (meters 50) :period 600 :length 5)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4937
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-rnd-flt spt-num 8.0 8.0 1.0)
+    (sp-flt spt-scale-x (meters 2.5))
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.07) (meters 0.03) 1.0)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-omega 2.048 2.048 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.06666667) 1.0)
+    (sp-rnd-flt spt-fade-g -2.55 -2.55 1.0)
+    (sp-flt spt-fade-b -8.0)
+    (sp-rnd-flt spt-fade-a -0.64 -0.64 1.0)
+    (sp-rnd-flt spt-friction 0.85 0.02 1.0)
+    (sp-int spt-timer 100)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 80.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4938
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 3))
+    (sp-flt spt-rot-x 40.96)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-flt spt-b 0.0)
+    (sp-rnd-flt spt-a 96.0 16.0 1.0)
+    (sp-flt spt-omega 206848.0)
+    (sp-flt spt-scalevel-x (meters 0.08))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-g -10.2)
+    (sp-flt spt-fade-a -4.48)
+    (sp-int spt-timer 25)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 0.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-dig-digger-smoke
+  :id 1143
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 16)
+  :parts ((sp-item 4939 :fade-after (meters 200) :falloff-to (meters 300))
+    (sp-item 4940 :fade-after (meters 200) :flags (bit6))
+    (sp-item 4941 :fade-after (meters 200) :flags (bit6))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4940
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xca :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-y (meters 0) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 24) (meters 0.1) 1.0)
+    (sp-flt spt-rot-x 1228.8)
+    (sp-rnd-flt spt-rot-z (degrees -4.0) (degrees 8.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-rnd-flt spt-a 12.0 4.0 1.0)
+    (sp-flt spt-omega 822476.8)
+    (sp-flt spt-fade-a -1.0666667)
+    (sp-int spt-timer 15)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 6144.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4941
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-y (meters 0))
+    (sp-rnd-flt spt-scale-x (meters 6) (meters 2) 1.0)
+    (sp-flt spt-rot-x 1228.8)
+    (sp-rnd-flt spt-rot-z (degrees -4.0) (degrees 8.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-rnd-flt spt-a 20.0 4.0 1.0)
+    (sp-flt spt-omega 822476.8)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-flt spt-userdata 6144.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4939
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 0.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.06) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.026666667) (meters 0.02) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.36)
+    (sp-flt spt-fade-b -4.24)
+    (sp-rnd-flt spt-fade-a -0.047407407 -0.047407407 1.0)
+    (sp-rnd-flt spt-accel-x -2.7306666 -1.3653333 1.0)
+    (sp-rnd-flt spt-accel-y 0.4096 0.4096 1.0)
+    (sp-flt spt-friction 0.96)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 #xc00000 #xc00000 #xc03300)
+      )
+    (sp-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 4942)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4942
+  :init-specs ((sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b 0.0)
+    (sp-int-plain-rnd spt-next-time 10 39 1)
+    (sp-launcher-by-id spt-next-launcher 4943)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4943
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.013333334) (meters 0.0033333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.85333335)
+    (sp-flt spt-fade-g -0.79333335)
+    (sp-flt spt-fade-b -0.14)
+    (sp-int spt-next-time 150)
+    (sp-launcher-by-id spt-next-launcher 4944)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4944
+  :init-specs ((sp-flt spt-r 128.0)
+    (sp-flt spt-g 128.0)
+    (sp-flt spt-b 128.0)
+    (sp-rnd-flt spt-fade-r 0.0 -0.256 1.0)
+    (sp-copy-from-other spt-fade-g -1)
+    (sp-copy-from-other spt-fade-b -1)
+    (sp-flt spt-fade-a -0.072)
+    )
+  )
+
+;; definition for function birth-func-dig-digger-collide
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+;; ERROR: Bad vector register dependency: vf4
+;; ERROR: Bad vector register dependency: vf5
+;; ERROR: Bad vector register dependency: vf6
+;; ERROR: Bad vector register dependency: vf30
+;; ERROR: Bad vector register dependency: vf31
+(defun birth-func-dig-digger-collide ((arg0 sparticle-system)
+                             (arg1 sparticle-cpuinfo)
+                             (arg2 sprite-vec-data-3d)
+                             (arg3 sparticle-launcher)
+                             (arg4 sparticle-launch-state)
+                             )
+  (local-vars (v1-11 float))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf30 :class vf)
+         (vf31 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s5-0 (new 'stack-no-clear 'inline-array 'vector 5)))
+      (.svf (&-> s5-0 0 quad) vf4)
+      (.svf (&-> s5-0 1 quad) vf5)
+      (.svf (&-> s5-0 2 quad) vf6)
+      (.svf (&-> s5-0 3 quad) vf30)
+      (.svf (&-> s5-0 4 quad) vf31)
+      (let ((s3-0 (the-as object (-> (the-as process (-> arg4 control)) brother)))
+            (s4-0 (new 'stack-no-clear 'collide-query))
+            )
+        (let ((s2-0 (new 'stack-no-clear 'vector)))
+          (set! (-> s4-0 start-pos quad) (-> (the-as process-drawable s3-0) root trans quad))
+          (set! (-> s4-0 start-pos y) (+ 61440.0 (-> s4-0 start-pos y)))
+          (set! (-> s2-0 x) (-> arg1 vel-sxvel x))
+          (set! (-> s2-0 z) (-> arg1 vel-sxvel z))
+          (vector-normalize! s2-0 1.0)
+          (let ((a0-5 (-> s4-0 start-pos)))
+            (let ((v1-3 (-> s4-0 start-pos)))
+              (let ((a1-5 (* 245760.0 (- 0.2 (- 0.8 (-> arg1 friction))))))
+                (.mov vf7 a1-5)
+                )
+              (.lvf vf5 (&-> s2-0 quad))
+              (.lvf vf4 (&-> v1-3 quad))
+              )
+            (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+            (.mul.x.vf acc vf5 vf7 :mask #b111)
+            (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+            (.svf (&-> a0-5 quad) vf6)
+            )
+          )
+        (set-vector! (-> s4-0 move-dist) 0.0 -81920.0 0.0 1.0)
+        (let ((v1-5 s4-0))
+          (set! (-> v1-5 radius) 1228.8)
+          (set! (-> v1-5 collide-with) (collide-spec backgnd obstacle hit-by-player-list hit-by-others-list))
+          (set! (-> v1-5 ignore-process0) (the-as process-tree s3-0))
+          (set! (-> v1-5 ignore-process1) #f)
+          (set! (-> v1-5 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-5 action-mask) (collide-action solid))
+          )
+        (if (>= (fill-and-probe-using-line-sphere *collide-cache* s4-0) 0.0)
+            (set! (-> arg1 user-float) (+ 1024.0 (-> s4-0 best-other-tri intersect y)))
+            )
+        )
+      (.lvf vf4 (&-> s5-0 0 quad))
+      (.lvf vf5 (&-> s5-0 1 quad))
+      (.lvf vf6 (&-> s5-0 2 quad))
+      (.lvf vf30 (&-> s5-0 3 quad))
+      (.lvf vf31 (&-> s5-0 4 quad))
+      )
+    (.mov v1-11 vf31)
+    0
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-dig-digger-digging
+  :id 1144
+  :duration (seconds 0.017)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 64)
+  :parts ((sp-item 4945 :falloff-to (meters 200))
+    (sp-item 4946 :falloff-to (meters 100))
+    (sp-item 4947 :falloff-to (meters 200))
+    (sp-item 4948 :falloff-to (meters 200))
+    (sp-item 4949 :falloff-to (meters 300))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4945
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-dig-digger-collide)
+    (sp-flt spt-num 2.0)
+    (sp-flt spt-x (meters 8))
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-vel-x (meters 0.083333336) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.16666667) (meters 0.033333335) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00008333333))
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-accel-y -12.288)
+    (sp-rnd-flt spt-friction 0.95 0.04 1.0)
+    (sp-int spt-timer 1200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-func spt-func 'check-drop-level-dig-digger-rubble-sparks)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; definition for function check-drop-level-dig-digger-rubble-sparks
+;; INFO: Used lq/sq
+(defun check-drop-level-dig-digger-rubble-sparks ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 vector))
+  (when (and (< (-> arg2 y) (-> arg1 user-float)) (< (-> arg1 vel-sxvel y) 0.0))
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (sp-kill-particle arg0 arg1)
+      (set-vector! gp-0 (-> arg2 x) (-> arg1 user-float) (-> arg2 z) 1.0)
+      (let ((t9-1 sp-launch-particles-var)
+            (a0-2 *sp-particle-system-2d*)
+            (a1-2 (-> *part-id-table* 4950))
+            (a2-1 *launch-matrix*)
+            )
+        (set! (-> a2-1 trans quad) (-> gp-0 quad))
+        (t9-1 a0-2 a1-2 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      (let ((t9-2 sp-launch-particles-var)
+            (a0-3 *sp-particle-system-2d*)
+            (a1-3 (-> *part-id-table* 4951))
+            (a2-2 *launch-matrix*)
+            )
+        (set! (-> a2-2 trans quad) (-> gp-0 quad))
+        (t9-2 a0-3 a1-3 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      (let ((t9-3 sp-launch-particles-var)
+            (a0-4 *sp-particle-system-2d*)
+            (a1-4 (-> *part-id-table* 4952))
+            (a2-3 *launch-matrix*)
+            )
+        (set! (-> a2-3 trans quad) (-> gp-0 quad))
+        (t9-3 a0-4 a1-4 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defpart 4948
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 6.0)
+    (sp-flt spt-x (meters 9))
+    (sp-rnd-flt spt-y (meters 1) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 4) (meters 6) 1.0)
+    (sp-flt spt-rot-x 2048.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-flt spt-a 0.0)
+    (sp-flt spt-fade-g -3.2)
+    (sp-flt spt-fade-b -3.2)
+    (sp-flt spt-fade-a 0.8)
+    (sp-int spt-timer 40)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 4096.0)
+    (sp-int spt-next-time 20)
+    (sp-launcher-by-id spt-next-launcher 4953)
+    (sp-rnd-flt spt-rotate-y (degrees -45.0) (degrees 135.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4953
+  :init-specs ((sp-flt spt-fade-a -0.8))
+  )
+
+;; failed to figure out what this is:
+(defpart 4946
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-flt spt-num 3.0)
+    (sp-flt spt-x (meters 8))
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.02) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-rnd-flt spt-b 0.0 128.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-omega 2.048 2.048 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.23333333) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.4) (meters 0.033333335) 1.0)
+    (sp-flt spt-fade-g -0.85333335)
+    (sp-flt spt-fade-b -1.7066667)
+    (sp-flt spt-accel-y -12.288)
+    (sp-rnd-flt spt-friction 0.9 0.04 1.0)
+    (sp-int-plain-rnd spt-timer 100 49 1)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4947
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-flt spt-num 3.0)
+    (sp-flt spt-x (meters 8))
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.3) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-omega 4.096 4.096 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.083333336) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.16666667) (meters 0.033333335) 1.0)
+    (sp-flt spt-scalevel-x (meters -0.00008333333))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.14222223 -0.21333334 1.0)
+    (sp-flt spt-accel-y -12.288)
+    (sp-rnd-flt spt-friction 0.95 0.04 1.0)
+    (sp-int spt-timer 900)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 sp-cpuinfo-flag-14)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 -1758461952 -1758461696 -1758461440 -1758461184 -1758460928)
+      )
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4949
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-flt spt-x (meters 9))
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 3) (meters 3) 1.0)
+    (sp-rnd-flt spt-r 80.0 16.0 1.0)
+    (sp-rnd-flt spt-g 70.0 16.0 1.0)
+    (sp-rnd-flt spt-b 70.0 16.0 1.0)
+    (sp-rnd-flt spt-a 96.0 32.0 1.0)
+    (sp-flt spt-vel-x (meters 0.11333334))
+    (sp-rnd-flt spt-vel-y (meters 0.16666667) (meters 0.033333335) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.011666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -2.7306666 1.0)
+    (sp-rnd-flt spt-friction 0.9 0.04 1.0)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4950
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 1.0 3.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 96.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-rnd-flt spt-fade-a -0.42666668 -0.85333335 1.0)
+    (sp-flt spt-accel-y -2.7306666)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 -1758461952 -1758461696 -1758461440 -1758461184 -1758460928)
+      )
+    (sp-rnd-flt spt-conerot-x (degrees 10.0) (degrees 60.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4951
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #x973))
+    (sp-func spt-birth-func 'birth-func-texture-group)
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 96.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.04) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-rnd-flt spt-friction 0.94 0.02 1.0)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-userdata)
+      :flags (sp-flag plain-v2)
+      :object (new 'static 'boxed-array :type int32 40 1 0 -1758461952 -1758461696 -1758461440 -1758461184 -1758460928)
+      )
+    (sp-int-plain-rnd spt-next-time 150 299 1)
+    (sp-launcher-by-id spt-next-launcher 4954)
+    (sp-flt spt-conerot-x (degrees 90.0))
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4954
+  :init-specs ((sp-flt spt-rotvel-z (degrees 0.0)) (sp-rnd-flt spt-fade-a -0.28444445 -0.28444445 1.0))
+  )
+
+;; failed to figure out what this is:
+(defpart 4952
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.5 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 1) (meters 1) 1.0)
+    (sp-rnd-flt spt-r 80.0 16.0 1.0)
+    (sp-rnd-flt spt-g 70.0 16.0 1.0)
+    (sp-rnd-flt spt-b 70.0 16.0 1.0)
+    (sp-rnd-flt spt-a 32.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-fade-a -0.053333335 -0.053333335 1.0)
+    (sp-rnd-flt spt-accel-y 0.0 1.3653333 1.0)
+    (sp-rnd-flt spt-friction 0.9 0.05 1.0)
+    (sp-int spt-timer 2400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 70.0) (degrees 20.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; definition for method 15 of type hud-dig-clasp
+;; WARN: Return type mismatch int vs none.
+(defmethod draw hud-dig-clasp ((obj hud-dig-clasp))
+  (set-hud-piece-position!
+    (the-as hud-sprite (-> obj sprites))
+    (the int (+ 457.0 (* 130.0 (-> obj offset))))
+    210
+    )
+  (format (clear (-> obj strings 0 text)) "~D" (-> obj values 0 current))
+  (set-as-offset-from! (the-as hud-sprite (-> obj strings 0 pos)) (the-as vector4w (-> obj sprites)) -18 29)
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+;; definition for method 16 of type hud-dig-clasp
+;; WARN: Return type mismatch int vs none.
+(defmethod update-values hud-dig-clasp ((obj hud-dig-clasp))
+  (set! (-> obj values 0 target) (the int (-> *game-info* counter)))
+  ((method-of-type hud update-values) obj)
+  0
+  (none)
+  )
+
+;; definition for method 17 of type hud-dig-clasp
+;; WARN: Return type mismatch int vs none.
+(defmethod init-callback hud-dig-clasp ((obj hud-dig-clasp))
+  (set! (-> obj level) (level-get *level* 'dig1))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :page #xb1c)))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 0 scale-x) 1.2)
+  (set! (-> obj sprites 0 scale-y) 1.2)
+  (alloc-string-if-needed obj 0)
+  (set! (-> obj strings 0 scale) 0.6)
+  (set! (-> obj strings 0 flags) (font-flags kerning middle large))
+  0
+  (none)
+  )
+
+;; definition of type dig-clasp
+(deftype dig-clasp (process-drawable)
+  ((b    basic               :offset-assert 200)
+   (conn connection-minimap  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 24
+  :size-assert         #xd0
+  :flag-assert         #x18005000d0
+  (:methods
+    (broken () _type_ :state 20)
+    (break-it () _type_ :state 21)
+    (idle () _type_ :state 22)
+    (dig-clasp-method-23 (_type_ vector) vector 23)
+    )
+  )
+
+;; definition for method 3 of type dig-clasp
+(defmethod inspect dig-clasp ((obj dig-clasp))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tb: ~A~%" (-> obj b))
+  (format #t "~2Tconn: #<connection-minimap @ #x~X>~%" (-> obj conn))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-clasp dig-clasp dig-clasp-lod0-jg dig-clasp-idle-ja
+              ((dig-clasp-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-clasp-explode dig-clasp dig-clasp-explode-lod0-jg dig-clasp-explode-idle-ja
+              ((dig-clasp-explode-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 8)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-clasp-b dig-clasp-b dig-clasp-b-lod0-jg dig-clasp-b-idle-ja
+              ((dig-clasp-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              )
+
+;; definition for symbol *dig-clasp-exploder-params*, type joint-exploder-static-params
+(define *dig-clasp-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 3 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    )
+  )
+
+;; definition for method 23 of type dig-clasp
+(defmethod dig-clasp-method-23 dig-clasp ((obj dig-clasp) (arg0 vector))
+  (if (-> obj b)
+      (vector<-cspace! arg0 (-> obj node-list data 3))
+      (vector<-cspace! arg0 (-> obj node-list data 6))
+      )
+  )
+
+;; failed to figure out what this is:
+(defstate broken (dig-clasp)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('broken?)
+                      #t
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (when (-> self conn)
+      (kill-callback (-> *minimap* engine) (-> self conn))
+      (set! (-> self conn) #f)
+      )
+    (cond
+      ((-> self b)
+       (ja :group! dig-digger-idle-ja
+           :num! (identity (the float (+ (-> (the-as art-joint-anim dig-digger-idle-ja) frames num-frames) -1)))
+           )
+       (setup-masks (-> self draw) 0 2)
+       )
+      (else
+        (ja :group! dig-digger-idle-ja
+            :num! (identity (the float (+ (-> (the-as art-joint-anim dig-digger-idle-ja) frames num-frames) -1)))
+            )
+        (setup-masks (-> self draw) 0 2)
+        )
+      )
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior dig-clasp) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate break-it (dig-clasp)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('broken?)
+                      #t
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (sound-play "dig-tether-snap")
+    (talker-speech-class-method-10 (-> *talker-speech* 191))
+    (talker-speech-class-method-10 (-> *talker-speech* 192))
+    (cond
+      ((-> self b)
+       (ja :group! dig-digger-idle-ja :num! min)
+       (setup-masks (-> self draw) 0 2)
+       )
+      (else
+        (ja :group! dig-digger-idle-ja :num! min)
+        (setup-masks (-> self draw) 0 2)
+        )
+      )
+    (let ((gp-3 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-dig-clasp-explode" (the-as (pointer uint32) #f))
+        5
+        gp-3
+        *dig-clasp-exploder-params*
+        :to self
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (ja :num! (seek!))
+    (if (nonzero? (-> self part))
+        (spawn (-> self part) (dig-clasp-method-23 self (new 'stack-no-clear 'vector)))
+        )
+    (if (ja-done? 0)
+        (go-virtual broken)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-clasp) sleep-code)
+  :post (the-as (function none :behavior dig-clasp) ja-post)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-clasp)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('tether-position)
+       (dig-clasp-method-23 self (the-as vector (-> event param 0)))
+       )
+      (('attack)
+       (let ((v1-2 (the-as attack-info (-> event param 1))))
+         (when (and (logtest? (-> v1-2 mask) (attack-info-mask mode)) (= (-> v1-2 mode) 'board))
+           (cpad-set-buzz! (-> *cpad-list* cpads 0) 0 85 (seconds 0.1))
+           (go-virtual break-it)
+           )
+         )
+       )
+      (('break)
+       (go-virtual break-it)
+       )
+      )
+    )
+  :enter (behavior ()
+    (ja-post)
+    (none)
+    )
+  :code (the-as (function none :behavior dig-clasp) sleep-code)
+  )
+
+;; definition for method 11 of type dig-clasp
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-clasp ((obj dig-clasp) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 transform-index) 6)
+      (set-vector! (-> v1-2 local-sphere) 0.0 -3072.0 0.0 4096.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-clasp" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj draw light-index) (the-as uint 1))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1142) obj))
+  (set! (-> obj b) #f)
+  (set! (-> obj conn) (minimap-method-12 *minimap* obj (the-as uint 16) (the-as int #f) (the-as vector #t) 0))
+  (if (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+      (go (method-of-object obj broken))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+;; definition of type dig-clasp-b
+(deftype dig-clasp-b (dig-clasp)
+  ()
+  :heap-base #x50
+  :method-count-assert 24
+  :size-assert         #xd0
+  :flag-assert         #x18005000d0
+  )
+
+;; definition for method 3 of type dig-clasp-b
+(defmethod inspect dig-clasp-b ((obj dig-clasp-b))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type dig-clasp inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 11 of type dig-clasp-b
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-clasp-b ((obj dig-clasp-b) (arg0 entity-actor))
+  (when (not (task-node-closed? (game-task-node dig-knock-down-resolution)))
+    (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+      (let ((v1-2 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+        (set! (-> v1-2 prim-core collide-as) (collide-spec enemy))
+        (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+        (set! (-> v1-2 transform-index) 3)
+        (set-vector! (-> v1-2 local-sphere) 0.0 -3072.0 0.0 4096.0)
+        (set! (-> s4-0 total-prims) (the-as uint 1))
+        (set! (-> s4-0 root-prim) v1-2)
+        )
+      (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+      (let ((v1-5 (-> s4-0 root-prim)))
+        (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+        (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+        )
+      (set! (-> obj root) s4-0)
+      )
+    (process-drawable-from-entity! obj arg0)
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-clasp-b" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (set! (-> obj draw light-index) (the-as uint 1))
+    (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1142) obj))
+    (set! (-> obj b) (the-as basic #t))
+    (set! (-> obj conn) (minimap-method-12 *minimap* obj (the-as uint 16) (the-as int #f) (the-as vector #t) 0))
+    (if (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+        (go (method-of-object obj broken))
+        (go (method-of-object obj idle))
+        )
+    )
+  (none)
+  )
+
+;; definition of type dig-tether-chain
+(deftype dig-tether-chain (structure)
+  ((position  vector    :inline :offset-assert   0)
+   (velocity  vector    :inline :offset-assert  16)
+   (joint-mod joint-mod         :offset-assert  32)
+   )
+  :method-count-assert 9
+  :size-assert         #x24
+  :flag-assert         #x900000024
+  )
+
+;; definition for method 3 of type dig-tether-chain
+(defmethod inspect dig-tether-chain ((obj dig-tether-chain))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'dig-tether-chain)
+  (format #t "~1Tposition: #<vector @ #x~X>~%" (-> obj position))
+  (format #t "~1Tvelocity: #<vector @ #x~X>~%" (-> obj velocity))
+  (format #t "~1Tjoint-mod: ~A~%" (-> obj joint-mod))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type dig-tether
+(deftype dig-tether (process-drawable)
+  ((clasp             entity-actor                  :offset-assert 200)
+   (clasp-info-ok     symbol                        :offset-assert 204)
+   (clasp-pos         vector              :inline   :offset-assert 208)
+   (digger-pos        vector              :inline   :offset-assert 224)
+   (digger-vertical   vector              :inline   :offset-assert 240)
+   (frame             oscillating-float   :inline   :offset-assert 256)
+   (frame-kicker      delayed-rand-float  :inline   :offset-assert 280)
+   (old-dist          float                         :offset-assert 308)
+   (chain-joints      dig-tether-chain    8 :inline :offset-assert 320)
+   (chain-offset-rand delayed-rand-vector :inline   :offset-assert 704)
+   (chain-offset      oscillating-vector  :inline   :offset-assert 752)
+   (joint-one         joint-mod                     :offset-assert 812)
+   (snapped-look      lod-set             :inline   :offset-assert 816)
+   )
+  :heap-base #x2f0
+  :method-count-assert 25
+  :size-assert         #x361
+  :flag-assert         #x1902f00361
+  (:methods
+    (broken () _type_ :state 20)
+    (idle () _type_ :state 21)
+    (dig-tether-method-22 (_type_) none 22)
+    (dig-tether-method-23 (_type_) none 23)
+    (dig-tether-method-24 (_type_) none 24)
+    )
+  )
+
+;; definition for method 3 of type dig-tether
+(defmethod inspect dig-tether ((obj dig-tether))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tclasp: ~A~%" (-> obj clasp))
+  (format #t "~2Tclasp-info-ok: ~A~%" (-> obj clasp-info-ok))
+  (format #t "~2Tclasp-pos: #<vector @ #x~X>~%" (-> obj clasp-pos))
+  (format #t "~2Tdigger-pos: #<vector @ #x~X>~%" (-> obj digger-pos))
+  (format #t "~2Tdigger-vertical: #<vector @ #x~X>~%" (-> obj digger-vertical))
+  (format #t "~2Tframe: #<oscillating-float @ #x~X>~%" (-> obj frame))
+  (format #t "~2Tframe-kicker: #<delayed-rand-float @ #x~X>~%" (-> obj frame-kicker))
+  (format #t "~2Told-dist: ~f~%" (-> obj old-dist))
+  (format #t "~2Tchain-joints[8] @ #x~X~%" (-> obj chain-joints))
+  (format #t "~2Tchain-offset-rand: #<delayed-rand-vector @ #x~X>~%" (-> obj chain-offset-rand))
+  (format #t "~2Tchain-offset: #<oscillating-vector @ #x~X>~%" (-> obj chain-offset))
+  (format #t "~2Tjoint-one: ~A~%" (-> obj joint-one))
+  (format #t "~2Tsnapped-look: #<lod-set @ #x~X>~%" (-> obj snapped-look))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-tether-unsnapped dig-tether dig-tether-unsnapped-lod0-jg dig-tether-idle-ja
+              ((dig-tether-unsnapped-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 80)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-tether-snapped dig-tether dig-tether-snapped-lod0-jg dig-tether-idle-ja
+              ((dig-tether-snapped-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 80)
+              )
+
+;; definition for method 22 of type dig-tether
+;; WARN: Return type mismatch int vs none.
+(defmethod dig-tether-method-22 dig-tether ((obj dig-tether))
+  (with-pp
+    (when (-> obj clasp)
+      (let* ((s4-0 (-> obj clasp extra process))
+             (s5-0 (if (type? s4-0 dig-clasp)
+                       s4-0
+                       )
+                   )
+             (a1-1 (new 'stack-no-clear 'event-message-block))
+             )
+        (set! (-> a1-1 from) (process->ppointer pp))
+        (set! (-> a1-1 num-params) 0)
+        (set! (-> a1-1 message) 'broken?)
+        (cond
+          ((or (send-event-function s5-0 a1-1)
+               (logtest? (-> obj clasp extra perm status) (entity-perm-status subtask-complete))
+               )
+           (go (method-of-object obj broken))
+           )
+          (s5-0
+            (send-event s5-0 'tether-position (-> obj clasp-pos))
+            (set! (-> obj clasp-info-ok) #t)
+            )
+          )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for method 23 of type dig-tether
+;; INFO: Used lq/sq
+(defmethod dig-tether-method-23 dig-tether ((obj dig-tether))
+  (set-params! (-> obj chain-offset-rand) 75 150 2048.0 204.8)
+  (set-params! (-> obj chain-offset) (the-as vector #f) 4.096 20.48 0.9)
+  (mode-set! (-> obj joint-one) (joint-mod-mode joint-set-world))
+  (dotimes (s5-0 7)
+    (cond
+      ((-> obj clasp-info-ok)
+       (vector<-cspace! (the-as vector (-> obj chain-joints s5-0)) (-> obj chain-joints s5-0 joint-mod joint))
+       )
+      (else
+        (set! (-> obj chain-joints s5-0 position quad) (-> obj root trans quad))
+        (set! (-> obj chain-joints s5-0 position y)
+              (- (-> obj chain-joints s5-0 position y) (* 4096.0 (the float s5-0)))
+              )
+        )
+      )
+    (vector-reset! (+ (the-as uint (-> obj chain-joints 0 velocity)) (* 48 s5-0)))
+    (mode-set! (-> obj chain-joints s5-0 joint-mod) (joint-mod-mode joint-set-world))
+    )
+  (set! (-> obj chain-joints 7 position quad) (-> obj chain-joints 6 position quad))
+  (vector-reset! (-> obj chain-joints 7 velocity))
+  (lods-assign! (-> obj draw) (-> obj snapped-look))
+  (none)
+  )
+
+;; definition for method 24 of type dig-tether
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod dig-tether-method-24 dig-tether ((obj dig-tether))
+  (local-vars (sv-144 dig-tether-chain) (sv-160 vector))
+  (update-with-delay! (-> obj chain-offset-rand))
+  (update! (-> obj chain-offset) (-> obj chain-offset-rand value))
+  (let ((s5-0 (new 'stack-no-clear 'matrix))
+        (s4-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s4-0 quad) (-> obj root trans quad))
+    (let ((s3-0 (new 'stack-no-clear 'vector))
+          (f30-0 0.2)
+          (s2-0 (-> obj chain-offset))
+          (f28-0 0.1)
+          (s1-0 (new 'stack-no-clear 'vector))
+          )
+      (vector-! (-> s5-0 vector 2) (the-as vector (-> obj chain-joints)) (-> obj root trans))
+      (vector-normalize! (-> s5-0 vector 2) 1.0)
+      (vector-cross! (the-as vector (-> s5-0 vector)) (-> obj digger-vertical) (-> s5-0 vector 2))
+      (vector-normalize! (the-as vector (-> s5-0 vector)) 1.0)
+      (vector-cross! (-> s5-0 vector 1) (-> s5-0 vector 2) (the-as vector (-> s5-0 vector)))
+      (matrix->quaternion (-> obj root quat) s5-0)
+      (set! (-> obj joint-one trans quad) (-> obj root trans quad))
+      (quaternion-copy! (-> obj joint-one quat) (-> obj root quat))
+      (set! (-> s3-0 quad) (-> s5-0 vector 1 quad))
+      (dotimes (s0-0 8)
+        (set! sv-144 (-> obj chain-joints s0-0))
+        (set! sv-160 (new 'stack-no-clear 'vector))
+        (let ((v1-23 (-> sv-144 position quad)))
+          (set! (-> sv-160 quad) v1-23)
+          )
+        (set! (-> sv-160 y) (+ -2048.0 (-> sv-160 y)))
+        (vector+float*! sv-160 sv-160 (the-as vector s2-0) f28-0)
+        (set! f28-0 (fmin 1.0 (+ 0.2 f28-0)))
+        (when (< s0-0 7)
+          (vector+float*!
+            sv-160
+            sv-160
+            (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* 48 (+ s0-0 1))))
+            f30-0
+            )
+          (set! f30-0 (fmin 0.9 (+ 0.2 f30-0)))
+          )
+        (vector-! s1-0 sv-160 s4-0)
+        (vector-normalize! s1-0 12288.0)
+        (vector+! sv-160 s1-0 s4-0)
+        (vector-! s1-0 sv-160 (-> obj digger-pos))
+        (vector-flatten! s1-0 s1-0 (-> obj digger-vertical))
+        (let ((f0-6 (vector-normalize-ret-len! s1-0 1.0)))
+          (if (< f0-6 73728.0)
+              (vector+float*! sv-160 sv-160 s1-0 (- 73728.0 f0-6))
+              )
+          )
+        (vector-! (-> sv-144 velocity) sv-160 (-> sv-144 position))
+        (vector-float*! (-> sv-144 velocity) (-> sv-144 velocity) 0.75)
+        (let ((f0-9 (vector-length (-> sv-144 velocity))))
+          (if (< 6144.0 f0-9)
+              (vector-float*! (-> sv-144 velocity) (-> sv-144 velocity) (/ 2048.0 f0-9))
+              )
+          )
+        (vector+! sv-160 (-> sv-144 position) (-> sv-144 velocity))
+        (set! (-> sv-144 position quad) (-> sv-160 quad))
+        (if (-> sv-144 joint-mod)
+            (set! (-> sv-144 joint-mod trans quad) (-> sv-160 quad))
+            )
+        (when (< s0-0 7)
+          (vector-! (-> s5-0 vector 2) (the-as vector (-> obj chain-joints (+ s0-0 1))) sv-160)
+          (vector-normalize! (-> s5-0 vector 2) 1.0)
+          (vector-cross! (the-as vector (-> s5-0 vector)) s3-0 (-> s5-0 vector 2))
+          (vector-normalize! (the-as vector (-> s5-0 vector)) 1.0)
+          (vector-cross! (-> s5-0 vector 1) (-> s5-0 vector 2) (the-as vector (-> s5-0 vector)))
+          (matrix->quaternion (-> sv-144 joint-mod quat) s5-0)
+          (set! (-> s3-0 quad) (-> s5-0 vector 1 quad))
+          )
+        (set! (-> s4-0 quad) (-> sv-160 quad))
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for function dig-tether-handler
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch vector vs object.
+(defbehavior dig-tether-handler dig-tether ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (the-as object (case arg2
+                   (('set-pos)
+                    (set! (-> self root trans quad) (-> (the-as vector (-> arg3 param 0)) quad))
+                    (set! (-> self digger-pos quad) (-> (the-as vector (-> arg3 param 1)) quad))
+                    (let ((v0-0 (-> self digger-vertical)))
+                      (set! (-> v0-0 quad) (-> (the-as vector (-> arg3 param 2)) quad))
+                      v0-0
+                      )
+                    )
+                   )
+          )
+  )
+
+;; failed to figure out what this is:
+(defstate broken (dig-tether)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('broken?)
+       #t
+       )
+      (else
+        (dig-tether-handler proc arg1 event-type event)
+        )
+      )
+    )
+  :enter (behavior ()
+    (dig-tether-method-23 self)
+    (none)
+    )
+  :trans (behavior ()
+    (dig-tether-method-24 self)
+    (none)
+    )
+  :code (the-as (function none :behavior dig-tether) sleep-code)
+  :post (the-as (function none :behavior dig-tether) ja-post)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-tether)
+  :virtual #t
+  :event dig-tether-handler
+  :enter (behavior ()
+    (set! (-> self clasp-info-ok) #f)
+    (set-params! (-> self frame) 0.5 0.01 0.02 0.97)
+    (set-params! (-> self frame-kicker) 9 30 0.4)
+    (set! (-> self old-dist) 0.0)
+    (none)
+    )
+  :trans (behavior ()
+    (dig-tether-method-22 self)
+    (when (-> self clasp-info-ok)
+      (let* ((v1-4 (vector-! (new 'stack-no-clear 'vector) (-> self clasp-pos) (-> self root trans)))
+             (f30-0 (vector-length v1-4))
+             )
+        (let ((gp-0 (new 'stack-no-clear 'matrix)))
+          (vector-float*! (-> gp-0 vector 2) v1-4 (/ 1.0 f30-0))
+          (set-vector! (-> gp-0 vector 0) (-> gp-0 vector 2 z) 0.0 (- (-> gp-0 vector 2 x)) 1.0)
+          (vector-normalize! (the-as vector (-> gp-0 vector)) 1.0)
+          (vector-cross! (-> gp-0 vector 1) (-> gp-0 vector 2) (the-as vector (-> gp-0 vector)))
+          (vector-reset! (-> gp-0 trans))
+          (set! (-> gp-0 vector 0 w) 0.0)
+          (set! (-> gp-0 vector 1 w) 0.0)
+          (set! (-> gp-0 vector 2 w) 0.0)
+          (matrix->quaternion (-> self root quat) gp-0)
+          )
+        (set! (-> self root scale z) (* 0.000003937752 f30-0))
+        (when (!= (-> self old-dist) 0.0)
+          (let ((f2-0 (fabs (- f30-0 (-> self old-dist)))))
+            (set! (-> self frame target) (fmin 1.0 (fmax 0.0 (* 0.0008719308 (- 573.44 f2-0)))))
+            )
+          )
+        (set! (-> self old-dist) f30-0)
+        )
+      (update! (-> self frame-kicker))
+      (update! (-> self frame) (-> self frame-kicker value))
+      (ja :num-func num-func-identity :frame-num (* 10.0 (-> self frame value)))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-tether) sleep-code)
+  :post (the-as (function none :behavior dig-tether) ja-post)
+  )
+
+;; definition for method 7 of type dig-tether
+;; WARN: Return type mismatch process-drawable vs dig-tether.
+(defmethod relocate dig-tether ((obj dig-tether) (arg0 int))
+  (if (nonzero? (-> obj joint-one))
+      (&+! (-> obj joint-one) arg0)
+      )
+  (dotimes (v1-4 7)
+    (if (nonzero? (-> obj chain-joints v1-4 joint-mod))
+        (&+! (-> obj chain-joints v1-4 joint-mod) arg0)
+        )
+    )
+  (the-as dig-tether ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; definition for function dig-tether-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-tether-init-by-other dig-tether ((arg0 vector) (arg1 entity))
+  (set! (-> self root) (new 'process 'trsqv))
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-tether-snapped" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> self draw light-index) (the-as uint 1))
+  (set! (-> self clasp) (the-as entity-actor arg1))
+  (set! (-> self root pause-adjust-distance) 819200.0)
+  (set! (-> self joint-one) (new 'process 'joint-mod (joint-mod-mode flex-blend) self 3))
+  (set! (-> self joint-one track-mode) (track-mode no-scale))
+  (dotimes (gp-1 7)
+    (set! (-> self chain-joints gp-1 joint-mod)
+          (new 'process 'joint-mod (joint-mod-mode flex-blend) self (+ gp-1 4))
+          )
+    (set! (-> self chain-joints gp-1 joint-mod track-mode) (track-mode no-scale))
+    )
+  (set! (-> self chain-joints 7 joint-mod) #f)
+  (setup-lods!
+    (-> self snapped-look)
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-tether-snapped" (the-as (pointer uint32) #f)))
+    (-> self draw art-group)
+    (-> self entity)
+    )
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type dig-digger-tether-info
+(deftype dig-digger-tether-info (structure)
+  ((rp       int32   :offset-assert   0)
+   (handle   handle  :offset-assert   8)
+   (broken-x float   :offset-assert  16)
+   (broken-z float   :offset-assert  20)
+   )
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
+
+;; definition for method 3 of type dig-digger-tether-info
+(defmethod inspect dig-digger-tether-info ((obj dig-digger-tether-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'dig-digger-tether-info)
+  (format #t "~1Trp: ~D~%" (-> obj rp))
+  (format #t "~1Thandle: ~D~%" (-> obj handle))
+  (format #t "~1Tbroken-x: ~f~%" (-> obj broken-x))
+  (format #t "~1Tbroken-z: ~f~%" (-> obj broken-z))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type dig-digger
+(deftype dig-digger (process-drawable)
+  ((actor-group       (pointer actor-group)               :offset-assert 200)
+   (actor-group-count int32                               :offset-assert 204)
+   (tethers           dig-digger-tether-info   24 :inline :offset-assert 208)
+   (vertical          oscillating-vector       :inline    :offset-assert 976)
+   (vertical-rand     delayed-rand-vector      :inline    :offset-assert 1040)
+   (start-y           float                               :offset-assert 1088)
+   (y-offset          bouncing-float           :inline    :offset-assert 1092)
+   (y-offset-kicker   delayed-rand-float       :inline    :offset-assert 1136)
+   (twist             oscillating-float        :inline    :offset-assert 1164)
+   (twist-kicker      delayed-rand-float       :inline    :offset-assert 1192)
+   (smoke-part        sparticle-launch-control            :offset-assert 1220)
+   (motor-sound       uint32                              :offset-assert 1224)
+   (bit-sound         uint32                              :offset-assert 1228)
+   (movie-handle      handle                              :offset-assert 1232)
+   (hud-counter       handle                              :offset-assert 1240)
+   (speech-time       time-frame                          :offset-assert 1248)
+   (speech-count      int32                               :offset-assert 1256)
+   )
+  :heap-base #x470
+  :method-count-assert 25
+  :size-assert         #x4ec
+  :flag-assert         #x19047004ec
+  (:methods
+    (idle () _type_ :state 20)
+    (hidden () _type_ :state 21)
+    (dig-digger-method-22 (_type_ int) entity 22)
+    (dig-digger-method-23 (_type_) none 23)
+    (dig-digger-method-24 (_type_) none 24)
+    )
+  )
+
+;; definition for method 3 of type dig-digger
+(defmethod inspect dig-digger ((obj dig-digger))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-7)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tactor-group: #x~X~%" (-> obj actor-group))
+  (dotimes (s5-0 (-> obj actor-group-count))
+    (format #t "~T  [~D]~2Tactor-group: ~`actor-group`P~%" s5-0 (-> obj actor-group s5-0))
+    )
+  (format #t "~2Tactor-group-count: ~D~%" (-> obj actor-group-count))
+  (format #t "~2Ttethers[24] @ #x~X~%" (-> obj tethers))
+  (format #t "~2Tvertical: #<oscillating-vector @ #x~X>~%" (-> obj vertical))
+  (format #t "~2Tvertical-rand: #<delayed-rand-vector @ #x~X>~%" (-> obj vertical-rand))
+  (format #t "~2Tstart-y: ~f~%" (-> obj start-y))
+  (format #t "~2Ty-offset: #<bouncing-float @ #x~X>~%" (-> obj y-offset))
+  (format #t "~2Ty-offset-kicker: #<delayed-rand-float @ #x~X>~%" (-> obj y-offset-kicker))
+  (format #t "~2Ttwist: #<oscillating-float @ #x~X>~%" (-> obj twist))
+  (format #t "~2Ttwist-kicker: #<delayed-rand-float @ #x~X>~%" (-> obj twist-kicker))
+  (format #t "~2Tsmoke-part: ~A~%" (-> obj smoke-part))
+  (format #t "~2Tmotor-sound: ~D~%" (-> obj motor-sound))
+  (format #t "~2Tbit-sound: ~D~%" (-> obj bit-sound))
+  (format #t "~2Tmovie-handle: ~D~%" (-> obj movie-handle))
+  (format #t "~2Thud-counter: ~D~%" (-> obj hud-counter))
+  (format #t "~2Tspeech-time: ~D~%" (-> obj speech-time))
+  (format #t "~2Tspeech-count: ~D~%" (-> obj speech-count))
+  (label cfg-7)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-digger dig-digger dig-digger-lod0-jg dig-digger-idle-ja
+              ((dig-digger-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 36 0 40)
+              :origin-joint-index 3
+              )
+
+;; definition for method 22 of type dig-digger
+(defmethod dig-digger-method-22 dig-digger ((obj dig-digger) (arg0 int))
+  (if (and (> (-> obj actor-group-count) 0) (< arg0 (-> obj actor-group 0 length)))
+      (-> obj actor-group 0 data arg0 actor)
+      (the-as entity #f)
+      )
+  )
+
+;; definition for method 23 of type dig-digger
+;; WARN: Return type mismatch int vs none.
+(defmethod dig-digger-method-23 dig-digger ((obj dig-digger))
+  (dotimes (s5-0 24)
+    (let ((s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj tethers s5-0 rp))))
+          (s3-0 (dig-digger-method-22 obj s5-0))
+          )
+      (if (and s3-0 (not (handle->process (-> obj tethers s5-0 handle))))
+          (set! (-> obj tethers s5-0 handle) (ppointer->handle (process-spawn dig-tether s4-0 s3-0 :to obj)))
+          )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 24 of type dig-digger
+;; WARN: Return type mismatch int vs none.
+(defmethod dig-digger-method-24 dig-digger ((obj dig-digger))
+  (with-pp
+    (set! (-> obj vertical target x) 0.0)
+    (set! (-> obj vertical target z) 0.0)
+    (let ((s4-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) (the-as vector (-> obj vertical)) 1.0))
+          (s5-0 0)
+          )
+      (dotimes (s3-0 24)
+        (let* ((s2-0 (-> obj tethers s3-0))
+               (s1-0 (handle->process (-> s2-0 handle)))
+               )
+          (cond
+            (s1-0
+              (let ((v1-10 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj tethers s3-0 rp)))))
+                (send-event s1-0 'set-pos v1-10 (-> obj root trans) s4-0)
+                )
+              (cond
+                ((send-event s1-0 'broken?)
+                 (+! (-> obj vertical target x) (-> s2-0 broken-x))
+                 (+! (-> obj vertical target z) (-> s2-0 broken-z))
+                 )
+                (else
+                  (+! s5-0 1)
+                  )
+                )
+              )
+            (else
+              (+! (-> obj vertical target x) (-> s2-0 broken-x))
+              (+! (-> obj vertical target z) (-> s2-0 broken-z))
+              )
+            )
+          )
+        )
+      (set! (-> *game-info* counter) (the float s5-0))
+      (when (and (= s5-0 24)
+                 (>= (- (-> pp clock frame-counter) (-> obj speech-time)) (seconds 20))
+                 *target*
+                 (and (>= 409600.0 (vector-vector-distance (-> obj root trans) (-> *target* control trans)))
+                      (zero? (logand (focus-status teleporting) (-> *target* focus-status)))
+                      )
+                 )
+        (let ((v1-37 (logand (-> obj speech-count) 1)))
+          (cond
+            ((zero? v1-37)
+             (talker-spawn-func (-> *talker-speech* 191) *entity-pool* (target-pos 0) (the-as region #f))
+             (if (and *target* (zero? (logand (focus-status board) (-> *target* focus-status))))
+                 (talker-spawn-func (-> *talker-speech* 115) *entity-pool* (target-pos 0) (the-as region #f))
+                 )
+             )
+            ((= v1-37 1)
+             (talker-spawn-func (-> *talker-speech* 192) *entity-pool* (target-pos 0) (the-as region #f))
+             )
+            )
+          )
+        (set! (-> obj speech-time) (-> pp clock frame-counter))
+        (+! (-> obj speech-count) 1)
+        )
+      (cond
+        ((zero? s5-0)
+         (send-event (handle->process (-> obj hud-counter)) 'hide-and-die)
+         (set! (-> obj hud-counter) (the-as handle #f))
+         (when (= (-> obj movie-handle) #f)
+           (set! (-> obj movie-handle)
+                 (ppointer->handle (process-spawn scene-player :init scene-player-init "dig-digger-explode" #t #f))
+                 )
+           (if (handle->process (-> obj movie-handle))
+               (cleanup-for-death obj)
+               )
+           )
+         )
+        ((>= 4 s5-0)
+         (eval!
+           (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (the-as vector #f))
+           '(want-anim "dig-digger-explode")
+           )
+         )
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-digger)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('touch 'attack)
+       (when ((method-of-type touching-shapes-entry prims-touching?)
+              (the-as touching-shapes-entry (-> event param 0))
+              (the-as collide-shape (-> self root))
+              (the-as uint 1)
+              )
+         (let ((a0-7 (if (type? proc process-focusable)
+                         proc
+                         )
+                     )
+               )
+           (when a0-7
+             (let ((a1-4 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-4 from) (process->ppointer self))
+               (set! (-> a1-4 num-params) 2)
+               (set! (-> a1-4 message) 'attack)
+               (set! (-> a1-4 param 0) (-> event param 0))
+               (let ((a2-3 (new 'static 'attack-info :mask (attack-info-mask id))))
+                 (let* ((v1-7 *game-info*)
+                        (a3-2 (+ (-> v1-7 attack-id) 1))
+                        )
+                   (set! (-> v1-7 attack-id) a3-2)
+                   (set! (-> a2-3 id) a3-2)
+                   )
+                 (set! (-> a1-4 param 1) (the-as uint a2-3))
+                 )
+               (if (send-event-function a0-7 a1-4)
+                   #f
+                   )
+               )
+             )
+           )
+         )
+       )
+      (('hide)
+       (go-virtual hidden)
+       )
+      )
+    )
+  :enter (behavior ()
+    (set-params! (-> self vertical) (new 'static 'vector :y 16.0) 0.01 0.1 0.9)
+    (set-params! (-> self vertical-rand) 15 75 1.0 0.0)
+    (set-params! (-> self y-offset) 0.0 1.0 0.0 0.7 0.08 0.3 0.97)
+    (set-params! (-> self y-offset-kicker) 18 30 1.0)
+    (set-params! (-> self twist) 0.0 0.01 0.1 0.9)
+    (set-params! (-> self twist-kicker) 24 75 1.0)
+    (ja-post)
+    (dig-digger-method-23 self)
+    (set! (-> self motor-sound) (the-as uint (new-sound-id)))
+    (set! (-> self bit-sound) (the-as uint (new-sound-id)))
+    (none)
+    )
+  :exit (behavior ()
+    (sound-stop (the-as sound-id (-> self motor-sound)))
+    (sound-stop (the-as sound-id (-> self bit-sound)))
+    (send-event (handle->process (-> self hud-counter)) 'hide-and-die)
+    (set! (-> self hud-counter) (the-as handle #f))
+    (none)
+    )
+  :trans (behavior ()
+    (let ((f0-0 (vector-vector-distance-squared (ear-trans 0) (-> self root trans)))
+          (f1-0 1228800.0)
+          )
+      (when (< f0-0 (* f1-0 f1-0))
+        (let ((gp-1 (new 'stack-no-clear 'vector)))
+          (vector<-cspace! gp-1 (-> self node-list data 29))
+          (sound-play "digger-motor" :id (the-as sound-id (-> self motor-sound)) :position gp-1)
+          )
+        (sound-play "digger-bit" :id (the-as sound-id (-> self bit-sound)) :position (-> self root trans))
+        )
+      )
+    (ja :num! (loop!))
+    (update-with-delay! (-> self vertical-rand))
+    (update! (-> self vertical) (-> self vertical-rand value))
+    (update-and-clear! (-> self twist-kicker))
+    (if (!= (-> self twist-kicker value) 0.0)
+        (set! (-> self twist-kicker value) 1.0)
+        )
+    (update! (-> self twist) (fabs (-> self twist-kicker value)))
+    (let ((gp-2 (new 'stack-no-clear 'matrix)))
+      (vector-normalize-copy! (-> gp-2 vector 1) (the-as vector (-> self vertical)) 1.0)
+      (set-vector!
+        (-> gp-2 vector 0)
+        (cos (* 32768.0 (-> self twist value)))
+        0.0
+        (sin (* 32768.0 (-> self twist value)))
+        1.0
+        )
+      (vector-cross! (-> gp-2 vector 2) (the-as vector (-> gp-2 vector)) (-> gp-2 vector 1))
+      (vector-normalize! (-> gp-2 vector 2) 1.0)
+      (vector-cross! (the-as vector (-> gp-2 vector)) (-> gp-2 vector 1) (-> gp-2 vector 2))
+      (vector-reset! (-> gp-2 trans))
+      (set! (-> gp-2 vector 0 w) 0.0)
+      (set! (-> gp-2 vector 1 w) 0.0)
+      (set! (-> gp-2 vector 2 w) 0.0)
+      (matrix->quaternion (-> self root quat) gp-2)
+      )
+    (update! (-> self y-offset-kicker))
+    (update! (-> self y-offset) (-> self y-offset-kicker value))
+    (set! (-> self root trans y) (+ (-> self start-y) (* 4096.0 (-> self y-offset osc value))))
+    (when (nonzero? (-> self smoke-part))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 28))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 29))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 30))
+      (spawn-with-cspace (-> self smoke-part) (-> self node-list data 31))
+      )
+    (if (nonzero? (-> self part))
+        (spawn (-> self part) (-> self root trans))
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-digger) sleep-code)
+  :post (behavior ()
+    (transform-post)
+    (dig-digger-method-24 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate hidden (dig-digger)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (let ((v1-0 event-type)
+          (a0-1 'explode)
+          )
+      (the-as object (if (= v1-0 a0-1)
+                         (set-dig1-explosion! (the-as float a0-1))
+                         )
+              )
+      )
+    )
+  :enter (behavior ()
+    (while (-> self child)
+      (deactivate (-> self child 0))
+      )
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (none)
+    )
+  :code (the-as (function none :behavior dig-digger) sleep-code)
+  )
+
+;; definition for method 10 of type dig-digger
+(defmethod deactivate dig-digger ((obj dig-digger))
+  (if (nonzero? (-> obj smoke-part))
+      (kill-and-free-particles (-> obj smoke-part))
+      )
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 7 of type dig-digger
+;; WARN: Return type mismatch process-drawable vs dig-digger.
+(defmethod relocate dig-digger ((obj dig-digger) (arg0 int))
+  (when (nonzero? (-> obj smoke-part))
+    (if (nonzero? (-> obj smoke-part))
+        (&+! (-> obj smoke-part) arg0)
+        )
+    )
+  (the-as dig-digger ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; definition for method 11 of type dig-digger
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-digger ((obj dig-digger) (arg0 entity-actor))
+  (local-vars (sv-16 res-tag))
+  (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s4-0 reaction) cshape-reaction-default)
+    (set! (-> s4-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s4-0 penetrated-by) (penetrate))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 10) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 11))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid deadly))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 143360.0 0.0 159744.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 9) (the-as uint 1))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-13 prim-core action) (collide-action solid deadly))
+      (set! (-> v1-13 transform-index) 3)
+      (set-vector! (-> v1-13 local-sphere) 0.0 36864.0 0.0 65536.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 172032.0 0.0 86016.0)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-17 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-17 prim-core action) (collide-action solid))
+      (set! (-> v1-17 transform-index) 3)
+      (set-vector! (-> v1-17 local-sphere) 0.0 151552.0 0.0 86016.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-19 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-19 prim-core action) (collide-action solid))
+      (set! (-> v1-19 transform-index) 3)
+      (set-vector! (-> v1-19 local-sphere) 0.0 110592.0 0.0 69632.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-21 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-21 prim-core action) (collide-action solid))
+      (set! (-> v1-21 transform-index) 3)
+      (set-vector! (-> v1-21 local-sphere) 0.0 73728.0 0.0 65536.0)
+      )
+    (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0))))
+      (set! (-> v1-23 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-23 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-23 prim-core action) (collide-action solid))
+      (set! (-> v1-23 transform-index) 3)
+      (set-vector! (-> v1-23 local-sphere) 0.0 266240.0 0.0 40960.0)
+      )
+    (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (the-as uint 0))))
+      (set! (-> v1-25 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-25 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-25 prim-core action) (collide-action solid))
+      (set! (-> v1-25 transform-index) 3)
+      (set-vector! (-> v1-25 local-sphere) 16384.0 249856.0 -16384.0 20480.0)
+      )
+    (let ((v1-27 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0))))
+      (set! (-> v1-27 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-27 prim-core action) (collide-action solid))
+      (set! (-> v1-27 transform-index) 3)
+      (set-vector! (-> v1-27 local-sphere) 8192.0 245760.0 24576.0 16384.0)
+      )
+    (let ((v1-29 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0))))
+      (set! (-> v1-29 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-29 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-29 prim-core action) (collide-action solid))
+      (set! (-> v1-29 transform-index) 3)
+      (set-vector! (-> v1-29 local-sphere) -61440.0 102400.0 0.0 20480.0)
+      )
+    (let ((v1-31 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (the-as uint 0))))
+      (set! (-> v1-31 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-31 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list))
+      (set! (-> v1-31 prim-core action) (collide-action solid))
+      (set! (-> v1-31 transform-index) 3)
+      (set-vector! (-> v1-31 local-sphere) -57344.0 81920.0 0.0 16384.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-34 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-34 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-34 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (set! (-> obj root pause-adjust-distance) 819200.0)
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-digger" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj draw light-index) (the-as uint 1))
+  (logior! (-> obj skel status) (joint-control-status sync-math))
+  (set! sv-16 (new 'static 'res-tag))
+  (let ((v1-46 (res-lump-data (-> obj entity) 'actor-groups pointer :tag-ptr (& sv-16))))
+    (cond
+      ((and v1-46 (nonzero? (-> sv-16 elt-count)))
+       (set! (-> obj actor-group) (the-as (pointer actor-group) v1-46))
+       (set! (-> obj actor-group-count) (the-as int (-> sv-16 elt-count)))
+       )
+      (else
+        (set! (-> obj actor-group) (the-as (pointer actor-group) #f))
+        (set! (-> obj actor-group-count) 0)
+        0
+        )
+      )
+    )
+  (dotimes (v1-52 24)
+    (set! (-> obj tethers v1-52 handle) (the-as handle #f))
+    (let ((a0-77 v1-52))
+      (cond
+        ((zero? a0-77)
+         (set! (-> obj tethers v1-52 rp) 18)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) -1.0)
+         )
+        ((= a0-77 1)
+         (set! (-> obj tethers v1-52 rp) 16)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) -1.0)
+         )
+        ((= a0-77 2)
+         (set! (-> obj tethers v1-52 rp) 17)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) -1.0)
+         )
+        ((= a0-77 3)
+         (set! (-> obj tethers v1-52 rp) 24)
+         (set! (-> obj tethers v1-52 broken-x) -1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 4)
+         (set! (-> obj tethers v1-52 rp) 22)
+         (set! (-> obj tethers v1-52 broken-x) -1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 5)
+         (set! (-> obj tethers v1-52 rp) 23)
+         (set! (-> obj tethers v1-52 broken-x) -1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 6)
+         (set! (-> obj tethers v1-52 rp) 6)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) 1.0)
+         )
+        ((= a0-77 7)
+         (set! (-> obj tethers v1-52 rp) 4)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) 1.0)
+         )
+        ((= a0-77 8)
+         (set! (-> obj tethers v1-52 rp) 5)
+         (set! (-> obj tethers v1-52 broken-x) 0.0)
+         (set! (-> obj tethers v1-52 broken-z) 1.0)
+         )
+        ((= a0-77 9)
+         (set! (-> obj tethers v1-52 rp) 12)
+         (set! (-> obj tethers v1-52 broken-x) 1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 10)
+         (set! (-> obj tethers v1-52 rp) 10)
+         (set! (-> obj tethers v1-52 broken-x) 1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 11)
+         (set! (-> obj tethers v1-52 rp) 11)
+         (set! (-> obj tethers v1-52 broken-x) 1.0)
+         (set! (-> obj tethers v1-52 broken-z) 0.0)
+         )
+        ((= a0-77 12)
+         (set! (-> obj tethers v1-52 rp) 25)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 13)
+         (set! (-> obj tethers v1-52 rp) 26)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 14)
+         (set! (-> obj tethers v1-52 rp) 27)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 15)
+         (set! (-> obj tethers v1-52 rp) 19)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 16)
+         (set! (-> obj tethers v1-52 rp) 21)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 17)
+         (set! (-> obj tethers v1-52 rp) 20)
+         (set! (-> obj tethers v1-52 broken-x) -0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 18)
+         (set! (-> obj tethers v1-52 rp) 14)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 19)
+         (set! (-> obj tethers v1-52 rp) 13)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 20)
+         (set! (-> obj tethers v1-52 rp) 15)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) -0.707)
+         )
+        ((= a0-77 21)
+         (set! (-> obj tethers v1-52 rp) 8)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 22)
+         (set! (-> obj tethers v1-52 rp) 7)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        ((= a0-77 23)
+         (set! (-> obj tethers v1-52 rp) 9)
+         (set! (-> obj tethers v1-52 broken-x) 0.707)
+         (set! (-> obj tethers v1-52 broken-z) 0.707)
+         )
+        (else
+          (set! (-> obj tethers v1-52 rp) 3)
+          (set! (-> obj tethers v1-52 broken-x) 0.0)
+          (set! (-> obj tethers v1-52 broken-z) 0.0)
+          )
+        )
+      )
+    )
+  (set! (-> obj start-y) (-> obj root trans y))
+  (set! (-> obj smoke-part) (create-launch-control (-> *part-group-id-table* 1143) obj))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1144) obj))
+  (set! (-> obj motor-sound) (the-as uint 0))
+  (set! (-> obj bit-sound) (the-as uint 0))
+  (set! (-> obj movie-handle) (the-as handle #f))
+  (set! (-> obj hud-counter) (ppointer->handle (process-spawn hud-dig-clasp :init hud-init-by-other :to obj)))
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition (debug) for function bustclasp
+;; WARN: Return type mismatch object vs none.
+(defun-debug bustclasp ((arg0 int))
+  (format (clear *temp-string*) "dig-clasp-~S" arg0)
+  (let ((v1-0 (entity-by-name *temp-string*)))
+    (when v1-0
+      (send-event
+        (if v1-0
+            (-> v1-0 extra process)
+            )
+        'break
+        )
+      (format #t "found clasp ~D~%" arg0)
+      )
+    )
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/dig/dig-obs_REF.gc b/test/decompiler/reference/jak2/levels/dig/dig-obs_REF.gc
new file mode 100644
index 0000000000..7510c9f45e
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/dig/dig-obs_REF.gc
@@ -0,0 +1,1007 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type dig-sinking-plat
+(deftype dig-sinking-plat (rigid-body-platform)
+  ((anchor-point      vector      :inline :offset-assert 384)
+   (sync              sync-linear :inline :offset-assert 400)
+   (last-ridden-time  time-frame          :offset-assert 416)
+   (prev-pos          float               :offset-assert 424)
+   (path-pos          float               :offset-assert 428)
+   (surface-height    float               :offset-assert 432)
+   (once              basic               :offset-assert 436)
+   (bubbling-sound-id uint32              :offset-assert 440)
+   )
+  :heap-base #x140
+  :method-count-assert 57
+  :size-assert         #x1bc
+  :flag-assert         #x39014001bc
+  )
+
+;; definition for method 3 of type dig-sinking-plat
+(defmethod inspect dig-sinking-plat ((obj dig-sinking-plat))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type rigid-body-platform inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tanchor-point: #<vector @ #x~X>~%" (-> obj anchor-point))
+  (format #t "~2Tsync: #<sync-linear @ #x~X>~%" (-> obj sync))
+  (format #t "~2Tlast-ridden-time: ~D~%" (-> obj last-ridden-time))
+  (format #t "~2Tprev-pos: ~f~%" (-> obj prev-pos))
+  (format #t "~2Tpath-pos: ~f~%" (-> obj path-pos))
+  (format #t "~2Tsurface-height: ~f~%" (-> obj surface-height))
+  (format #t "~2Tonce: ~A~%" (-> obj once))
+  (format #t "~2Tbubbling-sound-id: ~D~%" (-> obj bubbling-sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-sinking-plat dig-sinking-plat dig-sinking-plat-lod0-jg dig-sinking-plat-idle-ja
+              ((dig-sinking-plat-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -2 0 5.25)
+              )
+
+;; definition for method 29 of type dig-sinking-plat
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-29 dig-sinking-plat ((obj dig-sinking-plat) (arg0 float))
+  ((the-as (function rigid-body-platform float none) (find-parent-method dig-sinking-plat 29)) obj arg0)
+  (rigid-body-platform-method-56 obj (-> obj anchor-point))
+  0
+  (none)
+  )
+
+;; definition for method 32 of type dig-sinking-plat
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-32 dig-sinking-plat ((obj dig-sinking-plat))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak hit-by-others-list player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 -8192.0 0.0 21504.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for symbol *dig-sinking-platform-constants*, type rigid-body-object-constants
+(define *dig-sinking-platform-constants* (new 'static 'rigid-body-object-constants
+                                           :mass 4.0
+                                           :inv-mass 0.25
+                                           :cm-joint-y (meters -2)
+                                           :cm-joint-w 1.0
+                                           :linear-damping 0.9
+                                           :angular-damping 0.48
+                                           :friction-factor 0.1
+                                           :inertial-tensor-x (meters 6)
+                                           :inertial-tensor-y (meters 4)
+                                           :inertial-tensor-z (meters 6)
+                                           :max-time-step 0.02
+                                           :gravity (meters 80)
+                                           :idle-distance (meters 200)
+                                           :attack-force-scale 2.0
+                                           :name '*dig-sinking-platform-constants*
+                                           )
+        )
+
+;; definition for method 53 of type dig-sinking-plat
+(defmethod rigid-body-platform-method-53 dig-sinking-plat ((obj dig-sinking-plat) (arg0 vector))
+  (-> obj surface-height)
+  )
+
+;; definition for method 37 of type dig-sinking-plat
+(defmethod rigid-body-object-method-37 dig-sinking-plat ((obj dig-sinking-plat))
+  (with-pp
+    (when (not (logtest? (-> obj path flags) (path-control-flag not-found)))
+      (set! (-> obj prev-pos) (-> obj path-pos))
+      (set! (-> obj path-pos) (get-norm! (-> obj sync) 0))
+      (when (< (-> obj path-pos) (-> obj prev-pos))
+        (let ((a0-2 (-> obj skel root-channel 0)))
+          (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+          (set! (-> a0-2 param 0)
+                (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 2)) frames num-frames) -1))
+                )
+          (set! (-> a0-2 param 1) 1.0)
+          (set! (-> a0-2 frame-num) 0.0)
+          (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-seek!)
+          )
+        (let ((a0-3 (-> obj skel root-channel 0)))
+          (set! (-> a0-3 param 0) (the float (+ (-> a0-3 frame-group frames num-frames) -1)))
+          (set! (-> a0-3 param 1) 1.0)
+          (joint-control-channel-group-eval! a0-3 (the-as art-joint-anim #f) num-func-seek!)
+          )
+        )
+      (let ((f30-0 (/ 300.0 (the float (-> obj sync period)))))
+        (let* ((f0-12 (/ 1.0 (- 1.0 (* 2.0 f30-0))))
+               (f0-13 (* (fmax 0.0 (- (-> obj path-pos) f30-0)) f0-12))
+               )
+          (get-point-at-percent-along-path! (-> obj path) (-> obj anchor-point) f0-13 'interp)
+          )
+        (cond
+          ((< (-> obj path-pos) f30-0)
+           (set! (-> obj float-height-offset) (* -8192.0 (/ (- f30-0 (-> obj path-pos)) f30-0)))
+           )
+          ((< (- 1.0 (* 2.0 f30-0)) (-> obj path-pos))
+           (cond
+             ((< (- 1.0 f30-0) (-> obj path-pos))
+              (set! (-> obj float-height-offset) (* -8192.0 (/ (- (-> obj path-pos) (- 1.0 f30-0)) f30-0)))
+              (let ((a0-5 (-> obj skel root-channel 0)))
+                (set! (-> a0-5 param 0) (the float (+ (-> a0-5 frame-group frames num-frames) -1)))
+                (set! (-> a0-5 param 1) 1.0)
+                (joint-control-channel-group-eval! a0-5 (the-as art-joint-anim #f) num-func-seek!)
+                )
+              )
+             (else
+               (when (-> obj once)
+                 (let ((a0-6 (-> obj skel root-channel 0)))
+                   (set! (-> a0-6 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+                   (set! (-> a0-6 param 0)
+                         (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 3)) frames num-frames) -1))
+                         )
+                   (set! (-> a0-6 param 1) 1.0)
+                   (set! (-> a0-6 frame-num) 0.0)
+                   (joint-control-channel-group! a0-6 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-seek!)
+                   )
+                 (set! (-> obj once) #f)
+                 )
+               (let ((a0-7 (-> obj skel root-channel 0)))
+                 (set! (-> a0-7 param 0) (the float (+ (-> a0-7 frame-group frames num-frames) -1)))
+                 (set! (-> a0-7 param 1) 1.0)
+                 (joint-control-channel-group-eval! a0-7 (the-as art-joint-anim #f) num-func-seek!)
+                 )
+               )
+             )
+           )
+          (else
+            (set! (-> obj float-height-offset) 0.0)
+            )
+          )
+        )
+      )
+    (cond
+      ((>= (- (-> pp clock frame-counter) (-> obj last-ridden-time)) (seconds 0.5))
+       (when (nonzero? (-> obj bubbling-sound-id))
+         (let ((v1-84 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
+           (set! (-> v1-84 command) (sound-command set-param))
+           (set! (-> v1-84 id) (the-as sound-id (-> obj bubbling-sound-id)))
+           (set! (-> v1-84 params volume) -4)
+           (set! (-> v1-84 auto-time) 120)
+           (set! (-> v1-84 auto-from) 2)
+           (set! (-> v1-84 params mask) (the-as uint 17))
+           (-> v1-84 id)
+           )
+         (set! (-> obj bubbling-sound-id) (the-as uint 0))
+         0
+         )
+       )
+      (else
+        (if (zero? (-> obj bubbling-sound-id))
+            (set! (-> obj bubbling-sound-id) (the-as uint (sound-play "lava-plat-sink")))
+            )
+        )
+      )
+    ((method-of-type rigid-body-platform rigid-body-object-method-37) obj)
+    (none)
+    )
+  )
+
+;; definition for method 56 of type dig-sinking-plat
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-platform-method-56 dig-sinking-plat ((obj dig-sinking-plat) (arg0 vector))
+  (when (not (logtest? (-> obj path flags) (path-control-flag not-found)))
+    (let ((v1-4 (new 'stack-no-clear 'vector)))
+      (cond
+        ((< (-> obj prev-pos) (-> obj path-pos))
+         (vector-! v1-4 arg0 (-> obj rbody state position))
+         (set! (-> v1-4 y) 0.0)
+         (let* ((f0-2 (vector-length v1-4))
+                (f1-2 (* 1000.0 (fmax 0.0 (fmin 4096.0 (+ -4096.0 f0-2)))))
+                )
+           (when (< 0.0 f1-2)
+             (vector-float*! v1-4 v1-4 (/ f1-2 f0-2))
+             (rigid-body-method-20 (-> obj rbody state) v1-4)
+             )
+           )
+         )
+        (else
+          (let ((v1-5 (new 'stack-no-clear 'vector)))
+            (set! (-> v1-5 quad) (-> arg0 quad))
+            (set! (-> v1-5 y) (+ -8192.0 (-> v1-5 y)))
+            (let ((a0-16 (-> obj rbody))
+                  (a2-2 (-> obj root-override-2 quat))
+                  )
+              (rigid-body-method-26 (-> a0-16 state) v1-5 a2-2)
+              )
+            )
+          (set! (-> obj once) (the-as basic #t))
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-sinking-plat)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('ridden)
+       (set! (-> self last-ridden-time) (-> self clock frame-counter))
+       )
+      )
+    (the-as object (rigid-body-object-event-handler proc arg1 event-type event))
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate active (dig-sinking-plat)
+  :virtual #t
+  :event (-> (method-of-type dig-sinking-plat idle) event)
+  )
+
+;; definition for method 33 of type dig-sinking-plat
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-33 dig-sinking-plat ((obj dig-sinking-plat))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-sinking-plat" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (rigid-body-object-method-31 obj *dig-sinking-platform-constants*)
+  (set! (-> obj anchor-point quad) (-> obj root-override-2 trans quad))
+  (set! (-> obj surface-height) (+ -4096.0 (-> obj root-override-2 trans y)))
+  (let ((s5-1 (-> obj info-override control-point-count)))
+    (dotimes (s4-1 s5-1)
+      (let ((s3-0 (-> obj control-point-array data s4-1)))
+        (let ((f30-0 (* 65536.0 (/ (the float s4-1) (the float s5-1)))))
+          (set! (-> s3-0 local-pos x) (* 16384.0 (sin f30-0)))
+          (set! (-> s3-0 local-pos y) -8192.0)
+          (set! (-> s3-0 local-pos z) (* 16384.0 (cos f30-0)))
+          )
+        (set! (-> s3-0 local-pos w) 1.0)
+        )
+      )
+    )
+  (let ((s5-2 (-> obj entity)))
+    (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 s5-2 #f))
+    (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+    (set! (-> obj fact)
+          (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+          )
+    (let ((a1-5 (new 'stack-no-clear 'sync-info-params)))
+      (let ((v1-25 0))
+        (if #f
+            (set! v1-25 (logior v1-25 1))
+            )
+        (set! (-> a1-5 sync-type) (the-as basic 'sync-linear))
+        (set! (-> a1-5 sync-flags) (the-as sync-flags v1-25))
+        )
+      (set! (-> a1-5 entity) s5-2)
+      (set! (-> a1-5 period) (the-as uint 3000))
+      (set! (-> a1-5 percent) 0.0)
+      (initialize! (-> obj sync) a1-5)
+      )
+    )
+  (set! (-> obj bubbling-sound-id) (the-as uint 0))
+  (set! (-> obj once) (the-as basic #t))
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-dig-log
+  :id 1145
+  :bounds (static-bspherem 0 0 0 2)
+  :parts ((sp-item 4956)
+    (sp-item 4957)
+    (sp-item 4958 :binding 4955)
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4955 :flags (bit1 start-dead))
+    (sp-item 4959)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4956
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 3.0 2.0 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 128.0)
+    (sp-rnd-flt spt-g 96.0 32.0 1.0)
+    (sp-rnd-flt spt-b 64.0 32.0 1.0)
+    (sp-rnd-flt spt-a 8.0 8.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.016666668) (meters 0.016666668) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.02) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.006666667))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.053333335)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 900)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4957
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #xade))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-flt spt-x (meters 4))
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters 0.02) (meters 0.02) 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.026666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-flt spt-fade-a -0.35555556)
+    (sp-flt spt-accel-y -5.4613333)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4958
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #xade))
+    (sp-rnd-flt spt-num 0.05 0.05 1.0)
+    (sp-rnd-flt spt-x (meters -10) (meters 12) 1.0)
+    (sp-flt spt-y (meters 38))
+    (sp-rnd-flt spt-scale-x (meters 0.6) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-rnd-flt spt-vel-x (meters -0.00066666666) (meters 0.0013333333) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-flt spt-fade-a -0.16)
+    (sp-flt spt-accel-y -17.749332)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-rotate-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4959
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.2 0.2 1.0)
+    (sp-rnd-flt spt-x (meters -8) (meters 8) 1.0)
+    (sp-flt spt-y (meters 38))
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 8.0 8.0 1.0)
+    (sp-flt spt-scalevel-x (meters 0.033333335))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.04)
+    (sp-flt spt-accel-y -5.4613333)
+    (sp-flt spt-friction 0.98)
+    (sp-int spt-timer 1200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-flt spt-rotate-y (degrees 90.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4955
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 2.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 180.0 32.0 1.0)
+    (sp-rnd-flt spt-g 150.0 32.0 1.0)
+    (sp-rnd-flt spt-b 130.0 32.0 1.0)
+    (sp-rnd-flt spt-a 8.0 4.0 1.0)
+    (sp-flt spt-scalevel-x (meters 0.01))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.04)
+    (sp-int spt-timer 1200)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    )
+  )
+
+;; definition of type dig-log-button-info
+(deftype dig-log-button-info (basic)
+  ((cam-ret-mode symbol         :offset-assert   4)
+   (cam-ret-dir  vector :inline :offset-assert  16)
+   )
+  :method-count-assert 9
+  :size-assert         #x20
+  :flag-assert         #x900000020
+  )
+
+;; definition for method 3 of type dig-log-button-info
+(defmethod inspect dig-log-button-info ((obj dig-log-button-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj (-> obj type))
+  (format #t "~1Tcam-ret-mode: ~A~%" (-> obj cam-ret-mode))
+  (format #t "~1Tcam-ret-dir: #<vector @ #x~X>~%" (-> obj cam-ret-dir))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *dig-log-button-infos*, type (array dig-log-button-info)
+(define *dig-log-button-infos* (new 'static 'boxed-array :type dig-log-button-info
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'instant
+                                   :cam-ret-dir (new 'static 'vector :x 0.1464 :z -0.9892 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'normal
+                                   :cam-ret-dir (new 'static 'vector :x 0.9805 :z 0.1963 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'normal
+                                   :cam-ret-dir (new 'static 'vector :x 0.8602 :z 0.5099 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'instant
+                                   :cam-ret-dir (new 'static 'vector :x -0.9946 :z 0.1035 :w 1.0)
+                                   )
+                                 (new 'static 'dig-log-button-info
+                                   :cam-ret-mode 'normal
+                                   :cam-ret-dir (new 'static 'vector :x 0.9966 :z -0.0813 :w 1.0)
+                                   )
+                                 )
+        )
+
+;; definition for symbol *dig-log-heights*, type (inline-array vector)
+(define *dig-log-heights* (new 'static 'inline-array vector 2
+                            (new 'static 'vector :x 56320.0 :y 32768.0 :z 23552.0 :w 14336.0)
+                            (new 'static 'vector :x 5120.0 :y -4096.0)
+                            )
+        )
+
+;; definition of type dig-log
+(deftype dig-log (process-drawable)
+  ((pressed-count    int8     :offset-assert 200)
+   (total-buttons    int8     :offset-assert 201)
+   (last-button-id   int8     :offset-assert 202)
+   (base-y           float    :offset-assert 204)
+   (hud-handle       handle   :offset-assert 208)
+   (pad-ihj1bn234i1b int32  2 :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xe0
+  :flag-assert         #x17006000e0
+  (:methods
+    (idle () _type_ :state 20)
+    (moving () _type_ :state 21)
+    (dig-log-method-22 (_type_ symbol) symbol 22)
+    )
+  )
+
+;; definition for method 3 of type dig-log
+(defmethod inspect dig-log ((obj dig-log))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tpressed-count: ~D~%" (-> obj pressed-count))
+  (format #t "~2Ttotal-buttons: ~D~%" (-> obj total-buttons))
+  (format #t "~2Tlast-button-id: ~D~%" (-> obj last-button-id))
+  (format #t "~2Tbase-y: ~f~%" (-> obj base-y))
+  (format #t "~2Thud-handle: ~D~%" (-> obj hud-handle))
+  (format #t "~2Tstate-time: ~D~%" (-> obj state-time))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-log dig-log dig-log-lod0-jg dig-log-idle-ja
+              ((dig-log-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 7.25 0 11)
+              :origin-joint-index 3
+              )
+
+;; definition for function dig-log-event-handler
+(defbehavior dig-log-event-handler dig-log ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('hit)
+     (set! (-> self last-button-id) (the-as int (/ (the-as int (-> arg3 param 0)) 8)))
+     (set! (-> self pressed-count) (min (+ (-> self pressed-count) 1) (-> self total-buttons)))
+     (set! (-> *game-info* counter) (the float (- (-> self total-buttons) (-> self pressed-count))))
+     (cond
+       ((= (-> self pressed-count) (-> self total-buttons))
+        (dig-log-method-22 self #f)
+        (task-node-close! (game-task-node dig-find-totem-raise-log))
+        )
+       (else
+         (dig-log-method-22 self #t)
+         )
+       )
+     (go-virtual moving)
+     )
+    (('hud-dig-button)
+     (dig-log-method-22 self (the-as symbol (-> arg3 param 0)))
+     )
+    )
+  )
+
+;; definition for method 12 of type dig-log
+(defmethod run-logic? dig-log ((obj dig-log))
+  #t
+  )
+
+;; definition for method 22 of type dig-log
+;; WARN: Return type mismatch int vs symbol.
+;; WARN: disable def twice: 16. This may happen when a cond (no else) is nested inside of another conditional, but it should be rare.
+(defmethod dig-log-method-22 dig-log ((obj dig-log) (arg0 symbol))
+  (the-as
+    symbol
+    (cond
+      (arg0
+        (when (!= (-> obj pressed-count) (-> obj total-buttons))
+          (when (not (handle->process (-> obj hud-handle)))
+            (let ((v0-0 (ppointer->handle (process-spawn hud-dig-button :init hud-init-by-other :to obj))))
+              (set! (-> obj hud-handle) (the-as handle v0-0))
+              v0-0
+              )
+            )
+          )
+        )
+      (else
+        (send-event (handle->process (-> obj hud-handle)) 'hide-and-die)
+        (set! (-> obj hud-handle) (the-as handle #f))
+        (the-as int #f)
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-log)
+  :virtual #t
+  :event dig-log-event-handler
+  :code (the-as (function none :behavior dig-log) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate moving (dig-log)
+  :virtual #t
+  :enter (behavior ()
+    (set-setting! 'ignore-target #t 0 0)
+    (none)
+    )
+  :exit (behavior ()
+    (remove-setting! 'ignore-target)
+    (none)
+    )
+  :code (behavior ()
+    (local-vars (v1-12 object))
+    (let ((gp-0 (-> *dig-log-button-infos* (-> self last-button-id))))
+      (let* ((t0-0 (if (= (-> self pressed-count) (-> self total-buttons))
+                       "diglog5"
+                       "diglog1"
+                       )
+                   )
+             (s5-0 (add-process *gui-control* self (gui-channel jak) (gui-action queue) t0-0 -99.0 0))
+             )
+        (set! (-> self state-time) (-> self clock frame-counter))
+        (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.15))
+          (suspend)
+          )
+        (until v1-12
+          (suspend)
+          (set! v1-12
+                (and *target* (not (logtest? (-> *target* focus-status) (focus-status in-air))) (process-grab? *target* #f))
+                )
+          )
+        (while (!= (get-status *gui-control* s5-0) (gui-status ready))
+          (suspend)
+          )
+        (set! (-> self state-time) (-> self clock frame-counter))
+        (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.2))
+          (suspend)
+          )
+        (set-setting! 'entity-name "camera-249" 0 0)
+        (set-action!
+          *gui-control*
+          (gui-action play)
+          s5-0
+          (gui-channel none)
+          (gui-action none)
+          (the-as string #f)
+          (the-as (function gui-connection symbol) #f)
+          (the-as process #f)
+          )
+        )
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5))
+        (suspend)
+        )
+      (let ((f30-0
+              (+ (-> (&-> *dig-log-heights* 0 data (- (-> self total-buttons) (-> self pressed-count))) 0) (-> self base-y))
+              )
+            (s5-1 (-> self clock frame-counter))
+            )
+        (until (>= (-> self root trans y) f30-0)
+          (set! (-> self root trans y)
+                (seek-with-smooth (-> self root trans y) f30-0 (* 4096.0 (-> self clock seconds-per-frame)) 0.25 40.96)
+                )
+          (when (>= (-> self clock frame-counter) s5-1)
+            (activate!
+              *camera-smush-control*
+              (rand-vu-float-range 614.4 1433.6)
+              45
+              75
+              1.0
+              0.95
+              (-> *display* camera-clock)
+              )
+            (set! s5-1 (+ (-> self clock frame-counter) (rand-vu-int-range (seconds 0.05) (seconds 0.15))))
+            )
+          (let ((a1-10 (new 'stack-no-clear 'vector)))
+            (set! (-> a1-10 quad) (-> self root trans quad))
+            (set! (-> a1-10 y) (+ 59592.703 (-> self base-y)))
+            (spawn (-> self part) a1-10)
+            )
+          (suspend)
+          )
+        )
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+        (suspend)
+        )
+      (if (= (-> gp-0 cam-ret-mode) 'instant)
+          (persist-with-delay *setting-control* 'interp-time (seconds 0.05) 'interp-time 'abs 0.0 0)
+          )
+      (set-setting! 'string-startup-vector 'abs (-> gp-0 cam-ret-dir) 0)
+      (remove-setting! 'entity-name)
+      (when (!= (-> gp-0 cam-ret-mode) 'instant)
+        (set! (-> self state-time) (-> self clock frame-counter))
+        (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1))
+          (suspend)
+          )
+        )
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
+      (suspend)
+      )
+    (remove-setting! 'string-startup-vector)
+    (until (process-release? *target*)
+      (suspend)
+      )
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4))
+      (suspend)
+      )
+    (go-virtual idle)
+    (none)
+    )
+  :post (the-as (function none :behavior dig-log) transform-post)
+  )
+
+;; definition for method 11 of type dig-log
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-log ((obj dig-log) (arg0 entity-actor))
+  (local-vars (sv-16 res-tag))
+  (set! (-> obj hud-handle) (the-as handle #f))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 29696.0 0.0 45056.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (set! (-> obj base-y) (-> obj root trans y))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-log" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj pressed-count) 0)
+  (set! (-> obj total-buttons) 0)
+  (set! sv-16 (new 'static 'res-tag))
+  (let ((v1-19 (res-lump-data (-> obj entity) 'actor-groups (pointer actor-group) :tag-ptr (& sv-16))))
+    (when (and v1-19 (nonzero? (-> sv-16 elt-count)))
+      (let ((s5-2 (-> v1-19 0)))
+        (countdown (s4-2 (-> s5-2 length))
+          (let ((s3-1 (-> s5-2 data s4-2 actor)))
+            (when s3-1
+              (minimap-method-12 *minimap* obj (the-as uint 16) (the-as int #f) (the-as vector s3-1) 0)
+              (+! (-> obj total-buttons) 1)
+              (if (logtest? (-> s3-1 extra perm status) (entity-perm-status subtask-complete))
+                  (+! (-> obj pressed-count) 1)
+                  )
+              )
+            )
+          )
+        )
+      )
+    )
+  (if (task-node-closed? (game-task-node dig-find-totem-raise-log))
+      (set! (-> obj pressed-count) (-> obj total-buttons))
+      )
+  (set! (-> obj root trans y)
+        (+ (-> (&-> *dig-log-heights* 0 data (- (-> obj total-buttons) (-> obj pressed-count))) 0) (-> obj base-y))
+        )
+  (transform-post)
+  (when (!= (-> obj pressed-count) (-> obj total-buttons))
+    (set! (-> *game-info* counter) (the float (- (-> obj total-buttons) (-> obj pressed-count))))
+    (if (string= (-> *game-info* last-continue name) "dig3b-back-room")
+        (dig-log-method-22 obj #t)
+        )
+    )
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1145) obj))
+  (set! (-> obj event-hook) dig-log-event-handler)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type dig-button
+(deftype dig-button (process-drawable)
+  ((down-y float  :offset-assert 200)
+   )
+  :heap-base #x50
+  :method-count-assert 23
+  :size-assert         #xcc
+  :flag-assert         #x17005000cc
+  (:methods
+    (idle-up () _type_ :state 20)
+    (going-down () _type_ :state 21)
+    (idle-down () _type_ :state 22)
+    )
+  )
+
+;; definition for method 3 of type dig-button
+(defmethod inspect dig-button ((obj dig-button))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tdown-y: ~f~%" (-> obj down-y))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-button dig-button dig-button-lod0-jg dig-button-idle-ja
+              ((dig-button-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 3)
+              )
+
+;; definition for method 12 of type dig-button
+(defmethod run-logic? dig-button ((obj dig-button))
+  #t
+  )
+
+;; failed to figure out what this is:
+(defstate idle-up (dig-button)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as
+      object
+      (case event-type
+        (('attack)
+         (when (logtest? (-> (the-as attack-info (-> event param 1)) penetrate-using) (penetrate flop))
+           (go-virtual going-down)
+           #f
+           )
+         )
+        )
+      )
+    )
+  :code (behavior ()
+    (transform-post)
+    (suspend)
+    (transform-post)
+    (sleep-code)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate going-down (dig-button)
+  :virtual #t
+  :code (behavior ()
+    (sound-play "dig-button")
+    (until (= (-> self root trans y) (-> self down-y))
+      (seek! (-> self root trans y) (-> self down-y) (* 16384.0 (-> self clock seconds-per-frame)))
+      (logior! (-> self skel status) (joint-control-status sync-math))
+      (transform-post)
+      (logclear! (-> self skel status) (joint-control-status sync-math))
+      (suspend)
+      )
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (let ((gp-1 (res-lump-struct (-> self entity) 'on-activate structure)))
+      (if gp-1
+          (eval!
+            (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f))
+            (the-as pair gp-1)
+            )
+          )
+      )
+    (go-virtual idle-down)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle-down (dig-button)
+  :virtual #t
+  :code (behavior ()
+    (set! (-> self root trans y) (-> self down-y))
+    (transform-post)
+    (suspend)
+    (transform-post)
+    (sleep-code)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type dig-button
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-button ((obj dig-button) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 3)
+      (set-vector! (-> v1-2 local-sphere) 0.0 0.0 0.0 12288.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-button" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj down-y) (+ -2048.0 (-> obj root trans y)))
+  (if (task-node-closed? (game-task-node dig-find-totem-raise-log))
+      (process-entity-status! obj (entity-perm-status subtask-complete) #t)
+      )
+  (if (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status subtask-complete)))
+      (go (method-of-object obj idle-down))
+      (go (method-of-object obj idle-up))
+      )
+  (none)
+  )
+
+;; definition for method 15 of type hud-dig-button
+;; WARN: Return type mismatch int vs none.
+(defmethod draw hud-dig-button ((obj hud-dig-button))
+  (set-hud-piece-position!
+    (the-as hud-sprite (-> obj sprites))
+    (the int (+ 487.0 (* 130.0 (-> obj offset))))
+    210
+    )
+  (format (clear (-> obj strings 0 text)) "~D" (-> obj values 0 current))
+  (set-as-offset-from! (the-as hud-sprite (-> obj strings 0 pos)) (the-as vector4w (-> obj sprites)) -16 20)
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+;; definition for method 16 of type hud-dig-button
+;; WARN: Return type mismatch int vs none.
+(defmethod update-values hud-dig-button ((obj hud-dig-button))
+  (set! (-> obj values 0 target) (the int (-> *game-info* counter)))
+  ((method-of-type hud update-values) obj)
+  0
+  (none)
+  )
+
+;; definition for method 17 of type hud-dig-button
+;; WARN: Return type mismatch int vs none.
+(defmethod init-callback hud-dig-button ((obj hud-dig-button))
+  (set! (-> obj level) (level-get *level* 'dig3a))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :page #xd21)))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 0 scale-x) 1.0)
+  (set! (-> obj sprites 0 scale-y) 1.0)
+  (alloc-string-if-needed obj 0)
+  (set! (-> obj strings 0 scale) 0.6)
+  (set! (-> obj strings 0 flags) (font-flags kerning middle large))
+  0
+  (none)
+  )
+
+;; definition for function dig3-login
+;; WARN: Return type mismatch int vs none.
+(defun dig3-login ()
+  (set! *nav-network* (new 'loading-level 'nav-network))
+  0
+  (none)
+  )
+
+;; definition for function dig3-activate
+;; WARN: Return type mismatch int vs none.
+(defun dig3-activate ()
+  (setup-user-array (-> *part-id-table* 1309) "grenadier-grenade-part")
+  (setup-user-array (-> *part-id-table* 638) "grenadier-grenade-part")
+  (setup-user-array (-> *part-id-table* 639) "grenadier-grenade-part")
+  0
+  (none)
+  )
+
+;; definition for function dig3-deactivate
+;; WARN: Return type mismatch int vs none.
+(defun dig3-deactivate ()
+  (set! *nav-network* (the-as nav-network 0))
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/dig/dig1-obs_REF.gc b/test/decompiler/reference/jak2/levels/dig/dig1-obs_REF.gc
new file mode 100644
index 0000000000..0f8063fa90
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/dig/dig1-obs_REF.gc
@@ -0,0 +1,1243 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type dig-conveyor
+(deftype dig-conveyor (conveyor)
+  ()
+  :heap-base #x80
+  :method-count-assert 28
+  :size-assert         #x100
+  :flag-assert         #x1c00800100
+  )
+
+;; definition for method 3 of type dig-conveyor
+(defmethod inspect dig-conveyor ((obj dig-conveyor))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type conveyor inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-conveyor dig-conveyor dig-conveyor-lod0-jg dig-conveyor-idle-ja
+              ((dig-conveyor-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 2 -8 10)
+              :longest-edge (meters 8.7193)
+              :origin-joint-index 3
+              )
+
+;; definition for method 24 of type dig-conveyor
+;; WARN: Return type mismatch int vs none.
+(defmethod init! dig-conveyor ((obj dig-conveyor))
+  "Initializes defaults for things like the `speed` and `belt-radius`"
+  (set! (-> obj speed) 30720.0)
+  (set! (-> obj belt-radius) 15974.4)
+  (set! (-> obj pull-y-threshold) 10240.0)
+  (set! (-> obj draw light-index) (the-as uint 2))
+  (none)
+  )
+
+;; definition for method 22 of type dig-conveyor
+(defmethod get-art-group dig-conveyor ((obj dig-conveyor))
+  "@returns The respective [[art-group]] for the [[conveyor]]"
+  (art-group-get-by-name *level* "skel-dig-conveyor" (the-as (pointer uint32) #f))
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-dig-cylinder-hit
+  :id 1146
+  :duration (seconds 2)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 6)
+  :parts ((sp-item 4960 :flags (bit6) :period 900 :length 5)
+    (sp-item 4961 :flags (bit6) :period 900 :length 5)
+    (sp-item 4962 :period 900 :length 15)
+    (sp-item 4963 :fade-after (meters 60) :period 900 :length 10 :offset 10)
+    (sp-item 4964 :fade-after (meters 60) :falloff-to (meters 60) :period 900 :length 50 :offset 20)
+    (sp-item 4965 :fade-after (meters 200) :falloff-to (meters 200) :period 900 :length 25 :offset 20)
+    (sp-item 4966 :fade-after (meters 150) :falloff-to (meters 150) :period 900 :length 20 :offset 30)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4966
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-flt spt-num 0.8)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-rot-z)
+      :flags (sp-flag spflag7)
+      :random-rangef 65536.0
+      :random-multf 1.0
+      )
+    (sp-rnd-flt spt-scale-y (meters 0.8) (meters 0.2) 1.0)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.1) (meters 0.26666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -6.2)
+    (sp-flt spt-fade-b -6.2)
+    (sp-flt spt-fade-a -0.1254902)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 4967)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-conerot-x)
+      :flags (sp-flag from-pointer)
+      :func '*sp-temp*
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4965
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-flt spt-num 0.8)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (sp-flt spt-rot-z (degrees 0.0))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.26666668) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -6.2)
+    (sp-flt spt-fade-b -6.2)
+    (sp-flt spt-fade-a -0.1254902)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int spt-next-time 25)
+    (sp-launcher-by-id spt-next-launcher 4967)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4967
+  :init-specs ((sp-flt spt-fade-r -2.1666667)
+    (sp-flt spt-fade-g -5.0)
+    (sp-flt spt-fade-b -5.0)
+    (sp-rnd-flt spt-fade-a -0.062068965 -0.72 1.0)
+    (sp-int-plain-rnd spt-next-time 15 14 1)
+    (sp-launcher-by-id spt-next-launcher 4968)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4968
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.016666668) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.7)
+    (sp-flt spt-fade-g -1.7)
+    (sp-flt spt-fade-b -0.8)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 4969)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4969
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0033333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.5833333)
+    (sp-flt spt-fade-g -0.75)
+    (sp-flt spt-fade-b -0.9444444)
+    (sp-int-plain-rnd spt-next-time 150 29 1)
+    (sp-launcher-by-id spt-next-launcher 4970)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4970
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g 0.0) (sp-flt spt-fade-b 0.0) (sp-flt spt-fade-a -0.1125))
+  )
+
+;; failed to figure out what this is:
+(defpart 4961
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xca :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 5))
+    (sp-flt spt-rot-x 2048.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.13333334))
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -2.1333334)
+    (sp-flt spt-fade-b -4.266667)
+    (sp-flt spt-fade-a 0.0)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14 glow)
+    (sp-int spt-next-time 75)
+    (sp-launcher-by-id spt-next-launcher 4971)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4971
+  :init-specs ((sp-flt spt-scalevel-x (meters 0))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.85333335)
+    (sp-flt spt-fade-g -1.7066667)
+    (sp-flt spt-fade-b -1.7066667)
+    (sp-flt spt-fade-a -0.64)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4960
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 5))
+    (sp-flt spt-rot-x 2048.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 24.0)
+    (sp-flt spt-scalevel-x (meters 0.5))
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -4.266667)
+    (sp-flt spt-fade-b -4.266667)
+    (sp-flt spt-fade-a 0.0)
+    (sp-int spt-timer 65)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
+    (sp-int spt-next-time 30)
+    (sp-launcher-by-id spt-next-launcher 4972)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4972
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2857143))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.8285714)
+    (sp-flt spt-fade-g -3.6571429)
+    (sp-flt spt-fade-b -3.6571429)
+    (sp-flt spt-fade-a -1.3714286)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4964
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 6.0 2.0 1.0)
+    (sp-flt spt-x (meters 0.25))
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.25) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 16.0 48.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.083333336) (meters 0.083333336) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -3.1)
+    (sp-flt spt-fade-b -0.1)
+    (sp-rnd-flt spt-accel-y -0.68266666 -1.3653333 1.0)
+    (sp-flt spt-friction 0.87)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 4973)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4973
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0016666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.14444445)
+    (sp-flt spt-fade-g -0.33333334)
+    (sp-flt spt-fade-b -0.33333334)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 4974)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4974
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g -0.08695652) (sp-flt spt-fade-a -0.18478261))
+  )
+
+;; failed to figure out what this is:
+(defpart 4962
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 2.0 1.0 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 0.6) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2.5) (meters 2) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 70.0 20.0 1.0)
+    (sp-rnd-flt spt-g 70.0 20.0 1.0)
+    (sp-rnd-flt spt-b 70.0 20.0 1.0)
+    (sp-rnd-flt spt-a 0.0 40.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.033333335) (meters 0.02) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 3.3)
+    (sp-flt spt-fade-g 1.2)
+    (sp-flt spt-fade-b 1.2)
+    (sp-flt spt-fade-a 1.76)
+    (sp-flt spt-friction 0.88)
+    (sp-int spt-timer 710)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 4975)
+    (sp-rnd-flt spt-conerot-x (degrees -1440.0) (degrees 2880.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4975
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.0833334)
+    (sp-flt spt-fade-g -2.1666667)
+    (sp-flt spt-fade-b -2.1666667)
+    (sp-flt spt-fade-a -0.46666667)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 4976)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4976
+  :init-specs ((sp-flt spt-fade-r -1.7)
+    (sp-flt spt-fade-g -0.8)
+    (sp-flt spt-fade-b -0.8)
+    (sp-flt spt-fade-a -1.0)
+    (sp-int spt-next-time 50)
+    (sp-launcher-by-id spt-next-launcher 4977)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4977
+  :init-specs ((sp-flt spt-scalevel-x (meters 0))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.17)
+    (sp-flt spt-fade-g -0.3)
+    (sp-flt spt-fade-b -0.3)
+    (sp-flt spt-fade-a -0.1)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4963
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x31 :page #xc))
+    (sp-rnd-flt spt-num 4.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.5) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-r 192.0 64.0 1.0)
+    (sp-flt spt-g 65.0)
+    (sp-rnd-flt spt-b 128.0 64.0 1.0)
+    (sp-rnd-flt spt-a 32.0 96.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.13333334) (meters 0.02) 1.0)
+    (sp-flt spt-fade-r -1.4222223)
+    (sp-flt spt-fade-g -1.4222223)
+    (sp-flt spt-fade-b -1.4222223)
+    (sp-flt spt-fade-a -1.4222223)
+    (sp-int spt-timer 90)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    )
+  )
+
+;; definition of type dig-bomb-crate-cylinder
+(deftype dig-bomb-crate-cylinder (rigid-body-object)
+  ((flash-counter int8        :offset-assert 272)
+   (attack-id     uint32      :offset-assert 276)
+   (wait-time     time-frame  :offset-assert 280)
+   )
+  :heap-base #xa0
+  :method-count-assert 54
+  :size-assert         #x120
+  :flag-assert         #x3600a00120
+  (:methods
+    (die () _type_ :state 53)
+    )
+  )
+
+;; definition for method 3 of type dig-bomb-crate-cylinder
+(defmethod inspect dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type rigid-body-object inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tflash-counter: ~D~%" (-> obj flash-counter))
+  (format #t "~2Tattack-id: ~D~%" (-> obj attack-id))
+  (format #t "~2Twait-time: ~D~%" (-> obj wait-time))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type dig-bomb-crate-cylinder-spawn-params
+(deftype dig-bomb-crate-cylinder-spawn-params (structure)
+  ((pos  vector     :inline :offset-assert   0)
+   (vel  vector     :inline :offset-assert  16)
+   (avel vector     :inline :offset-assert  32)
+   (quat quaternion :inline :offset-assert  48)
+   )
+  :method-count-assert 9
+  :size-assert         #x40
+  :flag-assert         #x900000040
+  )
+
+;; definition for method 3 of type dig-bomb-crate-cylinder-spawn-params
+(defmethod inspect dig-bomb-crate-cylinder-spawn-params ((obj dig-bomb-crate-cylinder-spawn-params))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'dig-bomb-crate-cylinder-spawn-params)
+  (format #t "~1Tpos: #<vector @ #x~X>~%" (-> obj pos))
+  (format #t "~1Tvel: #<vector @ #x~X>~%" (-> obj vel))
+  (format #t "~1Tavel: #<vector @ #x~X>~%" (-> obj avel))
+  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> obj quat))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-bomb-crate-cylinder dig-bomb-crate-cylinder dig-bomb-crate-cylinder-lod0-jg dig-bomb-crate-cylinder-idle-ja
+              ((dig-bomb-crate-cylinder-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 1.5)
+              )
+
+;; definition for symbol *dig-bomb-crate-cylinder-constants*, type rigid-body-object-constants
+(define *dig-bomb-crate-cylinder-constants* (new 'static 'rigid-body-object-constants
+                                              :mass 1.0
+                                              :inv-mass 1.0
+                                              :cm-joint-w 1.0
+                                              :linear-damping 0.99
+                                              :angular-damping 0.9
+                                              :bounce-factor 0.5
+                                              :friction-factor 0.1
+                                              :inertial-tensor-x (meters 1)
+                                              :inertial-tensor-y (meters 3)
+                                              :inertial-tensor-z (meters 1)
+                                              :max-time-step 0.02
+                                              :gravity (meters 80)
+                                              :idle-distance (meters 200)
+                                              :attack-force-scale 2.0
+                                              :name '*dig-bomb-crate-cylinder-constants*
+                                              )
+        )
+
+;; failed to figure out what this is:
+(defstate idle (dig-bomb-crate-cylinder)
+  :virtual #t
+  :code (behavior ()
+    (go-virtual die)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate active (dig-bomb-crate-cylinder)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type rigid-body-object active) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self flash-counter) 0)
+    0
+    (none)
+    )
+  :trans (behavior ()
+    (let ((v1-2 (ja-group)))
+      (when (and v1-2 (= v1-2 (-> self draw art-group data 3)))
+        (let* ((gp-0 (-> self flash-counter))
+               (v1-5 gp-0)
+               )
+          (cond
+            ((zero? v1-5)
+             (when (>= (ja-aframe-num 0) 1.4)
+               (sound-play "dig-bomb-beep" :position (-> self root-override-2 trans))
+               (set-vector! (-> self draw color-mult) 1.1 0.25 0.25 1.0)
+               (set! (-> self flash-counter) (+ gp-0 1))
+               )
+             )
+            ((= v1-5 1)
+             (set-vector! (-> self draw color-mult) 1.0 1.0 1.0 1.0)
+             (set-vector! (-> self draw color-emissive) 1.0 1.0 1.0 1.0)
+             (set! (-> self flash-counter) (+ gp-0 1))
+             )
+            ((= v1-5 2)
+             (set-vector! (-> self draw color-mult) 1.0 1.0 1.0 1.0)
+             (set-vector! (-> self draw color-emissive) 0.0 0.0 0.0 1.0)
+             (set! (-> self flash-counter) (+ gp-0 1))
+             )
+            ((= v1-5 3)
+             (when (< (ja-aframe-num 0) 1.4)
+               (set! (-> self flash-counter) 0)
+               0
+               )
+             )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((f30-0 (rand-vu-float-range 0.22 0.27)))
+      (set! (-> self wait-time) (+ (-> self clock frame-counter) (the int (rand-vu-float-range 0.0 450.0))))
+      (while (< (-> self clock frame-counter) (-> self wait-time))
+        (suspend)
+        )
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      (ja-no-eval :group! (-> self draw art-group data 2)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (let ((gp-1 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.5))
+          (suspend)
+          )
+        )
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      (ja-no-eval :group! (-> self draw art-group data 2)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (let ((gp-2 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-2) (seconds 0.5))
+          (suspend)
+          )
+        )
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    f30-0
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max f30-0))
+        )
+      )
+    (ja-no-eval :group! (-> self draw art-group data 2)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (let ((gp-3 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (ja-no-eval :group! (-> self draw art-group data 3)
+                :num! (seek!
+                  (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                  0.375
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.375))
+      )
+    (ja-no-eval :group! (-> self draw art-group data 2)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (let ((gp-4 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
+        (suspend)
+        )
+      )
+    (ja-no-eval :group! (-> self draw art-group data 3)
+                :num! (seek!
+                  (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                  0.4375
+                  )
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek! max 0.4375))
+      )
+    (ja-no-eval :group! (-> self draw art-group data 2)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (let ((gp-5 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-5) (seconds 0.125))
+        (suspend)
+        )
+      )
+    (dotimes (gp-6 12)
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek!
+                    (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1))
+                    0.437
+                    )
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max 0.437))
+        )
+      (ja-no-eval :group! (-> self draw art-group data 2)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 2)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (let ((s5-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) s5-0) (seconds 0.05))
+          (suspend)
+          )
+        )
+      )
+    (go-virtual die)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (dig-bomb-crate-cylinder)
+  :virtual #t
+  :enter (behavior ()
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (let ((v1-6 (-> self root-override-2 root-prim)))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (none)
+    )
+  :code (behavior ()
+    (sound-play "dig-bomb-explo")
+    (let ((gp-1 (new 'stack-no-clear 'explosion-init-params)))
+      (set! (-> gp-1 spawn-point quad) (-> self root-override-2 trans quad))
+      (quaternion-copy! (-> gp-1 spawn-quat) (-> self root-override-2 quat))
+      (set! (-> gp-1 radius) 28672.0)
+      (set! (-> gp-1 group) (-> *part-group-id-table* 1146))
+      (set! (-> gp-1 collide-with)
+            (collide-spec backgnd jak crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
+            )
+      (set! (-> gp-1 penetrate-using) (penetrate explode))
+      (explosion-spawn (the-as process-drawable *entity-pool*) explosion gp-1)
+      )
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; definition for method 46 of type dig-bomb-crate-cylinder
+(defmethod rigid-body-object-method-46 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder) (arg0 process-drawable) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('track)
+     #t
+     )
+    (else
+      ((method-of-type rigid-body-object rigid-body-object-method-46) obj arg0 arg1 arg2 arg3)
+      )
+    )
+  (none)
+  )
+
+;; definition for method 47 of type dig-bomb-crate-cylinder
+;; WARN: Return type mismatch object vs symbol.
+(defmethod rigid-body-object-method-47 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder) (arg0 process-drawable) (arg1 attack-info) (arg2 object) (arg3 penetrate))
+  (the-as
+    symbol
+    (cond
+      ((logtest? (penetrate jak-yellow-shot jak-red-shot jak-blue-shot jak-dark-shot enemy-yellow-shot enemy-dark-shot)
+                 arg3
+                 )
+       (go (method-of-object obj die))
+       )
+      (else
+        (if (logtest? (penetrate explode) arg3)
+            (set! arg3 (penetrate spin))
+            )
+        ((method-of-type rigid-body-object rigid-body-object-method-47) obj arg0 arg1 arg2 (the-as penetrate arg3))
+        )
+      )
+    )
+  )
+
+;; definition for method 45 of type dig-bomb-crate-cylinder
+(defmethod rigid-body-object-method-45 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder) (arg0 rigid-body-object-constants))
+  (let* ((f0-0 (-> arg0 info inv-inertial-tensor vector 0 x))
+         (f1-0 28672.0)
+         (f30-0 (* f0-0 (/ 1.0 f1-0) (-> obj info inv-mass)))
+         )
+    (if (< (* 28672.0 (-> obj info mass)) (-> arg0 info inv-inertial-tensor vector 0 x))
+        (sound-play-by-name
+          (static-sound-name "barrel-bomb-hit")
+          (new-sound-id)
+          (the int (* 1024.0 f30-0))
+          0
+          0
+          (sound-group sfx)
+          (-> obj root-override-2 trans)
+          )
+        )
+    )
+  )
+
+;; definition for method 37 of type dig-bomb-crate-cylinder
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-37 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder))
+  (with-pp
+    (let ((a1-0 (new 'stack-no-clear 'collide-query)))
+      (set! (-> a1-0 start-pos quad) (-> obj rbody state position quad))
+      (vector-float*! (-> a1-0 move-dist) (-> obj rbody state lin-velocity) (-> pp clock seconds-per-frame))
+      (let ((v1-3 a1-0))
+        (set! (-> v1-3 radius) (+ 4096.0 (-> obj root-override-2 root-prim local-sphere w)))
+        (set! (-> v1-3 collide-with) (-> obj root-override-2 root-prim prim-core collide-with))
+        (set! (-> v1-3 ignore-process0) obj)
+        (set! (-> v1-3 ignore-process1) #f)
+        (set! (-> v1-3 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (set! (-> v1-3 action-mask) (collide-action solid))
+        )
+      (fill-using-line-sphere *collide-cache* a1-0)
+      )
+    (if *display-collide-cache*
+        (debug-draw *collide-cache*)
+        )
+    (rigid-body-object-method-30 obj)
+    (set! (-> obj root-override-2 transv quad) (-> obj rbody state lin-velocity quad))
+    (quaternion-copy! (-> obj root-override-2 quat) (-> obj rbody state rotation))
+    (rigid-body-method-24 (-> obj rbody state))
+    (let ((v1-19 (-> obj rbody))
+          (a1-2 (-> obj root-override-2 trans))
+          )
+      (rigid-body-method-23 (-> v1-19 state) a1-2)
+      )
+    (set! (-> obj node-list data 0 bone transform trans quad) (-> obj root-override-2 trans quad))
+    (transform-post)
+    0
+    (none)
+    )
+  )
+
+;; definition for method 32 of type dig-bomb-crate-cylinder
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-32 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak crate enemy obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 7168.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-12 prim-core collide-with)
+            (collide-spec backgnd jak crate enemy obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 0)
+      (set-vector! (-> v1-12 local-sphere) 0.0 2048.0 0.0 4505.6)
+      )
+    (let ((v1-14 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-14 prim-core collide-with)
+            (collide-spec backgnd jak crate enemy obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 0)
+      (set-vector! (-> v1-14 local-sphere) 0.0 -2048.0 0.0 4096.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-17 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-17 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-17 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 33 of type dig-bomb-crate-cylinder
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-33 dig-bomb-crate-cylinder ((obj dig-bomb-crate-cylinder))
+  (initialize-skeleton
+    obj
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-dig-bomb-crate-cylinder" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (rigid-body-object-method-31 obj *dig-bomb-crate-cylinder-constants*)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logior! (-> obj rbody state flags) (rigid-body-flag enable-collision))
+  (set! (-> obj draw light-index) (the-as uint 10))
+  0
+  (none)
+  )
+
+;; definition for function dig-bomb-crate-cylinder-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-bomb-crate-cylinder-init-by-other dig-bomb-crate-cylinder ((arg0 dig-bomb-crate-cylinder-spawn-params) (arg1 entity-actor))
+  (process-entity-set! self arg1)
+  (rigid-body-object-method-32 self)
+  (set! (-> self root-override-2 trans quad) (-> arg0 pos quad))
+  (quaternion-copy! (-> self root-override-2 quat) (-> arg0 quat))
+  (rigid-body-object-method-33 self)
+  (set! (-> self mask) (logior (process-mask platform) (-> self mask)))
+  (vector-float*! (-> self rbody state lin-momentum) (-> arg0 vel) (-> self info mass))
+  (vector-float*! (-> self rbody state ang-momentum) (-> arg0 avel) (-> self info mass))
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition for function dig-bomb-crate-cylinder-spawn
+(defun dig-bomb-crate-cylinder-spawn ((arg0 process-tree) (arg1 dig-bomb-crate-cylinder-spawn-params) (arg2 entity-actor))
+  (process-spawn dig-bomb-crate-cylinder arg1 arg2 :to arg0)
+  )
+
+;; definition of type dig-bomb-crate
+(deftype dig-bomb-crate (process-focusable)
+  ()
+  :heap-base #x50
+  :method-count-assert 30
+  :size-assert         #xcc
+  :flag-assert         #x1e005000cc
+  (:methods
+    (idle () _type_ :state 27)
+    (die () _type_ :state 28)
+    (dig-bomb-crate-method-29 (_type_ vector) none 29)
+    )
+  )
+
+;; definition for method 3 of type dig-bomb-crate
+(defmethod inspect dig-bomb-crate ((obj dig-bomb-crate))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-bomb-crate dig-bomb-crate dig-bomb-crate-lod0-jg dig-bomb-crate-idle-ja
+              ((dig-bomb-crate-lod0-mg (meters 20)) (dig-bomb-crate-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 2 0 4.5)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-bomb-crate-explode dig-bomb-crate dig-bomb-crate-explode-lod0-jg dig-bomb-crate-explode-idle-ja
+              ((dig-bomb-crate-explode-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 2 0 4.5)
+              )
+
+;; definition for symbol *dig-bomb-crate-exploder-params*, type joint-exploder-static-params
+(define *dig-bomb-crate-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 3 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 13 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    :art-level #f
+    )
+  )
+
+;; definition for symbol *dig-bomb-crate-array*, type (inline-array vector)
+(define *dig-bomb-crate-array* (new 'static 'inline-array vector 8
+                                 (new 'static 'vector :x -5038.08 :y 5120.0 :z -5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 5120.0 :z -5038.08)
+                                 (new 'static 'vector :x -5038.08 :y 5120.0 :z 5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 5120.0 :z 5038.08)
+                                 (new 'static 'vector :x -5038.08 :y 15155.2 :z -5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 15155.2 :z -5038.08)
+                                 (new 'static 'vector :x -5038.08 :y 15155.2 :z 5038.08)
+                                 (new 'static 'vector :x 5038.08 :y 15155.2 :z 5038.08)
+                                 )
+        )
+
+;; definition for method 29 of type dig-bomb-crate
+;; WARN: Return type mismatch int vs none.
+(defmethod dig-bomb-crate-method-29 dig-bomb-crate ((obj dig-bomb-crate) (arg0 vector))
+  (let ((s4-0 (-> obj root-override trans)))
+    (dotimes (s3-0 8)
+      (let ((a0-2 (-> *dig-bomb-crate-array* s3-0))
+            (s2-0 (new 'stack-no-clear 'dig-bomb-crate-cylinder-spawn-params))
+            )
+        (vector+! (-> s2-0 pos) s4-0 a0-2)
+        (vector-! (-> s2-0 vel) (-> s2-0 pos) arg0)
+        (vector-normalize! (-> s2-0 vel) (rand-vu-float-range 81920.0 163840.0))
+        (+! (-> s2-0 vel y) (rand-vu-float-range 12288.0 32768.0))
+        (quaternion-identity! (-> s2-0 quat))
+        (set! (-> s2-0 avel x) (rand-vu-float-range -3.0 3.0))
+        (set! (-> s2-0 avel y) (rand-vu-float-range -3.0 3.0))
+        (set! (-> s2-0 avel z) (rand-vu-float-range -3.0 3.0))
+        (dig-bomb-crate-cylinder-spawn
+          *entity-pool*
+          (the-as dig-bomb-crate-cylinder-spawn-params (-> s2-0 pos))
+          (-> obj entity)
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 20 of type dig-bomb-crate
+(defmethod get-trans dig-bomb-crate ((obj dig-bomb-crate) (arg0 int))
+  "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])"
+  (local-vars (v0-0 vector))
+  (let ((v1-0 (-> obj root-override)))
+    (case arg0
+      ((2 3)
+       (set! v0-0 (new 'static 'vector))
+       (vector+! v0-0 (-> v1-0 trans) (new 'static 'vector :y 12288.0))
+       )
+      (else
+        (set! v0-0 (-> v1-0 trans))
+        )
+      )
+    )
+  v0-0
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-bomb-crate)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (logclear! (-> self mask) (process-mask actor-pause))
+       (go-virtual die)
+       )
+      (('track)
+       #t
+       )
+      )
+    )
+  :code (the-as (function none :behavior dig-bomb-crate) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate die (dig-bomb-crate)
+  :virtual #t
+  :enter (behavior ()
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (let ((v1-6 (-> self root-override root-prim)))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (let* ((gp-0 *target*)
+           (a0-4 (if (type? gp-0 process-focusable)
+                     gp-0
+                     )
+                 )
+           )
+      (if a0-4
+          (dig-bomb-crate-method-29 self (get-trans a0-4 0))
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (suspend)
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (sound-play "bomb-rack-break")
+    (let ((gp-1 (new 'stack 'joint-exploder-tuning (the-as uint 1))))
+      (let* ((s5-1 *target*)
+             (a0-5 (if (type? s5-1 process-focusable)
+                       s5-1
+                       )
+                   )
+             )
+        (when a0-5
+          (set! (-> gp-1 fountain-rand-transv-lo quad) (-> (get-trans a0-5 0) quad))
+          (set! (-> gp-1 fountain-rand-transv-lo y) (+ -16384.0 (-> gp-1 fountain-rand-transv-lo y)))
+          )
+        )
+      (set! (-> gp-1 fountain-rand-transv-hi x) 24576.0)
+      (set! (-> gp-1 fountain-rand-transv-hi y) 81920.0)
+      (set! (-> gp-1 fountain-rand-transv-hi z) 12288.0)
+      (set! (-> gp-1 fountain-rand-transv-hi w) 32768.0)
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-dig-bomb-crate-explode" (the-as (pointer uint32) #f))
+        6
+        gp-1
+        *dig-bomb-crate-exploder-params*
+        :to self
+        )
+      )
+    (suspend)
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 4))
+        (suspend)
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type dig-bomb-crate
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-bomb-crate ((obj dig-bomb-crate) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 penetrated-by)
+          (penetrate
+            generic-attack
+            lunge
+            flop
+            punch
+            spin
+            roll
+            uppercut
+            bonk
+            tube
+            vehicle
+            flut-attack
+            board
+            mech-punch
+            dark-punch
+            dark-giant
+            )
+          )
+    (let ((v1-3 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec enemy camera-blocker))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-3 prim-core action) (collide-action solid))
+      (set! (-> v1-3 transform-index) 3)
+      (set-vector! (-> v1-3 local-sphere) 0.0 8192.0 0.0 18432.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-3)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-6 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-6 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-6 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-bomb-crate" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj mask) (logior (process-mask enemy) (-> obj mask)))
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-jump-pad dig-jump-pad dig-jump-pad-lod0-jg dig-jump-pad-idle-ja
+              ((dig-jump-pad-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 15)
+              )
+
+;; definition of type dig-jump-pad
+(deftype dig-jump-pad (bouncer)
+  ()
+  :heap-base #x60
+  :method-count-assert 25
+  :size-assert         #xd4
+  :flag-assert         #x19006000d4
+  )
+
+;; definition for method 3 of type dig-jump-pad
+(defmethod inspect dig-jump-pad ((obj dig-jump-pad))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type bouncer inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 23 of type dig-jump-pad
+;; WARN: Return type mismatch int vs none.
+(defmethod init-skeleton! dig-jump-pad ((obj dig-jump-pad))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-jump-pad" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 24 of type dig-jump-pad
+;; WARN: Return type mismatch int vs none.
+(defmethod bouncer-method-24 dig-jump-pad ((obj dig-jump-pad))
+  "TODO - collision stuff"
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec crate))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set! (-> s4-0 transform-index) 0)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 61440.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 2))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-8 prim-core action) (collide-action solid))
+      (set! (-> v1-8 transform-index) 0)
+      (set-vector! (-> v1-8 local-sphere) 0.0 0.0 0.0 12288.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 8))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-10 prim-core action) (collide-action))
+      (set-vector! (-> v1-10 local-sphere) 0.0 4096.0 0.0 6144.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-13 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-13 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-13 prim-core collide-with))
+      )
+    (set! (-> obj root) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate fire (dig-jump-pad)
+  :virtual #t
+  :code (behavior ()
+    (sound-play "dig-air-lifter")
+    (let ((s5-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)))
+          (gp-1 (get-process *default-dead-pool* part-tracker #x4000))
+          )
+      (when gp-1
+        (let ((t9-4 (method-of-type part-tracker activate)))
+          (t9-4
+            (the-as part-tracker gp-1)
+            *entity-pool*
+            (symbol->string (-> part-tracker symbol))
+            (the-as pointer #x70004000)
+            )
+          )
+        (let ((t9-5 run-function-in-process)
+              (a0-5 gp-1)
+              (a1-4 part-tracker-init)
+              (a2-5 (-> *part-group-id-table* 1147))
+              (a3-2 0)
+              (t0-1 #f)
+              (t1-1 #f)
+              (t2-1 #f)
+              (t3-0 *launch-matrix*)
+              )
+          (set! (-> t3-0 trans quad) (-> s5-1 quad))
+          ((the-as (function object object object object object object object object none) t9-5)
+           a0-5
+           a1-4
+           a2-5
+           a3-2
+           t0-1
+           t1-1
+           t2-1
+           t3-0
+           )
+          )
+        (-> gp-1 ppointer)
+        )
+      )
+    (let ((t9-6 (-> (method-of-type bouncer fire) code)))
+      (if t9-6
+          ((the-as (function none) t9-6))
+          )
+      )
+    (none)
+    )
+  )
diff --git a/test/decompiler/reference/jak2/levels/dig/dig2-obs_REF.gc b/test/decompiler/reference/jak2/levels/dig/dig2-obs_REF.gc
new file mode 100644
index 0000000000..ae9a31e551
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/dig/dig2-obs_REF.gc
@@ -0,0 +1,84 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type dig-breakable-door
+(deftype dig-breakable-door (process-focusable)
+  ((anim         basic  :offset-assert 204)
+   (art-name     basic  :offset-assert 208)
+   (collide-mesh int32  :offset-assert 212)
+   )
+  :heap-base #x60
+  :method-count-assert 28
+  :size-assert         #xd8
+  :flag-assert         #x1c006000d8
+  (:methods
+    (idle () _type_ :state 27)
+    )
+  )
+
+;; definition for method 3 of type dig-breakable-door
+(defmethod inspect dig-breakable-door ((obj dig-breakable-door))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tanim: ~A~%" (-> obj anim))
+  (format #t "~2Tart-name: ~A~%" (-> obj art-name))
+  (format #t "~2Tcollide-mesh: ~D~%" (-> obj collide-mesh))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-breakable-door dig-breakable-door dig-breakable-door-lod0-jg dig-breakable-door-idle-ja
+              ((dig-breakable-door-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 6 0 10.3)
+              :origin-joint-index 3
+              )
+
+;; failed to figure out what this is:
+(defstate idle (dig-breakable-door)
+  :virtual #t
+  :code (behavior ()
+    (until #f
+      (transform-post)
+      (logior! (-> self mask) (process-mask sleep))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  )
+
+;; definition for method 11 of type dig-breakable-door
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-breakable-door ((obj dig-breakable-door) (arg0 entity-actor))
+  (stack-size-set! (-> obj main-thread) 512)
+  (set! (-> obj mask) (logior (process-mask collectable) (-> obj mask)))
+  (let ((s4-0 (art-group-get-by-name *level* "skel-dig-breakable-door" (the-as (pointer uint32) #f))))
+    (let ((s3-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+      (let ((v1-7 (new 'process 'collide-shape-prim-mesh s3-0 (the-as uint 0) (the-as uint 0))))
+        (set! (-> v1-7 prim-core collide-as) (collide-spec obstacle))
+        (set! (-> v1-7 prim-core collide-with) (collide-spec jak player-list))
+        (set! (-> v1-7 prim-core action) (collide-action solid))
+        (set! (-> v1-7 transform-index) 3)
+        (set-vector! (-> v1-7 local-sphere) 0.0 24576.0 0.0 42188.8)
+        (set! (-> s3-0 total-prims) (the-as uint 1))
+        (set! (-> s3-0 root-prim) v1-7)
+        )
+      (set! (-> s3-0 nav-radius) (* 0.75 (-> s3-0 root-prim local-sphere w)))
+      (let ((v1-10 (-> s3-0 root-prim)))
+        (set! (-> s3-0 backup-collide-as) (-> v1-10 prim-core collide-as))
+        (set! (-> s3-0 backup-collide-with) (-> v1-10 prim-core collide-with))
+        )
+      (set! (-> obj root-override) s3-0)
+      )
+    (process-drawable-from-entity! obj arg0)
+    (initialize-skeleton obj (the-as skeleton-group s4-0) (the-as pair 0))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/dig/dig3-obs_REF.gc b/test/decompiler/reference/jak2/levels/dig/dig3-obs_REF.gc
new file mode 100644
index 0000000000..ee47f3dd50
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/dig/dig3-obs_REF.gc
@@ -0,0 +1,2285 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-dig-spikey-sphere-bounce
+  :id 1148
+  :duration (seconds 0.017)
+  :linger-duration (seconds 1.5)
+  :bounds (static-bspherem 0 0 0 2)
+  :parts ((sp-item 4978) (sp-item 4979) (sp-item 4980))
+  )
+
+;; failed to figure out what this is:
+(defpart 4978
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.06666667) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.16)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-rnd-flt spt-friction 0.92 0.03 1.0)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 65.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4980
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 3) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 3) (meters 1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters -0.026666667) (meters -0.06666667) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.08 -0.08 1.0)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-rnd-flt spt-friction 0.92 0.03 1.0)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 3600.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4979
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-rnd-flt spt-scale-x (meters 1.5) (meters 0.5) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.10666667) (meters 0.053333335) 1.0)
+    (sp-flt spt-scalevel-x (meters 0.0016666667))
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a -0.21333334)
+    (sp-flt spt-accel-y -1.3653333)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 150)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 60.0) (degrees 20.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-dig-spikey-sphere-break
+  :id 1149
+  :duration (seconds 2)
+  :linger-duration (seconds 3)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 4978 :period 1500 :length 15)
+    (sp-item 4979 :period 1500 :length 15)
+    (sp-item 4982 :period 1500 :length 15)
+    (sp-item 4983 :fade-after (meters 130) :falloff-to (meters 130) :flags (is-3d) :period 1500 :length 15 :binding 4981)
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    (sp-item 4981 :fade-after (meters 90) :falloff-to (meters 90) :flags (start-dead))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4982
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 32.0)
+    (sp-flt spt-y (meters 3))
+    (sp-rnd-flt spt-scale-x (meters 2.5) (meters 2.5) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 2.5) (meters 2.5) 1.0)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.033333335) (meters 0.13333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-rnd-flt spt-fade-a -0.04 -0.04 1.0)
+    (sp-rnd-flt spt-accel-y -1.3653333 -0.13653333 1.0)
+    (sp-rnd-flt spt-friction 0.9 0.02 1.0)
+    (sp-int spt-timer 800)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-rnd-flt spt-conerot-x (degrees 30.0) (degrees 70.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 1) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4981
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 16.0 16.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-rnd-flt spt-fade-a -0.10666667 -0.21333334 1.0)
+    (sp-rnd-flt spt-accel-y 0.0 -2.048 1.0)
+    (sp-int spt-timer 300)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12 use-global-acc)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4983
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xc :page #xc))
+    (sp-flt spt-num 16.0)
+    (sp-flt spt-y (meters 3))
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.5) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-r 0.0 32.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 128.0)
+    (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-rotvel-x (degrees -4.8) (degrees 9.6) 1.0)
+    (sp-rnd-flt spt-rotvel-y (degrees -4.8) (degrees 9.6) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -4.8) (degrees 9.6) 1.0)
+    (sp-rnd-flt spt-accel-y -13.653334 -6.826667 1.0)
+    (sp-rnd-flt spt-friction 0.95 0.02 1.0)
+    (sp-int spt-timer 400)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-int-plain-rnd spt-next-time 100 199 1)
+    (sp-launcher-by-id spt-next-launcher 237)
+    (sp-rnd-flt spt-conerot-x (degrees 30.0) (degrees 70.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 2) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 4984
+  :init-specs ((sp-rnd-flt spt-fade-a -1.28 -1.28 1.0))
+  )
+
+;; definition of type dig-spikey-step
+(deftype dig-spikey-step (process-drawable)
+  ((smush         smush-control :inline :offset-assert 208)
+   (init-quat     quaternion    :inline :offset-assert 240)
+   (shudder-angle float                 :offset-assert 256)
+   (rot-angle     float                 :offset-assert 260)
+   (cycle-time    float                 :offset-assert 264)
+   (cycle-offset  float                 :offset-assert 268)
+   )
+  :heap-base #x90
+  :method-count-assert 21
+  :size-assert         #x110
+  :flag-assert         #x1500900110
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type dig-spikey-step
+(defmethod inspect dig-spikey-step ((obj dig-spikey-step))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tsmush: #<smush-control @ #x~X>~%" (&-> obj stack 72))
+  (format #t "~2Tinit-quat: #<quaternion @ #x~X>~%" (-> obj init-quat))
+  (format #t "~2Tshudder-angle: ~f~%" (-> obj shudder-angle))
+  (format #t "~2Trot-angle: ~f~%" (-> obj rot-angle))
+  (format #t "~2Tcycle-time: ~f~%" (-> obj cycle-time))
+  (format #t "~2Tcycle-offset: ~f~%" (-> obj cycle-offset))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-spikey-step dig-spikey-step dig-spikey-step-lod0-jg dig-spikey-step-idle-ja
+              ((dig-spikey-step-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 6 9)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (dig-spikey-step)
+  :virtual #t
+  :trans (the-as (function none :behavior dig-spikey-step) rider-trans)
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (the int (-> self cycle-offset)))
+        (suspend)
+        )
+      )
+    (until #f
+      (let ((gp-1 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-1) (the int (-> self cycle-time)))
+          (suspend)
+          )
+        )
+      ((method-of-type smush-control activate!)
+       (the-as smush-control (&-> self stack 72))
+       -1.0
+       60
+       225
+       1.0
+       1.0
+       (-> self clock)
+       )
+      (sound-play "spikey-shake" :position (-> self root trans))
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.75))
+          (set! (-> self shudder-angle)
+                (* 364.0889 ((method-of-type smush-control update!) (the-as smush-control (&-> self stack 72))))
+                )
+          (suspend)
+          )
+        )
+      (set! (-> self shudder-angle) 0.0)
+      ((method-of-type smush-control set-zero!) (the-as smush-control (&-> self stack 72)))
+      (let ((gp-4 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.25))
+          (suspend)
+          )
+        )
+      (sound-play "spikey-turn" :position (-> self root trans))
+      (let* ((f0-7 1.0)
+             (f30-1 (* 65536.0 f0-7))
+             (gp-6 (-> self clock frame-counter))
+             )
+        (until (>= (- (-> self clock frame-counter) gp-6) (seconds 1))
+          (set! (-> self rot-angle)
+                (the float (sar (shl (the int (+ (-> self rot-angle) (* f30-1 (-> self clock seconds-per-frame)))) 48) 48))
+                )
+          (suspend)
+          )
+        )
+      (let ((v1-42 #x10000))
+        (if (< (-> self rot-angle) 0.0)
+            (set! (-> self rot-angle)
+                  (the float (sar (shl (* v1-42 (/ (- (the int (-> self rot-angle)) (/ v1-42 2)) v1-42)) 48) 48))
+                  )
+            (set! (-> self rot-angle)
+                  (the float (sar (shl (* v1-42 (/ (+ (the int (-> self rot-angle)) (/ v1-42 2)) v1-42)) 48) 48))
+                  )
+            )
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (let ((a2-1 (quaternion-vector-angle!
+                  (new 'stack-no-clear 'quaternion)
+                  *z-vector*
+                  (+ (-> self rot-angle) (-> self shudder-angle))
+                  )
+                )
+          )
+      (quaternion*! (-> self root quat) (-> self init-quat) a2-1)
+      )
+    (rider-post)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type dig-spikey-step
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-spikey-step ((obj dig-spikey-step) (arg0 entity-actor))
+  (local-vars (sv-16 int))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 24576.0 36864.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-spikey-step" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (quaternion-copy! (-> obj init-quat) (-> obj root quat))
+  (let ((f28-0 4.0)
+        (f30-0 0.0)
+        )
+    (set! sv-16 0)
+    (let ((v1-20 (res-lump-data arg0 'cycle-speed (pointer float) :tag-ptr (the-as (pointer res-tag) (& sv-16)))))
+      (when v1-20
+        (set! f28-0 (-> v1-20 0))
+        (set! f30-0 (-> v1-20 1))
+        )
+      )
+    (set! (-> obj cycle-time) (the float (max 0 (+ (the int (* 300.0 f28-0)) -525))))
+    (set! (-> obj cycle-offset) (the float (the int (* 300.0 f30-0))))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type dig-spikey-sphere
+(deftype dig-spikey-sphere (projectile-bounce)
+  ((death-height  float  :offset-assert 496)
+   (pad-i1hb23h1b float  :offset-assert 500)
+   )
+  :heap-base #x180
+  :method-count-assert 42
+  :size-assert         #x1f8
+  :flag-assert         #x2a018001f8
+  )
+
+;; definition for method 3 of type dig-spikey-sphere
+(defmethod inspect dig-spikey-sphere ((obj dig-spikey-sphere))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type projectile-bounce inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tattack-id: ~D~%" (-> obj attack-id))
+  (format #t "~2Tdeath-height: ~f~%" (-> obj pad-i1hb23h1b))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-spikey-sphere dig-spikey-sphere dig-spikey-sphere-lod0-jg dig-spikey-sphere-idle-ja
+              ((dig-spikey-sphere-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4.2)
+              :shadow dig-spikey-sphere-shadow-mg
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-spikey-sphere-explode dig-spikey-sphere dig-spikey-sphere-explode-lod0-jg dig-spikey-sphere-explode-idle-ja
+              ((dig-spikey-sphere-explode-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4.2)
+              )
+
+;; definition for symbol *dig-spikey-sphere-exploder-params*, type joint-exploder-static-params
+(define *dig-spikey-sphere-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 3 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    :art-level #f
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (dig-spikey-sphere)
+  :virtual #t
+  :enter (behavior ()
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (let ((v1-6 (-> self root-override root-prim)))
+      (set! (-> v1-6 prim-core collide-as) (collide-spec))
+      (set! (-> v1-6 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-dig-spikey-sphere-explode" (the-as (pointer uint32) #f))
+        6
+        gp-0
+        *dig-spikey-sphere-exploder-params*
+        :to self
+        )
+      )
+    (sound-play "spikey-break")
+    (suspend)
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 4))
+        (suspend)
+        )
+      )
+    (let ((t9-7 (-> (method-of-type projectile-bounce die) code)))
+      (if t9-7
+          ((the-as (function none) t9-7))
+          )
+      )
+    (none)
+    )
+  )
+
+;; definition for function spikey-sphere-update-velocity
+;; WARN: Return type mismatch int vs none.
+(defun spikey-sphere-update-velocity ((arg0 dig-spikey-sphere))
+  (with-pp
+    (set! (-> arg0 root-override transv y)
+          (- (-> arg0 root-override transv y) (* 327680.0 (-> pp clock seconds-per-frame)))
+          )
+    0
+    (none)
+    )
+  )
+
+;; definition for function spikey-sphere-reaction
+(defbehavior spikey-sphere-reaction dig-spikey-sphere ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector))
+  (cshape-reaction-update-state arg0 arg1 arg3)
+  (let ((f30-0 (vector-dot arg3 (-> arg0 surface-normal)))
+        (s3-0 (new 'stack-no-clear 'vector))
+        )
+    (sound-play "spikey-bounce")
+    (vector-float*! s3-0 (-> arg0 surface-normal) (* 1.6 f30-0))
+    (vector-! arg2 arg3 s3-0)
+    )
+  (-> arg0 status)
+  )
+
+;; definition for method 30 of type dig-spikey-sphere
+;; WARN: Return type mismatch int vs none.
+(defmethod init-collision! dig-spikey-sphere ((obj dig-spikey-sphere))
+  "Init the [[projectile]]'s [[collide-shape]]"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) spikey-sphere-reaction)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec backgnd player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 12288.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for function spikey-sphere-move
+(defun spikey-sphere-move ((arg0 dig-spikey-sphere))
+  (quaternion*! (-> arg0 root-override quat) (-> arg0 tumble-quat) (-> arg0 root-override quat))
+  (projectile-move-fill-all-dirs arg0)
+  (none)
+  )
+
+;; definition for method 39 of type dig-spikey-sphere
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch time-frame vs sound-id.
+(defmethod play-impact-sound! dig-spikey-sphere ((obj dig-spikey-sphere))
+  "Plays impact sound
+       :virtual"
+  (let* ((a0-1 (-> obj root-override))
+         (s5-0 (-> a0-1 status))
+         )
+    (when (logtest? s5-0 (collide-status touch-surface))
+      (vector-float*! (-> a0-1 transv) (-> a0-1 transv) 0.9)
+      (cond
+        ((< (-> obj root-override trans y) (-> obj pad-i1hb23h1b))
+         (let ((s4-0 (get-process *default-dead-pool* part-tracker #x4000)))
+           (when s4-0
+             (let ((t9-1 (method-of-type part-tracker activate)))
+               (t9-1
+                 (the-as part-tracker s4-0)
+                 *entity-pool*
+                 (symbol->string (-> part-tracker symbol))
+                 (the-as pointer #x70004000)
+                 )
+               )
+             (let ((t9-2 run-function-in-process)
+                   (a0-5 s4-0)
+                   (a1-3 part-tracker-init)
+                   (a2-4 (-> *part-group-id-table* 1149))
+                   (a3-1 0)
+                   (t0-0 #f)
+                   (t1-0 #f)
+                   (t2-0 #f)
+                   (t3-0 *launch-matrix*)
+                   )
+               (set! (-> t3-0 trans quad) (-> obj root-override grount-touch-point quad))
+               ((the-as (function object object object object object object object object none) t9-2)
+                a0-5
+                a1-3
+                a2-4
+                a3-1
+                t0-0
+                t1-0
+                t2-0
+                t3-0
+                )
+               )
+             (-> s4-0 ppointer)
+             )
+           )
+         (go (method-of-object obj die))
+         )
+        (else
+          (let ((s4-1 (get-process *default-dead-pool* part-tracker #x4000)))
+            (when s4-1
+              (let ((t9-5 (method-of-type part-tracker activate)))
+                (t9-5
+                  (the-as part-tracker s4-1)
+                  *entity-pool*
+                  (symbol->string (-> part-tracker symbol))
+                  (the-as pointer #x70004000)
+                  )
+                )
+              (let ((t9-6 run-function-in-process)
+                    (a0-8 s4-1)
+                    (a1-6 part-tracker-init)
+                    (a2-9 (-> *part-group-id-table* 1148))
+                    (a3-3 0)
+                    (t0-1 #f)
+                    (t1-1 #f)
+                    (t2-1 #f)
+                    (t3-1 *launch-matrix*)
+                    )
+                (set! (-> t3-1 trans quad) (-> obj root-override grount-touch-point quad))
+                ((the-as (function object object object object object object object object none) t9-6)
+                 a0-8
+                 a1-6
+                 a2-9
+                 a3-3
+                 t0-1
+                 t1-1
+                 t2-1
+                 t3-1
+                 )
+                )
+              (-> s4-1 ppointer)
+              )
+            )
+          )
+        )
+      )
+    (the-as sound-id (when (and (logtest? s5-0 (collide-status impact-surface))
+                                (>= (- (-> self clock frame-counter) (-> obj played-bounce-time)) (seconds 0.3))
+                                )
+                       (let ((v0-7 (-> self clock frame-counter)))
+                         (set! (-> obj played-bounce-time) v0-7)
+                         v0-7
+                         )
+                       )
+            )
+    )
+  )
+
+;; definition for method 31 of type dig-spikey-sphere
+;; WARN: Return type mismatch int vs none.
+(defmethod init-proj-settings! dig-spikey-sphere ((obj dig-spikey-sphere))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+       :virtual"
+  (with-pp
+    (set! (-> obj attack-mode) 'eco-dark)
+    (initialize-skeleton
+      obj
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-spikey-sphere" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (let ((t9-2 (method-of-type projectile-bounce init-proj-settings!)))
+      (t9-2 obj)
+      )
+    (set! (-> obj max-speed) 163840.0)
+    (set! (-> obj timeout) (seconds 8))
+    (logclear! (-> obj mask) (process-mask actor-pause))
+    (set! (-> obj notify-handle) (the-as handle #f))
+    (set! (-> obj update-velocity) spikey-sphere-update-velocity)
+    (set! (-> obj max-hits) #xffff)
+    (set! (-> obj move) spikey-sphere-move)
+    (set-vector! (-> obj root-override quat) 0.0 0.0 0.0 1.0)
+    (set! (-> obj pad-i1hb23h1b) (+ -204800.0 (-> obj root-override trans y)))
+    (let ((v1-16 (-> obj starting-dir)))
+      (quaternion-axis-angle!
+        (-> obj tumble-quat)
+        (-> v1-16 z)
+        (-> v1-16 y)
+        (-> v1-16 x)
+        (* -65536.0 (-> pp clock seconds-per-frame))
+        )
+      )
+    (set! (-> obj draw light-index) (the-as uint 4))
+    (sound-play "spikey-roll")
+    0
+    (none)
+    )
+  )
+
+;; definition of type dig-spikey-sphere-door
+(deftype dig-spikey-sphere-door (process-drawable)
+  ((sync      sync-linear :inline :offset-assert 200)
+   (prev-sync float               :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xdc
+  :flag-assert         #x16006000dc
+  (:methods
+    (idle () _type_ :state 20)
+    (active () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type dig-spikey-sphere-door
+(defmethod inspect dig-spikey-sphere-door ((obj dig-spikey-sphere-door))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tsync: #<sync-linear @ #x~X>~%" (-> obj sync))
+  (format #t "~2Tprev-sync: ~f~%" (-> obj prev-sync))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-spikey-sphere-door dig-spikey-sphere-door dig-spikey-sphere-door-lod0-jg dig-spikey-sphere-door-idle-ja
+              ((dig-spikey-sphere-door-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -4 0 7)
+              :origin-joint-index 4
+              )
+
+;; failed to figure out what this is:
+(defstate idle (dig-spikey-sphere-door)
+  :virtual #t
+  :trans (behavior ()
+    (let ((f30-0 (-> self prev-sync))
+          (f0-0 (get-norm! (-> self sync) 0))
+          )
+      (set! (-> self prev-sync) f0-0)
+      (if (< f0-0 f30-0)
+          (go-virtual active)
+          )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-spikey-sphere-door) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate active (dig-spikey-sphere-door)
+  :virtual #t
+  :code (behavior ()
+    (sound-play "spikey-door")
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.1))
+        (suspend)
+        )
+      )
+    (let ((gp-2 (new 'stack-no-clear 'vector))
+          (s5-1 (new 'static 'vector :x -16384.0 :y -16384.0))
+          )
+      (vector-z-quaternion! gp-2 (-> self root quat))
+      (let ((v1-7 (new 'stack-no-clear 'projectile-init-by-other-params)))
+        (set! (-> v1-7 ent) (-> self entity))
+        (set! (-> v1-7 charge) 1.0)
+        (set! (-> v1-7 options) (projectile-options))
+        (set! (-> v1-7 notify-handle) (the-as handle #f))
+        (set! (-> v1-7 owner-handle) (the-as handle #f))
+        (set! (-> v1-7 ignore-handle) (process->handle self))
+        (let* ((a0-8 *game-info*)
+               (a1-6 (+ (-> a0-8 attack-id) 1))
+               )
+          (set! (-> a0-8 attack-id) a1-6)
+          (set! (-> v1-7 attack-id) a1-6)
+          )
+        (set! (-> v1-7 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+        (vector+! (-> v1-7 pos) (-> self root trans) s5-1)
+        (vector-float*! (-> v1-7 vel) gp-2 163840.0)
+        (spawn-projectile
+          dig-spikey-sphere
+          (the-as projectile-init-by-other-params (&-> v1-7 ent))
+          self
+          *default-dead-pool*
+          )
+        )
+      )
+    (ja-no-eval :group! (ja-group)
+                :num! (seek! (the float (+ (-> (ja-group) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (go-virtual idle)
+    (none)
+    )
+  :post (the-as (function none :behavior dig-spikey-sphere-door) ja-post)
+  )
+
+;; definition for method 11 of type dig-spikey-sphere-door
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-spikey-sphere-door ((obj dig-spikey-sphere-door) (arg0 entity-actor))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-dig-spikey-sphere-door" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (let ((a1-5 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-4 0))
+      (if #f
+          (set! v1-4 (logior v1-4 1))
+          )
+      (set! (-> a1-5 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-5 sync-flags) (the-as sync-flags v1-4))
+      )
+    (set! (-> a1-5 entity) arg0)
+    (set! (-> a1-5 period) (the-as uint 1200))
+    (set! (-> a1-5 percent) 0.0)
+    (initialize! (-> obj sync) a1-5)
+    )
+  (set! (-> obj prev-sync) (get-norm! (-> obj sync) 0))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj draw light-index) (the-as uint 3))
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-balloon-lurker-trapeze dig-balloon-lurker dig-balloon-lurker-trapeze-lod0-jg dig-balloon-lurker-trapeze-jak-off-ja
+              ((dig-balloon-lurker-trapeze-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 20)
+              :shadow dig-balloon-lurker-trapeze-shadow-mg
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-balloon-lurker dig-balloon-lurker dig-balloon-lurker-lod0-jg dig-balloon-lurker-idle-ja
+              ((dig-balloon-lurker-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 8 0 16)
+              )
+
+;; definition of type dig-balloon-lurker
+(deftype dig-balloon-lurker (process-drawable)
+  ((init-quat        quaternion    :inline :offset-assert 208)
+   (sync             sync-eased    :inline :offset-assert 224)
+   (swing-sync       sync-linear   :inline :offset-assert 272)
+   (smush            smush-control :inline :offset-assert 288)
+   (pov-cam-offset   vector        :inline :offset-assert 320)
+   (options          int32                 :offset-assert 336)
+   (bouncing         basic                 :offset-assert 340)
+   (bounce-scale     meters                :offset-assert 344)
+   (bob-counter      float                 :offset-assert 348)
+   (forward-backward basic                 :offset-assert 352)
+   (grabbed          basic                 :offset-assert 356)
+   (trapeze-grabbed  basic                 :offset-assert 360)
+   (pedal-anim-frame float                 :offset-assert 364)
+   (pedal-anim-speed float                 :offset-assert 368)
+   (pedal-sound-id   uint32                :offset-assert 372)
+   )
+  :heap-base #x100
+  :method-count-assert 21
+  :size-assert         #x178
+  :flag-assert         #x1501000178
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type dig-balloon-lurker
+(defmethod inspect dig-balloon-lurker ((obj dig-balloon-lurker))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tinit-quat: #<quaternion @ #x~X>~%" (-> obj init-quat))
+  (format #t "~2Tsync: #<sync-eased @ #x~X>~%" (-> obj sync))
+  (format #t "~2Tswing-sync: #<sync-linear @ #x~X>~%" (-> obj swing-sync))
+  (format #t "~2Tsmush: #<smush-control @ #x~X>~%" (-> obj smush))
+  (format #t "~2Tpov-cam-offset: #<vector @ #x~X>~%" (-> obj pov-cam-offset))
+  (format #t "~2Toptions: ~D~%" (-> obj options))
+  (format #t "~2Tbouncing: ~A~%" (-> obj bouncing))
+  (format #t "~2Tbounce-scale: (meters ~m)~%" (-> obj bounce-scale))
+  (format #t "~2Tbob-counter: ~f~%" (-> obj bob-counter))
+  (format #t "~2Tforward-backward: ~A~%" (-> obj forward-backward))
+  (format #t "~2Tgrabbed: ~A~%" (-> obj grabbed))
+  (format #t "~2Ttrapeze-grabbed: ~A~%" (-> obj trapeze-grabbed))
+  (format #t "~2Tpedal-anim-frame: ~f~%" (-> obj pedal-anim-frame))
+  (format #t "~2Tpedal-anim-speed: ~f~%" (-> obj pedal-anim-speed))
+  (format #t "~2Tpedal-sound-id: ~D~%" (-> obj pedal-sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type dig-balloon-lurker-trapeze
+(deftype dig-balloon-lurker-trapeze (process-drawable)
+  ((parent-ptr       (pointer dig-balloon-lurker)  :offset         16)
+   (swing-type       float                         :offset-assert 200)
+   (swing-pole       (pointer swingpole)           :offset-assert 204)
+   (swing-anim-frame float                         :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 22
+  :size-assert         #xd4
+  :flag-assert         #x16006000d4
+  (:methods
+    (idle () _type_ :state 20)
+    (dig-balloon-lurker-trapeze-method-21 (_type_) none 21)
+    )
+  )
+
+;; definition for method 3 of type dig-balloon-lurker-trapeze
+(defmethod inspect dig-balloon-lurker-trapeze ((obj dig-balloon-lurker-trapeze))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tswing-type: ~f~%" (-> obj swing-type))
+  (format #t "~2Tswing-pole: #x~X~%" (-> obj swing-pole))
+  (format #t "~2Tswing-anim-frame: ~f~%" (-> obj swing-anim-frame))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for function dig-balloon-lurker-trapeze-init-by-other
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-balloon-lurker-trapeze-init-by-other dig-balloon-lurker-trapeze ((arg0 entity-actor))
+  (set! (-> self root) (new 'process 'trsqv))
+  (process-drawable-from-entity! self arg0)
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-dig-balloon-lurker-trapeze" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (set! (-> self swing-type) 0.0)
+  (set! (-> self swing-pole) (process-spawn swingpole :init swingpole-init 11 :to self))
+  (set! (-> self swing-anim-frame) 0.0)
+  (set! (-> self draw shadow-ctrl) (new
+                                     'process
+                                     'shadow-control
+                                     0.0
+                                     0.0
+                                     614400.0
+                                     (shadow-flags disable-fade shdf02 shdf03 shdf04 shdf07)
+                                     491520.0
+                                     )
+        )
+  (go-virtual idle)
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-balloon-lurker-trapeze)
+  :virtual #t
+  :code (behavior ()
+    (ja-channel-push! 2 0)
+    (ja :group! (-> self draw art-group data 6) :num! min)
+    (ja :chan 1 :group! (-> self draw art-group data 7) :num! min)
+    (until #f
+      (ja :num-func num-func-identity :frame-num (-> self swing-anim-frame))
+      (let ((a0-4 (-> self skel root-channel 1)))
+        (let ((f0-4 (* 0.6 (-> self swing-type))))
+          (set! (-> a0-4 frame-interp 1) f0-4)
+          (set! (-> a0-4 frame-interp 0) f0-4)
+          )
+        (set! (-> a0-4 param 0) 0.0)
+        (joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-chan)
+        )
+      (let* ((f30-0 (the float (ja-num-frames 0)))
+             (f0-10
+               (+ (* 1.5 f30-0 (get-norm! (-> self parent-ptr 0 swing-sync) 0)) (if (= (-> self parent-ptr 0 options) 1)
+                                                                                    (* 0.5 f30-0)
+                                                                                    0.0
+                                                                                    )
+                  )
+               )
+             )
+        (set! (-> self swing-anim-frame) (- f0-10 (* (the float (the int (/ f0-10 f30-0))) f30-0)))
+        )
+      (set! (-> self root trans quad) (-> self parent-ptr 0 root trans quad))
+      (quaternion-copy! (-> self root quat) (-> self parent-ptr 0 root quat))
+      (let ((v1-36 (and (-> self swing-pole 0 next-state) (= (-> self swing-pole 0 next-state name) 'active))))
+        (set! (-> self parent-ptr 0 trapeze-grabbed) (the-as basic v1-36))
+        )
+      (seek!
+        (-> self swing-type)
+        (if (-> self parent-ptr 0 trapeze-grabbed)
+            1.0
+            0.0
+            )
+        (* 0.02 (-> self clock time-adjust-ratio))
+        )
+      (dig-balloon-lurker-trapeze-method-21 self)
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior dig-balloon-lurker-trapeze) ja-post)
+  )
+
+;; definition for method 21 of type dig-balloon-lurker-trapeze
+;; WARN: Return type mismatch int vs none.
+(defmethod dig-balloon-lurker-trapeze-method-21 dig-balloon-lurker-trapeze ((obj dig-balloon-lurker-trapeze))
+  (cond
+    ((and (-> obj draw shadow)
+          (zero? (-> obj draw cur-lod))
+          (logtest? (-> obj draw status) (draw-control-status on-screen))
+          )
+     (let ((s5-0 (new 'stack-no-clear 'collide-query)))
+       (vector<-cspace! (-> s5-0 start-pos) (-> obj node-list data 11))
+       (set! (-> s5-0 start-pos y) (+ -24576.0 (-> obj root trans y)))
+       (set-vector! (-> s5-0 move-dist) 0.0 -34816.0 0.0 1.0)
+       (let ((v1-10 s5-0))
+         (set! (-> v1-10 radius) 8192.0)
+         (set! (-> v1-10 collide-with) (collide-spec backgnd))
+         (set! (-> v1-10 ignore-process0) obj)
+         (set! (-> v1-10 ignore-process1) #f)
+         (set! (-> v1-10 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+         (set! (-> v1-10 action-mask) (collide-action solid))
+         )
+       (cond
+         ((>= (fill-and-probe-using-line-sphere *collide-cache* s5-0) 0.0)
+          (-> s5-0 best-other-tri intersect)
+          (let ((v1-15 (-> obj draw shadow-ctrl)))
+            (logclear! (-> v1-15 settings flags) (shadow-flags disable-draw))
+            )
+          0
+          (let ((v1-18 (-> obj draw shadow-ctrl)))
+            (set! (-> v1-18 settings bot-plane w) (- (+ -6144.0 (-> s5-0 best-other-tri intersect y))))
+            )
+          0
+          (let ((v1-21 (-> obj draw shadow-ctrl)))
+            (set! (-> v1-21 settings top-plane w) (- (+ 6144.0 (-> s5-0 best-other-tri intersect y))))
+            )
+          0
+          (let* ((f1-4 (vector-vector-distance (-> s5-0 best-other-tri intersect) (-> obj root trans)))
+                 (f0-15 (* 0.000030517578 (fmin 32768.0 (fmax 0.0 (+ -57344.0 f1-4)))))
+                 )
+            (set! (-> obj draw shadow-ctrl settings shadow-dir w) (lerp 409600.0 40960.0 f0-15))
+            )
+          )
+         (else
+           (let ((v1-31 (-> obj draw shadow-ctrl)))
+             (logior! (-> v1-31 settings flags) (shadow-flags disable-draw))
+             )
+           0
+           )
+         )
+       )
+     )
+    (else
+      (let ((v1-34 (-> obj draw shadow-ctrl)))
+        (logior! (-> v1-34 settings flags) (shadow-flags disable-draw))
+        )
+      0
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for method 11 of type dig-balloon-lurker
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-balloon-lurker ((obj dig-balloon-lurker) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 3) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 4))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec crate))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 0)
+      (set-vector! (-> s3-0 local-sphere) 0.0 61440.0 0.0 61440.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-8 prim-core action) (collide-action solid))
+      (set! (-> v1-8 transform-index) 3)
+      (set-vector! (-> v1-8 local-sphere) 0.0 4096.0 0.0 28672.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-10 prim-core action) (collide-action solid))
+      (set! (-> v1-10 transform-index) 3)
+      (set-vector! (-> v1-10 local-sphere) 0.0 4096.0 36864.0 16384.0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 3)
+      (set-vector! (-> v1-12 local-sphere) 0.0 4096.0 -36864.0 20480.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-15 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-15 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-15 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-balloon-lurker" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (process-spawn dig-balloon-lurker-trapeze arg0 :to obj)
+  (quaternion-copy! (-> obj init-quat) (-> obj root quat))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj options) (res-lump-value arg0 'options int :time -1000000000.0))
+  (set! (-> obj path) (new 'process 'curve-control obj 'path -1000000000.0))
+  (set! (-> obj bouncing) #f)
+  (set! (-> obj bounce-scale) 1228.8)
+  (set! (-> obj bob-counter) (if (= (-> obj options) 1)
+                                 145.0
+                                 0.0
+                                 )
+        )
+  (set! (-> obj forward-backward) #f)
+  (set! (-> obj grabbed) #f)
+  (set! (-> obj trapeze-grabbed) #f)
+  (set! (-> obj pedal-anim-frame) 0.0)
+  (set! (-> obj pedal-anim-speed) 0.5)
+  (set-vector! (-> obj pov-cam-offset) 0.0 -20480.0 0.0 1.0)
+  (set! (-> obj pedal-sound-id) (the-as uint (new-sound-id)))
+  (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+  (let ((a1-23 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-39 0))
+      (if #t
+          (set! v1-39 (logior v1-39 1))
+          )
+      (set! (-> a1-23 sync-type) (the-as basic 'sync-eased))
+      (set! (-> a1-23 sync-flags) (the-as sync-flags v1-39))
+      )
+    (set! (-> a1-23 period) (the-as uint 3600))
+    (set! (-> a1-23 entity) arg0)
+    (set! (-> a1-23 percent) 0.0)
+    (set! (-> a1-23 ease-in) 0.15)
+    (set! (-> a1-23 ease-out) 0.15)
+    (set! (-> a1-23 pause-in) 0.0)
+    (set! (-> a1-23 pause-out) 0.0)
+    (initialize! (-> obj sync) a1-23)
+    )
+  (let ((a1-24 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-46 0))
+      (if #t
+          (set! v1-46 (logior v1-46 1))
+          )
+      (set! (-> a1-24 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-24 sync-flags) (the-as sync-flags v1-46))
+      )
+    (set! (-> a1-24 entity) arg0)
+    (set! (-> a1-24 period) (the-as uint 3600))
+    (set! (-> a1-24 percent) 0.0)
+    (initialize! (-> obj swing-sync) a1-24)
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition for method 10 of type dig-balloon-lurker
+(defmethod deactivate dig-balloon-lurker ((obj dig-balloon-lurker))
+  (sound-stop (the-as sound-id (-> obj pedal-sound-id)))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-balloon-lurker)
+  :virtual #t
+  :code (behavior ()
+    (until #f
+      (let ((f30-0 (get-norm! (-> self sync) 0)))
+        (cond
+          ((-> self forward-backward)
+           (if (< 0.9 f30-0)
+               (set! (-> self forward-backward) #f)
+               )
+           )
+          (else
+            (if (< f30-0 0.1)
+                (set! (-> self forward-backward) (the-as basic #t))
+                )
+            )
+          )
+        (seek!
+          (-> self pedal-anim-speed)
+          (if (-> self forward-backward)
+              -0.5
+              0.5
+              )
+          (* 0.01 (-> self clock time-adjust-ratio))
+          )
+        (let ((f0-7 (+ -1.0 (fabs (* 2.0 (-> self pedal-anim-speed)))))
+              (f1-5 (* 2.0 (fabs (-> self pedal-anim-speed))))
+              )
+          (sound-play-by-name
+            (static-sound-name "balon-lurk-loop")
+            (the-as sound-id (-> self pedal-sound-id))
+            (the int (* 1024.0 f1-5))
+            (the int (* 1524.0 f0-7))
+            0
+            (sound-group sfx)
+            #t
+            )
+          )
+        (ja :num-func num-func-identity :frame-num (-> self pedal-anim-frame))
+        (+! (-> self pedal-anim-frame) (* (-> self pedal-anim-speed) (-> self clock time-adjust-ratio)))
+        (cond
+          ((>= (-> self pedal-anim-frame) (the float (ja-num-frames 0)))
+           (set! (-> self pedal-anim-frame) (- (-> self pedal-anim-frame) (the float (ja-num-frames 0))))
+           )
+          ((< (-> self pedal-anim-frame) 0.0)
+           (+! (-> self pedal-anim-frame) (the float (ja-num-frames 0)))
+           )
+          )
+        (cond
+          ((-> self trapeze-grabbed)
+           (when (not (-> self grabbed))
+             (set-setting! 'mode-name 'cam-pov-track 0 0)
+             (let ((v1-33 (process->ppointer self)))
+               (set-setting! 'pov-handle v1-33 #x40400000 (-> v1-33 0 pid))
+               )
+             (set! (-> self pov-cam-offset z)
+                   (if (< 0.0 (vector-dot (-> self node-list data 0 bone transform vector 2) (-> (camera-matrix) vector 2)))
+                       -81920.0
+                       81920.0
+                       )
+                   )
+             (set-setting! 'pov-offset 'asdf (-> self pov-cam-offset) 0)
+             (set! (-> self grabbed) (the-as basic #t))
+             )
+           (when (not (-> self bouncing))
+             (activate! (-> self smush) -1.0 210 600 1.0 1.0 (-> self clock))
+             (set! (-> self bouncing) (the-as basic #t))
+             (cond
+               ((< (-> self bob-counter) 90.0)
+                (set! (-> self bob-counter) (- 180.0 (-> self bob-counter)))
+                )
+               ((< 270.0 (-> self bob-counter))
+                (set! (-> self bob-counter) (- 540.0 (-> self bob-counter)))
+                )
+               )
+             )
+           (seek! (-> self bob-counter) 270.0 (* 3.0 (-> self clock time-adjust-ratio)))
+           )
+          (else
+            (when (-> self grabbed)
+              (remove-setting! 'pov-handle)
+              (remove-setting! 'mode-name)
+              (remove-setting! 'pov-offset)
+              (set! (-> self grabbed) #f)
+              )
+            (+! (-> self bob-counter) (* 3.0 (-> self clock time-adjust-ratio)))
+            (if (< 360.0 (-> self bob-counter))
+                (set! (-> self bob-counter) (+ -360.0 (-> self bob-counter)))
+                )
+            (if (not (!= (-> self smush amp) 0.0))
+                (set! (-> self bouncing) #f)
+                )
+            )
+          )
+        (get-point-at-percent-along-path! (-> self path) (-> self root trans) f30-0 'interp)
+        (+! (-> self root trans y) (+ (* 2048.0 (sin (* 182.04445 (the float (the int (-> self bob-counter))))))
+                                      (* (-> self bounce-scale) (update! (-> self smush)))
+                                      )
+            )
+        (when (= (-> self options) 1)
+          (let ((a2-12 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) *y-vector* (* 182.04445 (* 70.0 f30-0)))))
+            (quaternion*! (-> self root quat) (-> self init-quat) a2-12)
+            )
+          )
+        )
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior dig-balloon-lurker) transform-post)
+  )
+
+;; definition of type dig-wheel-step
+(deftype dig-wheel-step (process-drawable)
+  ((anim-speed     float   :offset-assert 200)
+   (wheel-sound-id uint32  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xd0
+  :flag-assert         #x15005000d0
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type dig-wheel-step
+(defmethod inspect dig-wheel-step ((obj dig-wheel-step))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tanim-speed: ~f~%" (-> obj anim-speed))
+  (format #t "~2Twheel-sound-id: ~D~%" (-> obj wheel-sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-wheel-step dig-wheel-step dig-wheel-step-lod0-jg dig-wheel-step-idle-ja
+              ((dig-wheel-step-lod0-mg (meters 999999)))
+              :bounds (static-spherem 2 0 0 14)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (dig-wheel-step)
+  :virtual #t
+  :trans (behavior ()
+    (sound-play "wheel-plat-loop" :id (the-as sound-id (-> self wheel-sound-id)))
+    (rider-trans)
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-no-eval :group! (ja-group)
+                  :num! (seek! (the float (+ (-> (ja-group) frames num-frames) -1)) (-> self anim-speed))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek! max (-> self anim-speed)))
+        )
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior dig-wheel-step) rider-post)
+  )
+
+;; definition for method 10 of type dig-wheel-step
+(defmethod deactivate dig-wheel-step ((obj dig-wheel-step))
+  (sound-stop (the-as sound-id (-> obj wheel-sound-id)))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 11 of type dig-wheel-step
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-wheel-step ((obj dig-wheel-step) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 3) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 4))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 8192.0 0.0 0.0 57344.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-11 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-11 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-11 transform-index) 4)
+      (set-vector! (-> v1-11 local-sphere) 24576.0 0.0 0.0 24576.0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-13 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-13 transform-index) 5)
+      (set-vector! (-> v1-13 local-sphere) 24576.0 0.0 0.0 24576.0)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 43008.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-18 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-18 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-18 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-wheel-step" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj wheel-sound-id) (the-as uint (new-sound-id)))
+  (set! (-> obj draw light-index) (the-as uint 5))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (let* ((a0-30 (-> obj entity))
+         (f0-18 ((method-of-object a0-30 get-property-value-float)
+                 a0-30
+                 'rotspeed
+                 'interp
+                 -1000000000.0
+                 8192.0
+                 (the-as (pointer res-tag) #f)
+                 *res-static-buf*
+                 )
+                )
+         )
+    (set! (-> obj anim-speed) (* 0.000015258789 f0-18))
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type dig-tipping-rock
+(deftype dig-tipping-rock (rigid-body-platform)
+  ((anchor-point      vector     :inline :offset-assert 384)
+   (last-ridden-time  time-frame         :offset-assert 400)
+   (surface-height    float              :offset-assert 408)
+   (bubbling-sound-id uint32             :offset-assert 412)
+   )
+  :heap-base #x120
+  :method-count-assert 57
+  :size-assert         #x1a0
+  :flag-assert         #x39012001a0
+  )
+
+;; definition for method 3 of type dig-tipping-rock
+(defmethod inspect dig-tipping-rock ((obj dig-tipping-rock))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type rigid-body-platform inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tanchor-point: #<vector @ #x~X>~%" (-> obj anchor-point))
+  (format #t "~2Tlast-ridden-time: ~D~%" (-> obj last-ridden-time))
+  (format #t "~2Tsurface-height: ~f~%" (-> obj surface-height))
+  (format #t "~2Tbubbling-sound-id: ~D~%" (-> obj bubbling-sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *dig-tipping-rock-constants*, type rigid-body-platform-constants
+(define *dig-tipping-rock-constants* (new 'static 'rigid-body-platform-constants
+                                       :mass 4.0
+                                       :inv-mass 0.25
+                                       :cm-joint-z (meters -6)
+                                       :cm-joint-w 1.0
+                                       :linear-damping 0.9
+                                       :angular-damping 0.48
+                                       :friction-factor 0.1
+                                       :inertial-tensor-x (meters 4)
+                                       :inertial-tensor-y (meters 3)
+                                       :inertial-tensor-z (meters 21)
+                                       :max-time-step 0.02
+                                       :gravity (meters 80)
+                                       :idle-distance (meters 50)
+                                       :attack-force-scale 1.0
+                                       :name '*dig-tipping-rock-constants*
+                                       :drag-factor 2.0
+                                       :buoyancy-factor 1.2
+                                       :max-buoyancy-depth (meters 2)
+                                       :player-weight (meters 80)
+                                       :player-bonk-factor 0.5
+                                       :player-dive-factor 1.0
+                                       :player-force-distance (meters 30)
+                                       :player-force-clamp (meters 1000000)
+                                       :player-force-timeout #x1e
+                                       :explosion-force (meters 1000)
+                                       :control-point-count 4
+                                       :platform #t
+                                       :sound-name "mud-plat"
+                                       )
+        )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-tipping-rock dig-tipping-rock dig-tipping-rock-lod0-jg dig-tipping-rock-idle-ja
+              ((dig-tipping-rock-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 14.5)
+              :origin-joint-index 3
+              )
+
+;; definition for method 37 of type dig-tipping-rock
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-37 dig-tipping-rock ((obj dig-tipping-rock))
+  (with-pp
+    (let ((t9-0 (method-of-type rigid-body-platform rigid-body-object-method-37)))
+      (t9-0 obj)
+      )
+    (cond
+      ((>= (- (-> pp clock frame-counter) (-> obj last-ridden-time)) (seconds 0.5))
+       (when (nonzero? (-> obj bubbling-sound-id))
+         (let ((v1-5 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
+           (set! (-> v1-5 command) (sound-command set-param))
+           (set! (-> v1-5 id) (the-as sound-id (-> obj bubbling-sound-id)))
+           (set! (-> v1-5 params volume) -4)
+           (set! (-> v1-5 auto-time) 120)
+           (set! (-> v1-5 auto-from) 2)
+           (set! (-> v1-5 params mask) (the-as uint 17))
+           (-> v1-5 id)
+           )
+         (set! (-> obj bubbling-sound-id) (the-as uint 0))
+         0
+         )
+       )
+      (else
+        (if (zero? (-> obj bubbling-sound-id))
+            (set! (-> obj bubbling-sound-id) (the-as uint (sound-play "lava-plat-tip")))
+            )
+        )
+      )
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-tipping-rock)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('ridden)
+       (set! (-> self last-ridden-time) (-> self clock frame-counter))
+       )
+      )
+    (the-as object (rigid-body-object-event-handler proc arg1 event-type event))
+    )
+  :trans (the-as (function none :behavior dig-tipping-rock) rider-trans)
+  :code (the-as (function none :behavior dig-tipping-rock) sleep-code)
+  :post (behavior ()
+    (rigid-body-object-method-37 self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate active (dig-tipping-rock)
+  :virtual #t
+  :event (-> (method-of-type dig-tipping-rock idle) event)
+  )
+
+;; definition for method 29 of type dig-tipping-rock
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-29 dig-tipping-rock ((obj dig-tipping-rock) (arg0 float))
+  ((the-as (function rigid-body-platform float none) (find-parent-method dig-tipping-rock 29)) obj arg0)
+  (rigid-body-platform-method-56 obj (-> obj anchor-point))
+  0
+  (none)
+  )
+
+;; definition for method 32 of type dig-tipping-rock
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-32 dig-tipping-rock ((obj dig-tipping-rock))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 3)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 4096.0 59392.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 53 of type dig-tipping-rock
+(defmethod rigid-body-platform-method-53 dig-tipping-rock ((obj dig-tipping-rock) (arg0 vector))
+  (-> obj surface-height)
+  )
+
+;; definition for method 33 of type dig-tipping-rock
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-33 dig-tipping-rock ((obj dig-tipping-rock))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-tipping-rock" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (quaternion-rotate-local-x! (-> obj root-override-2 quat) (-> obj root-override-2 quat) -2555.2202)
+  (rigid-body-object-method-31 obj *dig-tipping-rock-constants*)
+  (set! (-> obj anchor-point quad) (-> obj rbody state position quad))
+  (let ((v1-8 (-> obj control-point-array)))
+    (let ((a0-8 (-> v1-8 data)))
+      (set! (-> a0-8 0 local-pos x) 0.0)
+      (set! (-> a0-8 0 local-pos y) 0.0)
+      (set! (-> a0-8 0 local-pos z) -8192.0)
+      (set! (-> a0-8 0 local-pos w) 1.0)
+      )
+    (let ((a0-9 (-> v1-8 data 1)))
+      (set! (-> a0-9 local-pos x) 0.0)
+      (set! (-> a0-9 local-pos y) 8192.0)
+      (set! (-> a0-9 local-pos z) -40960.0)
+      (set! (-> a0-9 local-pos w) 1.0)
+      )
+    (let ((a0-10 (-> v1-8 data 2)))
+      (set! (-> a0-10 local-pos x) 40960.0)
+      (set! (-> a0-10 local-pos y) 4096.0)
+      (set! (-> a0-10 local-pos z) -24576.0)
+      (set! (-> a0-10 local-pos w) 1.0)
+      )
+    (let ((v1-9 (-> v1-8 data 3)))
+      (set! (-> v1-9 local-pos x) -40960.0)
+      (set! (-> v1-9 local-pos y) 4096.0)
+      (set! (-> v1-9 local-pos z) -24576.0)
+      (set! (-> v1-9 local-pos w) 1.0)
+      )
+    )
+  (set! (-> obj surface-height) (+ 6144.0 (-> obj root-override-2 trans y)))
+  (set! (-> obj bubbling-sound-id) (the-as uint 0))
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-wall-bouncer dig-wall-bouncer 0 2
+              ((1 (meters 999999)))
+              :bounds (static-spherem 0 1 4 5.5)
+              )
+
+;; definition of type dig-wall-bouncer
+(deftype dig-wall-bouncer (bouncer)
+  ()
+  :heap-base #x60
+  :method-count-assert 25
+  :size-assert         #xd4
+  :flag-assert         #x19006000d4
+  )
+
+;; definition for method 3 of type dig-wall-bouncer
+(defmethod inspect dig-wall-bouncer ((obj dig-wall-bouncer))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type bouncer inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 23 of type dig-wall-bouncer
+;; WARN: Return type mismatch int vs none.
+(defmethod init-skeleton! dig-wall-bouncer ((obj dig-wall-bouncer))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-wall-bouncer" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 24 of type dig-wall-bouncer
+;; WARN: Return type mismatch int vs none.
+(defmethod bouncer-method-24 dig-wall-bouncer ((obj dig-wall-bouncer))
+  "TODO - collision stuff"
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 5) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 6))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec crate))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set! (-> s4-0 transform-index) 0)
+      (set-vector! (-> s4-0 local-sphere) 0.0 4096.0 16384.0 22528.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-8 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 1))))
+      (set! (-> v1-8 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-8 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-8 prim-core action) (collide-action solid))
+      (set! (-> v1-8 transform-index) 0)
+      (set-vector! (-> v1-8 local-sphere) 0.0 6144.0 16384.0 16384.0)
+      )
+    (let ((v1-10 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 3) (the-as uint 2))))
+      (set! (-> v1-10 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-10 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-10 prim-core action) (collide-action solid))
+      (set! (-> v1-10 transform-index) 0)
+      (set-vector! (-> v1-10 local-sphere) 0.0 4096.0 28672.0 12288.0)
+      )
+    (let ((v1-12 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 2))))
+      (set! (-> v1-12 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-12 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-12 prim-core action) (collide-action solid))
+      (set! (-> v1-12 transform-index) 0)
+      (set-vector! (-> v1-12 local-sphere) 12288.0 4096.0 16384.0 20480.0)
+      )
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 2) (the-as uint 2))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 0)
+      (set-vector! (-> v1-14 local-sphere) -12288.0 4096.0 16384.0 20480.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 4))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec crate))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-16 prim-core action) (collide-action))
+      (set! (-> v1-16 transform-index) 3)
+      (set-vector! (-> v1-16 local-sphere) 0.0 18432.0 16384.0 16384.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-19 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-19 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-19 prim-core collide-with))
+      )
+    (set! (-> obj root) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition of type dig-stomp-block
+(deftype dig-stomp-block (rigid-body-object)
+  ((desty float  :offset-assert 272)
+   (flag  basic  :offset-assert 276)
+   )
+  :heap-base #xa0
+  :method-count-assert 55
+  :size-assert         #x118
+  :flag-assert         #x3700a00118
+  (:methods
+    (waiting () _type_ :state 53)
+    (hit () _type_ :state 54)
+    )
+  )
+
+;; definition for method 3 of type dig-stomp-block
+(defmethod inspect dig-stomp-block ((obj dig-stomp-block))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type rigid-body-object inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tdesty: ~f~%" (-> obj desty))
+  (format #t "~2Tflag: ~A~%" (-> obj flag))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-stomp-block dig-stomp-block dig-stomp-block-lod0-jg dig-stomp-block-idle-ja
+              ((dig-stomp-block-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -3 0 5.5)
+              )
+
+;; definition for symbol *dig-stomp-block-constants*, type rigid-body-object-constants
+(define *dig-stomp-block-constants* (new 'static 'rigid-body-object-constants
+                                      :mass 1.0
+                                      :inv-mass 1.0
+                                      :cm-joint-w 1.0
+                                      :linear-damping 0.99
+                                      :angular-damping 0.9
+                                      :bounce-factor 0.5
+                                      :friction-factor 0.1
+                                      :inertial-tensor-x (meters 1)
+                                      :inertial-tensor-y (meters 3)
+                                      :inertial-tensor-z (meters 1)
+                                      :max-time-step 0.02
+                                      :gravity (meters 80)
+                                      :idle-distance (meters 200)
+                                      :attack-force-scale 1.0
+                                      :name '*dig-stomp-block-constants*
+                                      )
+        )
+
+;; failed to figure out what this is:
+(defstate waiting (dig-stomp-block)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('set-flag)
+       (let ((v0-0 (the-as object #t)))
+         (set! (-> self flag) (the-as basic v0-0))
+         v0-0
+         )
+       )
+      (('clear-flag)
+       (set! (-> self flag) #f)
+       #f
+       )
+      (('attack)
+       (case (-> (the-as attack-info (-> event param 1)) mode)
+         (('flop)
+          (when (not (-> self flag))
+            (set! (-> self desty) (+ -12288.0 (-> self root-override-2 trans y)))
+            (send-event (ppointer->process (-> self parent)) 'set-flag)
+            (go-virtual hit)
+            'solid
+            )
+          )
+         )
+       )
+      (('broken)
+       (go-virtual active)
+       )
+      )
+    )
+  :code (the-as (function none :behavior dig-stomp-block) sleep-code)
+  :post (the-as (function none :behavior dig-stomp-block) ja-post)
+  )
+
+;; failed to figure out what this is:
+(defstate hit (dig-stomp-block)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('broken)
+       (go-virtual active)
+       )
+      )
+    )
+  :code (behavior ()
+    (sound-play "stomp-block")
+    (while (< (-> self desty) (-> self root-override-2 trans y))
+      (set! (-> self root-override-2 trans y) (seek-with-smooth
+                                                (-> self root-override-2 trans y)
+                                                (-> self desty)
+                                                (* 24576.0 (-> self clock seconds-per-frame))
+                                                0.25
+                                                1.0
+                                                )
+            )
+      (suspend)
+      )
+    (set! (-> self flag) #f)
+    (send-event (ppointer->process (-> self parent)) 'clear-flag)
+    (go-virtual waiting)
+    (none)
+    )
+  :post (the-as (function none :behavior dig-stomp-block) transform-post)
+  )
+
+;; failed to figure out what this is:
+(defstate active (dig-stomp-block)
+  :virtual #t
+  :enter (behavior ()
+    (rigid-body-object-method-38 self)
+    (let ((s5-0 (new 'stack-no-clear 'vector))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> s5-0 x) (rand-vu-float-range -40960.0 40960.0))
+      (set! (-> s5-0 y) (rand-vu-float-range -40960.0 0.0))
+      (set! (-> s5-0 z) (rand-vu-float-range -40960.0 40960.0))
+      (vector-float*! (-> self rbody state lin-momentum) s5-0 (-> self info mass))
+      (set! (-> gp-0 x) (rand-vu-float-range -10000.0 10000.0))
+      (set! (-> gp-0 y) (rand-vu-float-range -10000.0 10000.0))
+      (set! (-> gp-0 z) (rand-vu-float-range -10000.0 10000.0))
+      (vector-float*! (-> self rbody state ang-momentum) gp-0 (-> self info mass))
+      )
+    (none)
+    )
+  )
+
+;; definition for method 37 of type dig-stomp-block
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-37 dig-stomp-block ((obj dig-stomp-block))
+  (with-pp
+    (let ((a1-0 (new 'stack-no-clear 'collide-query)))
+      (set! (-> a1-0 start-pos quad) (-> obj rbody state position quad))
+      (vector-float*! (-> a1-0 move-dist) (-> obj rbody state lin-velocity) (-> pp clock seconds-per-frame))
+      (let ((v1-3 a1-0))
+        (set! (-> v1-3 radius) (+ 4096.0 (-> obj root-override-2 root-prim local-sphere w)))
+        (set! (-> v1-3 collide-with) (-> obj root-override-2 root-prim prim-core collide-with))
+        (set! (-> v1-3 ignore-process0) obj)
+        (set! (-> v1-3 ignore-process1) #f)
+        (set! (-> v1-3 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+        (set! (-> v1-3 action-mask) (collide-action solid))
+        )
+      (fill-using-line-sphere *collide-cache* a1-0)
+      )
+    (let* ((a0-15 *collide-cache*)
+           (v1-6 (the-as object (-> a0-15 tris)))
+           )
+      (countdown (a0-16 (-> a0-15 num-tris))
+        (when (= (-> (the-as collide-cache-tri v1-6) pat event) (pat-event endlessfall))
+          (set! (-> (the-as collide-cache-tri v1-6) vertex 0 y)
+                (+ 409600.0 (-> (the-as collide-cache-tri v1-6) vertex 0 y))
+                )
+          (set! (-> (the-as collide-cache-tri v1-6) vertex 1 y)
+                (+ 409600.0 (-> (the-as collide-cache-tri v1-6) vertex 1 y))
+                )
+          (set! (-> (the-as collide-cache-tri v1-6) vertex 2 y)
+                (+ 409600.0 (-> (the-as collide-cache-tri v1-6) vertex 2 y))
+                )
+          )
+        (set! v1-6 (-> (the-as (inline-array collide-cache-tri) v1-6) 1))
+        )
+      )
+    (if *display-collide-cache*
+        (debug-draw *collide-cache*)
+        )
+    (rigid-body-object-method-30 obj)
+    (set! (-> obj root-override-2 transv quad) (-> obj rbody state lin-velocity quad))
+    (quaternion-copy! (-> obj root-override-2 quat) (-> obj rbody state rotation))
+    (rigid-body-method-24 (-> obj rbody state))
+    (let ((v1-22 (-> obj rbody))
+          (a1-8 (-> obj root-override-2 trans))
+          )
+      (rigid-body-method-23 (-> v1-22 state) a1-8)
+      )
+    (set! (-> obj node-list data 0 bone transform trans quad) (-> obj root-override-2 trans quad))
+    (transform-post)
+    0
+    (none)
+    )
+  )
+
+;; definition for method 32 of type dig-stomp-block
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-32 dig-stomp-block ((obj dig-stomp-block))
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 9) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 10))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak obstacle hit-by-others-list player-list pusher)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 -12288.0 0.0 22528.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 0)
+      (set-vector! (-> v1-14 local-sphere) -6144.0 -6144.0 -6144.0 6144.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid))
+      (set! (-> v1-16 transform-index) 0)
+      (set-vector! (-> v1-16 local-sphere) -6144.0 -6144.0 6144.0 6144.0)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-18 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-18 prim-core action) (collide-action solid))
+      (set! (-> v1-18 transform-index) 0)
+      (set-vector! (-> v1-18 local-sphere) 6144.0 -6144.0 -6144.0 6144.0)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-20 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-20 prim-core action) (collide-action solid))
+      (set! (-> v1-20 transform-index) 0)
+      (set-vector! (-> v1-20 local-sphere) 6144.0 -6144.0 6144.0 6144.0)
+      )
+    (let ((v1-22 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-22 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-22 prim-core action) (collide-action solid))
+      (set! (-> v1-22 transform-index) 0)
+      (set-vector! (-> v1-22 local-sphere) -6144.0 -18432.0 -6144.0 6144.0)
+      )
+    (let ((v1-24 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-24 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-24 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-24 prim-core action) (collide-action solid))
+      (set! (-> v1-24 transform-index) 0)
+      (set-vector! (-> v1-24 local-sphere) -6144.0 -18432.0 6144.0 6144.0)
+      )
+    (let ((v1-26 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-26 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-26 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-26 prim-core action) (collide-action solid))
+      (set! (-> v1-26 transform-index) 0)
+      (set-vector! (-> v1-26 local-sphere) 6144.0 -18432.0 -6144.0 6144.0)
+      )
+    (let ((v1-28 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-28 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-28 prim-core collide-with) (collide-spec backgnd obstacle hit-by-others-list))
+      (set! (-> v1-28 prim-core action) (collide-action solid))
+      (set! (-> v1-28 transform-index) 0)
+      (set-vector! (-> v1-28 local-sphere) 6144.0 -18432.0 6144.0 6144.0)
+      )
+    (let ((v1-30 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-30 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-30 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-30 prim-core action) (collide-action solid))
+      (set! (-> v1-30 transform-index) 3)
+      (set-vector! (-> v1-30 local-sphere) 0.0 -12288.0 0.0 22528.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-33 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-33 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-33 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override-2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 33 of type dig-stomp-block
+;; WARN: Return type mismatch int vs none.
+(defmethod rigid-body-object-method-33 dig-stomp-block ((obj dig-stomp-block))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-stomp-block" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (rigid-body-object-method-31 obj *dig-stomp-block-constants*)
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logior! (-> obj rbody state flags) (rigid-body-flag enable-collision))
+  (set! (-> obj draw light-index) (the-as uint 10))
+  (set! (-> obj flag) #f)
+  0
+  (none)
+  )
+
+;; definition for function dig-stomp-block-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior dig-stomp-block-init-by-other dig-stomp-block ((arg0 vector))
+  (set! (-> self mask) (logior (process-mask platform) (-> self mask)))
+  (rigid-body-object-method-32 self)
+  (set! (-> self root-override-2 trans quad) (-> arg0 quad))
+  (set-vector! (-> self root-override-2 quat) 0.0 1.0 0.0 0.0)
+  (rigid-body-object-method-33 self)
+  (transform-post)
+  (go-virtual waiting)
+  (none)
+  )
+
+;; definition of type dig-stomp-block-controller
+(deftype dig-stomp-block-controller (process-drawable)
+  ((stomp-blocks (pointer dig-stomp-block) 4 :offset-assert 200)
+   (played-fall? symbol                      :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 21
+  :size-assert         #xdc
+  :flag-assert         #x15006000dc
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type dig-stomp-block-controller
+(defmethod inspect dig-stomp-block-controller ((obj dig-stomp-block-controller))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tstomp-blocks[4] @ #x~X~%" (-> obj stomp-blocks))
+  (format #t "~2Tplayed-fall?: ~A~%" (-> obj played-fall?))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *dig-stomp-block-table*, type vector
+(define *dig-stomp-block-table* (new 'static 'vector :x 36864.0 :y 12288.0 :z -12288.0 :w -36864.0))
+
+;; failed to figure out what this is:
+(defstate idle (dig-stomp-block-controller)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (the-as object (case event-type
+                     (('set-flag)
+                      (dotimes (gp-0 4)
+                        (if (-> self stomp-blocks gp-0)
+                            (send-event (ppointer->process (-> self stomp-blocks gp-0)) 'set-flag)
+                            )
+                        )
+                      #f
+                      )
+                     (('clear-flag)
+                      (dotimes (gp-1 4)
+                        (if (-> self stomp-blocks gp-1)
+                            (send-event (ppointer->process (-> self stomp-blocks gp-1)) 'clear-flag)
+                            )
+                        )
+                      #f
+                      )
+                     )
+            )
+    )
+  :enter (behavior ()
+    (change-parent self *pusher-pool*)
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (dotimes (s5-0 4)
+        (set! (-> gp-0 quad) (-> self root trans quad))
+        (+! (-> gp-0 x) (-> *dig-stomp-block-table* data s5-0))
+        (set! (-> self stomp-blocks s5-0) (process-spawn dig-stomp-block gp-0 :to self))
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior dig-stomp-block-controller) sleep-code)
+  :post (behavior ()
+    (dotimes (v1-0 4)
+      (when (-> self stomp-blocks v1-0)
+        )
+      )
+    (let ((v1-3 #f))
+      (dotimes (a0-5 3)
+        (let ((a1-2 (-> self stomp-blocks a0-5))
+              (a2-3 (-> self stomp-blocks (+ a0-5 1)))
+              )
+          (when (and a1-2 a2-3)
+            (if (< 20480.0 (fabs (- (-> a1-2 0 root-override-2 trans y) (-> a2-3 0 root-override-2 trans y))))
+                (set! v1-3 #t)
+                )
+            )
+          )
+        )
+      (when v1-3
+        (when (not (-> self played-fall?))
+          (set! (-> self played-fall?) #t)
+          (sound-play "blocks-fall")
+          )
+        (dotimes (gp-1 4)
+          (if (-> self stomp-blocks gp-1)
+              (send-event (ppointer->process (-> self stomp-blocks gp-1)) 'broken)
+              )
+          )
+        )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 11 of type dig-stomp-block-controller
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-stomp-block-controller ((obj dig-stomp-block-controller) (arg0 entity-actor))
+  (set! (-> obj played-fall?) #f)
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type dig-totem
+(deftype dig-totem (process-drawable)
+  ()
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xc8
+  :flag-assert         #x15005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type dig-totem
+(defmethod inspect dig-totem ((obj dig-totem))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-dig-totem-entity dig-totem dig-totem-lod0-jg dig-totem-idle-ja
+              ((dig-totem-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 13 0 14.5)
+              )
+
+;; definition for method 12 of type dig-totem
+(defmethod run-logic? dig-totem ((obj dig-totem))
+  #t
+  )
+
+;; failed to figure out what this is:
+(defstate idle (dig-totem)
+  :virtual #t
+  :code (the-as (function none :behavior dig-totem) sleep-code)
+  )
+
+;; definition for method 11 of type dig-totem
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! dig-totem ((obj dig-totem) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 3)
+      (set-vector! (-> v1-2 local-sphere) 0.0 53248.0 0.0 59392.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-dig-totem-entity" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpa-obs_REF.gc b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpa-obs_REF.gc
new file mode 100644
index 0000000000..be2486cac5
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpa-obs_REF.gc
@@ -0,0 +1,669 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type fort-elec-switch
+(deftype fort-elec-switch (process-drawable)
+  ((root-override      collide-shape          :offset        128)
+   (l-bolt             lightning-control      :offset-assert 200)
+   (notify-actor       entity-actor           :offset-assert 204)
+   (tank-actor         entity-actor           :offset-assert 208)
+   (switch-group       (pointer actor-group)  :offset-assert 212)
+   (switch-group-count int32                  :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xdc
+  :flag-assert         #x17006000dc
+  (:methods
+    (idle () _type_ :state 20)
+    (play-hint () _type_ :state 21)
+    (die () _type_ :state 22)
+    )
+  )
+
+;; definition for method 3 of type fort-elec-switch
+(defmethod inspect fort-elec-switch ((obj fort-elec-switch))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-7)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tl-bolt: ~A~%" (-> obj l-bolt))
+  (format #t "~2Tnotify-actor: ~A~%" (-> obj notify-actor))
+  (format #t "~2Ttank-actor: ~A~%" (-> obj tank-actor))
+  (format #t "~2Tswitch-group: #x~X~%" (-> obj switch-group))
+  (dotimes (s5-0 (-> obj switch-group-count))
+    (format #t "~T  [~D]~2Tswitch-group: ~`actor-group`P~%" s5-0 (-> obj switch-group s5-0))
+    )
+  (format #t "~2Tswitch-group-count: ~D~%" (-> obj switch-group-count))
+  (label cfg-7)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-elec-switch fort-elec-switch fort-elec-switch-lod0-jg fort-elec-switch-idle-ja
+              ((fort-elec-switch-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 2 0 3)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (fort-elec-switch)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (go-virtual die)
+       'push
+       )
+      (('hint)
+       (go-virtual play-hint)
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-elec-switch) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate play-hint (fort-elec-switch)
+  :virtual #t
+  :event (-> (method-of-type fort-elec-switch idle) event)
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 16))
+        (suspend)
+        )
+      )
+    (until (logtest? (-> self draw status) (draw-control-status on-screen))
+      (suspend)
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.4))
+        (suspend)
+        )
+      )
+    (talker-spawn-func (-> *talker-speech* 86) *entity-pool* (target-pos 0) (the-as region #f))
+    (sleep-code)
+    (none)
+    )
+  :post (-> (method-of-type fort-elec-switch idle) post)
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-elec-switch)
+  :virtual #t
+  :enter (behavior ()
+    (process-entity-status! self (entity-perm-status subtask-complete) #t)
+    (let ((v1-0 (-> self l-bolt))
+          (v0-1 3)
+          )
+      (let ((a0-2 (!= v0-1 (-> v1-0 state mode))))
+        (case v0-1
+          ((3)
+           (if a0-2
+               (set! (-> v1-0 state counter) 0.0)
+               )
+           )
+          ((1)
+           (set! (-> v1-0 state start-color) (-> v1-0 spec start-color))
+           (set! (-> v1-0 state end-color) (-> v1-0 spec end-color))
+           )
+          )
+        )
+      (set! (-> v1-0 state mode) (the-as lightning-mode v0-1))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((v1-1 (-> self root-override root-prim)))
+      (set! (-> v1-1 prim-core collide-as) (collide-spec))
+      (set! (-> v1-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (let ((gp-0 (new 'stack-no-clear 'vector)))
+      (set! (-> gp-0 quad) (-> self root-override trans quad))
+      (set! (-> gp-0 y) (+ 8192.0 (-> gp-0 y)))
+      (let ((s5-0 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-0
+          (let ((t9-1 (method-of-type part-tracker activate)))
+            (t9-1
+              (the-as part-tracker s5-0)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-2 run-function-in-process)
+                (a0-6 s5-0)
+                (a1-2 part-tracker-init)
+                (a2-4 (-> *part-group-id-table* 125))
+                (a3-1 0)
+                (t0-0 #f)
+                (t1-0 #f)
+                (t2-0 #f)
+                (t3-0 *launch-matrix*)
+                )
+            (set! (-> t3-0 trans quad) (-> gp-0 quad))
+            ((the-as (function object object object object object object object object none) t9-2)
+             a0-6
+             a1-2
+             a2-4
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-0 ppointer)
+          )
+        )
+      )
+    (sound-play "elec-switch")
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (let ((v1-22 #t))
+      (when (-> self switch-group)
+        (dotimes (a0-11 (-> self switch-group-count))
+          (let ((a1-6 (-> self switch-group a0-11)))
+            (dotimes (a2-7 (-> a1-6 length))
+              (if (not (logtest? (-> a1-6 data a2-7 actor extra perm status) (entity-perm-status subtask-complete)))
+                  (set! v1-22 #f)
+                  )
+              )
+            )
+          )
+        )
+      (when v1-22
+        (set-setting! 'entity-name "camera-180" 0 0)
+        (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+        (process-grab? *target* #f)
+        (let ((a1-13 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-13 from) (process->ppointer self))
+          (set! (-> a1-13 num-params) 0)
+          (set! (-> a1-13 message) 'fire-suppress-on)
+          (let ((t9-8 send-event-function)
+                (v1-30 (-> self tank-actor))
+                )
+            (t9-8
+              (if v1-30
+                  (-> v1-30 extra process)
+                  )
+              a1-13
+              )
+            )
+          )
+        (let ((gp-3 (-> self clock frame-counter)))
+          (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.75))
+            (suspend)
+            )
+          )
+        (let ((a1-14 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-14 from) (process->ppointer self))
+          (set! (-> a1-14 num-params) 0)
+          (set! (-> a1-14 message) 'shutdown)
+          (let ((t9-9 send-event-function)
+                (v1-40 (-> self notify-actor))
+                )
+            (t9-9
+              (if v1-40
+                  (-> v1-40 extra process)
+                  )
+              a1-14
+              )
+            )
+          )
+        (let ((gp-4 (-> self clock frame-counter)))
+          (until (>= (- (-> self clock frame-counter) gp-4) (seconds 1.5))
+            (suspend)
+            )
+          )
+        (remove-setting! 'entity-name)
+        (remove-setting! 'process-mask)
+        (process-release? *target*)
+        (let ((a1-17 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-17 from) (process->ppointer self))
+          (set! (-> a1-17 num-params) 0)
+          (set! (-> a1-17 message) 'fire-suppress-off)
+          (let ((t9-13 send-event-function)
+                (v1-54 (-> self tank-actor))
+                )
+            (t9-13
+              (if v1-54
+                  (-> v1-54 extra process)
+                  )
+              a1-17
+              )
+            )
+          )
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; definition for method 7 of type fort-elec-switch
+;; WARN: Return type mismatch process-drawable vs fort-elec-switch.
+(defmethod relocate fort-elec-switch ((obj fort-elec-switch) (arg0 int))
+  (if (nonzero? (-> obj l-bolt))
+      (&+! (-> obj l-bolt) arg0)
+      )
+  (the-as fort-elec-switch ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; definition for method 11 of type fort-elec-switch
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-elec-switch ((obj fort-elec-switch) (arg0 entity-actor))
+  (local-vars (sv-16 res-tag))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 3)
+      (set-vector! (-> v1-2 local-sphere) 0.0 8192.0 0.0 12288.0)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-elec-switch" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj notify-actor) (entity-actor-lookup arg0 'alt-actor 0))
+  (set! (-> obj tank-actor) (entity-actor-lookup arg0 'alt-actor 1))
+  (set! sv-16 (new 'static 'res-tag))
+  (let ((v1-11 (res-lump-data (-> obj entity) 'actor-groups pointer :tag-ptr (& sv-16))))
+    (cond
+      ((and v1-11 (nonzero? (-> sv-16 elt-count)))
+       (set! (-> obj switch-group) (the-as (pointer actor-group) v1-11))
+       (set! (-> obj switch-group-count) (the-as int (-> sv-16 elt-count)))
+       )
+      (else
+        (set! (-> obj switch-group) (the-as (pointer actor-group) #f))
+        (set! (-> obj switch-group-count) 0)
+        0
+        )
+      )
+    )
+  (let ((a0-18 (-> obj skel root-channel 0)))
+    (set! (-> a0-18 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+    (set! (-> a0-18 frame-num) 0.0)
+    (joint-control-channel-group! a0-18 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-identity)
+    )
+  (transform-post)
+  (let ((a2-8 (new 'static 'lightning-spec
+                :name #f
+                :flags (lightning-spec-flags lsf2)
+                :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80)
+                :end-color (new 'static 'rgba :a #x80)
+                :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5)
+                :fade-start-factor 0.2
+                :fade-time 120.0
+                :texture (new 'static 'texture-id :index #x83 :page #xc)
+                :reduction 0.42
+                :num-points 8
+                :box-size 3072.0
+                :merge-factor 0.5
+                :merge-count 2
+                :radius 3072.0
+                :duration -1.0
+                :sound #f
+                )
+              )
+        )
+    (set! (-> obj l-bolt) (new 'process 'lightning-control a2-8 obj 0.0))
+    )
+  (let ((a0-20 (new 'stack-no-clear 'vector))
+        (v1-26 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> a0-20 quad) (-> obj root-override trans quad))
+    (set! (-> v1-26 quad) (-> obj root-override trans quad))
+    (set! (-> a0-20 y) (+ 4915.2 (-> a0-20 y)))
+    (set! (-> v1-26 y) (+ 17203.2 (-> v1-26 y)))
+    (set! (-> obj l-bolt state meet data 0 quad) (-> a0-20 quad))
+    (let ((a0-22 (-> obj l-bolt)))
+      (set! (-> a0-22 state meet data (+ (-> a0-22 state points-to-draw) -1) quad) (-> v1-26 quad))
+      )
+    )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type fort-fence
+(deftype fort-fence (process-drawable)
+  ((root-override collide-shape  :offset        128)
+   (anim          spool-anim     :offset-assert 200)
+   (exit-anim     basic          :offset-assert 204)
+   (loading?      symbol         :offset-assert 208)
+   (tank          handle         :offset-assert 216)
+   )
+  :heap-base #x60
+  :method-count-assert 24
+  :size-assert         #xe0
+  :flag-assert         #x18006000e0
+  (:methods
+    (idle () _type_ :state 20)
+    (breaking () _type_ :state 21)
+    (fort-fence-method-22 (_type_) none 22)
+    (fort-fence-method-23 (_type_) none 23)
+    )
+  )
+
+;; definition for method 3 of type fort-fence
+(defmethod inspect fort-fence ((obj fort-fence))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tanim: ~A~%" (-> obj anim))
+  (format #t "~2Texit-anim: ~A~%" (-> obj exit-anim))
+  (format #t "~2Tloading?: ~A~%" (-> obj loading?))
+  (format #t "~2Ttank: ~D~%" (-> obj tank))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-fence-a fort-fence fort-fence-a-lod0-jg fort-fence-a-idle-ja
+              ((fort-fence-a-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 5.6 0 16)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-fence-b fort-fence fort-fence-b-lod0-jg fort-fence-b-idle-ja
+              ((fort-fence-b-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 11 0 18)
+              )
+
+;; definition for method 22 of type fort-fence
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-fence-method-22 fort-fence ((obj fort-fence))
+  0
+  (none)
+  )
+
+;; definition for method 23 of type fort-fence
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-fence-method-23 fort-fence ((obj fort-fence))
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (fort-fence)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('break)
+       (go-virtual breaking)
+       )
+      (('start-loading)
+       (set! (-> self tank) (process->handle proc))
+       (let ((v0-0 (the-as object #t)))
+         (set! (-> self loading?) (the-as symbol v0-0))
+         v0-0
+         )
+       )
+      )
+    )
+  :trans (behavior ()
+    (when (-> self loading?)
+      (let ((a1-0 (new 'stack-no-clear 'event-message-block)))
+        (set! (-> a1-0 from) (process->ppointer self))
+        (set! (-> a1-0 num-params) 0)
+        (set! (-> a1-0 message) 'trans)
+        (let ((a1-1 (send-event-function (handle->process (-> self tank)) a1-0)))
+          (when a1-1
+            (let ((f0-0 (vector-vector-distance (-> self root-override trans) (the-as vector a1-1))))
+              (gui-control-method-12
+                *gui-control*
+                self
+                (gui-channel art-load)
+                (gui-action queue)
+                (-> self anim name)
+                0
+                (lerp-scale 1.0 100.0 f0-0 163840.0 327680.0)
+                (new 'static 'sound-id)
+                )
+              )
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-fence) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate breaking (fort-fence)
+  :virtual #t
+  :enter (behavior ()
+    (set! (-> self draw bounds w) 327680.0)
+    (let* ((a0-0 (the-as collide-shape-prim-group (-> self root-override root-prim)))
+           (v1-4 (-> a0-0 child 0))
+           )
+      (let ((a0-2 (-> a0-0 child 1)))
+        (set! (-> a0-2 prim-core collide-as) (-> v1-4 prim-core collide-as))
+        )
+      (set! (-> v1-4 prim-core collide-as) (collide-spec))
+      )
+    0
+    (none)
+    )
+  :exit (behavior ()
+    (let ((a0-0 (-> self anim)))
+      (when (and a0-0 (= (-> *setting-control* user-current spooling) (process->ppointer self)))
+        (ja-abort-spooled-anim a0-0 (the-as art-joint-anim #f) -1)
+        (ja-channel-set! 1)
+        (ja :group! (-> self exit-anim) :num! min)
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (ja-play-spooled-anim
+      (-> self anim)
+      (ja-group)
+      (the-as art-joint-anim (-> self exit-anim))
+      (the-as (function process-drawable symbol) false-func)
+      )
+    (logior! (-> self mask) (process-mask sleep))
+    (suspend)
+    0
+    (none)
+    )
+  :post (the-as (function none :behavior fort-fence) transform-post)
+  )
+
+;; definition for method 11 of type fort-fence
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-fence ((obj fort-fence) (arg0 entity-actor))
+  (stack-size-set! (-> obj main-thread) 512)
+  (fort-fence-method-23 obj)
+  (process-drawable-from-entity! obj arg0)
+  (fort-fence-method-22 obj)
+  (process-entity-status! obj (entity-perm-status no-kill) #t)
+  (set! (-> obj loading?) #f)
+  (let ((a0-6 (-> obj skel root-channel 0)))
+    (set! (-> a0-6 frame-group) (if (> (-> obj skel active-channels) 0)
+                                    (-> obj skel root-channel 0 frame-group)
+                                    )
+          )
+    (set! (-> a0-6 frame-num) 0.0)
+    (joint-control-channel-group!
+      a0-6
+      (if (> (-> obj skel active-channels) 0)
+          (-> obj skel root-channel 0 frame-group)
+          )
+      num-func-identity
+      )
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type fort-fence-a
+(deftype fort-fence-a (fort-fence)
+  ()
+  :heap-base #x60
+  :method-count-assert 24
+  :size-assert         #xe0
+  :flag-assert         #x18006000e0
+  )
+
+;; definition for method 3 of type fort-fence-a
+(defmethod inspect fort-fence-a ((obj fort-fence-a))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type fort-fence inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-fence-b
+(deftype fort-fence-b (fort-fence)
+  ()
+  :heap-base #x60
+  :method-count-assert 24
+  :size-assert         #xe0
+  :flag-assert         #x18006000e0
+  )
+
+;; definition for method 3 of type fort-fence-b
+(defmethod inspect fort-fence-b ((obj fort-fence-b))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type fort-fence inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 22 of type fort-fence-a
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-fence-method-22 fort-fence-a ((obj fort-fence-a))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-fence-a" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj anim)
+        (new 'static 'spool-anim :name "fort-fence-a" :anim-name "a-break" :parts 2 :command-list '())
+        )
+  (set! (-> obj exit-anim) (-> obj draw art-group data 3))
+  0
+  (none)
+  )
+
+;; definition for method 22 of type fort-fence-b
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-fence-method-22 fort-fence-b ((obj fort-fence-b))
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-fence-b" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj anim)
+        (new 'static 'spool-anim :name "fort-fence-b" :anim-name "b-break" :parts 2 :command-list '())
+        )
+  (set! (-> obj exit-anim) (-> obj draw art-group data 8))
+  0
+  (none)
+  )
+
+;; definition for method 23 of type fort-fence-a
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-fence-method-23 fort-fence-a ((obj fort-fence-a))
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 22937.6 0.0 65536.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-7 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set! (-> v1-7 transform-index) 3)
+      (set-vector! (-> v1-7 local-sphere) 0.0 22937.6 0.0 65536.0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 3)
+      (set-vector! (-> v1-9 local-sphere) 0.0 22937.6 0.0 65536.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 23 of type fort-fence-b
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-fence-method-23 fort-fence-b ((obj fort-fence-b))
+  (let ((s5-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 22937.6 0.0 65536.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-7 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-7 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-7 prim-core action) (collide-action solid))
+      (set! (-> v1-7 transform-index) 13)
+      (set-vector! (-> v1-7 local-sphere) 0.0 -16384.0 0.0 73728.0)
+      )
+    (let ((v1-9 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-9 prim-core collide-as) (collide-spec))
+      (set! (-> v1-9 prim-core action) (collide-action solid))
+      (set! (-> v1-9 transform-index) 13)
+      (set-vector! (-> v1-9 local-sphere) 0.0 -16384.0 0.0 73728.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-12 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-12 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-12 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s5-0)
+    )
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpb-obs_REF.gc b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpb-obs_REF.gc
new file mode 100644
index 0000000000..83d7599170
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpb-obs_REF.gc
@@ -0,0 +1,509 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type fort-plat-orbit
+(deftype fort-plat-orbit (process-drawable)
+  ((sync sync-linear :inline :offset-assert 200)
+   )
+  :heap-base #x60
+  :method-count-assert 21
+  :size-assert         #xd8
+  :flag-assert         #x15006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type fort-plat-orbit
+(defmethod inspect fort-plat-orbit ((obj fort-plat-orbit))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tsync: #<sync-linear @ #x~X>~%" (-> obj sync))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-plat-orbit fort-plat-orbit fort-plat-orbit-lod0-jg fort-plat-orbit-idle-ja
+              ((fort-plat-orbit-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 16 0 22)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (fort-plat-orbit)
+  :virtual #t
+  :trans (the-as (function none :behavior fort-plat-orbit) rider-trans)
+  :code (behavior ()
+    (until #f
+      (let ((f30-0 (the float (ja-num-frames 0))))
+        (cond
+          ((logtest? (actor-option user17) (-> self fact options))
+           (let ((gp-0 (-> self skel root-channel 0)))
+             (set! (-> gp-0 num-func) num-func-identity)
+             (let ((f0-4 (+ (- 0.5 (* (get-current-phase-no-mod (-> self sync)) f30-0)) f30-0)))
+               (set! (-> gp-0 frame-num) (- f0-4 (* (the float (the int (/ f0-4 f30-0))) f30-0)))
+               )
+             )
+           )
+          (else
+            (ja :num-func num-func-identity :frame-num (* (get-current-phase-no-mod (-> self sync)) f30-0))
+            )
+          )
+        )
+      (update! (-> self sound))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (the-as (function none :behavior fort-plat-orbit) rider-post)
+  )
+
+;; definition for method 11 of type fort-plat-orbit
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-plat-orbit ((obj fort-plat-orbit) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s4-0 reaction) cshape-reaction-default)
+    (set! (-> s4-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 5) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 6))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid rideable))
+      (set-vector! (-> s3-0 local-sphere) 0.0 65536.0 0.0 90112.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-14 transform-index) 5)
+      (set-vector! (-> v1-14 local-sphere) 0.0 0.0 -16384.0 36864.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-16 transform-index) 6)
+      (set-vector! (-> v1-16 local-sphere) -16384.0 0.0 0.0 36864.0)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-18 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-18 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-18 transform-index) 7)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 16384.0 36864.0)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-20 prim-core collide-as) (collide-spec pusher))
+      (set! (-> v1-20 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-20 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-20 transform-index) 8)
+      (set-vector! (-> v1-20 local-sphere) 16384.0 0.0 0.0 36864.0)
+      )
+    (let ((v1-22 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0))))
+      (set! (-> v1-22 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-22 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-22 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-22 transform-index) 4)
+      (set-vector! (-> v1-22 local-sphere) 0.0 36864.0 0.0 49152.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-25 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-25 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-25 prim-core collide-with))
+      )
+    (set! (-> obj root) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-plat-orbit" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (set! (-> obj fact)
+        (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+        )
+  (let ((a1-23 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-34 0))
+      (if #t
+          (set! v1-34 (logior v1-34 1))
+          )
+      (set! (-> a1-23 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-23 sync-flags) (the-as sync-flags v1-34))
+      )
+    (set! (-> a1-23 entity) (-> obj entity))
+    (set! (-> a1-23 period) (the-as uint 6000))
+    (set! (-> a1-23 percent) 0.0)
+    (initialize! (-> obj sync) a1-23)
+    )
+  (let ((a0-48 (-> obj skel root-channel 0)))
+    (set! (-> a0-48 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+    (set! (-> a0-48 frame-num) 0.0)
+    (joint-control-channel-group! a0-48 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-identity)
+    )
+  (transform-post)
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "plat-orbit" :fo-max 70) (-> obj root trans))
+        )
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type fort-plat-shuttle-plat
+(deftype fort-plat-shuttle-plat (process-drawable)
+  ((path-pos   float  :offset-assert 200)
+   (path-speed float  :offset-assert 204)
+   )
+  :heap-base #x50
+  :method-count-assert 21
+  :size-assert         #xd0
+  :flag-assert         #x15005000d0
+  (:methods
+    (idle () _type_ :state 20)
+    )
+  )
+
+;; definition for method 3 of type fort-plat-shuttle-plat
+(defmethod inspect fort-plat-shuttle-plat ((obj fort-plat-shuttle-plat))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tpath-pos: ~f~%" (-> obj path-pos))
+  (format #t "~2Tpath-speed: ~f~%" (-> obj path-speed))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-plat-shuttle fort-plat-shuttle fort-plat-shuttle-lod0-jg fort-plat-shuttle-idle-ja
+              ((fort-plat-shuttle-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -0.5 0 7.6)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (fort-plat-shuttle-plat)
+  :virtual #t
+  :trans (the-as (function none :behavior fort-plat-shuttle-plat) rider-trans)
+  :code (behavior ()
+    (until (< 1.0 (-> self path-pos))
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  :post (behavior ()
+    (+! (-> self path-pos) (* (-> self path-speed) (-> self clock seconds-per-frame)))
+    (let* ((f0-2 (-> self path-pos))
+           (f30-0 (if (< 0.5 f0-2)
+                      (- 1.0 f0-2)
+                      f0-2
+                      )
+                  )
+           (f0-4 (total-distance (-> self path)))
+           (f0-6 (fmin 40960.0 (* f30-0 f0-4)))
+           (f0-7 (lerp-scale 0.0 1.0 f0-6 0.0 40960.0))
+           )
+      (set-vector! (-> self draw color-mult) f0-7 f0-7 f0-7 1.0)
+      )
+    (get-point-in-path! (-> self path) (-> self root trans) (-> self path-pos) 'interp)
+    (update-trans! (-> self sound) (-> self root trans))
+    (update! (-> self sound))
+    (rider-post)
+    (none)
+    )
+  )
+
+;; definition for function fort-plat-shuttle-plat-init-by-other
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-plat-shuttle-plat-init-by-other fort-plat-shuttle-plat ((arg0 float))
+  (rlet ((vf0 :class vf))
+    (init-vf0-vector)
+    (let ((s5-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
+      (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+      (set! (-> s5-0 reaction) cshape-reaction-default)
+      (set! (-> s5-0 no-reaction)
+            (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+            )
+      (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+        (set! (-> s4-0 prim-core collide-as) (collide-spec obstacle pusher))
+        (set! (-> s4-0 prim-core collide-with) (collide-spec jak bot player-list))
+        (set! (-> s4-0 prim-core action) (collide-action solid rideable pull-rider-can-collide))
+        (set! (-> s4-0 transform-index) 3)
+        (set-vector! (-> s4-0 local-sphere) 0.0 -2048.0 0.0 31129.6)
+        (set! (-> s5-0 total-prims) (the-as uint 1))
+        (set! (-> s5-0 root-prim) s4-0)
+        )
+      (pusher-init s5-0)
+      (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+      (let ((v1-16 (-> s5-0 root-prim)))
+        (set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+        (set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+        )
+      (set! (-> self root) s5-0)
+      )
+    (initialize-skeleton
+      self
+      (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-plat-shuttle" (the-as (pointer uint32) #f)))
+      (the-as pair 0)
+      )
+    (set! (-> self path) (new 'process 'path-control self 'path 0.0 (the-as entity #f) #f))
+    (set! (-> self path-pos) arg0)
+    (get-point-in-path! (-> self path) (-> self root trans) arg0 'interp)
+    (set! (-> self path-speed) (/ 24576.0 (total-distance (-> self path))))
+    (.svf (&-> (-> self draw color-mult) quad) vf0)
+    (logclear! (-> self mask) (process-mask actor-pause))
+    (set! (-> self draw light-index) (the-as uint 1))
+    (set! (-> self sound)
+          (new 'process 'ambient-sound (static-sound-spec "plat-shuttle" :fo-max 70) (-> self root trans))
+          )
+    (go-virtual idle)
+    (none)
+    )
+  )
+
+;; definition of type fort-plat-shuttle
+(deftype fort-plat-shuttle (process-drawable)
+  ((next-spawn-time time-frame          :offset-assert 200)
+   (sync            sync-linear :inline :offset-assert 208)
+   )
+  :heap-base #x60
+  :method-count-assert 23
+  :size-assert         #xe0
+  :flag-assert         #x17006000e0
+  (:methods
+    (dormant () _type_ :state 20)
+    (idle () _type_ :state 21)
+    (fort-plat-shuttle-method-22 (_type_) symbol 22)
+    )
+  )
+
+;; definition for method 3 of type fort-plat-shuttle
+(defmethod inspect fort-plat-shuttle ((obj fort-plat-shuttle))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tnext-spawn-time: ~D~%" (-> obj next-spawn-time))
+  (format #t "~2Tsync: #<sync-linear @ #x~X>~%" (-> obj sync))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defstate dormant (fort-plat-shuttle)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('trigger)
+       (go-virtual idle)
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-plat-shuttle) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (fort-plat-shuttle)
+  :virtual #t
+  :enter (behavior ()
+    (fort-plat-shuttle-method-22 self)
+    (set! (-> self next-spawn-time) (get-timeframe-offset! (-> self sync) 0))
+    (none)
+    )
+  :trans (behavior ()
+    (when (>= (-> self clock frame-counter) (-> self next-spawn-time))
+      (process-spawn fort-plat-shuttle-plat 0 :to self)
+      (set! (-> self next-spawn-time) (get-timeframe-offset! (-> self sync) 0))
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-plat-shuttle) sleep-code)
+  )
+
+;; definition for method 22 of type fort-plat-shuttle
+(defmethod fort-plat-shuttle-method-22 fort-plat-shuttle ((obj fort-plat-shuttle))
+  (with-pp
+    (let* ((f28-0 (total-distance (-> obj path)))
+           (s5-0 (-> obj sync))
+           (f26-0 81.92)
+           (a0-3 (- (-> pp clock frame-counter) (get-timeframe-offset! s5-0 0)))
+           (v1-6 (-> s5-0 period))
+           (f30-0 (/ (* f26-0 (the float a0-3)) f28-0))
+           (f28-1 (/ (* f26-0 (the float v1-6)) f28-0))
+           )
+      (while (>= 1.0 f30-0)
+        (if (>= f30-0 0.0)
+            (process-spawn fort-plat-shuttle-plat f30-0 :to obj)
+            )
+        (+! f30-0 f28-1)
+        )
+      )
+    #f
+    )
+  )
+
+;; definition for method 11 of type fort-plat-shuttle
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-plat-shuttle ((obj fort-plat-shuttle) (arg0 entity-actor))
+  (local-vars (sv-64 int))
+  (set! (-> obj root) (new 'process 'trsqv))
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-plat-shuttle" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj fact)
+        (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+        )
+  (let ((s4-1 (new 'stack-no-clear 'sync-info-params)))
+    (let ((s3-1 1200))
+      0.0
+      (set! sv-64 0)
+      (let ((v1-7 (res-lump-data arg0 'sync (pointer float) :tag-ptr (the-as (pointer res-tag) (& sv-64)))))
+        (when v1-7
+          (set! s3-1 (the int (* 300.0 (-> v1-7 0))))
+          (-> v1-7 1)
+          )
+        )
+      (let ((v1-8 0))
+        (if #t
+            (set! v1-8 (logior v1-8 1))
+            )
+        (set! (-> s4-1 sync-type) (the-as basic 'sync-linear))
+        (set! (-> s4-1 sync-flags) (the-as sync-flags v1-8))
+        )
+      (set! (-> s4-1 entity) arg0)
+      (set! (-> s4-1 period) (the-as uint s3-1))
+      )
+    (set! (-> s4-1 percent) 0.0)
+    (initialize! (-> obj sync) s4-1)
+    )
+  (set! (-> obj path) (new 'process 'path-control obj 'path 0.0 (the-as entity #f) #f))
+  (logior! (-> obj path flags) (path-control-flag display draw-line draw-point draw-text))
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (if (logtest? (actor-option user17) (-> obj fact options))
+      (go (method-of-object obj dormant))
+      (go (method-of-object obj idle))
+      )
+  (none)
+  )
+
+;; definition of type fort-conveyor
+(deftype fort-conveyor (conveyor)
+  ()
+  :heap-base #x80
+  :method-count-assert 28
+  :size-assert         #x100
+  :flag-assert         #x1c00800100
+  )
+
+;; definition for method 3 of type fort-conveyor
+(defmethod inspect fort-conveyor ((obj fort-conveyor))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type conveyor inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-conveyor fort-conveyor fort-conveyor-lod0-jg fort-conveyor-idle-ja
+              ((fort-conveyor-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 36)
+              )
+
+;; definition for method 22 of type fort-conveyor
+(defmethod get-art-group fort-conveyor ((obj fort-conveyor))
+  "@returns The respective [[art-group]] for the [[conveyor]]"
+  (art-group-get-by-name *level* "skel-fort-conveyor" (the-as (pointer uint32) #f))
+  )
+
+;; definition for method 23 of type fort-conveyor
+;; WARN: Return type mismatch collide-shape-moving vs none.
+(defmethod reset-root! fort-conveyor ((obj fort-conveyor))
+  "Re-initializes the `root` [[trsqv]]"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 0)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 69632.0 90112.0)
+      (set! (-> s5-0 total-prims) (the-as uint 1))
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-15 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-15 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-15 prim-core collide-with))
+      )
+    (set! (-> s5-0 rider-max-momentum) 8192.0)
+    (set! (-> obj root) s5-0)
+    )
+  (none)
+  )
+
+;; definition for method 24 of type fort-conveyor
+;; WARN: Return type mismatch vector vs none.
+(defmethod init! fort-conveyor ((obj fort-conveyor))
+  "Initializes defaults for things like the `speed` and `belt-radius`"
+  (set! (-> obj belt-radius) 24576.0)
+  (set! (-> obj pull-y-threshold) 16384.0)
+  (cond
+    ((name= (-> obj name) "fort-conveyor-2")
+     (set! (-> obj speed) -21299.2)
+     (set-vector! (-> obj root scale) 1.0 1.0 0.9 1.0)
+     )
+    ((name= (-> obj name) "fort-conveyor-3")
+     (set! (-> obj speed) -18432.0)
+     (set-vector! (-> obj root scale) 1.0 1.0 0.79 1.0)
+     )
+    )
+  (none)
+  )
+
+;; definition for method 25 of type fort-conveyor
+(defmethod set-and-get-ambient-sound! fort-conveyor ((obj fort-conveyor))
+  "So long as [[actor-option::16]] is not set, fetch the [[ambient-sound]] for the [[conveyor]]
+       and return it as well.  Otherwise, set it to `0`"
+  (let* ((s5-0 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) 0.0 'interp))
+         (v1-2 (get-point-in-path! (-> obj path) (new 'stack-no-clear 'vector) 1.0 'interp))
+         (a3-3 (vector+! (new 'stack-no-clear 'vector) s5-0 v1-2))
+         )
+    (vector-float*! a3-3 a3-3 0.5)
+    (let ((v0-2 (new 'process 'ambient-sound (static-sound-spec "fort-conveyor" :fo-max 50) a3-3)))
+      (set! (-> obj sound) v0-2)
+      v0-2
+      )
+    )
+  )
diff --git a/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpc-obs_REF.gc b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpc-obs_REF.gc
new file mode 100644
index 0000000000..d0c0da9d04
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fordumpc-obs_REF.gc
@@ -0,0 +1,1112 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for method 15 of type hud-rocketsensor
+;; WARN: Return type mismatch int vs none.
+(defmethod draw hud-rocketsensor ((obj hud-rocketsensor))
+  (set-hud-piece-position!
+    (the-as hud-sprite (-> obj sprites))
+    (the int (+ 457.0 (* 130.0 (-> obj offset))))
+    210
+    )
+  (format (clear (-> obj strings 0 text)) "~D" (-> obj values 0 current))
+  (set-as-offset-from! (the-as hud-sprite (-> obj strings 0 pos)) (the-as vector4w (-> obj sprites)) -17 25)
+  ((method-of-type hud draw) obj)
+  0
+  (none)
+  )
+
+;; definition for method 16 of type hud-rocketsensor
+;; WARN: Return type mismatch int vs none.
+(defmethod update-values hud-rocketsensor ((obj hud-rocketsensor))
+  (set! (-> obj values 0 target) (the int (-> *game-info* counter)))
+  ((method-of-type hud update-values) obj)
+  0
+  (none)
+  )
+
+;; definition for method 17 of type hud-rocketsensor
+;; WARN: Return type mismatch int vs none.
+(defmethod init-callback hud-rocketsensor ((obj hud-rocketsensor))
+  (set! (-> obj level) (level-get *level* 'fordumpc))
+  (set! (-> obj gui-id)
+        (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0)
+        )
+  (logior! (-> obj flags) (hud-flags show))
+  (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :page #xb1f)))
+  (set! (-> obj sprites 0 flags) (the-as uint 4))
+  (set! (-> obj sprites 0 scale-x) 1.2)
+  (set! (-> obj sprites 0 scale-y) 1.2)
+  (alloc-string-if-needed obj 0)
+  (set! (-> obj strings 0 scale) 0.6)
+  (set! (-> obj strings 0 flags) (font-flags kerning middle large))
+  0
+  (none)
+  )
+
+;; definition of type fort-dump-bomb-a
+(deftype fort-dump-bomb-a (process-drawable)
+  ((root-override collide-shape  :offset 128)
+   )
+  :heap-base #x50
+  :method-count-assert 22
+  :size-assert         #xc8
+  :flag-assert         #x16005000c8
+  (:methods
+    (idle () _type_ :state 20)
+    (die () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type fort-dump-bomb-a
+(defmethod inspect fort-dump-bomb-a ((obj fort-dump-bomb-a))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-dump-bomb-a fort-dump-bomb-a fort-dump-bomb-a-lod0-jg fort-dump-bomb-a-idle-ja
+              ((fort-dump-bomb-a-lod0-mg (meters 20)) (fort-dump-bomb-a-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 2.5 0 3.3)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (fort-dump-bomb-a)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack)
+       (let* ((s5-0 (-> event param 0))
+              (gp-0 (the-as attack-info (-> event param 1)))
+              (s4-0 proc)
+              (v1-1 (if (type? s4-0 process-drawable)
+                        (the-as process-drawable s4-0)
+                        )
+                    )
+              )
+         (if (and s5-0 v1-1 (or (= (-> gp-0 mode) 'fort-robotank-shot) (= (-> gp-0 mode) 'explode)))
+             (go-virtual die)
+             )
+         )
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-dump-bomb-a) sleep-code)
+  :post (behavior ()
+    (spawn (-> self part) (-> self root-override trans))
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-dump-bomb-a)
+  :virtual #t
+  :code (behavior ()
+    (let ((v1-1 (-> self root-override root-prim)))
+      (set! (-> v1-1 prim-core collide-as) (collide-spec))
+      (set! (-> v1-1 prim-core collide-with) (collide-spec))
+      )
+    0
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (sound-play "fort-bomb")
+    (let ((gp-1 (new 'stack-no-clear 'matrix)))
+      (set! (-> gp-1 quad 0) (-> self root-override trans quad))
+      (set! (-> gp-1 vector 0 y) (+ 8192.0 (-> gp-1 vector 0 y)))
+      (let ((s5-1 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-1
+          (let ((t9-3 (method-of-type part-tracker activate)))
+            (t9-3
+              (the-as part-tracker s5-1)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-4 run-function-in-process)
+                (a0-8 s5-1)
+                (a1-3 part-tracker-init)
+                (a2-5 (-> *part-group-id-table* 572))
+                (a3-2 0)
+                (t0-1 #f)
+                (t1-1 #f)
+                (t2-1 #f)
+                (t3-0 *launch-matrix*)
+                )
+            (set! (-> t3-0 trans quad) (-> gp-1 quad 0))
+            ((the-as (function object object object object object object object object none) t9-4)
+             a0-8
+             a1-3
+             a2-5
+             a3-2
+             t0-1
+             t1-1
+             t2-1
+             t3-0
+             )
+            )
+          (-> s5-1 ppointer)
+          )
+        )
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; definition for method 11 of type fort-dump-bomb-a
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-dump-bomb-a ((obj fort-dump-bomb-a) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-2 prim-core collide-as) (collide-spec bot))
+      (set! (-> v1-2 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-2 prim-core action) (collide-action solid))
+      (set! (-> v1-2 transform-index) 0)
+      (set-vector! (-> v1-2 local-sphere) 0.0 10240.0 0.0 13516.8)
+      (set! (-> s4-0 total-prims) (the-as uint 1))
+      (set! (-> s4-0 root-prim) v1-2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-5 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-dump-bomb-a" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 573) obj))
+  (let ((a0-13 (-> obj skel root-channel 0)))
+    (set! (-> a0-13 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-13 frame-num) 0.0)
+    (joint-control-channel-group! a0-13 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-identity)
+    )
+  (transform-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
+
+;; definition of type fort-missile-target
+(deftype fort-missile-target (process-drawable)
+  ((root-override collide-shape-moving           :offset        128)
+   (part-mat      matrix               2 :inline :offset-assert 208)
+   (sound-id      uint32                         :offset-assert 336)
+   )
+  :heap-base #xe0
+  :method-count-assert 22
+  :size-assert         #x154
+  :flag-assert         #x1600e00154
+  (:methods
+    (idle () _type_ :state 20)
+    (die () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type fort-missile-target
+(defmethod inspect fort-missile-target ((obj fort-missile-target))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tpart-mat[2] @ #x~X~%" (-> obj part-mat))
+  (format #t "~2Tsound-id: ~D~%" (-> obj sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-missile-target fort-missile-target fort-missile-target-lod0-jg fort-missile-target-idle-ja
+              ((fort-missile-target-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -0.5 -0.5 3.4)
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-missile-target-explode fort-missile-target fort-missile-target-explode-lod0-jg fort-missile-target-explode-idle-ja
+              ((fort-missile-target-explode-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -0.5 -0.5 3.4)
+              )
+
+;; definition for symbol *fort-missile-target-exploder-params*, type joint-exploder-static-params
+(define *fort-missile-target-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 5 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    :art-level #f
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (fort-missile-target)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('attack 'touch)
+       (let* ((gp-0 (-> event param 0))
+              (s5-0 (the-as attack-info (-> event param 1)))
+              (s4-0 proc)
+              (v1-1 (if (type? s4-0 projectile)
+                        (the-as projectile s4-0)
+                        )
+                    )
+              )
+         (if (and gp-0 v1-1 (= (-> s5-0 mode) 'fort-robotank-shot))
+             (go-virtual die)
+             )
+         )
+       )
+      (('trigger)
+       (go-virtual die)
+       )
+      )
+    )
+  :code (the-as (function none :behavior fort-missile-target) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-missile-target)
+  :virtual #t
+  :enter (behavior ()
+    (let ((v1-1 (the-as collide-shape-prim-group (-> self root-override root-prim))))
+      (set! (-> v1-1 child 0 prim-core collide-as) (collide-spec))
+      (set! (-> v1-1 child 0 prim-core collide-with) (collide-spec))
+      )
+    0
+    (setup-masks (-> self draw) 2 0)
+    (setup-masks (-> self draw) 0 1)
+    (let ((s5-0 (-> self root-override trans))
+          (s1-0 (-> self root-override quat))
+          (s3-0 (new 'stack-no-clear 'vector))
+          (gp-0 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> gp-0 x) 0.0)
+      (set! (-> gp-0 y) 2048.0)
+      (set! (-> gp-0 z) -8192.0)
+      (set! (-> gp-0 w) 0.0)
+      (let ((s2-0 (new 'stack-no-clear 'vector))
+            (s4-0 (new 'stack-no-clear 'vector))
+            )
+        (vector-orient-by-quat! gp-0 gp-0 (-> self root-override quat))
+        (vector+! gp-0 (-> self root-override trans) gp-0)
+        (let ((t9-3 vector-orient-by-quat!)
+              (a0-6 s3-0)
+              (a1-4 s3-0)
+              )
+          (set! (-> a1-4 x) 0.0)
+          (set! (-> a1-4 y) 2048.0)
+          (set! (-> a1-4 z) 5734.4)
+          (set! (-> a1-4 w) 0.0)
+          (t9-3 a0-6 a1-4 s1-0)
+          )
+        (vector+! s2-0 s5-0 s3-0)
+        (let ((t9-4 vector-orient-by-quat!)
+              (a0-8 s3-0)
+              (a1-7 s3-0)
+              )
+          (set! (-> a1-7 x) 0.0)
+          (set! (-> a1-7 y) -10649.6)
+          (set! (-> a1-7 z) -819.2)
+          (set! (-> a1-7 w) 0.0)
+          (t9-4 a0-8 a1-7 s1-0)
+          )
+        (vector+! s4-0 s5-0 s3-0)
+        (let ((s5-1 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) gp-0 s2-0) 1.0))
+              (gp-1 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) gp-0 s4-0) 1.0))
+              )
+          (forward-up->inv-matrix (the-as matrix (-> self part-mat)) s5-1 *up-vector*)
+          (set! (-> self part-mat 0 trans quad) (-> s2-0 quad))
+          (forward-up->inv-matrix (-> self part-mat 1) gp-1 *up-vector*)
+          )
+        (set! (-> self part-mat 1 trans quad) (-> s4-0 quad))
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-fort-missile-target-explode" (the-as (pointer uint32) #f))
+        5
+        gp-0
+        *fort-missile-target-exploder-params*
+        :to self
+        )
+      )
+    (activate! *camera-smush-control* 819.2 37 210 1.0 0.995 (-> self clock))
+    (sound-play "fort-target")
+    (suspend)
+    (let ((gp-2 (get-process *default-dead-pool* part-tracker #x4000)))
+      (when gp-2
+        (let ((t9-9 (method-of-type part-tracker activate)))
+          (t9-9
+            (the-as part-tracker gp-2)
+            *entity-pool*
+            (symbol->string (-> part-tracker symbol))
+            (the-as pointer #x70004000)
+            )
+          )
+        (let ((t9-10 run-function-in-process)
+              (a0-10 gp-2)
+              (a1-9 part-tracker-init)
+              (a2-13 (-> *part-group-id-table* 581))
+              (a3-5 0)
+              (t0-3 #f)
+              (t1-3 #f)
+              (t2-2 #f)
+              (t3-0 *launch-matrix*)
+              )
+          (set! (-> t3-0 trans quad) (-> self root-override trans quad))
+          ((the-as (function object object object object object object object object none) t9-10)
+           a0-10
+           a1-9
+           a2-13
+           a3-5
+           t0-3
+           t1-3
+           t2-2
+           t3-0
+           )
+          )
+        (-> gp-2 ppointer)
+        )
+      )
+    (let ((gp-3 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-3) (seconds 1))
+        (suspend)
+        )
+      )
+    (send-event (ppointer->process (-> self parent)) 'died)
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (sound-play "missile-steam" :id (the-as sound-id (-> self sound-id)))
+    (spawn-with-matrix (-> self part) (the-as matrix (-> self part-mat)))
+    (spawn-with-matrix (-> self part) (-> self part-mat 1))
+    (none)
+    )
+  )
+
+;; definition for method 10 of type fort-missile-target
+(defmethod deactivate fort-missile-target ((obj fort-missile-target))
+  (sound-stop (the-as sound-id (-> obj sound-id)))
+  ((the-as (function process-drawable none) (find-parent-method fort-missile-target 10)) obj)
+  (none)
+  )
+
+;; definition for function fort-missile-target-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-missile-target-init-by-other fort-missile-target ((arg0 vector) (arg1 vector))
+  (stack-size-set! (-> self main-thread) 512)
+  (let ((s4-0 (new 'process 'collide-shape self (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 4) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 5))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 -2048.0 -2048.0 14745.6)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-11 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-11 prim-core action) (collide-action solid))
+      (set! (-> v1-11 transform-index) 3)
+      (set-vector! (-> v1-11 local-sphere) 0.0 -2048.0 -2048.0 13926.4)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-13 prim-core action) (collide-action solid))
+      (set! (-> v1-13 transform-index) 3)
+      (set-vector! (-> v1-13 local-sphere) 0.0 2048.0 4915.2 4915.2)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-15 prim-core action) (collide-action solid))
+      (set! (-> v1-15 transform-index) 3)
+      (set-vector! (-> v1-15 local-sphere) 0.0 -10649.6 -819.2 5734.4)
+      )
+    (let ((v1-17 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> v1-17 prim-core action) (collide-action semi-solid))
+      (set! (-> v1-17 transform-index) 3)
+      (set-vector! (-> v1-17 local-sphere) 0.0 -2048.0 -2048.0 13107.2)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-20 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-20 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-20 prim-core collide-with))
+      )
+    (set! (-> self root-override) (the-as collide-shape-moving s4-0))
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (forward-up-nopitch->quaternion (-> self root-override quat) arg1 *y-vector*)
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-fort-missile-target" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (set! (-> self draw light-index) (the-as uint 17))
+  (set! (-> self part) (create-launch-control (-> *part-group-id-table* 582) self))
+  (setup-masks (-> self draw) -1 0)
+  (ja-no-eval :group! (-> self draw art-group data 2) :num! zero)
+  (transform-post)
+  (set! (-> self sound-id) (the-as uint (new-sound-id)))
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type fort-missile
+(deftype fort-missile (process-drawable)
+  ((root-override      collide-shape              :offset        128)
+   (part-doom          sparticle-launch-control   :offset-assert 200)
+   (hud                handle                     :offset-assert 208)
+   (door-actor         entity-actor             2 :offset-assert 216)
+   (tank-actor         entity-actor               :offset-assert 224)
+   (bomb               handle                   4 :offset-assert 232)
+   (bomb-count         uint32                     :offset-assert 264)
+   (attack-id          uint32                     :offset-assert 268)
+   (explosion-sound-id uint32                     :offset-assert 272)
+   (alarm-sound-id     uint32                     :offset-assert 276)
+   )
+  :heap-base #xa0
+  :method-count-assert 25
+  :size-assert         #x118
+  :flag-assert         #x1900a00118
+  (:methods
+    (idle () _type_ :state 20)
+    (targets-active () _type_ :state 21)
+    (missile-countdown () _type_ :state 22)
+    (die () _type_ :state 23)
+    (dormant () _type_ :state 24)
+    )
+  )
+
+;; definition for method 3 of type fort-missile
+(defmethod inspect fort-missile ((obj fort-missile))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tpart-doom: ~A~%" (-> obj part-doom))
+  (format #t "~2Thud: ~D~%" (-> obj hud))
+  (format #t "~2Tdoor-actor[2] @ #x~X~%" (-> obj door-actor))
+  (format #t "~2Ttank-actor: ~A~%" (-> obj tank-actor))
+  (format #t "~2Tbomb[4] @ #x~X~%" (-> obj bomb))
+  (format #t "~2Tbomb-count: ~D~%" (-> obj bomb-count))
+  (format #t "~2Tattack-id: ~D~%" (-> obj attack-id))
+  (format #t "~2Texplosion-sound-id: ~D~%" (-> obj explosion-sound-id))
+  (format #t "~2Talarm-sound-id: ~D~%" (-> obj alarm-sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-missile fort-missile fort-missile-lod0-jg fort-missile-idle-ja
+              ((fort-missile-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 -11 0 29)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :trans (behavior ()
+    (if (and (task-node-closed? (game-task-node fortress-dump-deal)) *target*)
+        (go-virtual targets-active)
+        )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-missile) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate targets-active (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('die)
+       (go-virtual die)
+       )
+      (('died)
+       (+! (-> self bomb-count) -1)
+       (let ((v1-5 (-> self bomb-count)))
+         (cond
+           ((= v1-5 3)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv079" -99.0 0)
+            )
+           ((= v1-5 2)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv080" -99.0 0)
+            )
+           ((= v1-5 1)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv081" -99.0 0)
+            )
+           ((zero? v1-5)
+            (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv082" -99.0 0)
+            )
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (if *target*
+        (set! (-> self hud) (ppointer->handle (process-spawn hud-rocketsensor :init hud-init-by-other :to *target*)))
+        )
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 8))
+        (suspend)
+        )
+      )
+    (until (logtest? (-> self draw status) (draw-control-status on-screen))
+      (suspend)
+      )
+    (when (= (-> self bomb-count) 4)
+      (let ((gp-1 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.4))
+          (suspend)
+          )
+        )
+      (add-process *gui-control* self (gui-channel daxter) (gui-action play) "ds017" -99.0 0)
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 20))
+        (suspend)
+        )
+      )
+    (if (= (-> self bomb-count) 4)
+        (add-process *gui-control* self (gui-channel daxter) (gui-action play) "ds018" -99.0 0)
+        )
+    (while (> (-> self bomb-count) 0)
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 0.2))
+          (suspend)
+          )
+        )
+      )
+    (let ((gp-4 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.8))
+        (suspend)
+        )
+      )
+    (go-virtual missile-countdown)
+    (none)
+    )
+  :post (behavior ()
+    (set! (-> *game-info* counter) (the float (-> self bomb-count)))
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate missile-countdown (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('halt)
+       (go-virtual dormant)
+       )
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :exit (behavior ()
+    (set-fordumpc-light-flag! #f)
+    (send-event (handle->process (-> self hud)) 'hide-and-die)
+    (sound-stop (the-as sound-id (-> self alarm-sound-id)))
+    (none)
+    )
+  :code (behavior ()
+    (send-event (handle->process (-> self hud)) 'hide-and-die)
+    (let ((a1-1 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-1 from) (process->ppointer self))
+      (set! (-> a1-1 num-params) 0)
+      (set! (-> a1-1 message) 'fire-suppress-on)
+      (let ((t9-1 send-event-function)
+            (v1-8 (-> self tank-actor))
+            )
+        (t9-1
+          (if v1-8
+              (-> v1-8 extra process)
+              )
+          a1-1
+          )
+        )
+      )
+    (set-fordumpc-light-flag! #t)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.2))
+        (suspend)
+        )
+      )
+    (while (not (process-grab? *target* #f))
+      (suspend)
+      )
+    (set-setting! 'entity-name "camera-182" 0 0)
+    (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+    (task-node-close! (game-task-node fortress-dump-missile))
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.75))
+        (suspend)
+        )
+      )
+    (let ((a1-5 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-5 from) (process->ppointer self))
+      (set! (-> a1-5 num-params) 0)
+      (set! (-> a1-5 message) 'open)
+      (let ((t9-7 send-event-function)
+            (v1-28 (-> self door-actor 0))
+            )
+        (t9-7
+          (if v1-28
+              (-> v1-28 extra process)
+              )
+          a1-5
+          )
+        )
+      )
+    (let ((a1-6 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-6 from) (process->ppointer self))
+      (set! (-> a1-6 num-params) 0)
+      (set! (-> a1-6 message) 'open)
+      (let ((t9-8 send-event-function)
+            (v1-33 (-> self door-actor 1))
+            )
+        (t9-8
+          (if v1-33
+              (-> v1-33 extra process)
+              )
+          a1-6
+          )
+        )
+      )
+    (let ((gp-2 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-2) (seconds 1.5))
+        (suspend)
+        )
+      )
+    (remove-setting! 'entity-name)
+    (remove-setting! 'process-mask)
+    (process-release? *target*)
+    (let ((a1-9 (new 'stack-no-clear 'event-message-block)))
+      (set! (-> a1-9 from) (process->ppointer self))
+      (set! (-> a1-9 num-params) 0)
+      (set! (-> a1-9 message) 'fire-suppress-off)
+      (let ((t9-12 send-event-function)
+            (v1-47 (-> self tank-actor))
+            )
+        (t9-12
+          (if v1-47
+              (-> v1-47 extra process)
+              )
+          a1-9
+          )
+        )
+      )
+    (when *target*
+      (set! (-> *game-info* timer) 0)
+      (set! (-> self hud) (ppointer->handle (process-spawn hud-timer :init hud-init-by-other :to *target*)))
+      )
+    (let ((gp-4 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-4) (seconds 0.4))
+        (suspend)
+        )
+      )
+    (set! (-> self explosion-sound-id)
+          (the-as uint (add-process *gui-control* self (gui-channel background) (gui-action queue) "big-xplo" -99.0 0))
+          )
+    (dotimes (gp-5 10)
+      (set! (-> *game-info* timer) (the-as time-frame (- 3000 (the int (* 300.0 (the float gp-5))))))
+      (let ((s5-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) s5-0) (seconds 1))
+          (suspend)
+          )
+        )
+      )
+    (go-virtual die)
+    (none)
+    )
+  :post (behavior ()
+    (sound-play "fort-alarm" :id (the-as sound-id (-> self alarm-sound-id)))
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-missile)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('halt)
+       (go-virtual dormant)
+       )
+      (('touched)
+       (let ((s4-0 proc))
+         (when (if (type? s4-0 process-drawable)
+                   s4-0
+                   )
+           (let ((a1-2 (new 'stack-no-clear 'event-message-block)))
+             (set! (-> a1-2 from) (process->ppointer self))
+             (set! (-> a1-2 num-params) 2)
+             (set! (-> a1-2 message) 'attack)
+             (set! (-> a1-2 param 0) (-> event param 0))
+             (let ((v1-8 (new 'static 'attack-info :mask (attack-info-mask mode id))))
+               (set! (-> v1-8 id) (-> self attack-id))
+               (set! (-> v1-8 mode) 'explode)
+               (set! (-> a1-2 param 1) (the-as uint v1-8))
+               )
+             (send-event-function proc a1-2)
+             )
+           )
+         )
+       )
+      )
+    )
+  :enter (behavior ()
+    (set-setting! 'allow-pause #f 0 0)
+    (set-setting! 'allow-progress #f 0 0)
+    (none)
+    )
+  :exit (behavior ()
+    (remove-setting! 'allow-pause)
+    (remove-setting! 'allow-progress)
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.4))
+        (suspend)
+        )
+      )
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (when *scene-player*
+      (cleanup-for-death self)
+      (deactivate self)
+      )
+    (let ((gp-1 (new 'stack-no-clear 'matrix)))
+      (set! (-> gp-1 quad 0) (-> self root-override trans quad))
+      (let ((s5-0 (get-process *default-dead-pool* part-tracker #x4000)))
+        (when s5-0
+          (let ((t9-3 (method-of-type part-tracker activate)))
+            (t9-3
+              (the-as part-tracker s5-0)
+              *entity-pool*
+              (symbol->string (-> part-tracker symbol))
+              (the-as pointer #x70004000)
+              )
+            )
+          (let ((t9-4 run-function-in-process)
+                (a0-8 s5-0)
+                (a1-2 part-tracker-init)
+                (a2-4 (-> *part-group-id-table* 125))
+                (a3-1 0)
+                (t0-0 #f)
+                (t1-0 #f)
+                (t2-0 #f)
+                (t3-0 *launch-matrix*)
+                )
+            (set! (-> t3-0 trans quad) (-> gp-1 quad 0))
+            ((the-as (function object object object object object object object object none) t9-4)
+             a0-8
+             a1-2
+             a2-4
+             a3-1
+             t0-0
+             t1-0
+             t2-0
+             t3-0
+             )
+            )
+          (-> s5-0 ppointer)
+          )
+        )
+      )
+    (let ((gp-2 (new 'stack-no-clear 'vector))
+          (v1-24 (-> self root-override trans))
+          (a0-9 (new 'stack-no-clear 'vector))
+          )
+      (set! (-> a0-9 x) 0.0)
+      (set! (-> a0-9 y) -87244.8)
+      (set! (-> a0-9 z) 0.0)
+      (set! (-> a0-9 w) 0.0)
+      (let* ((gp-3 (vector+! gp-2 v1-24 a0-9))
+             (s4-0 (get-process *default-dead-pool* manipy #x4000))
+             (s5-1 (when s4-0
+                     (let ((t9-6 (method-of-type manipy activate)))
+                       (t9-6 (the-as manipy s4-0) self (symbol->string (-> manipy symbol)) (the-as pointer #x70004000))
+                       )
+                     (run-now-in-process
+                       s4-0
+                       manipy-init
+                       gp-3
+                       (-> self entity)
+                       (art-group-get-by-name *level* "skel-bomb-blast" (the-as (pointer uint32) #f))
+                       #f
+                       0
+                       )
+                     (-> s4-0 ppointer)
+                     )
+                   )
+             (f30-0 1.4)
+             )
+        (when s5-1
+          (send-event (ppointer->process s5-1) 'anim-mode 'play1)
+          (send-event (ppointer->process s5-1) 'anim "idle")
+          (set-vector! (-> (the-as process-drawable (-> s5-1 0)) root scale) f30-0 1.0 f30-0 1.0)
+          )
+        )
+      )
+    (when *target*
+      (set-action!
+        *gui-control*
+        (gui-action play)
+        (the-as sound-id (-> self explosion-sound-id))
+        (gui-channel none)
+        (gui-action none)
+        (the-as string #f)
+        (the-as (function gui-connection symbol) #f)
+        (the-as process #f)
+        )
+      (while (let ((a1-13 (new 'stack-no-clear 'event-message-block)))
+               (set! (-> a1-13 from) (process->ppointer self))
+               (set! (-> a1-13 num-params) 2)
+               (set! (-> a1-13 message) 'attack-invinc)
+               (set! (-> a1-13 param 0) (the-as uint #f))
+               (let ((v1-56 (new 'static 'attack-info :mask (attack-info-mask mode id))))
+                 (let* ((a0-19 *game-info*)
+                        (a2-11 (+ (-> a0-19 attack-id) 1))
+                        )
+                   (set! (-> a0-19 attack-id) a2-11)
+                   (set! (-> v1-56 id) a2-11)
+                   )
+                 (set! (-> v1-56 mode) 'big-explosion)
+                 (set! (-> a1-13 param 1) (the-as uint v1-56))
+                 )
+               (not (send-event-function *target* a1-13))
+               )
+        (suspend)
+        )
+      (setup
+        *screen-filter*
+        (new 'static 'vector :x 255.0 :y 255.0 :z 255.0)
+        (new 'static 'vector :x 255.0 :y 255.0 :z 255.0 :w 128.0)
+        (* 0.3 (-> self clock seconds-per-frame))
+        (bucket-id tex-all-map)
+        )
+      )
+    (let* ((v1-63 *game-info*)
+           (a0-24 (+ (-> v1-63 attack-id) 1))
+           )
+      (set! (-> v1-63 attack-id) a0-24)
+      (set! (-> self attack-id) a0-24)
+      )
+    (let ((v1-65 (-> self root-override root-prim)))
+      (let ((a1-15 (-> (the-as collide-shape-prim-group v1-65) child 2))
+            (a0-27 (-> (the-as collide-shape-prim-group v1-65) child 1))
+            )
+        (set! (-> a1-15 prim-core action) (collide-action))
+        (set! (-> a1-15 prim-core collide-with) (collide-spec))
+        (set! (-> a0-27 prim-core action) (collide-action deadly))
+        (set! (-> a0-27 prim-core collide-as) (collide-spec obstacle))
+        (set! (-> a0-27 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list))
+        (set! (-> a0-27 local-sphere w) 131072.0)
+        (set! (-> a0-27 prim-core world-sphere w) 131072.0)
+        )
+      (set! (-> v1-65 local-sphere w) 155648.0)
+      (set! (-> v1-65 prim-core world-sphere w) 155648.0)
+      )
+    (update-transforms (-> self root-override))
+    (let ((a1-21 (new 'stack-no-clear 'overlaps-others-params)))
+      (set! (-> a1-21 options) (overlaps-others-options))
+      (set! (-> a1-21 collide-with-filter) (the-as collide-spec -1))
+      (set! (-> a1-21 tlist) *touching-list*)
+      (find-overlapping-shapes (-> self root-override) a1-21)
+      )
+    (suspend)
+    0
+    (let ((v1-74 (-> self root-override root-prim)))
+      (set! (-> v1-74 prim-core collide-as) (collide-spec))
+      (set! (-> v1-74 prim-core collide-with) (collide-spec))
+      )
+    0
+    (countdown (gp-4 5)
+      (let ((s5-3 (new 'stack-no-clear 'matrix)))
+        (position-in-front-of-camera! (-> s5-3 trans) (+ 28672.0 (* 20480.0 (the float gp-4))) 0.0)
+        (position-in-front-of-camera! (-> s5-3 vector 2) 4096.0 0.0)
+        (vector-! (-> s5-3 vector 2) (-> s5-3 vector 2) (-> s5-3 trans))
+        (vector-normalize! (-> s5-3 vector 2) 1.0)
+        (vector-cross! (the-as vector (-> s5-3 vector)) *up-vector* (-> s5-3 vector 2))
+        (vector-normalize! (the-as vector (-> s5-3 vector)) 1.0)
+        (vector-cross! (-> s5-3 vector 1) (-> s5-3 vector 2) (the-as vector (-> s5-3 vector)))
+        (vector-normalize! (-> s5-3 vector 1) 1.0)
+        (set! (-> s5-3 vector 0 w) 0.0)
+        (set! (-> s5-3 vector 1 w) 0.0)
+        (set! (-> s5-3 vector 2 w) 0.0)
+        (set! (-> s5-3 trans w) 1.0)
+        (spawn-with-matrix (-> self part-doom) s5-3)
+        )
+      (set! (-> self state-time) (-> self clock frame-counter))
+      (until (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.2))
+        (suspend)
+        )
+      )
+    (let ((gp-5 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-5) (seconds 10))
+        (suspend)
+        )
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate dormant (fort-missile)
+  :virtual #t
+  :code (the-as (function none :behavior fort-missile) sleep-code)
+  )
+
+;; definition for method 10 of type fort-missile
+(defmethod deactivate fort-missile ((obj fort-missile))
+  (set-fordumpc-light-flag! #f)
+  (send-event (handle->process (-> obj hud)) 'hide-and-die)
+  (if (nonzero? (-> obj part-doom))
+      (kill-and-free-particles (-> obj part-doom))
+      )
+  (sound-stop (the-as sound-id (-> obj alarm-sound-id)))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 7 of type fort-missile
+;; WARN: Return type mismatch process-drawable vs fort-missile.
+(defmethod relocate fort-missile ((obj fort-missile) (arg0 int))
+  (if (nonzero? (-> obj part-doom))
+      (&+! (-> obj part-doom) arg0)
+      )
+  (the-as
+    fort-missile
+    ((the-as (function process-drawable int process-drawable) (find-parent-method fort-missile 7)) obj arg0)
+    )
+  )
+
+;; definition for method 11 of type fort-missile
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-missile ((obj fort-missile) (arg0 entity-actor))
+  (stack-size-set! (-> obj main-thread) 512)
+  (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum usually-hit-by-player))))
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 2) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 3))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec obstacle camera-blocker))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot obstacle hit-by-others-list player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid deadly))
+      (set! (-> s3-0 transform-index) 3)
+      (set-vector! (-> s3-0 local-sphere) 0.0 -45056.0 0.0 118784.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (let ((v1-11 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-11 prim-core collide-as) (collide-spec obstacle))
+      (set! (-> v1-11 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-11 prim-core action) (collide-action solid))
+      (set! (-> v1-11 transform-index) 3)
+      (set-vector! (-> v1-11 local-sphere) 0.0 -45056.0 0.0 118784.0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
+      (set! (-> v1-13 transform-index) 3)
+      (set-vector! (-> v1-13 local-sphere) 0.0 -81920.0 0.0 32768.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-16 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-16 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-16 prim-core collide-with))
+      )
+    (set! (-> s4-0 event-self) 'touched)
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-missile" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> obj door-actor 0) (entity-actor-lookup arg0 'alt-actor 0))
+  (set! (-> obj door-actor 1) (entity-actor-lookup arg0 'alt-actor 1))
+  (set! (-> obj tank-actor) (entity-actor-lookup arg0 'alt-actor 2))
+  (let ((s5-1 (new 'stack-no-clear 'vector)))
+    (set! (-> s5-1 x) 0.0)
+    (set! (-> s5-1 y) -36864.0)
+    (set! (-> s5-1 z) 34406.4)
+    (set! (-> s5-1 w) 1.0)
+    (let ((s4-2 (new 'stack-no-clear 'vector)))
+      (dotimes (s3-2 4)
+        (let ((s2-1 (vector+! (new 'stack-no-clear 'vector) (-> obj root-override trans) s5-1))
+              (s1-0 (new 'stack-no-clear 'vector))
+              )
+          (vector-normalize! (vector-! s4-2 s2-1 (-> obj root-override trans)) 1.0)
+          (vector-float*! s1-0 s4-2 -1.0)
+          (set! (-> obj bomb s3-2) (ppointer->handle (process-spawn fort-missile-target s2-1 s1-0 :to obj)))
+          )
+        (vector-rotate-y! s5-1 s5-1 16384.0)
+        )
+      )
+    )
+  (set! (-> obj bomb-count) (the-as uint 4))
+  (set! (-> obj hud) (the-as handle #f))
+  (set! (-> obj part-doom) (create-launch-control (-> *part-group-id-table* 583) obj))
+  (set! (-> obj alarm-sound-id) (the-as uint (new-sound-id)))
+  (let ((a0-36 (-> obj skel root-channel 0)))
+    (set! (-> a0-36 frame-group) (the-as art-joint-anim (-> obj draw art-group data 2)))
+    (set! (-> a0-36 frame-num) 0.0)
+    (joint-control-channel-group! a0-36 (the-as art-joint-anim (-> obj draw art-group data 2)) num-func-identity)
+    )
+  (ja-post)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fort-robotank-turret_REF.gc b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fort-robotank-turret_REF.gc
new file mode 100644
index 0000000000..15359d2975
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fort-robotank-turret_REF.gc
@@ -0,0 +1,1747 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type fort-robotank-turret
+(deftype fort-robotank-turret (process-focusable)
+  ((los                 los-control         :inline   :offset-assert 208)
+   (reticle             handle                        :offset-assert 360)
+   (screen              handle                        :offset-assert 368)
+   (tank-quat           quaternion          :inline   :offset-assert 384)
+   (tank-quat-vibe-only quaternion          :inline   :offset-assert 400)
+   (rotate-quat         quaternion          :inline   :offset-assert 416)
+   (rotate-rate         float                         :offset-assert 432)
+   (rotate-mult         float                         :offset-assert 436)
+   (shot-range          float                         :offset-assert 440)
+   (fov-mult            float                         :offset-assert 444)
+   (offset              vector              :inline   :offset-assert 448)
+   (sight-pos           vector              :inline   :offset-assert 464)
+   (firing-sight-pos    vector              :inline   :offset-assert 480)
+   (aim-pos             vector              3 :inline :offset-assert 496)
+   (aim-pos-2           vector              :inline   :offset        512)
+   (aim-pos-1           vector              :inline   :offset        528)
+   (gun-timer           time-frame                    :offset-assert 544)
+   (gun-elev-jmod       joint-mod-set-local           :offset-assert 552)
+   (gun-elev            float                         :offset-assert 556)
+   (gun-elev-cam        float                         :offset-assert 560)
+   (gun-joint-l         int32               2         :offset-assert 564)
+   (gun-joint-r         int32               2         :offset-assert 572)
+   (gun-spread          float                         :offset-assert 580)
+   (gun-index           int32                         :offset-assert 584)
+   (flags               uint16                        :offset-assert 588)
+   (turn-sound-id       uint32                        :offset-assert 592)
+   )
+  :heap-base #x1e0
+  :method-count-assert 35
+  :size-assert         #x254
+  :flag-assert         #x2301e00254
+  (:methods
+    (idle () _type_ :state 27)
+    (ready () _type_ :state 28)
+    (fire () _type_ :state 29)
+    (die () _type_ :state 30)
+    (fort-robotank-turret-method-31 (_type_ vector vector) none 31)
+    (fort-robotank-turret-method-32 (_type_ (inline-array vector)) (pointer process) 32)
+    (fort-robotank-turret-method-33 (_type_) none 33)
+    (fort-robotank-turret-method-34 (_type_ vector float) symbol 34)
+    )
+  )
+
+;; definition for method 3 of type fort-robotank-turret
+(defmethod inspect fort-robotank-turret ((obj fort-robotank-turret))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-focusable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tlos: #<los-control @ #x~X>~%" (-> obj los))
+  (format #t "~2Treticle: ~D~%" (-> obj reticle))
+  (format #t "~2Tscreen: ~D~%" (-> obj screen))
+  (format #t "~2Ttank-quat: #<quaternion @ #x~X>~%" (-> obj tank-quat))
+  (format #t "~2Ttank-quat-vibe-only: #<quaternion @ #x~X>~%" (-> obj tank-quat-vibe-only))
+  (format #t "~2Trotate-quat: #<quaternion @ #x~X>~%" (-> obj rotate-quat))
+  (format #t "~2Trotate-rate: ~f~%" (-> obj rotate-rate))
+  (format #t "~2Trotate-mult: ~f~%" (-> obj rotate-mult))
+  (format #t "~2Tshot-range: ~f~%" (-> obj shot-range))
+  (format #t "~2Tfov-mult: ~f~%" (-> obj fov-mult))
+  (format #t "~2Toffset: #<vector @ #x~X>~%" (-> obj offset))
+  (format #t "~2Tsight-pos: #<vector @ #x~X>~%" (-> obj sight-pos))
+  (format #t "~2Tfiring-sight-pos: #<vector @ #x~X>~%" (-> obj firing-sight-pos))
+  (format #t "~2Taim-pos[3] @ #x~X~%" (-> obj aim-pos))
+  (format #t "~2Tgun-timer: ~D~%" (-> obj gun-timer))
+  (format #t "~2Tgun-elev-jmod: ~A~%" (-> obj gun-elev-jmod))
+  (format #t "~2Tgun-elev: ~f~%" (-> obj gun-elev))
+  (format #t "~2Tgun-elev-cam: ~f~%" (-> obj gun-elev-cam))
+  (format #t "~2Tgun-joint-l[2] @ #x~X~%" (-> obj gun-joint-l))
+  (format #t "~2Tgun-joint-r[2] @ #x~X~%" (-> obj gun-joint-r))
+  (format #t "~2Tgun-spread: ~f~%" (-> obj gun-spread))
+  (format #t "~2Tgun-index: ~D~%" (-> obj gun-index))
+  (format #t "~2Tflags: ~D~%" (-> obj flags))
+  (format #t "~2Tturn-sound-id: ~D~%" (-> obj turn-sound-id))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-robotank-reticle
+(deftype fort-robotank-reticle (process-drawable)
+  ((shadow-jmod  joint-mod          :offset-assert 200)
+   (sight-jmod   joint-mod          :offset-assert 204)
+   (ring-jmod    joint-mod  3       :offset-assert 208)
+   (ring-timer   time-frame         :offset-assert 224)
+   (sight-scale  vector     :inline :offset-assert 240)
+   (collide-dist float              :offset-assert 256)
+   )
+  :heap-base #x90
+  :method-count-assert 22
+  :size-assert         #x104
+  :flag-assert         #x1600900104
+  (:methods
+    (idle () _type_ :state 20)
+    (lock () _type_ :state 21)
+    )
+  )
+
+;; definition for method 3 of type fort-robotank-reticle
+(defmethod inspect fort-robotank-reticle ((obj fort-robotank-reticle))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tshadow-jmod: ~A~%" (-> obj shadow-jmod))
+  (format #t "~2Tsight-jmod: ~A~%" (-> obj sight-jmod))
+  (format #t "~2Tring-jmod[3] @ #x~X~%" (-> obj ring-jmod))
+  (format #t "~2Tring-timer: ~D~%" (-> obj ring-timer))
+  (format #t "~2Tsight-scale: #<vector @ #x~X>~%" (-> obj sight-scale))
+  (format #t "~2Tcollide-dist: ~f~%" (-> obj collide-dist))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-roboscreen
+(deftype fort-roboscreen (process-drawable)
+  ((anim-frame float   :offset-assert 200)
+   (transition float   :offset-assert 204)
+   (gui-id-1   uint32  :offset-assert 208)
+   (gui-id-2   uint32  :offset-assert 212)
+   )
+  :heap-base #x60
+  :method-count-assert 25
+  :size-assert         #xd8
+  :flag-assert         #x19006000d8
+  (:methods
+    (idle () _type_ :state 20)
+    (active () _type_ :state 21)
+    (deactive () _type_ :state 22)
+    (die () _type_ :state 23)
+    (fort-roboscreen-method-24 (_type_) none 24)
+    )
+  )
+
+;; definition for method 3 of type fort-roboscreen
+(defmethod inspect fort-roboscreen ((obj fort-roboscreen))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tanim-frame: ~f~%" (-> obj anim-frame))
+  (format #t "~2Ttransition: ~f~%" (-> obj transition))
+  (format #t "~2Tgui-id-1: ~D~%" (-> obj gui-id-1))
+  (format #t "~2Tgui-id-2: ~D~%" (-> obj gui-id-2))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-roboscreen fort-roboscreen fort-roboscreen-lod0-jg fort-roboscreen-idle-ja
+              ((fort-roboscreen-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 8)
+              )
+
+;; failed to figure out what this is:
+(defstate idle (fort-roboscreen)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('trigger)
+       (set! (-> self state-time) (-> self clock frame-counter))
+       (go-virtual active)
+       )
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :enter (behavior ()
+    (logior! (-> self draw status) (draw-control-status no-draw))
+    (set! (-> self transition) 0.0)
+    (none)
+    )
+  :code (the-as (function none :behavior fort-roboscreen) sleep-code)
+  )
+
+;; failed to figure out what this is:
+(defstate active (fort-roboscreen)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('untrigger)
+       (go-virtual deactive)
+       )
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :enter (behavior ()
+    (logclear! (-> self draw status) (draw-control-status no-draw))
+    (set-action!
+      *gui-control*
+      (gui-action play)
+      (the-as sound-id (-> self gui-id-1))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (set-action!
+      *gui-control*
+      (gui-action play)
+      (the-as sound-id (-> self gui-id-2))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (none)
+    )
+  :exit (behavior ()
+    (set-action!
+      *gui-control*
+      (gui-action hidden)
+      (the-as sound-id (-> self gui-id-1))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (set-action!
+      *gui-control*
+      (gui-action hidden)
+      (the-as sound-id (-> self gui-id-2))
+      (gui-channel none)
+      (gui-action none)
+      (the-as string #f)
+      (the-as (function gui-connection symbol) #f)
+      (the-as process #f)
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (when (and (not (paused?)) (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)))
+        (seek! (-> self anim-frame) 0.0 (* 0.2 (-> self clock time-adjust-ratio)))
+        (seek! (-> self transition) 1.0 (* 0.01 (-> self clock time-adjust-ratio)))
+        )
+      (set-roboscreen-alpha! (-> self transition))
+      (ja :num-func num-func-identity :frame-num (-> self anim-frame))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (fort-roboscreen-method-24 self)
+    (ja-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate deactive (fort-roboscreen)
+  :virtual #t
+  :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
+    (case event-type
+      (('die)
+       (go-virtual die)
+       )
+      )
+    )
+  :code (behavior ()
+    (until #f
+      (when (not (paused?))
+        (seek! (-> self anim-frame) 15.0 (* 0.2 (-> self clock time-adjust-ratio)))
+        (seek! (-> self transition) 0.0 (* 0.015 (-> self clock time-adjust-ratio)))
+        )
+      (set-roboscreen-alpha! (-> self transition))
+      (when (= (-> self anim-frame) 15.0)
+        (set-roboscreen-alpha! 0.0)
+        (go-virtual idle)
+        )
+      (ja :num-func num-func-identity :frame-num (-> self anim-frame))
+      (suspend)
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (fort-roboscreen-method-24 self)
+    (ja-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-roboscreen)
+  :virtual #t
+  :code (behavior ()
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (seek! (-> self transition) 0.0 (-> self clock seconds-per-frame))
+        (set-roboscreen-alpha! (-> self transition))
+        (suspend)
+        )
+      )
+    (none)
+    )
+  )
+
+;; definition for method 24 of type fort-roboscreen
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod fort-roboscreen-method-24 fort-roboscreen ((obj fort-roboscreen))
+  (rlet ((acc :class vf)
+         (vf0 :class vf)
+         (vf4 :class vf)
+         (vf5 :class vf)
+         (vf6 :class vf)
+         (vf7 :class vf)
+         )
+    (init-vf0-vector)
+    (let ((s3-0 (camera-matrix))
+          (s5-0 (new 'stack-no-clear 'vector))
+          (gp-0 (new 'stack-no-clear 'vector))
+          (f30-0 4096.0)
+          )
+      (let ((f0-4 (* 0.00013563369 (tan (* 0.5 (-> *math-camera* fov))) f30-0)))
+        (set-vector! (-> obj root scale) f0-4 f0-4 f0-4 1.0)
+        )
+      (set! (-> gp-0 quad) (-> (camera-pos) quad))
+      (vector-normalize-copy! s5-0 (-> s3-0 vector 2) 1.0)
+      (matrix->quaternion (-> obj root quat) s3-0)
+      (let ((v1-10 (-> obj root trans)))
+        (let ((a0-5 f30-0))
+          (.mov vf7 a0-5)
+          )
+        (.lvf vf5 (&-> s5-0 quad))
+        (.lvf vf4 (&-> gp-0 quad))
+        (.add.x.vf vf6 vf0 vf0 :mask #b1000)
+        (.mul.x.vf acc vf5 vf7 :mask #b111)
+        (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
+        (.svf (&-> v1-10 quad) vf6)
+        )
+      )
+    0
+    (none)
+    )
+  )
+
+;; definition for function fort-roboscreen-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-roboscreen-init-by-other fort-roboscreen ((arg0 vector) (arg1 quaternion) (arg2 entity-actor))
+  (process-entity-set! self arg2)
+  (set! (-> self root) (new 'process 'trsqv))
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (quaternion-copy! (-> self root quat) arg1)
+  (initialize-skeleton
+    self
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-roboscreen" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (set! (-> self anim-frame) 15.0)
+  (set! (-> self transition) 0.0)
+  (set! (-> self gui-id-1)
+        (the-as
+          uint
+          (add-process *gui-control* self (gui-channel hud-center-left) (gui-action hidden) (-> self name) 81920.0 0)
+          )
+        )
+  (set! (-> self gui-id-2)
+        (the-as
+          uint
+          (add-process *gui-control* self (gui-channel hud-middle-left) (gui-action hidden) (-> self name) 81920.0 0)
+          )
+        )
+  (set-vector! (-> self draw color-emissive) 0.0 0.0 0.0 0.0)
+  (set-vector! (-> self draw color-emissive) 0.0 0.0 0.0 0.0)
+  (logior! (-> self skel status) (joint-control-status blend-shape))
+  (ja :group! (-> self draw art-group data 3))
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition for method 10 of type fort-roboscreen
+(defmethod deactivate fort-roboscreen ((obj fort-roboscreen))
+  (disable *screen-filter*)
+  (set-roboscreen-alpha! 0.0)
+  ((the-as (function process-drawable none) (find-parent-method fort-roboscreen 10)) obj)
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defpartgroup group-robotank-steamescape
+  :id 561
+  :bounds (static-bspherem 0 0 0 6)
+  :parts ((sp-item 2471 :fade-after (meters 100) :falloff-to (meters 100) :flags (bit7)))
+  )
+
+;; failed to figure out what this is:
+(defpart 2471
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 0.5 1.0 1.0)
+    (sp-rnd-flt spt-x (meters -3) (meters 5) 1.0)
+    (sp-rnd-flt spt-y (meters -0.1) (meters 0.3) 1.0)
+    (sp-rnd-flt spt-z (meters 0.2) (meters 0.2) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.25) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 64.0 128.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 0.0)
+    (sp-rnd-flt spt-vel-z (meters 0.005) (meters 0.0025) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.0016666667) (meters 0.0033333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-a 0.64)
+    (sp-rnd-flt spt-accel-y 0.68266666 0.68266666 1.0)
+    (sp-flt spt-friction 0.99)
+    (sp-int spt-timer 600)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12)
+    (sp-int-plain-rnd spt-next-time 25 24 1)
+    (sp-launcher-by-id spt-next-launcher 2472)
+    (sp-rnd-flt spt-launchrot-x (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-rnd-flt spt-launchrot-y (degrees -5.0) (degrees 10.0) 1.0)
+    (sp-flt spt-rotate-y (degrees 0.0))
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 2472
+  :init-specs ((sp-rnd-flt spt-fade-a -0.064 -0.064 1.0))
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-robotank-reticle fort-robotank-sight fort-robotank-sight-lod0-jg fort-robotank-sight-idle-ja
+              ((fort-robotank-sight-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0.5 84)
+              :longest-edge (meters 80)
+              :shadow fort-robotank-sight-shadow-mg
+              :origin-joint-index 5
+              )
+
+;; definition for function fort-robotank-reticle-post
+;; INFO: Used lq/sq
+(defbehavior fort-robotank-reticle-post fort-robotank-reticle ()
+  (let ((s5-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root quat)))
+        (s1-0 (new 'stack-no-clear 'vector))
+        (s3-0 (camera-pos))
+        (s4-0 (-> self draw shadow-ctrl settings shadow-dir))
+        (gp-0 (-> self draw shadow-ctrl settings bot-plane))
+        (s2-0 (-> self draw shadow-ctrl settings top-plane))
+        )
+    (-> self draw shadow-ctrl settings)
+    (vector-normalize! s5-0 1.0)
+    (vector-negate! s1-0 s5-0)
+    (set! (-> s4-0 x) (-> s5-0 x))
+    (set! (-> s4-0 y) (-> s5-0 y))
+    (set! (-> s4-0 z) (-> s5-0 z))
+    (set! (-> s4-0 w) -16384.0)
+    (set! (-> s2-0 quad) (-> s5-0 quad))
+    (set! (-> gp-0 quad) (-> s5-0 quad))
+    (let ((s4-1 (new 'stack-no-clear 'vector)))
+      (vector+float*! s4-1 (-> self root trans) s5-0 -4096.0)
+      (set! (-> s2-0 w) (- (vector-dot s4-1 s5-0)))
+      (vector+float*! s4-1 (-> self root trans) s5-0 (-> self collide-dist))
+      (let* ((a1-6 (vector-! (new 'stack-no-clear 'vector) s3-0 s4-1))
+             (f1-0 (vector-length a1-6))
+             (a2-2
+               (vector-normalize-copy! (new 'stack-no-clear 'vector) a1-6 (fmax -20480.0 (fmin 20480.0 (* 0.75 f1-0))))
+               )
+             (v1-26 (vector-float*! (new 'stack-no-clear 'vector) s5-0 (- (vector-dot a2-2 s5-0))))
+             )
+        (vector+! s4-1 s4-1 v1-26)
+        )
+      (set! (-> gp-0 w) (- (vector-dot s4-1 s5-0)))
+      )
+    )
+  0
+  (vector-seek! (-> self sight-jmod twist-max) (-> self sight-scale) (* 6.0 (-> self clock seconds-per-frame)))
+  (ja-post)
+  (none)
+  )
+
+;; definition for function fort-robotank-reticle-handler
+;; INFO: Used lq/sq
+(defbehavior fort-robotank-reticle-handler fort-robotank-reticle ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (case arg2
+    (('update-trans-only)
+     (set! v0-0 (-> self root trans))
+     (set! (-> (the-as vector v0-0) quad) (-> (the-as vector (-> arg3 param 0)) quad))
+     v0-0
+     )
+    (('update)
+     (let ((s5-0 (the-as object (-> arg3 param 0)))
+           (gp-0 (-> arg3 param 1))
+           )
+       (let ((a1-3 (vector-normalize-copy!
+                     (new 'stack-no-clear 'vector)
+                     (vector-! (new 'stack-no-clear 'vector) (the-as vector gp-0) (the-as vector s5-0))
+                     1.0
+                     )
+                   )
+             )
+         (set! (-> self root trans quad) (-> (the-as vector s5-0) quad))
+         (forward-up->quaternion (-> self root quat) a1-3 *up-vector*)
+         )
+       (let ((f0-0 (vector-length (vector-! (new 'stack-no-clear 'vector) (the-as vector gp-0) (the-as vector s5-0))))
+             (gp-1 (-> self sight-scale))
+             )
+         (set! (-> gp-1 z) (* 0.000024414063 f0-0))
+         (let ((f0-1 (lerp-scale 0.1 6.0 f0-0 61440.0 163840.0)))
+           (set! (-> gp-1 x) f0-1)
+           (set! (-> gp-1 y) f0-1)
+           f0-1
+           )
+         )
+       )
+     )
+    (('collide-dist)
+     (set! (-> self collide-dist) (the-as float (-> arg3 param 0)))
+     )
+    (('on)
+     (let ((v1-14 (-> self draw shadow-ctrl)))
+       (logclear! (-> v1-14 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     (set! v0-0 (logclear (-> self draw status) (draw-control-status no-draw)))
+     (set! (-> self draw status) (the-as draw-control-status v0-0))
+     v0-0
+     )
+    (('off)
+     (let ((v1-19 (-> self draw shadow-ctrl)))
+       (logior! (-> v1-19 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     (set! v0-0 (logior (-> self draw status) (draw-control-status no-draw)))
+     (set! (-> self draw status) (the-as draw-control-status v0-0))
+     v0-0
+     )
+    (('spotlight-on)
+     (let ((v1-25 (-> self draw shadow-ctrl)))
+       (logclear! (-> v1-25 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     )
+    (('spotlight-off)
+     (let ((v1-27 (-> self draw shadow-ctrl)))
+       (logior! (-> v1-27 settings flags) (shadow-flags disable-draw))
+       )
+     0
+     )
+    (('lock)
+     (go-virtual lock)
+     )
+    (('unlock)
+     (go-virtual idle)
+     )
+    (('die)
+     (go empty-state)
+     )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (fort-robotank-reticle)
+  :virtual #t
+  :event fort-robotank-reticle-handler
+  :enter (behavior ()
+    (set! (-> self ring-timer) 0)
+    (dotimes (v1-0 3)
+      (set! (-> self ring-jmod v1-0 twist z) (the-as float #t))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-no-eval :group! (-> self draw art-group data 3) :num! zero)
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (when (< (-> self ring-timer) (-> self clock frame-counter))
+      (let ((v1-2 (rand-vu-int-range 0 7)))
+        (dotimes (a0-3 3)
+          (if (logand (ash 1 a0-3) v1-2)
+              (set! (-> self ring-jmod a0-3 twist y) (* -1.0 (-> self ring-jmod a0-3 twist y)))
+              )
+          )
+        )
+      (set! (-> self ring-timer)
+            (+ (-> self clock frame-counter) (the int (* 300.0 (rand-vu-float-range 0.6 1.8))))
+            )
+      )
+    (fort-robotank-reticle-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate lock (fort-robotank-reticle)
+  :virtual #t
+  :event fort-robotank-reticle-handler
+  :enter (behavior ()
+    (dotimes (v1-0 3)
+      (set! (-> self ring-jmod v1-0 twist z) (the-as float #f))
+      )
+    (none)
+    )
+  :code (behavior ()
+    (ja-channel-push! 1 (seconds 0.04))
+    (ja-no-eval :group! (-> self draw art-group data 4)
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (sleep-code)
+    (none)
+    )
+  :post fort-robotank-reticle-post
+  )
+
+;; definition for method 7 of type fort-robotank-reticle
+;; WARN: Return type mismatch process-drawable vs fort-robotank-reticle.
+(defmethod relocate fort-robotank-reticle ((obj fort-robotank-reticle) (arg0 int))
+  (if (nonzero? (-> obj shadow-jmod))
+      (&+! (-> obj shadow-jmod) arg0)
+      )
+  (if (nonzero? (-> obj sight-jmod))
+      (&+! (-> obj sight-jmod) arg0)
+      )
+  (dotimes (v1-8 3)
+    (if (nonzero? (-> obj ring-jmod v1-8))
+        (&+! (-> obj ring-jmod v1-8) arg0)
+        )
+    )
+  (the-as fort-robotank-reticle ((method-of-type process-drawable relocate) obj arg0))
+  )
+
+;; definition for function fort-robotank-reticle-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-robotank-reticle-init-by-other fort-robotank-reticle ((arg0 vector))
+  (set! (-> self root) (new 'process 'trsqv))
+  (set! (-> self root trans quad) (-> arg0 quad))
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-fort-robotank-reticle" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (set-vector! (-> self root scale) 0.6 0.6 1.0 1.0)
+  (set! (-> self collide-dist) 491520.0)
+  (set! (-> self shadow-jmod) (the-as joint-mod (new 'process 'joint-mod-set-local self 4 #f #f #t)))
+  (set-vector! (-> self shadow-jmod twist-max) 0.3 0.3 1.0 1.0)
+  (set! (-> self sight-jmod) (the-as joint-mod (new 'process 'joint-mod-set-local self 5 #f #f #t)))
+  (set-vector! (-> self sight-jmod twist-max) 1.0 1.0 1.0 1.0)
+  (set! (-> self sight-scale quad) (-> self sight-jmod twist-max quad))
+  (set! (-> self ring-jmod 0) (the-as joint-mod (new 'process 'joint-mod-spinner self 6 *z-vector* 49152.0)))
+  (set! (-> self ring-jmod 1) (the-as joint-mod (new 'process 'joint-mod-spinner self 7 *z-vector* -32768.0)))
+  (set! (-> self ring-jmod 2) (the-as joint-mod (new 'process 'joint-mod-spinner self 8 *z-vector* 8192.0)))
+  (let ((v1-20 (new
+                 'process
+                 'shadow-control
+                 0.0
+                 0.0
+                 614400.0
+                 (shadow-flags disable-fade shdf02 shdf03 shdf04 shdf07)
+                 491520.0
+                 )
+               )
+        )
+    (set! (-> v1-20 settings shadow-type) 1)
+    (set! (-> self draw shadow-ctrl) v1-20)
+    )
+  (ja-no-eval :group! (-> self draw art-group data 3) :num! zero)
+  (ja-post)
+  (set-setting! 'spotlight-color #f 0 (the-as uint #x80a0a0ff))
+  (go-virtual idle)
+  (none)
+  )
+
+;; definition of type fort-robotank-shot
+(deftype fort-robotank-shot (guard-shot)
+  ()
+  :heap-base #x170
+  :method-count-assert 40
+  :size-assert         #x1f0
+  :flag-assert         #x28017001f0
+  )
+
+;; definition for method 3 of type fort-robotank-shot
+(defmethod inspect fort-robotank-shot ((obj fort-robotank-shot))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type guard-shot inspect)))
+    (t9-0 obj)
+    )
+  (label cfg-4)
+  obj
+  )
+
+;; definition for method 28 of type fort-robotank-shot
+;; WARN: Return type mismatch int vs sound-id.
+(defmethod play-impact-sound fort-robotank-shot ((obj fort-robotank-shot) (arg0 projectile-options))
+  (let ((v1-0 arg0))
+    (cond
+      ((zero? v1-0)
+       (sound-play "robotank-shot")
+       )
+      ((= v1-0 (projectile-options lose-altitude))
+       (sound-play "fort-robotank-s")
+       )
+      )
+    )
+  (the-as sound-id 0)
+  )
+
+;; definition for method 30 of type fort-robotank-shot
+;; WARN: Return type mismatch int vs none.
+(defmethod init-collision! fort-robotank-shot ((obj fort-robotank-shot))
+  "Init the [[projectile]]'s [[collide-shape]]"
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction)
+          (the-as (function control-info collide-query vector vector collide-status) cshape-reaction-just-move)
+          )
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrate-using) (penetrate enemy-yellow-shot))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 3))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec projectile))
+      (set! (-> s4-0 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> s4-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 2457.6)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (let ((v1-13 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-13 prim-core collide-as) (collide-spec projectile))
+      (set! (-> v1-13 prim-core collide-with)
+            (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list)
+            )
+      (set! (-> v1-13 prim-core action) (collide-action solid deadly))
+      (set-vector! (-> v1-13 local-sphere) 0.0 0.0 0.0 819.2)
+      )
+    (let ((v1-15 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
+      (set! (-> v1-15 prim-core collide-as) (collide-spec projectile))
+      (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot crate hit-by-others-list player-list))
+      (set! (-> v1-15 prim-core action) (collide-action deadly))
+      (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 2457.6)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-18 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-18 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-18 prim-core collide-with))
+      )
+    (set! (-> s5-0 max-iteration-count) (the-as uint 1))
+    (set! (-> s5-0 event-self) 'touched)
+    (set! (-> obj root-override) s5-0)
+    )
+  (set! (-> obj root-override pat-ignore-mask)
+        (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
+        )
+  0
+  (none)
+  )
+
+;; definition for method 31 of type fort-robotank-shot
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defmethod init-proj-settings! fort-robotank-shot ((obj fort-robotank-shot))
+  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
+       :virtual"
+  (set! (-> obj tail-pos quad) (-> obj root-override trans quad))
+  (set! (-> obj attack-mode) 'fort-robotank-shot)
+  (set! (-> obj max-speed) 819200.0)
+  (set! (-> obj move) guard-shot-move)
+  (set! (-> obj update-velocity) projectile-update-velocity-space-wars)
+  (set! (-> obj timeout) (seconds 0.5))
+  (logior! (-> obj options) (projectile-options account-for-target-velocity))
+  (set-gravity-length (-> obj root-override dynam) 573440.0)
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-robotank-turret fort-robotank-top fort-robotank-top-lod0-jg fort-robotank-top-idle-ja
+              ((fort-robotank-top-lod0-mg (meters 20)) (fort-robotank-top-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 4)
+              :origin-joint-index 3
+              )
+
+;; failed to figure out what this is:
+(defpart 2473
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbc :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1.5) (meters 0.1) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 64.0 1.0)
+    (sp-flt spt-g 0.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 96.0 64.0 1.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-flt spt-fade-g -1.0666667)
+    (sp-flt spt-fade-b -1.0666667)
+    (sp-flt spt-fade-a -8.533334)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 1.0)
+    )
+  )
+
+;; definition for function draw-2d-hud
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch pointer vs symbol.
+;; WARN: Failed store: (s.w! (+ t5-0 8) 0) at op 82
+;; WARN: Failed store: (s.w! (+ t5-0 12) t6-1) at op 84
+;; WARN: Failed store: (s.d! (+ t5-2 8) t1-0) at op 90
+;; WARN: Failed store: (s.q! (+ t5-4 16) t6-3) at op 98
+;; WARN: Failed store: (s.q! (+ t5-4 32) t6-4) at op 100
+;; WARN: Failed store: (s.q! (+ t5-4 48) t6-5) at op 102
+;; WARN: Failed store: (s.d! (+ t5-6 8) t1-0) at op 108
+;; WARN: Failed store: (s.q! (+ t5-8 16) t3-1) at op 116
+;; WARN: Failed store: (s.q! (+ t5-8 32) t3-2) at op 118
+;; WARN: Failed store: (s.q! (+ t5-8 48) t3-3) at op 120
+;; WARN: Failed store: (s.d! (+ t4-5 8) t1-0) at op 126
+;; WARN: Failed store: (s.q! (+ t4-7 16) t2-1) at op 134
+;; WARN: Failed store: (s.q! (+ t4-7 32) t2-2) at op 136
+;; WARN: Failed store: (s.q! (+ t4-7 48) t2-3) at op 138
+;; WARN: Failed store: (s.d! (+ t3-7 8) t1-0) at op 144
+;; WARN: Failed store: (s.q! (+ t1-1 16) a3-1) at op 152
+;; WARN: Failed store: (s.q! (+ t1-1 32) a3-2) at op 154
+;; WARN: Failed store: (s.q! (+ t1-1 48) a1-2) at op 156
+;; WARN: Failed load: (set! t0-6 (l.d (+ a0-28 8))) at op 170
+;; WARN: Failed store: (s.d! (+ a0-28 8) a3-10) at op 175
+;; WARN: Failed store: (s.w! (+ a0-29 8) 0) at op 183
+;; WARN: Failed store: (s.w! (+ a0-29 12) 0) at op 184
+(defun draw-2d-hud ((arg0 vector))
+  "Unused but, maybe useful? TODO - dma buffer casting"
+  (let ((s5-0 (new 'stack-no-clear 'inline-array 'vector4w 4))
+        (gp-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> arg0 w) 1.0)
+    (the-as
+      symbol
+      (when (transform-point-qword! (-> s5-0 0) arg0)
+        (set! (-> s5-0 1 quad) (-> s5-0 0 quad))
+        (set! (-> s5-0 2 quad) (-> s5-0 0 quad))
+        (set! (-> s5-0 3 quad) (-> s5-0 0 quad))
+        (let ((v1-5 160))
+          (set! (-> s5-0 0 x) (- (-> s5-0 0 x) v1-5))
+          (set! (-> s5-0 0 y) (- (-> s5-0 0 y) v1-5))
+          (+! (-> s5-0 1 x) v1-5)
+          (set! (-> s5-0 1 y) (- (-> s5-0 1 y) v1-5))
+          (+! (-> s5-0 2 x) v1-5)
+          (+! (-> s5-0 2 y) v1-5)
+          (set! (-> s5-0 3 x) (- (-> s5-0 3 x) v1-5))
+          (+! (-> s5-0 3 y) v1-5)
+          )
+        (set! (-> gp-0 x) 0.0)
+        (set! (-> gp-0 y) (the-as float #x80))
+        (set! (-> gp-0 z) (the-as float #x80))
+        (set! (-> gp-0 w) (the-as float #x80))
+        (with-dma-buffer-add-bucket ((v1-15 (-> *display* frames (-> *display* on-screen) global-buf))
+                                     (bucket-id debug-no-zbuf1)
+                                     )
+          (let ((a1-1 (-> s5-0 0)))
+            (let ((t3-0 (-> s5-0 1))
+                  (t2-0 (-> s5-0 2))
+                  (a3-0 (-> s5-0 3))
+                  (t0-0 (make-u128 0 (the-as uint #x4024c00000008001)))
+                  (t1-0 #x4141)
+                  )
+              (+! (-> a1-1 z) -8192)
+              (+! (-> t3-0 z) -8192)
+              (+! (-> t2-0 z) -8192)
+              (+! (-> a3-0 z) -8192)
+              (let ((a0-28 (-> v1-15 base)))
+                (let* ((t4-0 v1-15)
+                       (t5-0 (-> t4-0 base))
+                       )
+                  (set! (-> (the-as (pointer int64) t5-0)) #x10000000)
+                  (s.w! (+ t5-0 8) 0)
+                  (let ((t6-1 #x50000000))
+                    (s.w! (+ t5-0 12) t6-1)
+                    )
+                  (set! (-> t4-0 base) (&+ t5-0 16))
+                  )
+                (let* ((t4-1 v1-15)
+                       (t5-2 (-> t4-1 base))
+                       )
+                  (set! (-> (the-as (pointer uint64) t5-2)) t0-0)
+                  (s.d! (+ t5-2 8) t1-0)
+                  (set! (-> t4-1 base) (&+ t5-2 16))
+                  )
+                (let* ((t4-2 v1-15)
+                       (t5-4 (-> t4-2 base))
+                       )
+                  (set! (-> (the-as (pointer uint128) t5-4)) (-> gp-0 quad))
+                  (let ((t6-3 (-> a1-1 quad)))
+                    (s.q! (+ t5-4 16) t6-3)
+                    )
+                  (let ((t6-4 (-> gp-0 quad)))
+                    (s.q! (+ t5-4 32) t6-4)
+                    )
+                  (let ((t6-5 (-> t3-0 quad)))
+                    (s.q! (+ t5-4 48) t6-5)
+                    )
+                  (set! (-> t4-2 base) (&+ t5-4 64))
+                  )
+                (let* ((t4-3 v1-15)
+                       (t5-6 (-> t4-3 base))
+                       )
+                  (set! (-> (the-as (pointer uint64) t5-6)) t0-0)
+                  (s.d! (+ t5-6 8) t1-0)
+                  (set! (-> t4-3 base) (&+ t5-6 16))
+                  )
+                (let* ((t4-4 v1-15)
+                       (t5-8 (-> t4-4 base))
+                       )
+                  (set! (-> (the-as (pointer uint128) t5-8)) (-> gp-0 quad))
+                  (let ((t3-1 (-> t3-0 quad)))
+                    (s.q! (+ t5-8 16) t3-1)
+                    )
+                  (let ((t3-2 (-> gp-0 quad)))
+                    (s.q! (+ t5-8 32) t3-2)
+                    )
+                  (let ((t3-3 (-> t2-0 quad)))
+                    (s.q! (+ t5-8 48) t3-3)
+                    )
+                  (set! (-> t4-4 base) (&+ t5-8 64))
+                  )
+                (let* ((t3-5 v1-15)
+                       (t4-5 (-> t3-5 base))
+                       )
+                  (set! (-> (the-as (pointer uint64) t4-5)) t0-0)
+                  (s.d! (+ t4-5 8) t1-0)
+                  (set! (-> t3-5 base) (&+ t4-5 16))
+                  )
+                (let* ((t3-6 v1-15)
+                       (t4-7 (-> t3-6 base))
+                       )
+                  (set! (-> (the-as (pointer uint128) t4-7)) (-> gp-0 quad))
+                  (let ((t2-1 (-> t2-0 quad)))
+                    (s.q! (+ t4-7 16) t2-1)
+                    )
+                  (let ((t2-2 (-> gp-0 quad)))
+                    (s.q! (+ t4-7 32) t2-2)
+                    )
+                  (let ((t2-3 (-> a3-0 quad)))
+                    (s.q! (+ t4-7 48) t2-3)
+                    )
+                  (set! (-> t3-6 base) (&+ t4-7 64))
+                  )
+                (let* ((t2-5 v1-15)
+                       (t3-7 (-> t2-5 base))
+                       )
+                  (set! (-> (the-as (pointer uint64) t3-7)) t0-0)
+                  (s.d! (+ t3-7 8) t1-0)
+                  (set! (-> t2-5 base) (&+ t3-7 16))
+                  )
+                (let* ((t0-2 v1-15)
+                       (t1-1 (-> t0-2 base))
+                       )
+                  (set! (-> (the-as (pointer uint128) t1-1)) (-> gp-0 quad))
+                  (let ((a3-1 (-> a3-0 quad)))
+                    (s.q! (+ t1-1 16) a3-1)
+                    )
+                  (let ((a3-2 (-> gp-0 quad)))
+                    (s.q! (+ t1-1 32) a3-2)
+                    )
+                  (let ((a1-2 (-> a1-1 quad)))
+                    (s.q! (+ t1-1 48) a1-2)
+                    )
+                  (set! (-> t0-2 base) (&+ t1-1 64))
+                  )
+                (let ((a3-6 (/ (the-as int (+ (- -16 (the-as int a0-28)) (the-as int (-> v1-15 base)))) 16)))
+                  (cond
+                    ((nonzero? a3-6)
+                     (logior! (-> (the-as (pointer uint64) a0-28)) (shr (shl a3-6 48) 48))
+                     (let ((a3-10 (logior (l.d (&+ a0-28 8)) (shl (shr (shl a3-6 48) 48) 32))))
+                       (s.d! (+ a0-28 8) a3-10)
+                       )
+                     )
+                    (else
+                      (set! (-> v1-15 base) a0-28)
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for method 32 of type fort-robotank-turret
+;; INFO: Used lq/sq
+(defmethod fort-robotank-turret-method-32 fort-robotank-turret ((obj fort-robotank-turret) (arg0 (inline-array vector)))
+  (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params)))
+    (let ((v1-0 (-> arg0 0))
+          (a0-1 (-> arg0 1))
+          )
+      (set! (-> gp-0 ent) (-> obj entity))
+      (set! (-> gp-0 charge) 1.0)
+      (set! (-> gp-0 options) (projectile-options))
+      (set! (-> gp-0 pos quad) (-> v1-0 quad))
+      (set! (-> gp-0 notify-handle) (process->handle obj))
+      (set! (-> gp-0 owner-handle) (the-as handle #f))
+      (set! (-> gp-0 ignore-handle) (process->handle obj))
+      (let* ((a1-10 *game-info*)
+             (a2-11 (+ (-> a1-10 attack-id) 1))
+             )
+        (set! (-> a1-10 attack-id) a2-11)
+        (set! (-> gp-0 attack-id) a2-11)
+        )
+      (set! (-> gp-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-! (-> gp-0 vel) a0-1 v1-0)
+      )
+    (vector-normalize! (-> gp-0 vel) 512000.0)
+    (spawn-projectile fort-robotank-shot gp-0 obj *default-dead-pool*)
+    )
+  )
+
+;; definition for method 33 of type fort-robotank-turret
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch (pointer process) vs none.
+(defmethod fort-robotank-turret-method-33 fort-robotank-turret ((obj fort-robotank-turret))
+  (local-vars (sv-144 vector) (sv-160 vector))
+  (let ((s3-0 (new 'stack-no-clear 'inline-array 'vector 2))
+        (s5-0 (new 'stack-no-clear 'inline-array 'vector 4))
+        )
+    (-> obj node-list data 11)
+    (let ((s4-0 (new 'stack-no-clear 'vector))
+          (s1-0 (-> obj sight-pos))
+          (s2-0 (-> obj gun-index))
+          )
+      0.0
+      0.0
+      (vector<-cspace! (-> s3-0 0) (-> obj node-list data (-> obj gun-joint-l s2-0)))
+      (vector<-cspace! (-> s3-0 1) (-> obj node-list data (-> obj gun-joint-r s2-0)))
+      (let ((f30-0 (* 0.5 (vector-length (vector-! (new 'stack-no-clear 'vector) (-> s3-0 1) (-> s3-0 0))))))
+        (let ((f28-0 (fmax 81920.0 (+ 12288.0 (vector-length (vector-! (new 'stack-no-clear 'vector) s1-0 (-> s3-0 0)))))))
+          (vector-normalize-copy! s4-0 (-> obj node-list data (-> obj gun-joint-l s2-0) bone transform vector 2) 1.0)
+          (let ((s0-0 vector-rotate-y!))
+            (set! sv-144 s4-0)
+            (set! sv-160 s4-0)
+            (let ((a2-1 (- 16384.0 (acos (/ f30-0 f28-0)))))
+              (s0-0 sv-144 sv-160 a2-1)
+              )
+            )
+          (set! (-> s5-0 0 quad) (-> s3-0 0 quad))
+          (vector+float*! (-> s5-0 1) (-> s5-0 0) s4-0 512000.0)
+          (set! (-> obj shot-range) (fmin 204800.0 f28-0))
+          )
+        (fort-robotank-turret-method-32 obj s5-0)
+        (let ((f28-1 (fmax 81920.0 (+ 12288.0 (vector-length (vector-! (new 'stack-no-clear 'vector) s1-0 (-> s3-0 1)))))))
+          (vector-normalize-copy! s4-0 (-> obj node-list data (-> obj gun-joint-r s2-0) bone transform vector 2) 1.0)
+          (vector-rotate-y! s4-0 s4-0 (- (- 16384.0 (acos (/ f30-0 f28-1)))))
+          (set! (-> s5-0 0 quad) (-> s3-0 1 quad))
+          (vector+float*! (-> s5-0 1) (-> s5-0 0) s4-0 512000.0)
+          (set! (-> obj shot-range) (fmin 204800.0 f28-1))
+          )
+        )
+      )
+    (fort-robotank-turret-method-32 obj s5-0)
+    )
+  (none)
+  )
+
+;; definition for method 31 of type fort-robotank-turret
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defmethod fort-robotank-turret-method-31 fort-robotank-turret ((obj fort-robotank-turret) (arg0 vector) (arg1 vector))
+  (let ((s3-0 (new 'stack-no-clear 'collide-query))
+        (f30-0 307200.0)
+        )
+    (set! (-> s3-0 start-pos quad) (-> arg0 quad))
+    (vector-float*! (-> s3-0 move-dist) arg1 f30-0)
+    (let ((v1-4 s3-0))
+      (set! (-> v1-4 radius) 4096.0)
+      (set! (-> v1-4 collide-with) (collide-spec backgnd jak bot enemy obstacle hit-by-others-list player-list))
+      (set! (-> v1-4 ignore-process0) (ppointer->process (-> obj parent)))
+      (set! (-> v1-4 ignore-process1) obj)
+      (set! (-> v1-4 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+      (set! (-> v1-4 action-mask) (collide-action solid semi-solid))
+      )
+    (let ((f28-0 (fill-and-probe-using-line-sphere *collide-cache* s3-0))
+          (s4-0 (-> obj sight-pos))
+          )
+      (cond
+        ((>= f28-0 0.0)
+         (let ((f0-3 (vector-length (-> s3-0 move-dist))))
+           (if (>= 20480.0 (* f0-3 f28-0))
+               (set! f28-0 (/ 20480.0 f0-3))
+               )
+           )
+         (vector+float*! s4-0 (-> s3-0 start-pos) (-> s3-0 move-dist) f28-0)
+         (let* ((s3-1 (-> s3-0 best-other-tri collide-ptr))
+                (s2-0 (if (type? s3-1 collide-shape-prim)
+                          (the-as collide-shape-prim s3-1)
+                          )
+                      )
+                (s3-2 (new 'stack-no-clear 'vector))
+                )
+           (set! (-> s3-2 quad) (-> s4-0 quad))
+           (vector+float*! s3-2 s3-2 (-> (math-camera-matrix) vector 2) -2048.0)
+           (cond
+             ((and s2-0
+                   (logtest? (process-mask target enemy) (-> s2-0 cshape process mask))
+                   (>= 307200.0 (vector-vector-distance s3-2 arg0))
+                   )
+              )
+             (else
+               (set! f30-0 (+ 12288.0 (* f30-0 f28-0)))
+               )
+             )
+           )
+         )
+        (else
+          (vector+! s4-0 (-> s3-0 start-pos) (-> s3-0 move-dist))
+          )
+        )
+      (send-event (handle->process (-> obj reticle)) 'update arg0 s4-0)
+      )
+    (send-event (handle->process (-> obj reticle)) 'collide-dist f30-0)
+    )
+  (none)
+  )
+
+;; definition for method 20 of type fort-robotank-turret
+;; WARN: Return type mismatch collide-prim-core vs vector.
+(defmethod get-trans fort-robotank-turret ((obj fort-robotank-turret) (arg0 int))
+  "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])"
+  (the-as vector (-> obj root-override root-prim prim-core))
+  )
+
+;; definition for function turret-post
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior turret-post fort-robotank-turret ()
+  (let* ((s5-0 *target*)
+         (gp-0 (if (type? s5-0 process-focusable)
+                   s5-0
+                   )
+               )
+         )
+    (cond
+      ((and (logtest? (-> self flags) 1) gp-0)
+       (send-event (handle->process (-> self reticle)) 'on)
+       (if (logtest? (-> self flags) 512)
+           (los-control-method-9 (-> self los) gp-0 (the-as vector #f) 1638.4)
+           )
+       (if *target*
+           (look-at! (-> *target* neck) (the-as vector (-> self root-override root-prim prim-core)) 'attacking self)
+           )
+       (set! (-> self aim-pos 0 quad) (-> self aim-pos-2 quad))
+       (set! (-> self aim-pos-2 quad) (-> (get-trans gp-0 0) quad))
+       (let ((s5-2 (-> self aim-pos-1))
+             (s4-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data (-> self gun-joint-l 0))))
+             )
+         (let ((v1-31 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data (-> self gun-joint-r 0)))))
+           (vector-! s5-2 (-> self aim-pos-2) (the-as vector (-> self aim-pos)))
+           (vector-float*! s5-2 s5-2 (* 0.8 (-> self clock frames-per-second)))
+           (set! (-> s5-2 y) 0.0)
+           (vector+! s5-2 (-> self aim-pos-2) s5-2)
+           (set! (-> s5-2 y) (+ 8192.0 (-> s5-2 y)))
+           (vector+! s4-0 s4-0 v1-31)
+           )
+         (vector-float*! s4-0 s4-0 0.5)
+         (let ((gp-2 (vector-! (new 'stack-no-clear 'vector) s5-2 s4-0))
+               (s3-1 (vector-! (new 'stack-no-clear 'vector) (-> self firing-sight-pos) s4-0))
+               (s5-3 (new 'stack-no-clear 'vector))
+               )
+           (let ((f30-0 (vector-length gp-2)))
+             (vector-normalize! gp-2 1.0)
+             (vector-normalize! s3-1 1.0)
+             (if (logtest? (-> self flags) 8)
+                 (set! (-> s5-3 quad) (-> s3-1 quad))
+                 (set! (-> s5-3 quad) (-> gp-2 quad))
+                 )
+             (when (logtest? (-> self flags) 128)
+               (let ((f0-6 (lerp-scale 1.0 0.2 f30-0 8192.0 327680.0)))
+                 (seek! (-> self fov-mult) f0-6 (* 2.0 (-> self clock seconds-per-frame)))
+                 )
+               (set-setting! 'fov 'rel (-> self fov-mult) 0)
+               (send-event (handle->process (-> self screen)) 'set-fov-mult (-> self fov-mult))
+               )
+             )
+           (let* ((f30-1 (vector-y-angle s5-3))
+                  (f0-12 (quaternion-y-angle (-> self rotate-quat)))
+                  (f0-13 (deg-diff f0-12 f30-1))
+                  )
+             (* (-> self rotate-mult) f0-13)
+             (let ((f1-6 12743.111))
+               (set! (-> self rotate-rate) (fmax (fmin (* 4.0 f0-13) f1-6) (- f1-6)))
+               )
+             )
+           (let ((f30-3 (fmax -4551.1113 (fmin 4551.1113 (- 16384.0 (acos (- (vector-dot s5-3 *y-vector*))))))))
+             (let* ((f0-29 (fmax -4551.1113 (fmin 4551.1113 (- 16384.0 (acos (- (vector-dot gp-2 *y-vector*)))))))
+                    (f2-1 (- (-> self gun-elev-cam) f0-29))
+                    (f1-12 (if (< f2-1 0.0)
+                               (fmin 3640.889 (* (fabs (* 0.1 f2-1)) (-> self clock frames-per-second)))
+                               910.2222
+                               )
+                           )
+                    )
+               (seek! (-> self gun-elev-cam) f0-29 (* f1-12 (-> self clock seconds-per-frame)))
+               )
+             (let* ((f28-2 (quaternion-y-angle (-> self rotate-quat)))
+                    (f0-33 (quaternion-y-angle (-> self tank-quat)))
+                    (f0-35 (* 2.0 (deg-diff f0-33 f28-2)))
+                    (f0-36 (cos f0-35))
+                    )
+               0.0
+               (let ((f0-41 (fmin f30-3 (if (< 0.0 f0-36)
+                                            (* 182.04445 (lerp 4.0 14.0 f0-36))
+                                            (* 182.04445 (lerp 4.0 18.0 (- f0-36)))
+                                            )
+                                  )
+                            )
+                     )
+                 (seek! (-> self gun-elev) f0-41 (* 2730.6667 (-> self clock seconds-per-frame)))
+                 )
+               )
+             )
+           )
+         )
+       (when (logtest? (-> self flags) 1024)
+         (cond
+           ((< -1456.3556 (-> self gun-elev))
+            (send-event (handle->process (-> self reticle)) 'spotlight-on)
+            )
+           ((< (-> self gun-elev) -2184.5334)
+            (send-event (handle->process (-> self reticle)) 'spotlight-off)
+            )
+           )
+         )
+       (quaternion-axis-angle! (-> self gun-elev-jmod transform quat) 1.0 0.0 0.0 (-> self gun-elev))
+       )
+      (else
+        (send-event (handle->process (-> self reticle)) 'off)
+        (send-event (handle->process (-> self reticle)) 'update-trans-only (-> self root-override trans))
+        )
+      )
+    )
+  (when (and (logtest? (-> self flags) 1) (zero? (logand (-> self flags) 8)))
+    (let* ((a1-32 (-> self node-list data (-> self gun-joint-l 0)))
+           (s4-1 (-> self node-list data (-> self gun-joint-r 0)))
+           (gp-4
+             (vector+!
+               (new 'stack-no-clear 'vector)
+               (vector<-cspace! (new 'stack-no-clear 'vector) a1-32)
+               (vector<-cspace! (new 'stack-no-clear 'vector) s4-1)
+               )
+             )
+           (a2-23
+             (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> self node-list data 11 bone transform vector 2) 1.0)
+             )
+           )
+      (vector-float*! gp-4 gp-4 0.5)
+      (fort-robotank-turret-method-31 self gp-4 a2-23)
+      )
+    )
+  (cond
+    ((logtest? (-> self flags) 64)
+     (sound-play
+       "robotank-turret"
+       :id (the-as sound-id (-> self turn-sound-id))
+       :position (-> self root-override trans)
+       )
+     (when (< (fabs (-> self rotate-rate)) 728.1778)
+       (set! (-> self flags) (logand -65 (-> self flags)))
+       (sound-stop (the-as sound-id (-> self turn-sound-id)))
+       (sound-play "robo-turret-end")
+       )
+     )
+    (else
+      (if (< 2184.5334 (fabs (-> self rotate-rate)))
+          (logior! (-> self flags) 64)
+          )
+      )
+    )
+  (quaternion-rotate-y!
+    (-> self rotate-quat)
+    (-> self rotate-quat)
+    (* (-> self rotate-rate) (-> self clock seconds-per-frame))
+    )
+  (quaternion*! (-> self root-override quat) (-> self rotate-quat) (-> self tank-quat-vibe-only))
+  (quaternion-normalize! (-> self root-override quat))
+  (transform-post)
+  (none)
+  )
+
+;; definition for function robotank-turret-handler
+(defbehavior robotank-turret-handler fort-robotank-turret ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (local-vars (v0-0 object))
+  (case arg2
+    (('trigger)
+     (when (and (-> self next-state) (= (-> self next-state name) 'idle))
+       (logior! (-> self flags) 1)
+       (go-virtual ready)
+       )
+     )
+    (('fire-suppress)
+     (cond
+       ((-> arg3 param 0)
+        (set! v0-0 (logior (-> self flags) 16))
+        (set! (-> self flags) (the-as uint v0-0))
+        )
+       (else
+         (set! v0-0 (logand -17 (-> self flags)))
+         (set! (-> self flags) (the-as uint v0-0))
+         )
+       )
+     v0-0
+     )
+    (('set-spread)
+     (set! (-> self gun-spread) (the-as float (-> arg3 param 0)))
+     )
+    (('use-los)
+     (cond
+       ((-> arg3 param 0)
+        (set! v0-0 (logior (-> self flags) 512))
+        (set! (-> self flags) (the-as uint v0-0))
+        )
+       (else
+         (set! v0-0 (logand -513 (-> self flags)))
+         (set! (-> self flags) (the-as uint v0-0))
+         )
+       )
+     v0-0
+     )
+    (('limit-reticle-elev)
+     (cond
+       ((-> arg3 param 0)
+        (set! v0-0 (logior (-> self flags) 1024))
+        (set! (-> self flags) (the-as uint v0-0))
+        )
+       (else
+         (set! v0-0 (logand -1025 (-> self flags)))
+         (set! (-> self flags) (the-as uint v0-0))
+         )
+       )
+     v0-0
+     )
+    (('pov-cam-on)
+     (let ((v1-22 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 3)))
+       (set! (-> v1-22 prim-core collide-as) (collide-spec obstacle pusher))
+       (set! (-> v1-22 prim-core collide-with) (collide-spec jak player-list))
+       )
+     (logior! (-> self flags) 128)
+     (send-event (handle->process (-> self screen)) 'trigger)
+     )
+    (('pov-cam-off)
+     (let ((v1-33 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child 3)))
+       (set! (-> v1-33 prim-core collide-as) (collide-spec))
+       (set! (-> v1-33 prim-core collide-with) (collide-spec))
+       )
+     0
+     (set! (-> self flags) (logand -129 (-> self flags)))
+     (remove-setting! 'fov)
+     (send-event (handle->process (-> self screen)) 'untrigger)
+     )
+    (('get-rotate-quat)
+     (-> self rotate-quat)
+     )
+    (('get-gun-elevation-cam)
+     (-> self gun-elev-cam)
+     )
+    (('update)
+     (-> arg3 param 1)
+     (new 'stack-no-clear 'vector)
+     (let ((s5-0 (new 'stack-no-clear 'quaternion)))
+       (let ((s4-0 (the-as object (-> arg3 param 2))))
+         (vector<-cspace+vector! (-> self root-override trans) (the-as cspace s4-0) (-> self offset))
+         (matrix->quaternion s5-0 (-> (the-as cspace s4-0) bone transform))
+         )
+       (quaternion-copy! (-> self tank-quat) s5-0)
+       )
+     (quaternion-copy! (-> self tank-quat-vibe-only) (the-as quaternion (-> arg3 param 3)))
+     )
+    (('die)
+     (go-virtual die)
+     )
+    )
+  )
+
+;; definition for method 34 of type fort-robotank-turret
+;; INFO: Used lq/sq
+(defmethod fort-robotank-turret-method-34 fort-robotank-turret ((obj fort-robotank-turret) (arg0 vector) (arg1 float))
+  (let ((s4-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj root-override trans)))
+        (s3-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override quat)))
+        (s5-0 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s5-0 quad) (-> s4-1 quad))
+    (set! (-> s3-0 y) 0.0)
+    (vector-normalize! s3-0 1.0)
+    (set! (-> s5-0 y) 0.0)
+    (vector-normalize! s5-0 1.0)
+    (>= (vector-dot s3-0 s5-0) (cos arg1))
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate idle (fort-robotank-turret)
+  :virtual #t
+  :event robotank-turret-handler
+  :code (the-as (function none :behavior fort-robotank-turret) sleep-code)
+  :post turret-post
+  )
+
+;; failed to figure out what this is:
+(defstate ready (fort-robotank-turret)
+  :virtual #t
+  :event robotank-turret-handler
+  :enter (behavior ()
+    (set! (-> self gun-timer) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (logtest? (-> self flags) 16)
+        (set! (-> self gun-timer) (-> self clock frame-counter))
+        )
+    (let ((gp-0 *target*))
+      (if (and (if (type? gp-0 process-focusable)
+                   gp-0
+                   )
+               (or (not (logtest? (-> self flags) 512)) (check-los? (-> self los) 0))
+               (>= (- (-> self clock frame-counter) (-> self gun-timer)) (seconds 1))
+               )
+          (go-virtual fire)
+          )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (ja-no-eval :group! (-> self draw art-group data 3)
+                  :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) frames num-frames) -1)))
+                  :frame-num 0.0
+                  )
+      (until (ja-done? 0)
+        (suspend)
+        (ja :num! (seek!))
+        )
+      )
+    #f
+    (none)
+    )
+  :post turret-post
+  )
+
+;; failed to figure out what this is:
+(defstate fire (fort-robotank-turret)
+  :virtual #t
+  :event robotank-turret-handler
+  :enter (behavior ()
+    (logior! (-> self flags) 256)
+    (let* ((gp-0 *target*)
+           (a0-1 (if (type? gp-0 process-focusable)
+                     gp-0
+                     )
+                 )
+           )
+      (when a0-1
+        (set! (-> self aim-pos 0 quad) (-> (get-trans a0-1 0) quad))
+        (set! (-> self aim-pos-2 quad) (-> self aim-pos 0 quad))
+        (set! (-> self aim-pos-1 quad) (-> self aim-pos 0 quad))
+        )
+      )
+    (none)
+    )
+  :trans (behavior ()
+    (let ((gp-0 *target*))
+      (when (or (not (if (type? gp-0 process-focusable)
+                         gp-0
+                         )
+                     )
+                (and (logtest? (-> self flags) 512) (not (logtest? (-> self flags) 8)) (skip-check-los? (-> self los) 0))
+                (logtest? (-> self flags) 16)
+                )
+        (set! (-> self flags) (logand -257 (-> self flags)))
+        (go-virtual ready)
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (until #f
+      (until (fort-robotank-turret-method-34 self (-> self aim-pos-1) 2730.6667)
+        (suspend)
+        )
+      (logior! (-> self flags) 8)
+      (set! (-> self firing-sight-pos quad) (-> self sight-pos quad))
+      (send-event (handle->process (-> self reticle)) 'lock)
+      (let ((gp-0 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.5))
+          (suspend)
+          )
+        )
+      (let ((gp-2 (max 2 (min 3 (rand-vu-int-range 0 3)))))
+        0
+        (dotimes (s5-2 gp-2)
+          (let ((s4-1 (max 2 (min 4 (rand-vu-int-range 1 8)))))
+            (dotimes (s3-2 s4-1)
+              (ja-no-eval :group! (-> self draw art-group data 4)
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek!))
+                )
+              (fort-robotank-turret-method-33 self)
+              (ja-no-eval :group! (-> self draw art-group data 5)
+                          :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames) -1)))
+                          :frame-num 0.0
+                          )
+              (until (ja-done? 0)
+                (suspend)
+                (ja :num! (seek!))
+                )
+              (set! (-> self gun-index) (- 1 (-> self gun-index)))
+              (suspend)
+              (if (< (vector-length
+                       (vector-! (new 'stack-no-clear 'vector) (-> self firing-sight-pos) (-> self root-override trans))
+                       )
+                     73728.0
+                     )
+                  (goto cfg-26)
+                  )
+              )
+            )
+          (let ((f30-0 (rand-vu-float-range 0.05 0.43))
+                (s4-2 (-> self clock frame-counter))
+                )
+            (until (>= (- (-> self clock frame-counter) s4-2) (the int (* 300.0 f30-0)))
+              (suspend)
+              )
+            )
+          )
+        )
+      (label cfg-26)
+      (set! (-> self flags) (logand -9 (-> self flags)))
+      (send-event (handle->process (-> self reticle)) 'unlock)
+      (until (fort-robotank-turret-method-34 self (-> self aim-pos-1) 2730.6667)
+        (suspend)
+        )
+      (let ((f30-1 (rand-vu-float-range
+                     (if (< 2730.6667 (-> self rotate-rate))
+                         1.2
+                         0.32
+                         )
+                     2.11
+                     )
+                   )
+            (gp-3 (-> self clock frame-counter))
+            )
+        (until (>= (- (-> self clock frame-counter) gp-3) (the int (* 300.0 f30-1)))
+          (suspend)
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  :post turret-post
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-robotank-turret)
+  :virtual #t
+  :code (behavior ()
+    (send-event (handle->process (-> self reticle)) 'die)
+    (send-event (handle->process (-> self screen)) 'die)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 1))
+        (suspend)
+        )
+      )
+    (while (-> self child)
+      (suspend)
+      )
+    (none)
+    )
+  )
+
+;; definition for method 10 of type fort-robotank-turret
+(defmethod deactivate fort-robotank-turret ((obj fort-robotank-turret))
+  (set! (-> obj flags) (logand -65 (-> obj flags)))
+  (sound-stop (the-as sound-id (-> obj turn-sound-id)))
+  (let ((a0-4 (handle->process (-> obj screen))))
+    (if a0-4
+        (deactivate a0-4)
+        )
+    )
+  ((method-of-type process-focusable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 7 of type fort-robotank-turret
+;; WARN: Return type mismatch process-focusable vs fort-robotank-turret.
+(defmethod relocate fort-robotank-turret ((obj fort-robotank-turret) (arg0 int))
+  (if (nonzero? (-> obj gun-elev-jmod))
+      (&+! (-> obj gun-elev-jmod) arg0)
+      )
+  (the-as fort-robotank-turret ((method-of-type process-focusable relocate) obj arg0))
+  )
+
+;; definition for function fort-robotank-turret-init-by-other
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch object vs none.
+(defbehavior fort-robotank-turret-init-by-other fort-robotank-turret ((arg0 vector) (arg1 quaternion) (arg2 vector) (arg3 float))
+  (let ((s2-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
+    (set! (-> s2-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s2-0 reaction) cshape-reaction-default)
+    (set! (-> s2-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s1-0 (new 'process 'collide-shape-prim-group s2-0 (the-as uint 4) 0)))
+      (set! (-> s2-0 total-prims) (the-as uint 5))
+      (set! (-> s1-0 prim-core collide-as) (collide-spec obstacle camera-blocker pusher))
+      (set! (-> s1-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s1-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s1-0 local-sphere) 0.0 0.0 0.0 36864.0)
+      (set! (-> s2-0 root-prim) s1-0)
+      )
+    (pusher-init s2-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 3)
+      (set-vector! (-> v1-14 local-sphere) 0.0 0.0 0.0 16384.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid))
+      (set! (-> v1-16 transform-index) 8)
+      (set-vector! (-> v1-16 local-sphere) 0.0 0.0 4096.0 6553.6)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-18 prim-core collide-as) (collide-spec obstacle pusher))
+      (set! (-> v1-18 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-18 prim-core action) (collide-action solid))
+      (set! (-> v1-18 transform-index) 5)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 4096.0 6553.6)
+      )
+    (let ((v1-20 (new 'process 'collide-shape-prim-mesh s2-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-20 prim-core action) (collide-action solid))
+      (set! (-> v1-20 transform-index) 3)
+      (set-vector! (-> v1-20 local-sphere) 0.0 20480.0 4096.0 31129.6)
+      )
+    (set! (-> s2-0 nav-radius) (* 0.75 (-> s2-0 root-prim local-sphere w)))
+    (let ((v1-23 (-> s2-0 root-prim)))
+      (set! (-> s2-0 backup-collide-as) (-> v1-23 prim-core collide-as))
+      (set! (-> s2-0 backup-collide-with) (-> v1-23 prim-core collide-with))
+      )
+    (set! (-> self root-override) s2-0)
+    )
+  (set! (-> self root-override trans quad) (-> arg0 quad))
+  (quaternion-copy! (-> self root-override quat) arg1)
+  (set! (-> self offset quad) (-> arg2 quad))
+  (initialize-skeleton
+    self
+    (the-as
+      skeleton-group
+      (art-group-get-by-name *level* "skel-fort-robotank-turret" (the-as (pointer uint32) #f))
+      )
+    (the-as pair 0)
+    )
+  (logclear! (-> self mask) (process-mask actor-pause))
+  (new-source! (-> self los) self (seconds 1) (collide-spec backgnd))
+  (set! (-> self gun-elev-jmod) (new 'process 'joint-mod-set-local self 4 #f #f #f))
+  (set! (-> self gun-elev-jmod set-rotation) #t)
+  (set! (-> self gun-elev) 0.0)
+  (set! (-> self gun-elev-cam) 0.0)
+  (set! (-> self gun-spread) 728.1778)
+  (quaternion-axis-angle! (-> self gun-elev-jmod transform quat) 1.0 0.0 0.0 (-> self gun-elev))
+  (quaternion-zero! (-> self tank-quat))
+  (quaternion-copy! (-> self rotate-quat) arg1)
+  (set! (-> self rotate-rate) 0.0)
+  (set! (-> self rotate-mult) arg3)
+  (set! (-> self aim-pos 0 quad) (-> self root-override trans quad))
+  (set! (-> self aim-pos-2 quad) (-> self root-override trans quad))
+  (set! (-> self aim-pos-1 quad) (-> self root-override trans quad))
+  (set! (-> self gun-timer) (-> self clock frame-counter))
+  (set! (-> self flags) (the-as uint 0))
+  (set! (-> self fov-mult) 1.0)
+  (set! (-> self shot-range) 204800.0)
+  (set! (-> self gun-joint-l 0) 10)
+  (set! (-> self gun-joint-r 0) 7)
+  (set! (-> self gun-joint-l 1) 9)
+  (set! (-> self gun-joint-r 1) 6)
+  (set! (-> self gun-index) 0)
+  (let ((gp-1 (new 'stack-no-clear 'vector)))
+    (set! (-> gp-1 quad) (-> self root-override trans quad))
+    (set! (-> gp-1 z) (+ 40960.0 (-> gp-1 z)))
+    (set! (-> gp-1 y) (+ 32768.0 (-> gp-1 y)))
+    (set! (-> self reticle) (ppointer->handle (process-spawn fort-robotank-reticle gp-1 :to self)))
+    )
+  (let ((gp-2 (new 'stack-no-clear 'vector))
+        (s4-2 (new 'stack-no-clear 'vector))
+        )
+    (set! (-> s4-2 x) 0.0)
+    (set! (-> s4-2 y) 32768.0)
+    (set! (-> s4-2 z) 12288.0)
+    (set! (-> s4-2 w) 0.0)
+    (let ((s5-2 (-> self root-override quat)))
+      (vector-orient-by-quat! s4-2 s4-2 s5-2)
+      (vector+! gp-2 (-> self root-override trans) s4-2)
+      (set! (-> self screen)
+            (ppointer->handle (process-spawn fort-roboscreen gp-2 s5-2 (-> self entity) :to *display-pool*))
+            )
+      )
+    )
+  (ja-no-eval :group! (-> self draw art-group data 3) :num! zero)
+  (transform-post)
+  (set! (-> self turn-sound-id) (the-as uint (new-sound-id)))
+  (go-virtual idle)
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fort-robotank_REF.gc b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fort-robotank_REF.gc
new file mode 100644
index 0000000000..22e79f22ca
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/fortress/ammo_dump/fort-robotank_REF.gc
@@ -0,0 +1,1383 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-robotank-barrel-sparks
+  :id 562
+  :bounds (static-bspherem 0 0 0 8)
+  :parts ((sp-item 2474 :fade-after (meters 120) :falloff-to (meters 120) :flags (bit7)))
+  )
+
+;; failed to figure out what this is:
+(defpart 2474
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
+    (sp-rnd-flt spt-num 1.0 6.0 1.0)
+    (sp-rnd-flt spt-x (meters -4) (meters 8) 1.0)
+    (sp-flt spt-scale-x (meters 1))
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-scale-y (meters 0.05) (meters 0.05) 1.0)
+    (sp-rnd-flt spt-r 32.0 96.0 1.0)
+    (sp-copy-from-other spt-g -1)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-flt spt-omega 6.144)
+    (sp-rnd-flt spt-vel-y (meters 0.016666668) (meters 0.033333335) 1.0)
+    (sp-flt spt-fade-r -0.85333335)
+    (sp-flt spt-fade-g -0.85333335)
+    (sp-rnd-flt spt-accel-y -10.922667 -4.096 1.0)
+    (sp-flt spt-friction 0.875)
+    (sp-int-plain-rnd spt-timer 25 99 1)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-0 sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 5 294 1)
+    (sp-launcher-by-id spt-next-launcher 2475)
+    (sp-rnd-flt spt-conerot-x (degrees -45.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees -45.0) (degrees 90.0) 1.0)
+    (sp-rnd-flt spt-conerot-z (degrees -45.0) (degrees 90.0) 1.0)
+    (sp-flt spt-rotate-y (degrees 0.0))
+    (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.2) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 2475
+  :init-specs ((sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b 0.0)
+    (sp-rnd-flt spt-fade-a -0.85333335 -1.7066667 1.0)
+    )
+  )
+
+;; definition of type fort-robotank-segment-event
+(deftype fort-robotank-segment-event (structure)
+  ((source     handle                         :offset-assert   0)
+   (event-type symbol                         :offset-assert   8)
+   (actor      string                         :offset-assert  12)
+   (pos-norm   float                          :offset-assert  16)
+   (param-obj  object                         :offset-assert  20)
+   (param-func (function fort-robotank none)  :offset         20)
+   (param-sym  symbol                         :offset         20)
+   )
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
+
+;; definition for method 3 of type fort-robotank-segment-event
+(defmethod inspect fort-robotank-segment-event ((obj fort-robotank-segment-event))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'fort-robotank-segment-event)
+  (format #t "~1Tsource: ~D~%" (-> obj source))
+  (format #t "~1Tevent-type: ~A~%" (-> obj event-type))
+  (format #t "~1Tactor: ~A~%" (-> obj actor))
+  (format #t "~1Tpos-norm: ~f~%" (-> obj pos-norm))
+  (format #t "~1Tparam: ~A~%" (-> obj param-obj))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-robotank-segment
+(deftype fort-robotank-segment (structure)
+  ((flags              uint16                                      :offset-assert   0)
+   (max-speed          float                                       :offset-assert   4)
+   (next-segment       int32                                       :offset-assert   8)
+   (next-segment-start float                                       :offset-assert  12)
+   (event-count        int32                                       :offset-assert  16)
+   (event-tbl          (inline-array fort-robotank-segment-event)  :offset-assert  20)
+   )
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
+
+;; definition for method 3 of type fort-robotank-segment
+(defmethod inspect fort-robotank-segment ((obj fort-robotank-segment))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'fort-robotank-segment)
+  (format #t "~1Tflags: ~D~%" (-> obj flags))
+  (format #t "~1Tmax-speed: ~f~%" (-> obj max-speed))
+  (format #t "~1Tnext-segment: ~D~%" (-> obj next-segment))
+  (format #t "~1Tnext-segment-start: ~f~%" (-> obj next-segment-start))
+  (format #t "~1Tevent-count: ~D~%" (-> obj event-count))
+  (format #t "~1Tevent-tbl: #x~X~%" (-> obj event-tbl))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-robotank-path-info
+(deftype fort-robotank-path-info (structure)
+  ((path          path-control         :offset-assert   0)
+   (dir           vector       :inline :offset-assert  16)
+   (u             float                :offset-assert  32)
+   (du            float                :offset-assert  36)
+   (du-final      float                :offset-assert  40)
+   (prev-u        float                :offset-assert  44)
+   (max-speed     float                :offset-assert  48)
+   (dist          float                :offset-assert  52)
+   (dir-y-angle   float                :offset-assert  56)
+   (start-y-angle float                :offset-assert  60)
+   )
+  :method-count-assert 9
+  :size-assert         #x40
+  :flag-assert         #x900000040
+  )
+
+;; definition for method 3 of type fort-robotank-path-info
+(defmethod inspect fort-robotank-path-info ((obj fort-robotank-path-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'fort-robotank-path-info)
+  (format #t "~1Tpath: ~A~%" (-> obj path))
+  (format #t "~1Tdir: #<vector @ #x~X>~%" (-> obj dir))
+  (format #t "~1Tu: ~f~%" (-> obj u))
+  (format #t "~1Tdu: ~f~%" (-> obj du))
+  (format #t "~1Tdu-final: ~f~%" (-> obj du-final))
+  (format #t "~1Tprev-u: ~f~%" (-> obj prev-u))
+  (format #t "~1Tmax-speed: ~f~%" (-> obj max-speed))
+  (format #t "~1Tdist: ~f~%" (-> obj dist))
+  (format #t "~1Tdir-y-angle: ~f~%" (-> obj dir-y-angle))
+  (format #t "~1Tstart-y-angle: ~f~%" (-> obj start-y-angle))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-robotank-path-info-array
+(deftype fort-robotank-path-info-array (inline-array-class)
+  ((data fort-robotank-path-info :inline :dynamic :offset-assert  16)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+;; definition for method 3 of type fort-robotank-path-info-array
+(defmethod inspect fort-robotank-path-info-array ((obj fort-robotank-path-info-array))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj (-> obj type))
+  (format #t "~1Tlength: ~D~%" (-> obj length))
+  (format #t "~1Tallocated-length: ~D~%" (-> obj allocated-length))
+  (format #t "~1Tdata[0] @ #x~X~%" (-> obj data))
+  (label cfg-4)
+  obj
+  )
+
+;; failed to figure out what this is:
+(set! (-> fort-robotank-path-info-array heap-base) (the-as uint 64))
+
+;; definition of type fort-robotank-wheel-info
+(deftype fort-robotank-wheel-info (structure)
+  ((jmod   joint-mod-spinner  :offset-assert   0)
+   (radius float              :offset-assert   4)
+   )
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+;; definition for method 3 of type fort-robotank-wheel-info
+(defmethod inspect fort-robotank-wheel-info ((obj fort-robotank-wheel-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'fort-robotank-wheel-info)
+  (format #t "~1Tjmod: ~A~%" (-> obj jmod))
+  (format #t "~1Tradius: ~f~%" (-> obj radius))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-robotank-tread-info
+(deftype fort-robotank-tread-info (structure)
+  ((wheel         fort-robotank-wheel-info 7 :inline :offset-assert   0)
+   (texture       texture-anim                       :offset-assert 112)
+   (locator-joint int32                              :offset-assert 116)
+   (pos           vector                   :inline   :offset-assert 128)
+   )
+  :method-count-assert 9
+  :size-assert         #x90
+  :flag-assert         #x900000090
+  )
+
+;; definition for method 3 of type fort-robotank-tread-info
+(defmethod inspect fort-robotank-tread-info ((obj fort-robotank-tread-info))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (format #t "[~8x] ~A~%" obj 'fort-robotank-tread-info)
+  (format #t "~1Twheel[7] @ #x~X~%" (-> obj wheel))
+  (format #t "~1Ttexture: #<texture-anim @ #x~X>~%" (-> obj texture))
+  (format #t "~1Tlocator-joint: ~D~%" (-> obj locator-joint))
+  (format #t "~1Tpos: #<vector @ #x~X>~%" (-> obj pos))
+  (label cfg-4)
+  obj
+  )
+
+;; definition of type fort-robotank
+(deftype fort-robotank (process-drawable)
+  ((root-override      collide-shape-moving                           :offset        128)
+   (barrel-part        sparticle-launch-control                       :offset-assert 200)
+   (roller-jmod        joint-mod                                      :offset-assert 204)
+   (vibe-jmod          joint-mod                                      :offset-assert 208)
+   (tread              fort-robotank-tread-info             2 :inline :offset-assert 224)
+   (path-info          fort-robotank-path-info-array                  :offset-assert 512)
+   (segment-table      (inline-array fort-robotank-segment)           :offset-assert 516)
+   (flags              uint16                                         :offset-assert 520)
+   (pov-cam-offset     vector                               2 :inline :offset-assert 528)
+   (turret             handle                                         :offset-assert 560)
+   (no-collision-timer time-frame                                     :offset-assert 568)
+   (buzz-timer         time-frame                                     :offset-assert 576)
+   (player-u           float                                          :offset-assert 584)
+   (player-prev-u      float                                          :offset-assert 588)
+   (roller-spin-rate   float                                          :offset-assert 592)
+   (engine-vibe-rate   float                                          :offset-assert 596)
+   (engine-vibe-amp    float                                          :offset-assert 600)
+   (attack-id          uint32                                         :offset-assert 604)
+   (path-index         int32                                          :offset-assert 608)
+   (path-count         int32                                          :offset-assert 612)
+   (continue-index     int32                                          :offset-assert 616)
+   (idle-sound         ambient-sound                                  :offset-assert 620)
+   (barrel-sound       ambient-sound                                  :offset-assert 624)
+   )
+  :heap-base #x200
+  :method-count-assert 28
+  :size-assert         #x274
+  :flag-assert         #x1c02000274
+  (:methods
+    (idle () _type_ :state 20)
+    (turning () _type_ :state 21)
+    (moving () _type_ :state 22)
+    (pause () _type_ :state 23)
+    (die () _type_ :state 24)
+    (fort-robotank-method-25 (_type_) event-message-block 25)
+    (fort-robotank-method-26 (_type_ int float float) symbol 26)
+    (fort-robotank-method-27 (_type_) none 27)
+    )
+  )
+
+;; definition for method 3 of type fort-robotank
+(defmethod inspect fort-robotank ((obj fort-robotank))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type process-drawable inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tbarrel-part: ~A~%" (-> obj barrel-part))
+  (format #t "~2Troller-jmod: ~A~%" (-> obj roller-jmod))
+  (format #t "~2Tvibe-jmod: ~A~%" (-> obj vibe-jmod))
+  (format #t "~2Ttread[2] @ #x~X~%" (-> obj tread))
+  (format #t "~2Tpath-info: ~A~%" (-> obj path-info))
+  (format #t "~2Tsegment-table: #x~X~%" (-> obj segment-table))
+  (format #t "~2Tflags: ~D~%" (-> obj flags))
+  (format #t "~2Tpov-cam-offset[2] @ #x~X~%" (-> obj pov-cam-offset))
+  (format #t "~2Tturret: ~D~%" (-> obj turret))
+  (format #t "~2Tno-collision-timer: ~D~%" (-> obj no-collision-timer))
+  (format #t "~2Tbuzz-timer: ~D~%" (-> obj buzz-timer))
+  (format #t "~2Tplayer-u: ~f~%" (-> obj player-u))
+  (format #t "~2Tplayer-prev-u: ~f~%" (-> obj player-prev-u))
+  (format #t "~2Troller-spin-rate: ~f~%" (-> obj roller-spin-rate))
+  (format #t "~2Tengine-vibe-rate: ~f~%" (-> obj engine-vibe-rate))
+  (format #t "~2Tengine-vibe-amp: ~f~%" (-> obj engine-vibe-amp))
+  (format #t "~2Tattack-id: ~D~%" (-> obj attack-id))
+  (format #t "~2Tpath-index: ~D~%" (-> obj path-index))
+  (format #t "~2Tpath-count: ~D~%" (-> obj path-count))
+  (format #t "~2Tcontinue-index: ~D~%" (-> obj continue-index))
+  (format #t "~2Tidle-sound: ~A~%" (-> obj idle-sound))
+  (format #t "~2Tbarrel-sound: ~A~%" (-> obj barrel-sound))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *fort-robotank-1-segment-table*, type (inline-array fort-robotank-segment)
+(define *fort-robotank-1-segment-table*
+  (new 'static 'inline-array fort-robotank-segment 4
+    (new 'static 'fort-robotank-segment
+      :flags #x17
+      :max-speed 6.0
+      :next-segment 1
+      :event-count 5
+      :event-tbl (new 'static 'inline-array fort-robotank-segment-event 5
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-on :actor "camera-229")
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-off :actor #f :pos-norm 0.3)
+        (new 'static 'fort-robotank-segment-event :event-type 'pov-cam-on :actor #f :pos-norm 0.3)
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-a-1"
+          :pos-norm 0.1
+          :param-obj 'start-loading
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-elec-gate-10"
+          :pos-norm 0.9375
+          :param-obj 'trigger
+          )
+        )
+      )
+    (new 'static 'fort-robotank-segment
+      :flags #x7
+      :max-speed 9.0
+      :next-segment 2
+      :event-count 4
+      :event-tbl (new 'static 'inline-array fort-robotank-segment-event 5
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'code
+          :pos-norm 0.01
+          :param-obj (lambda () (set-setting! 'target-height 'abs -981467136 0) (none))
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-a-1"
+          :pos-norm 0.0104
+          :param-obj 'break
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-b-1"
+          :pos-norm 0.66667
+          :param-obj 'start-loading
+          )
+        (new 'static 'fort-robotank-segment-event
+          :source (new 'static 'handle :process #x1 :u64 #x1)
+          :event-type 'pov-cam-off
+          :pos-norm 0.83
+          )
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'code
+          :pos-norm 0.83
+          :param-obj (lambda ((arg0 fort-robotank)) (send-event (handle->process (-> arg0 turret)) 'set-spread #x44e38e39) (none))
+          )
+        )
+      )
+    (new 'static 'fort-robotank-segment
+      :flags #x20
+      :max-speed 10.0
+      :next-segment 3
+      :event-count 4
+      :event-tbl (new 'static 'inline-array fort-robotank-segment-event 4
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'code
+          :param-obj (lambda ((arg0 fort-robotank)) (send-event (handle->process (-> arg0 turret)) 'set-spread #x43b60b61) (none))
+          )
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-on :actor "camera-176")
+        (new 'static 'fort-robotank-segment-event :event-type 'external-cam-off :pos-norm 0.38)
+        (new 'static 'fort-robotank-segment-event
+          :event-type 'send-event
+          :actor "fort-fence-b-1"
+          :pos-norm 0.0793
+          :param-obj 'break
+          )
+        )
+      )
+    (new 'static 'fort-robotank-segment :flags #x20 :max-speed 8.0 :next-segment 3)
+    )
+  )
+
+;; definition for symbol *fort-robotank-2-segment-table*, type (inline-array fort-robotank-segment)
+(define *fort-robotank-2-segment-table*
+  (new 'static 'inline-array fort-robotank-segment 1
+    (new 'static 'fort-robotank-segment :flags #x8 :max-speed 6.0 :next-segment-start 7.586)
+    )
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-robotank fort-robotank fort-robotank-lod0-jg fort-robotank-idle-ja
+              ((fort-robotank-lod0-mg (meters 20)) (fort-robotank-lod1-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 9)
+              :origin-joint-index 3
+              )
+
+;; definition for method 25 of type fort-robotank
+(defmethod fort-robotank-method-25 fort-robotank ((obj fort-robotank))
+  (with-pp
+    (let ((v1-0 (-> obj root-override)))
+      (when (< (-> *event-queue* length) (-> *event-queue* allocated-length))
+        (let ((v0-0 (-> *event-queue* data (-> *event-queue* length))))
+          (+! (-> *event-queue* length) 1)
+          (set! (-> v0-0 form-handle) (process->handle pp))
+          (set! (-> v0-0 to-handle) (process->handle (handle->process (-> obj turret))))
+          (set! (-> v0-0 num-params) 4)
+          (set! (-> v0-0 message) 'update)
+          (set! (-> v0-0 param 0) (the-as uint (-> v1-0 trans)))
+          (set! (-> v0-0 param 1) (the-as uint (-> v1-0 quat)))
+          (set! (-> v0-0 param 2) (the-as uint (-> obj node-list data 3)))
+          (set! (-> v0-0 param 3) (the-as uint (-> obj vibe-jmod twist)))
+          v0-0
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function fort-robotank-post
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defbehavior fort-robotank-post fort-robotank ()
+  (when (and (nonzero? (-> self no-collision-timer))
+             (>= (- (-> self clock frame-counter) (-> self no-collision-timer))
+                 (the-as time-frame (-> *TARGET-bank* hit-invulnerable-timeout))
+                 )
+             )
+    (let ((v1-7 (-> self root-override root-prim)))
+      (set! (-> v1-7 prim-core collide-as) (-> self root-override backup-collide-as))
+      (set! (-> v1-7 prim-core collide-with) (-> self root-override backup-collide-with))
+      )
+    (set! (-> self no-collision-timer) 0)
+    0
+    )
+  (fort-robotank-method-25 self)
+  (seek! (-> self roller-jmod twist y) (-> self roller-spin-rate) (* 16384.0 (-> self clock seconds-per-frame)))
+  (let ((gp-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 5)))
+        (s4-0 (get-field-spec-by-id (-> *part-id-table* 2474) (sp-field-id spt-num)))
+        (s5-0 (new 'stack-no-clear 'matrix))
+        )
+    (set! (-> s4-0 random-rangef) (lerp-scale 1.0 6.0 (-> self roller-jmod twist y) 8192.0 65536.0))
+    (set! (-> gp-0 y) (+ -6144.0 (-> gp-0 y)))
+    (quaternion->matrix s5-0 (-> self root-override quat))
+    (set! (-> s5-0 trans quad) (-> gp-0 quad))
+    (spawn-with-matrix (-> self barrel-part) s5-0)
+    )
+  (dotimes (gp-1 2)
+    (let* ((s5-1 (-> self tread gp-1))
+           (s4-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data (-> s5-1 locator-joint))))
+           )
+      (let ((s3-1 (vector-! (new 'stack-no-clear 'vector) s4-1 (-> s5-1 pos))))
+        (let ((s2-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> self root-override quat))))
+          (if (= gp-1 1)
+              (vector-float*! s2-0 s2-0 -1.0)
+              )
+          (let ((s1-0 (get-field-spec-by-id (-> *part-id-table* 2471) (sp-field-id spt-num)))
+                (f30-0 (vector-length s3-1))
+                (f28-0 (* 12288.0 (-> self clock seconds-per-frame)))
+                )
+            (set! (-> s1-0 initial-valuef) (lerp-scale 0.0 0.5 f30-0 0.0 f28-0))
+            (set! (-> s1-0 random-rangef) (lerp-scale 0.0 1.0 f30-0 0.0 f28-0))
+            )
+          (let ((a1-14 (forward-up-nopitch->inv-matrix (new 'stack-no-clear 'matrix) s2-0 *up-vector*)))
+            (set! (-> a1-14 trans quad) (-> s4-1 quad))
+            (set! (-> a1-14 trans y) (+ -2498.56 (-> a1-14 trans y)))
+            (spawn-with-matrix (-> self part) a1-14)
+            )
+          )
+        (vector-inv-orient-by-quat! s3-1 s3-1 (-> self root-override quat))
+        (let ((f30-1 (fabs (-> s3-1 z))))
+          (dotimes (s3-2 7)
+            (let ((s2-1 (-> s5-1 wheel s3-2)))
+              (set! (-> s2-1 jmod spin-rate) (* (atan f30-1 (-> s2-1 radius)) (-> self clock frames-per-second)))
+              )
+            )
+          (set! (-> s5-1 texture frame-delta) (* 0.00028388444 (-> self clock frames-per-second) f30-1))
+          )
+        )
+      (set! (-> s5-1 pos quad) (-> s4-1 quad))
+      )
+    )
+  (let ((v1-65 (-> self path-info data (-> self path-index))))
+    (cond
+      ((and (logtest? (-> self flags) 4) (!= (-> v1-65 u) (-> v1-65 prev-u)))
+       (seek! (-> self engine-vibe-rate) 3.0 (-> self clock seconds-per-frame))
+       (seek! (-> self engine-vibe-amp) 1.0 (-> self clock seconds-per-frame))
+       )
+      (else
+        (seek! (-> self engine-vibe-rate) 1.0 (-> self clock seconds-per-frame))
+        (seek! (-> self engine-vibe-amp) 0.4 (-> self clock seconds-per-frame))
+        )
+      )
+    )
+  (let* ((f0-35 30.0)
+         (f1-7 65536.0)
+         (f2-1 (the float (-> self clock frame-counter)))
+         (f0-36 (/ (* f1-7 (- f2-1 (* (the float (the int (/ f2-1 f0-35))) f0-35))) f0-35))
+         (f28-1 (sin f0-36))
+         (f30-2 (* 300.0 (/ 1.0 (-> self engine-vibe-rate))))
+         (f0-39 (the float (-> self clock frame-counter)))
+         (f24-0 (/ (- f0-39 (* (the float (the int (/ f0-39 f30-2))) f30-2)) f30-2))
+         (f28-2 (* f28-1 (sin (* 65536.0 f24-0))))
+         )
+    (let* ((f0-44 (sin 7281.778))
+           (f1-16 (- 1.0 f0-44))
+           (f26-0 0.0)
+           )
+      (when (and (or (< f0-44 f24-0) (< f24-0 f1-16))
+                 (>= (- (-> self clock frame-counter) (-> self buzz-timer)) (the int (* 0.5 f30-2)))
+                 )
+        (let* ((gp-2 *target*)
+               (a0-43 (if (type? gp-2 process-focusable)
+                          gp-2
+                          )
+                      )
+               )
+          (if a0-43
+              (set! f26-0
+                    (lerp-scale
+                      1.0
+                      0.0
+                      (vector-vector-distance (-> self root-override trans) (get-trans a0-43 0))
+                      81920.0
+                      327680.0
+                      )
+                    )
+              )
+          )
+        (cpad-set-buzz!
+          (-> *cpad-list* cpads 0)
+          1
+          (the int (* 255.0 (* 0.49 f26-0)))
+          (the-as time-frame (max 45 (the int (* 0.25 f30-2))))
+          )
+        (set! (-> self buzz-timer) (-> self clock frame-counter))
+        )
+      )
+    (quaternion-axis-angle!
+      (the-as quaternion (-> self vibe-jmod twist))
+      0.0
+      0.0
+      1.0
+      (* 182.04445 (* (-> self engine-vibe-amp) f28-2))
+      )
+    )
+  (dotimes (gp-4 (-> self path-count))
+    (debug-draw (-> self path-info data gp-4 path))
+    )
+  (when (logtest? (-> self flags) 128)
+    (let ((gp-5 (quaternion-inverse! (new 'stack-no-clear 'quaternion) (-> self root-override quat)))
+          (a1-28 (new 'stack-no-clear 'event-message-block))
+          )
+      (set! (-> a1-28 from) (process->ppointer self))
+      (set! (-> a1-28 num-params) 0)
+      (set! (-> a1-28 message) 'get-rotate-quat)
+      (let ((s5-3 (send-event-function (handle->process (-> self turret)) a1-28))
+            (s4-3 (new 'stack-no-clear 'quaternion))
+            (s2-3 (-> (the-as fort-robotank-turret (handle->process (-> self turret))) root-override trans))
+            (s1-1 (-> self root-override trans))
+            (s3-4 (new 'stack-no-clear 'vector))
+            )
+        (let ((a1-30 (new 'stack-no-clear 'event-message-block)))
+          (set! (-> a1-30 from) (process->ppointer self))
+          (set! (-> a1-30 num-params) 0)
+          (set! (-> a1-30 message) 'get-gun-elevation-cam)
+          (let ((f30-3 (the-as float (send-event-function (handle->process (-> self turret)) a1-30))))
+            (vector-! s3-4 s2-3 s1-1)
+            (vector-orient-by-quat! s3-4 s3-4 gp-5)
+            (quaternion*! s4-3 (the-as quaternion s5-3) gp-5)
+            (quaternion-normalize! s4-3)
+            (quaternion-rotate-local-x! s4-3 s4-3 f30-3)
+            )
+          )
+        (vector-orient-by-quat! (the-as vector (-> self pov-cam-offset)) (-> self pov-cam-offset 1) s4-3)
+        (vector+! (the-as vector (-> self pov-cam-offset)) (the-as vector (-> self pov-cam-offset)) s3-4)
+        )
+      )
+    )
+  (update-trans! (-> self sound) (-> self root-override trans))
+  (update! (-> self sound))
+  (update-trans! (-> self idle-sound) (-> self root-override trans))
+  (update! (-> self idle-sound))
+  (update-trans! (-> self barrel-sound) (-> self root-override trans))
+  (update! (-> self barrel-sound))
+  (pusher-post)
+  (none)
+  )
+
+;; definition for function fort-robotank-handler
+;; INFO: Used lq/sq
+(defbehavior fort-robotank-handler fort-robotank ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
+  (case arg2
+    (('trigger)
+     (when (and *target* (< (-> self continue-index) (the-as int (-> arg3 param 0))))
+       (if (< (-> self continue-index) 0)
+           (add-process *gui-control* self (gui-channel alert) (gui-action play) "cityv107" -99.0 0)
+           )
+       (when (< (-> *event-queue* length) (-> *event-queue* allocated-length))
+         (let ((v1-14 (-> *event-queue* data (-> *event-queue* length))))
+           (+! (-> *event-queue* length) 1)
+           (set! (-> v1-14 form-handle) (process->handle self))
+           (set! (-> v1-14 to-handle) (process->handle (handle->process (-> self turret))))
+           (set! (-> v1-14 num-params) 0)
+           (set! (-> v1-14 message) 'trigger)
+           )
+         )
+       (logior! (-> self flags) 32)
+       (set! (-> self continue-index) (the-as int (-> arg3 param 0)))
+       )
+     )
+    (('trans)
+     (-> self root-override trans)
+     )
+    (('die)
+     (go-virtual die)
+     )
+    (('fire-suppress-on)
+     (send-event (handle->process (-> self turret)) 'fire-suppress #t)
+     )
+    (('fire-suppress-off)
+     (send-event (handle->process (-> self turret)) 'fire-suppress #f)
+     )
+    (('touch 'attack)
+     (when ((method-of-type touching-shapes-entry prims-touching?)
+            (the-as touching-shapes-entry (-> arg3 param 0))
+            (-> self root-override)
+            (the-as uint 1)
+            )
+       (let ((s5-0 (if (type? arg0 process-focusable)
+                       (the-as process-focusable arg0)
+                       )
+                   )
+             )
+         (when s5-0
+           (let ((a0-48 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> self root-override quat)))
+                 (a1-19 (new 'stack-no-clear 'event-message-block))
+                 )
+             (set! (-> a1-19 from) (process->ppointer self))
+             (set! (-> a1-19 num-params) 2)
+             (set! (-> a1-19 message) 'attack-or-shove)
+             (set! (-> a1-19 param 0) (-> arg3 param 0))
+             (let ((v1-40 (new 'static 'attack-info :mask (attack-info-mask vector shove-back shove-up control id))))
+               (set! (-> v1-40 id) (-> self attack-id))
+               (set! (-> v1-40 vector quad) (-> a0-48 quad))
+               (set! (-> v1-40 shove-back) (if (and (-> self next-state) (= (-> self next-state name) 'idle))
+                                               16384.0
+                                               49152.0
+                                               )
+                     )
+               (set! (-> v1-40 shove-up) 24576.0)
+               (set! (-> v1-40 control) (if (logtest? (focus-status board) (-> s5-0 focus-status))
+                                            1.0
+                                            0.0
+                                            )
+                     )
+               (set! (-> a1-19 param 1) (the-as uint v1-40))
+               )
+             (when (send-event-function s5-0 a1-19)
+               (set! (-> self no-collision-timer) (-> self clock frame-counter))
+               (let ((v1-45 (-> self root-override root-prim)))
+                 (set! (-> v1-45 prim-core collide-as) (collide-spec))
+                 (set! (-> v1-45 prim-core collide-with) (collide-spec))
+                 )
+               0
+               )
+             )
+           )
+         )
+       )
+     )
+    (('stop-music)
+     (remove-setting! 'music)
+     (remove-setting! 'music-volume)
+     (remove-setting! 'sound-mode)
+     )
+    )
+  (none)
+  )
+
+;; definition for method 26 of type fort-robotank
+;; INFO: Used lq/sq
+(defmethod fort-robotank-method-26 fort-robotank ((obj fort-robotank) (arg0 int) (arg1 float) (arg2 float))
+  (local-vars
+    (sv-96 fort-robotank-segment-event)
+    (sv-112 (function process-tree event-message-block object))
+    (sv-128 event-message-block)
+    )
+  (with-pp
+    (let* ((s4-0 (* 0.00001 (the float (the int (+ 0.5 (* 100000.0 arg1))))))
+           (s3-0 (* 0.00001 (the float (the int (+ 0.5 (* 100000.0 arg2))))))
+           (s2-0 (-> obj segment-table (-> obj path-index)))
+           (s1-0 (-> s2-0 event-tbl))
+           )
+      (dotimes (s0-0 (-> s2-0 event-count))
+        (set! sv-96 (-> s1-0 s0-0))
+        (let ((f0-4 (-> sv-96 pos-norm)))
+          (when (and (= (-> sv-96 source) arg0) (>= s4-0 f0-4) (< s3-0 f0-4))
+            (case (-> sv-96 event-type)
+              (('send-event)
+               (set! sv-128 (new 'stack-no-clear 'event-message-block))
+               (set! (-> sv-128 from) (process->ppointer pp))
+               (set! (-> sv-128 num-params) 0)
+               (set! (-> sv-128 message) (the-as symbol (-> sv-96 param-obj)))
+               (set! sv-112 send-event-function)
+               (let ((a0-11 (process-by-ename (-> sv-96 actor))))
+                 (sv-112 a0-11 sv-128)
+                 )
+               )
+              (('code)
+               (let ((t9-2 (-> sv-96 param-obj)))
+                 (if t9-2
+                     ((the-as (function fort-robotank none) t9-2) obj)
+                     )
+                 )
+               )
+              (('pov-cam-on)
+               (set-setting! 'mode-name 'cam-pov-track 0 0)
+               (set-setting! 'allow-look-around #f 0 0)
+               (set-setting! 'target-height 'abs -968884224 0)
+               (let ((v1-27 (process->ppointer obj)))
+                 (set-setting! 'pov-handle v1-27 #x40400000 (-> v1-27 0 pid))
+                 )
+               (set-setting! 'pov-offset 'asdf (-> obj pov-cam-offset) 0)
+               (send-event (handle->process (-> obj turret)) 'pov-cam-on)
+               (logior! (-> obj flags) 128)
+               (let ((v1-41 (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 2)))
+                 (set! (-> v1-41 prim-core collide-as) (collide-spec enemy pusher))
+                 (set! (-> v1-41 prim-core collide-with) (collide-spec jak bot player-list))
+                 )
+               )
+              (('pov-cam-off)
+               (remove-setting! 'pov-handle)
+               (remove-setting! 'mode-name)
+               (remove-setting! 'allow-look-around)
+               (remove-setting! 'target-height)
+               (remove-setting! 'pov-offset)
+               (send-event (handle->process (-> obj turret)) 'pov-cam-off)
+               (set! (-> obj flags) (logand -129 (-> obj flags)))
+               (let ((v1-57 (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 2)))
+                 (set! (-> v1-57 prim-core collide-as) (collide-spec))
+                 (set! (-> v1-57 prim-core collide-with) (collide-spec))
+                 )
+               0
+               )
+              (('external-cam-on)
+               (hide-hud-quick #f)
+               (set-setting! 'entity-name (-> sv-96 actor) 0 0)
+               (set-setting! 'process-mask 'set 0 (process-mask movie enemy))
+               (remove-setting! 'target-height)
+               (process-grab? *target* #f)
+               (send-event (handle->process (-> obj turret)) 'fire-suppress #t)
+               )
+              (('external-cam-off)
+               (remove-setting! 'entity-name)
+               (remove-setting! 'process-mask)
+               (remove-setting! 'target-height)
+               (process-release? *target*)
+               (send-event (handle->process (-> obj turret)) 'fire-suppress #f)
+               )
+              )
+            )
+          )
+        )
+      )
+    #f
+    )
+  )
+
+;; definition for method 27 of type fort-robotank
+;; WARN: Return type mismatch object vs none.
+(defmethod fort-robotank-method-27 fort-robotank ((obj fort-robotank))
+  (let ((s5-0 (-> obj segment-table (-> obj path-index) flags)))
+    (send-event (handle->process (-> obj turret)) 'use-los (if (logtest? s5-0 16)
+                                                               #t
+                                                               #f
+                                                               )
+                )
+    (send-event (handle->process (-> obj turret)) 'limit-reticle-elev (if (logtest? s5-0 32)
+                                                                          #t
+                                                                          #f
+                                                                          )
+                )
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defstate idle (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (fort-robotank-method-25 self)
+    (set! (-> self roller-spin-rate) 2730.6667)
+    (none)
+    )
+  :trans (behavior ()
+    (when (and (name= (-> self name) "fort-robotank-6") (task-node-closed? (game-task-node fortress-dump-deal)))
+      (when (< (-> *event-queue* length) (-> *event-queue* allocated-length))
+        (let ((v1-8 (-> *event-queue* data (-> *event-queue* length))))
+          (+! (-> *event-queue* length) 1)
+          (set! (-> v1-8 form-handle) (process->handle self))
+          (set! (-> v1-8 to-handle) (process->handle (handle->process (-> self turret))))
+          (set! (-> v1-8 num-params) 0)
+          (set! (-> v1-8 message) 'trigger)
+          )
+        )
+      (logior! (-> self flags) 32)
+      )
+    (when (logtest? (-> self flags) 32)
+      (set! (-> self flags) (logand -33 (-> self flags)))
+      (set-setting! 'music 'danger11 0 0)
+      (set-setting! 'music-volume 'rel #x3f666666 0)
+      (go-virtual moving)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-robotank) sleep-code)
+  :post fort-robotank-post
+  )
+
+;; failed to figure out what this is:
+(defstate turning (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (set! (-> self path-info data (-> self path-index) start-y-angle)
+          (quaternion-y-angle (-> self root-override quat))
+          )
+    (set! (-> self roller-spin-rate) 32768.0)
+    (none)
+    )
+  :trans (behavior ()
+    (let* ((gp-0 (-> self path-info data (-> self path-index)))
+           (s5-0 (-> self root-override))
+           (f30-0 (quaternion-y-angle (-> s5-0 quat)))
+           (f28-0 (fabs (deg-diff f30-0 (-> gp-0 start-y-angle))))
+           (f30-1 (fabs (deg-diff f30-0 (vector-y-angle (-> gp-0 dir)))))
+           )
+      (let* ((f0-3 (fmin f28-0 f30-1))
+             (f0-6 (fmax 728.1778 (fmin 10012.444 (* 4.0 f0-3))))
+             )
+        (seek-toward-heading-vec! s5-0 (-> gp-0 dir) f0-6 (seconds 0.02))
+        )
+      (if (< f30-1 36.40889)
+          (go-virtual pause)
+          )
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-robotank) sleep-code)
+  :post (behavior ()
+    (fort-robotank-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate moving (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (set! (-> self roller-spin-rate) 65536.0)
+    (let ((v1-4 (-> self path-info data (-> self path-index))))
+      (set! (-> v1-4 u) 0.0)
+      (set! (-> v1-4 prev-u) -1.0)
+      (set! (-> v1-4 du) 0.0)
+      (set! (-> v1-4 du-final) 0.01)
+      )
+    (fort-robotank-method-27 self)
+    (none)
+    )
+  :exit (behavior ()
+    (set! (-> self flags) (logand -5 (-> self flags)))
+    (none)
+    )
+  :trans (behavior ()
+    (if (not *target*)
+        (go-virtual die)
+        )
+    (let* ((gp-0 *target*)
+           (a0-1 (if (type? gp-0 process-focusable)
+                     gp-0
+                     )
+                 )
+           )
+      (when a0-1
+        (if (< (-> (get-trans a0-1 0) y) (+ -18432.0 (-> self root-override trans y)))
+            (go-virtual die)
+            )
+        )
+      )
+    (let* ((v1-14 (-> self path-index))
+           (s5-0 (-> self path-info data v1-14))
+           (gp-1 (-> self segment-table v1-14))
+           )
+      (fort-robotank-method-26 self 0 (-> s5-0 u) (-> s5-0 prev-u))
+      (let ((s4-0 *target*))
+        (if (if (type? s4-0 process-focusable)
+                s4-0
+                )
+            (fort-robotank-method-26 self 1 (-> self player-u) (-> self player-prev-u))
+            )
+        )
+      (when (= (-> s5-0 u) 1.0)
+        (cond
+          ((logtest? (-> gp-1 flags) 1)
+           (set! (-> self path-index) (-> gp-1 next-segment))
+           (go-virtual turning)
+           )
+          (else
+            (set! (-> self path-index) (-> gp-1 next-segment))
+            (let ((gp-2 (-> self path-info data (-> self path-index))))
+              (set! (-> gp-2 u)
+                    (/ (-> self segment-table (-> self path-index) next-segment-start) (get-num-segments (-> gp-2 path)))
+                    )
+              (set! (-> gp-2 prev-u) (+ -0.1 (-> gp-2 u)))
+              (set! (-> gp-2 du) 0.01)
+              (set! (-> gp-2 du-final) 0.01)
+              )
+            0
+            (fort-robotank-method-27 self)
+            )
+          )
+        )
+      )
+    (none)
+    )
+  :code (behavior ()
+    (set! (-> self flags) (logand -5 (-> self flags)))
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.1))
+        (suspend)
+        )
+      )
+    (logior! (-> self flags) 4)
+    (sleep-code)
+    (none)
+    )
+  :post (behavior ()
+    (when (logtest? (-> self flags) 4)
+      (let* ((gp-0 *target*)
+             (s3-0 (if (type? gp-0 process-focusable)
+                       gp-0
+                       )
+                   )
+             (s5-0 (if s3-0
+                       (get-trans s3-0 0)
+                       (the-as vector #f)
+                       )
+                   )
+             (gp-1 (-> self path-info data (-> self path-index)))
+             )
+        (-> self segment-table (-> self path-index))
+        (let ((s4-0 (-> gp-1 path))
+              (s2-0 (new 'stack-no-clear 'vector))
+              )
+          (let ((f30-0 (-> gp-1 u))
+                (s0-0 (new 'stack-no-clear 'vector))
+                (s1-0 (-> self root-override))
+                )
+            (get-point-at-percent-along-path! s4-0 (-> s1-0 trans) f30-0 'interp)
+            (set! (-> s1-0 trans y) (+ 1024.0 (-> s1-0 trans y)))
+            (displacement-between-points-at-percent-normalized! s4-0 s0-0 f30-0)
+            (displacement-between-points-at-percent-scaled! s4-0 s2-0 f30-0 (-> gp-1 du-final))
+            (seek-toward-heading-vec! s1-0 s0-0 16384.0 (seconds 0.02))
+            )
+          (set! (-> gp-1 prev-u) (-> gp-1 u))
+          (set! (-> self player-prev-u) (-> self player-u))
+          (if s3-0
+              (set! (-> self player-u) (get-path-percentage-at-furthest-point s4-0 s5-0))
+              )
+          (let ((f30-1 (* (-> gp-1 du) (/ (-> gp-1 max-speed) (vector-length s2-0))))
+                (f28-0 1.0)
+                )
+            (if (logtest? (-> self segment-table (-> self path-index) flags) 1)
+                (set! f28-0
+                      (fmin 1.0 (* 0.000048828126
+                                   (+ 2048.0 (vector-vector-distance
+                                               (-> self root-override trans)
+                                               (get-point-at-percent-along-path! s4-0 (new 'stack-no-clear 'vector) 1.0 'interp)
+                                               )
+                                      )
+                                   )
+                            )
+                      )
+                )
+            (when s3-0
+              (let* ((s2-2 (-> self segment-table (-> self path-index) flags))
+                     (f26-1 (-> self player-u))
+                     (s3-1 (method-of-type path-control get-point-in-path!))
+                     (s3-2 (s3-1 s4-0 (new 'stack-no-clear 'vector) (* f26-1 (get-num-segments s4-0)) 'interp))
+                     (f20-0 (vector-vector-distance s3-2 s5-0))
+                     (f24-1 (total-distance s4-0))
+                     (f22-0 (+ -20480.0 f24-1))
+                     )
+                (when (logtest? s2-2 2)
+                  (if (< (* f26-1 f24-1) (fmin (+ 61440.0 (* (-> gp-1 u) f24-1)) f22-0))
+                      (set! f28-0 (if (and (< f20-0 8192.0) (< (-> gp-1 u) f26-1))
+                                      1.0
+                                      (fmin f28-0 (lerp-scale
+                                                    0.0
+                                                    1.0
+                                                    (if (< f26-1 (-> gp-1 u))
+                                                        0.0
+                                                        (vector-vector-distance (-> self root-override trans) s3-2)
+                                                        )
+                                                    6144.0
+                                                    61440.0
+                                                    )
+                                            )
+                                      )
+                            )
+                      )
+                  )
+                (when (logtest? s2-2 4)
+                  (if (< (fmin (+ 102400.0 (* (-> gp-1 u) f24-1)) f22-0) (* f26-1 f24-1))
+                      (set! f28-0
+                            (fmax
+                              f28-0
+                              (lerp-scale 1.0 2.0 (vector-vector-distance (-> self root-override trans) s3-2) 102400.0 143360.0)
+                              )
+                            )
+                      )
+                  )
+                )
+              )
+            (set! (-> gp-1 u) (fmax 0.0 (fmin 1.0 (+ (-> gp-1 u) (* f28-0 f30-1 (-> self clock seconds-per-frame))))))
+            (seek! (-> gp-1 du) (-> gp-1 du-final) (* 0.5 (-> self clock seconds-per-frame) (-> gp-1 du-final)))
+            (update-vol! (-> self sound) (lerp-scale 0.0 1.0 (* f28-0 f30-1) 0.0 0.03))
+            (update-vol! (-> self barrel-sound) (lerp-scale 0.0 1.0 (* f28-0 f30-1) 0.0 0.01))
+            )
+          )
+        )
+      )
+    (fort-robotank-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate pause (fort-robotank)
+  :virtual #t
+  :event (the-as
+    (function process int symbol event-message-block object :behavior fort-robotank)
+    fort-robotank-handler
+    )
+  :enter (behavior ()
+    (set! (-> self roller-spin-rate) 16384.0)
+    (none)
+    )
+  :trans (behavior ()
+    (when (logtest? (-> self flags) 32)
+      (set! (-> self flags) (logand -33 (-> self flags)))
+      (go-virtual moving)
+      )
+    (none)
+    )
+  :code (the-as (function none :behavior fort-robotank) sleep-code)
+  :post fort-robotank-post
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-robotank)
+  :virtual #t
+  :code (behavior ()
+    (remove-setting! 'pov-handle)
+    (remove-setting! 'pov-offset)
+    (remove-setting! 'mode-name)
+    (remove-setting! 'allow-look-around)
+    (remove-setting! 'entity-name)
+    (remove-setting! 'process-mask)
+    (remove-setting! 'target-height)
+    (send-event (handle->process (-> self turret)) 'die)
+    (let ((gp-0 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-0) (seconds 2))
+        (suspend)
+        )
+      )
+    (while (-> self child)
+      (suspend)
+      )
+    (none)
+    )
+  :post (the-as (function none :behavior fort-robotank) pusher-post)
+  )
+
+;; definition for method 10 of type fort-robotank
+(defmethod deactivate fort-robotank ((obj fort-robotank))
+  (stop! (-> obj idle-sound))
+  (stop! (-> obj barrel-sound))
+  ((method-of-type process-drawable deactivate) obj)
+  (none)
+  )
+
+;; definition for method 7 of type fort-robotank
+;; WARN: Return type mismatch process-drawable vs fort-robotank.
+(defmethod relocate fort-robotank ((obj fort-robotank) (arg0 int))
+  (if (nonzero? (-> obj barrel-part))
+      (&+! (-> obj barrel-part) arg0)
+      )
+  (if (nonzero? (-> obj roller-jmod))
+      (&+! (-> obj roller-jmod) arg0)
+      )
+  (if (nonzero? (-> obj vibe-jmod))
+      (&+! (-> obj vibe-jmod) arg0)
+      )
+  (if (nonzero? (-> obj idle-sound))
+      (&+! (-> obj idle-sound) arg0)
+      )
+  (if (nonzero? (-> obj barrel-sound))
+      (&+! (-> obj barrel-sound) arg0)
+      )
+  (let ((v1-20 (-> obj path-info)))
+    (when (nonzero? v1-20)
+      (dotimes (a0-2 (-> obj path-count))
+        (if (nonzero? (-> v1-20 data a0-2 path))
+            (&+! (-> v1-20 data a0-2 path) arg0)
+            )
+        )
+      (&+! (-> obj path-info) arg0)
+      )
+    )
+  (dotimes (v1-24 2)
+    (dotimes (a0-4 7)
+      (if (nonzero? (the-as
+                      joint-mod
+                      (-> (the-as (pointer uint32) (&+ (&+ (the-as (pointer uint32) obj) (* 144 v1-24)) (* a0-4 16))) 55)
+                      )
+                    )
+          (set! (-> (&+ (&+ (the-as (pointer uint32) obj) (* 144 v1-24)) (* a0-4 16)) 55)
+                (the-as
+                  uint
+                  (&+
+                    (the-as
+                      joint-mod
+                      (-> (the-as (pointer uint32) (&+ (&+ (the-as (pointer uint32) obj) (* 144 v1-24)) (* a0-4 16))) 55)
+                      )
+                    arg0
+                    )
+                  )
+                )
+          )
+      )
+    )
+  (the-as
+    fort-robotank
+    ((the-as (function process-drawable int process-drawable) (find-parent-method fort-robotank 7)) obj arg0)
+    )
+  )
+
+;; definition for method 11 of type fort-robotank
+;; WARN: Return type mismatch object vs none.
+(defmethod init-from-entity! fort-robotank ((obj fort-robotank) (arg0 entity-actor))
+  (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s4-0 reaction) cshape-reaction-default)
+    (set! (-> s4-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 3) 0)))
+      (set! (-> s4-0 total-prims) (the-as uint 4))
+      (set! (-> s3-0 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> s3-0 prim-core action) (collide-action solid))
+      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 47104.0)
+      (set! (-> s4-0 root-prim) s3-0)
+      )
+    (pusher-init s4-0)
+    (let ((v1-14 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 1))))
+      (set! (-> v1-14 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-14 prim-core action) (collide-action solid))
+      (set! (-> v1-14 transform-index) 5)
+      (set-vector! (-> v1-14 local-sphere) 0.0 0.0 0.0 24576.0)
+      )
+    (let ((v1-16 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-16 prim-core collide-as) (collide-spec enemy camera-blocker pusher))
+      (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list))
+      (set! (-> v1-16 prim-core action) (collide-action solid))
+      (set! (-> v1-16 transform-index) 3)
+      (set-vector! (-> v1-16 local-sphere) 0.0 0.0 -8192.0 28672.0)
+      )
+    (let ((v1-18 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0))))
+      (set! (-> v1-18 prim-core action) (collide-action solid))
+      (set! (-> v1-18 transform-index) 3)
+      (set-vector! (-> v1-18 local-sphere) 0.0 0.0 -8192.0 36864.0)
+      )
+    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
+    (let ((v1-21 (-> s4-0 root-prim)))
+      (set! (-> s4-0 backup-collide-as) (-> v1-21 prim-core collide-as))
+      (set! (-> s4-0 backup-collide-with) (-> v1-21 prim-core collide-with))
+      )
+    (set! (-> obj root-override) s4-0)
+    )
+  (process-drawable-from-entity! obj arg0)
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-robotank" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (process-entity-status! obj (entity-perm-status no-kill) #t)
+  (set! (-> obj fact)
+        (new 'process 'fact-info obj (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
+        )
+  (set! (-> obj flags) (the-as uint 0))
+  (set! (-> obj no-collision-timer) 0)
+  (set! (-> obj engine-vibe-rate) 1.0)
+  (set! (-> obj buzz-timer) 0)
+  (let* ((v1-31 *game-info*)
+         (a0-30 (+ (-> v1-31 attack-id) 1))
+         )
+    (set! (-> v1-31 attack-id) a0-30)
+    (set! (-> obj attack-id) a0-30)
+    )
+  (cond
+    ((name= (-> obj name) "fort-robotank-2")
+     (set! (-> obj segment-table) *fort-robotank-1-segment-table*)
+     (set! (-> obj path-count) 4)
+     )
+    ((name= (-> obj name) "fort-robotank-6")
+     (set! (-> obj segment-table) *fort-robotank-2-segment-table*)
+     (set! (-> obj path-count) 1)
+     )
+    (else
+      (go process-drawable-art-error "unknown actor-node name")
+      )
+    )
+  (set! (-> obj path-info) (new 'process 'fort-robotank-path-info-array (-> obj path-count)))
+  (dotimes (s5-2 (-> obj path-count))
+    (let ((s4-2 (-> obj path-info data s5-2)))
+      (if (logtest? (-> obj segment-table s5-2 flags) 8)
+          (set! (-> s4-2 path) (new 'process 'curve-control obj 'path -1000000000.0))
+          (set! (-> s4-2 path) (new 'process 'curve-control obj 'path (the float s5-2)))
+          )
+      (logior! (-> s4-2 path flags) (path-control-flag display draw-line draw-point draw-text))
+      (set! (-> s4-2 u) 0.0)
+      (set! (-> s4-2 du) (-> s4-2 u))
+      (set! (-> s4-2 max-speed) (* 4096.0 (-> obj segment-table s5-2 max-speed)))
+      (set! (-> s4-2 dist) (total-distance (-> s4-2 path)))
+      (set! (-> s4-2 start-y-angle) 0.0)
+      (displacement-between-two-points-normalized! (-> s4-2 path) (-> s4-2 dir) 0.0)
+      )
+    )
+  (set! (-> obj path-index) 0)
+  (set! (-> obj continue-index) -1)
+  (let ((s5-3 (new 'stack-no-clear 'vector)))
+    (let ((s4-3 (-> obj path-info data 0 path)))
+      (get-point-in-path! s4-3 (-> obj root-override trans) 0.0 'interp)
+      (set! (-> obj root-override trans y) (+ 1024.0 (-> obj root-override trans y)))
+      (displacement-between-points-at-percent-normalized! s4-3 s5-3 0.0)
+      )
+    (set-heading-vec! (-> obj root-override) s5-3)
+    )
+  (let ((a0-46 (-> obj skel root-channel 0)))
+    (set! (-> a0-46 frame-group) (the-as art-joint-anim (-> obj draw art-group data 3)))
+    (set! (-> a0-46 frame-num) 0.0)
+    (joint-control-channel-group! a0-46 (the-as art-joint-anim (-> obj draw art-group data 3)) num-func-identity)
+    )
+  (transform-post)
+  (let ((s5-4 (new 'stack-no-clear 'vector)))
+    (set-vector! s5-4 0.0 12541.952 -6778.88 1.0)
+    (set! (-> obj turret)
+          (ppointer->handle
+            (process-spawn
+              fort-robotank-turret
+              (-> obj root-override trans)
+              (-> obj root-override quat)
+              s5-4
+              #x42000000
+              :to obj
+              )
+            )
+          )
+    )
+  (set! (-> obj roller-jmod) (the-as joint-mod (new 'process 'joint-mod-spinner obj 5 *x-vector* 0.0)))
+  (set! (-> obj roller-spin-rate) 0.0)
+  (set! (-> obj vibe-jmod) (the-as joint-mod (new 'process 'joint-mod-blend-local obj 4 #t)))
+  (set! (-> obj vibe-jmod scale y) 0.5)
+  (quaternion-axis-angle! (the-as quaternion (-> obj vibe-jmod twist)) 0.0 0.0 1.0 0.0)
+  (let ((s5-5 (-> obj tread)))
+    (set! (-> s5-5 0 wheel 0 jmod) (new 'process 'joint-mod-spinner obj 6 *x-vector* 0.0))
+    (set! (-> s5-5 0 wheel 0 radius) 2048.0)
+    )
+  (let ((s5-6 (-> obj tread 0 wheel 1)))
+    (set! (-> s5-6 jmod) (new 'process 'joint-mod-spinner obj 7 *x-vector* 0.0))
+    (set! (-> s5-6 radius) 2048.0)
+    )
+  (let ((s5-7 (-> obj tread 0 wheel 2)))
+    (set! (-> s5-7 jmod) (new 'process 'joint-mod-spinner obj 8 *x-vector* 0.0))
+    (set! (-> s5-7 radius) 2048.0)
+    )
+  (let ((s5-8 (-> obj tread 0 wheel 3)))
+    (set! (-> s5-8 jmod) (new 'process 'joint-mod-spinner obj 9 *x-vector* 0.0))
+    (set! (-> s5-8 radius) 2048.0)
+    )
+  (let ((s5-9 (-> obj tread 0 wheel 4)))
+    (set! (-> s5-9 jmod) (new 'process 'joint-mod-spinner obj 10 *x-vector* 0.0))
+    (set! (-> s5-9 radius) 2048.0)
+    )
+  (let ((s5-10 (-> obj tread 0 wheel 5)))
+    (set! (-> s5-10 jmod) (new 'process 'joint-mod-spinner obj 11 *x-vector* 0.0))
+    (set! (-> s5-10 radius) 2048.0)
+    )
+  (let ((s5-11 (-> obj tread 0 wheel 6)))
+    (set! (-> s5-11 jmod) (new 'process 'joint-mod-spinner obj 12 *x-vector* 0.0))
+    (set! (-> s5-11 radius) 2048.0)
+    )
+  (let ((s5-12 (-> obj tread 1)))
+    (set! (-> s5-12 wheel 0 jmod) (new 'process 'joint-mod-spinner obj 13 *x-vector* 0.0))
+    (set! (-> s5-12 wheel 0 radius) 2048.0)
+    )
+  (let ((s5-13 (-> obj tread 1 wheel 1)))
+    (set! (-> s5-13 jmod) (new 'process 'joint-mod-spinner obj 14 *x-vector* 0.0))
+    (set! (-> s5-13 radius) 2048.0)
+    )
+  (let ((s5-14 (-> obj tread 1 wheel 2)))
+    (set! (-> s5-14 jmod) (new 'process 'joint-mod-spinner obj 15 *x-vector* 0.0))
+    (set! (-> s5-14 radius) 2048.0)
+    )
+  (let ((s5-15 (-> obj tread 1 wheel 3)))
+    (set! (-> s5-15 jmod) (new 'process 'joint-mod-spinner obj 16 *x-vector* 0.0))
+    (set! (-> s5-15 radius) 2048.0)
+    )
+  (let ((s5-16 (-> obj tread 1 wheel 4)))
+    (set! (-> s5-16 jmod) (new 'process 'joint-mod-spinner obj 17 *x-vector* 0.0))
+    (set! (-> s5-16 radius) 2048.0)
+    )
+  (let ((s5-17 (-> obj tread 1 wheel 5)))
+    (set! (-> s5-17 jmod) (new 'process 'joint-mod-spinner obj 18 *x-vector* 0.0))
+    (set! (-> s5-17 radius) 2048.0)
+    )
+  (let ((s5-18 (-> obj tread 1 wheel 6)))
+    (set! (-> s5-18 jmod) (new 'process 'joint-mod-spinner obj 19 *x-vector* 0.0))
+    (set! (-> s5-18 radius) 2048.0)
+    )
+  (set! (-> obj tread 0 texture) (-> *fortress-pris-texture-anim-array* array-data 0))
+  (set! (-> obj tread 0 texture frame-delta) 0.0)
+  (let ((v1-128 9))
+    (set! (-> obj tread 0 locator-joint) v1-128)
+    (vector<-cspace! (-> obj tread 0 pos) (-> obj node-list data v1-128))
+    )
+  (set! (-> obj tread 1 texture) (-> *fortress-pris-texture-anim-array* array-data 1))
+  (set! (-> obj tread 1 texture frame-delta) 0.0)
+  (let ((v1-135 16))
+    (set! (-> obj tread 1 locator-joint) v1-135)
+    (vector<-cspace! (-> obj tread 1 pos) (-> obj node-list data v1-135))
+    )
+  (set-vector! (-> obj pov-cam-offset 0) 0.0 13516.8 -13516.8 1.0)
+  (set-vector! (-> obj pov-cam-offset 1) 0.0 13516.8 -13516.8 1.0)
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 561) obj))
+  (set! (-> obj barrel-part) (create-launch-control (-> *part-group-id-table* 562) obj))
+  (set! (-> obj sound)
+        (new 'process 'ambient-sound (static-sound-spec "robotank-tread" :fo-max 70) (-> obj root-override trans))
+        )
+  (set! (-> obj idle-sound)
+        (new 'process 'ambient-sound (static-sound-spec "robotank-idle" :fo-max 50) (-> obj root-override trans))
+        )
+  (set! (-> obj barrel-sound)
+        (new 'process 'ambient-sound (static-sound-spec "robotank-barrel" :fo-max 50) (-> obj root-override trans))
+        )
+  (update-vol! (-> obj sound) 0.0)
+  (update-vol! (-> obj idle-sound) 1.0)
+  (update-vol! (-> obj barrel-sound) 0.25)
+  (go (method-of-object obj idle))
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/fortress/fort-turret_REF.gc b/test/decompiler/reference/jak2/levels/fortress/fort-turret_REF.gc
new file mode 100644
index 0000000000..5c2212be42
--- /dev/null
+++ b/test/decompiler/reference/jak2/levels/fortress/fort-turret_REF.gc
@@ -0,0 +1,1205 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; failed to figure out what this is:
+(defpartgroup group-fort-turret-hit
+  :id 685
+  :duration (seconds 3)
+  :linger-duration (seconds 1)
+  :flags (use-local-clock)
+  :bounds (static-bspherem 0 0 0 15)
+  :parts ((sp-item 3049 :period 1500 :length 25 :offset -10)
+    (sp-item 3050 :fade-after (meters 60) :period 1500 :length 30)
+    (sp-item 3051 :fade-after (meters 60) :falloff-to (meters 60) :period 1500 :length 100)
+    (sp-item 3052 :fade-after (meters 200) :falloff-to (meters 200) :period 1500 :length 50)
+    (sp-item 3053 :period 1500 :length 5 :offset -10)
+    (sp-item 3054 :fade-after (meters 150) :falloff-to (meters 150) :period 1500 :length 50)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3052
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x34 :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-rot-z)
+      :flags (sp-flag spflag7)
+      :random-rangef 65536.0
+      :random-multf 1.0
+      )
+    (sp-rnd-flt spt-scale-y (meters 0.8) (meters 0.2) 1.0)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 32.0 32.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.13333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.36)
+    (sp-flt spt-fade-b -4.24)
+    (sp-flt spt-fade-a -0.22068965)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-func spt-func 'sparticle-motion-blur)
+    (sp-int-plain-rnd spt-next-time 25 4 1)
+    (sp-launcher-by-id spt-next-launcher 3055)
+    (new 'static 'sp-field-init-spec
+      :field (sp-field-id spt-conerot-x)
+      :flags (sp-flag from-pointer)
+      :func '*sp-temp*
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3054
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x33 :page #xc))
+    (sp-rnd-flt spt-num 1.0 1.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0)
+    (sp-flt spt-rot-z (degrees 0.0))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 0.0)
+    (sp-rnd-flt spt-vel-y (meters 0.02) (meters 0.01) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.01) (meters 0.13333334) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.36)
+    (sp-flt spt-fade-b -4.24)
+    (sp-flt spt-fade-a 0.22068965)
+    (sp-flt spt-friction 0.95)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 25 4 1)
+    (sp-launcher-by-id spt-next-launcher 3055)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3055
+  :init-specs ((sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.0)
+    (sp-flt spt-fade-b 0.0)
+    (sp-int-plain-rnd spt-next-time 5 19 1)
+    (sp-launcher-by-id spt-next-launcher 3056)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3056
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.016666668) (meters 0.016666668) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.44)
+    (sp-flt spt-fade-g -2.36)
+    (sp-flt spt-fade-b -2.64)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 3057)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3057
+  :init-specs ((sp-rnd-flt spt-scalevel-x (meters 0.008333334) (meters 0.008333334) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -1.2944444)
+    (sp-flt spt-fade-g -0.7111111)
+    (sp-flt spt-fade-b -0.094444446)
+    (sp-rnd-flt spt-fade-a -0.06545454 -0.06545454 1.0)
+    (sp-int-plain-rnd spt-next-time 150 29 1)
+    (sp-launcher-by-id spt-next-launcher 3058)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3058
+  :init-specs ((sp-flt spt-fade-r 0.0) (sp-flt spt-fade-g 0.0) (sp-flt spt-fade-b 0.0))
+  )
+
+;; failed to figure out what this is:
+(defpart 3053
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x47 :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-flt spt-scale-x (meters 5))
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-flt spt-a 96.0)
+    (sp-flt spt-scalevel-x (meters 0.5))
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -1.28)
+    (sp-flt spt-fade-b -5.1)
+    (sp-flt spt-fade-a 0.0)
+    (sp-int spt-timer 100)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-int spt-next-time 50)
+    (sp-launcher-by-id spt-next-launcher 3059)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3059
+  :init-specs ((sp-flt spt-scalevel-x (meters -0.2))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -2.56)
+    (sp-flt spt-fade-b 0.0)
+    (sp-flt spt-fade-a -1.92)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3051
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x32 :page #xc))
+    (sp-rnd-flt spt-num 5.0 3.0 1.0)
+    (sp-flt spt-x (meters 0.25))
+    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.25) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 255.0)
+    (sp-flt spt-b 255.0)
+    (sp-rnd-flt spt-a 16.0 48.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0.083333336) (meters 0.083333336) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0016666667) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g -0.18)
+    (sp-flt spt-fade-b -2.12)
+    (sp-rnd-flt spt-accel-y -0.68266666 -1.3653333 1.0)
+    (sp-flt spt-friction 0.87)
+    (sp-int spt-timer 1000)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 3060)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3060
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0016666667))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 0.0)
+    (sp-flt spt-fade-g 0.02)
+    (sp-flt spt-fade-b 0.23555556)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 3061)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3061
+  :init-specs ((sp-flt spt-fade-r -0.5543478) (sp-flt spt-fade-g -0.5543478) (sp-flt spt-fade-a -0.13913043))
+  )
+
+;; failed to figure out what this is:
+(defpart 3049
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc))
+    (sp-rnd-flt spt-num 3.0 1.0 1.0)
+    (sp-rnd-flt spt-x (meters 0) (meters 0.6) 1.0)
+    (sp-rnd-flt spt-scale-x (meters 2) (meters 1.5) 1.0)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 70.0 20.0 1.0)
+    (sp-rnd-flt spt-g 70.0 20.0 1.0)
+    (sp-rnd-flt spt-b 70.0 20.0 1.0)
+    (sp-rnd-flt spt-a 0.0 40.0 1.0)
+    (sp-rnd-flt spt-vel-y (meters 0) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.033333335) (meters 0.016666668) 1.0)
+    (sp-rnd-flt spt-rotvel-z (degrees -0.12) (degrees 0.24) 1.0)
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r 3.3)
+    (sp-flt spt-fade-g 3.12)
+    (sp-flt spt-fade-b 1.18)
+    (sp-flt spt-fade-a 1.76)
+    (sp-flt spt-friction 0.88)
+    (sp-int spt-timer 710)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3)
+    (sp-int-plain-rnd spt-next-time 35 14 1)
+    (sp-launcher-by-id spt-next-launcher 3062)
+    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3062
+  :init-specs ((sp-flt spt-scalevel-x (meters 0.0033333334))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.53333336)
+    (sp-flt spt-fade-g -1.9666667)
+    (sp-flt spt-fade-b -2.2)
+    (sp-flt spt-fade-a -0.41666666)
+    (sp-int-plain-rnd spt-next-time 45 14 1)
+    (sp-launcher-by-id spt-next-launcher 3063)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3063
+  :init-specs ((sp-flt spt-scalevel-x (meters 0))
+    (sp-copy-from-other spt-scalevel-y -4)
+    (sp-flt spt-fade-r -0.38833332)
+    (sp-flt spt-fade-g -0.21333334)
+    (sp-flt spt-fade-b -0.028333334)
+    (sp-flt spt-fade-a -0.38833332)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3050
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x31 :page #xc))
+    (sp-rnd-flt spt-num 4.0 2.0 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.25) 1.0)
+    (sp-int spt-rot-x 4)
+    (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0)
+    (sp-rnd-flt spt-scale-y (meters 0.2) (meters 0.1) 1.0)
+    (sp-rnd-flt spt-r 128.0 128.0 1.0)
+    (sp-flt spt-g 96.0)
+    (sp-flt spt-b 64.0)
+    (sp-rnd-flt spt-a 64.0 64.0 1.0)
+    (sp-rnd-flt spt-scalevel-x (meters 0.13333334) (meters 0.02) 1.0)
+    (sp-flt spt-fade-g 1.6)
+    (sp-flt spt-fade-b 3.2)
+    (sp-flt spt-fade-a -1.6)
+    (sp-int spt-timer 80)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3064
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x9b :page #xb))
+    (sp-func spt-birth-func 'birth-func-laser-pointer)
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.075) (meters 0.05) 1.0)
+    (sp-flt spt-scale-y (meters 40))
+    (sp-flt spt-r 255.0)
+    (sp-flt spt-g 0.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 20.0)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14 left-multiply-quat)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3065
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbc :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.15) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-flt spt-r 255.0)
+    (sp-rnd-flt spt-g 128.0 128.0 1.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3066
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.25) 1.0)
+    (sp-flt spt-rot-x 204.8)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 128.0 1.0)
+    (sp-flt spt-g 0.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-rnd-flt spt-a 48.0 16.0 1.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-14 glow)
+    (sp-flt spt-userdata 1.0)
+    )
+  )
+
+;; failed to figure out what this is:
+(defpart 3067
+  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbc :page #xc))
+    (sp-flt spt-num 1.0)
+    (sp-rnd-flt spt-scale-x (meters 0.2) (meters 0.025) 1.0)
+    (sp-copy-from-other spt-scale-y -4)
+    (sp-rnd-flt spt-r 128.0 128.0 1.0)
+    (sp-flt spt-g 32.0)
+    (sp-copy-from-other spt-b -1)
+    (sp-flt spt-a 128.0)
+    (sp-flt spt-rotvel-z (degrees 0.3))
+    (sp-flt spt-fade-g -1.0666667)
+    (sp-flt spt-fade-b -1.0666667)
+    (sp-flt spt-fade-a -8.533334)
+    (sp-int spt-timer 5)
+    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-14)
+    )
+  )
+
+;; definition for function fort-turret-draw-laser-spot
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defun fort-turret-draw-laser-spot ((arg0 vector) (arg1 object) (arg2 symbol))
+  (new 'stack-no-clear 'vector)
+  (cond
+    (arg2
+      (let ((t9-0 sp-launch-particles-var)
+            (a0-1 *sp-particle-system-2d*)
+            (a1-1 (-> *part-id-table* 3066))
+            (a2-1 *launch-matrix*)
+            )
+        (set! (-> a2-1 trans quad) (-> arg0 quad))
+        (t9-0 a0-1 a1-1 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      (let ((t9-1 sp-launch-particles-var)
+            (a0-2 *sp-particle-system-2d*)
+            (a1-2 (-> *part-id-table* 3065))
+            (a2-2 *launch-matrix*)
+            )
+        (set! (-> a2-2 trans quad) (-> arg0 quad))
+        (t9-1 a0-2 a1-2 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      )
+    (else
+      (let ((t9-2 sp-launch-particles-var)
+            (a0-3 *sp-particle-system-2d*)
+            (a1-3 (-> *part-id-table* 3067))
+            (a2-3 *launch-matrix*)
+            )
+        (set! (-> a2-3 trans quad) (-> arg0 quad))
+        (t9-2 a0-3 a1-3 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0)
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for function fort-turret-draw-laser
+;; WARN: Return type mismatch int vs none.
+(defun fort-turret-draw-laser ((arg0 vector) (arg1 vector))
+  (let* ((s4-0 (-> *part-id-table* 3064))
+         (s3-0 (get-field-spec-by-id s4-0 (sp-field-id spt-scale-x)))
+         (f30-0 (-> s3-0 initial-valuef))
+         (f28-0 (-> s3-0 random-rangef))
+         )
+    (let ((f0-4 (fmin 1.0 (fmax 0.0 (* 0.000015287453 (+ -122.88 (vector-vector-distance (camera-pos) arg0)))))))
+      (set! (-> s3-0 initial-valuef) (* f30-0 f0-4))
+      (set! (-> s3-0 random-rangef) (* f28-0 f0-4))
+      )
+    (draw-beam s4-0 arg0 (vector-! (new 'stack-no-clear 'vector) arg1 arg0) #t #t)
+    (set! (-> s3-0 initial-valuef) f30-0)
+    (set! (-> s3-0 random-rangef) f28-0)
+    )
+  0
+  (none)
+  )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-turret fort-turret fort-turret-lod0-jg fort-turret-idle-ja
+              ((fort-turret-lod0-mg (meters 999999)))
+              :bounds (static-spherem 8 11.25 0 16.5)
+              :shadow fort-turret-shadow-mg
+              :origin-joint-index 3
+              :shadow-joint-index 3
+              )
+
+;; failed to figure out what this is:
+(defskelgroup skel-fort-turret-explode fort-turret fort-turret-explode-lod0-jg fort-turret-explode-idle-ja
+              ((fort-turret-explode-lod0-mg (meters 999999)))
+              :bounds (static-spherem 0 0 0 15)
+              )
+
+;; definition for symbol *fort-turret-exploder-params*, type joint-exploder-static-params
+(define *fort-turret-exploder-params*
+  (new 'static 'joint-exploder-static-params
+    :joints (new 'static 'boxed-array :type joint-exploder-static-joint-params
+      (new 'static 'joint-exploder-static-joint-params :joint-index 4 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 6 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 7 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 8 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 9 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 10 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 11 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 12 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 13 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 14 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 15 :parent-joint-index -1)
+      (new 'static 'joint-exploder-static-joint-params :joint-index 16 :parent-joint-index -1)
+      )
+    :collide-spec #x1
+    )
+  )
+
+;; definition of type fort-turret
+(deftype fort-turret (enemy)
+  ((gun-tilt-jm     joint-mod           :offset-assert 532)
+   (gun-shadow-jm   joint-mod           :offset-assert 536)
+   (aim-pos         vector      :inline :offset-assert 544)
+   (target-bullseye vector      :inline :offset-assert 560)
+   (gun-twist       float               :offset-assert 576)
+   (gun-tilt        float               :offset-assert 580)
+   (desired-twist   float               :offset-assert 584)
+   (desired-tilt    float               :offset-assert 588)
+   (los-clear       basic               :offset-assert 592)
+   (flash-state     basic               :offset-assert 596)
+   (flash-index     uint32              :offset-assert 600)
+   (can-shoot       symbol              :offset-assert 604)
+   (last-hit-time   time-frame          :offset-assert 608)
+   (init-mat        matrix      :inline :offset-assert 624)
+   (target-timeout  uint64              :offset-assert 688)
+   (beam-intersect  basic               :offset-assert 696)
+   (sync            sync-linear :inline :offset-assert 704)
+   (invincible      symbol              :offset-assert 720)
+   )
+  :heap-base #x260
+  :method-count-assert 143
+  :size-assert         #x2d4
+  :flag-assert         #x8f026002d4
+  (:methods
+    (attack () _type_ :state 137)
+    (sweep () _type_ :state 138)
+    (fort-turret-method-139 (_type_) none 139)
+    (fort-turret-method-140 (_type_ float float) quaternion 140)
+    (fort-turret-method-141 (_type_) vector 141)
+    (fort-turret-method-142 (_type_ symbol int) symbol 142)
+    )
+  )
+
+;; definition for method 3 of type fort-turret
+(defmethod inspect fort-turret ((obj fort-turret))
+  (when (not obj)
+    (set! obj obj)
+    (goto cfg-4)
+    )
+  (let ((t9-0 (method-of-type enemy inspect)))
+    (t9-0 obj)
+    )
+  (format #t "~2Tgun-tilt-jm: ~A~%" (-> obj gun-tilt-jm))
+  (format #t "~2Tgun-shadow-jm: ~A~%" (-> obj gun-shadow-jm))
+  (format #t "~2Taim-pos: #<vector @ #x~X>~%" (-> obj aim-pos))
+  (format #t "~2Ttarget-bullseye: #<vector @ #x~X>~%" (-> obj target-bullseye))
+  (format #t "~2Tgun-twist: ~f~%" (-> obj gun-twist))
+  (format #t "~2Tgun-tilt: ~f~%" (-> obj gun-tilt))
+  (format #t "~2Tdesired-twist: ~f~%" (-> obj desired-twist))
+  (format #t "~2Tdesired-tilt: ~f~%" (-> obj desired-tilt))
+  (format #t "~2Tlos-clear: ~A~%" (-> obj los-clear))
+  (format #t "~2Tflash-state: ~A~%" (-> obj flash-state))
+  (format #t "~2Tflash-index: ~D~%" (-> obj flash-index))
+  (format #t "~2Tcan-shoot: ~A~%" (-> obj can-shoot))
+  (format #t "~2Tlast-hit-time: ~D~%" (-> obj last-hit-time))
+  (format #t "~2Tinit-mat: #<matrix @ #x~X>~%" (-> obj init-mat))
+  (format #t "~2Ttarget-timeout: ~D~%" (-> obj target-timeout))
+  (format #t "~2Tbeam-intersect: ~A~%" (-> obj beam-intersect))
+  (format #t "~2Tsync: #<sync-linear @ #x~X>~%" (-> obj sync))
+  (format #t "~2Tinvincible: ~A~%" (-> obj invincible))
+  (label cfg-4)
+  obj
+  )
+
+;; definition for symbol *fort-turret-enemy-info*, type enemy-info
+(define *fort-turret-enemy-info* (new 'static 'enemy-info
+                                   :use-die-falling #f
+                                   :use-victory #f
+                                   :use-jump-blocked #f
+                                   :debug-draw-neck #f
+                                   :jump-debug-draw #f
+                                   :move-to-ground #f
+                                   :hover-if-no-ground #f
+                                   :idle-anim-script (new 'static 'array uint32 4 #x1010401 #x0 #x0 #x0)
+                                   :idle-anim 4
+                                   :notice-anim 4
+                                   :hostile-anim 4
+                                   :hit-anim 4
+                                   :knocked-anim -1
+                                   :knocked-land-anim -1
+                                   :die-anim 4
+                                   :die-falling-anim -1
+                                   :victory-anim -1
+                                   :jump-wind-up-anim -1
+                                   :jump-in-air-anim -1
+                                   :jump-land-anim -1
+                                   :neck-joint -1
+                                   :notice-distance (meters 150)
+                                   :notice-distance-delta (meters 10)
+                                   :proximity-notice-distance (meters 150)
+                                   :default-hit-points 1
+                                   :gnd-collide-with (collide-spec backgnd)
+                                   :overlaps-others-collide-with-filter (collide-spec jak bot player-list)
+                                   :movement-gravity (meters -100)
+                                   :friction 0.8
+                                   :attack-shove-back (meters 3)
+                                   :attack-shove-up (meters 2)
+                                   :attack-mode 'generic
+                                   :attack-damage 2
+                                   :jump-height-min (meters 3)
+                                   :jump-height-factor 0.5
+                                   :knocked-seek-ry-clamp 2730.6667
+                                   :knocked-soft-vxz-lo 72089.6
+                                   :knocked-soft-vxz-hi 108134.4
+                                   :knocked-soft-vy-lo 81920.0
+                                   :knocked-soft-vy-hi 122880.0
+                                   :knocked-medium-vxz-lo 147456.0
+                                   :knocked-medium-vxz-hi 196608.0
+                                   :knocked-medium-vy-lo 135168.0
+                                   :knocked-medium-vy-hi 151552.0
+                                   :knocked-hard-vxz-lo 78643.2
+                                   :knocked-hard-vxz-hi 117964.8
+                                   :knocked-hard-vy-lo 183500.8
+                                   :knocked-hard-vy-hi 209715.2
+                                   :knocked-huge-vxz-lo 164659.2
+                                   :knocked-huge-vxz-hi 249036.8
+                                   :knocked-huge-vy-lo 183500.8
+                                   :knocked-huge-vy-hi 217907.2
+                                   :knocked-yellow-vxz-lo 40960.0
+                                   :knocked-yellow-vxz-hi 49152.0
+                                   :knocked-yellow-vy-lo 57344.0
+                                   :knocked-yellow-vy-hi 81920.0
+                                   :knocked-red-vxz-lo 24576.0
+                                   :knocked-red-vxz-hi 196608.0
+                                   :knocked-red-vy-lo 94208.0
+                                   :knocked-red-vy-hi 151552.0
+                                   :knocked-blue-vxz-lo 40960.0
+                                   :knocked-blue-vxz-hi 49152.0
+                                   :knocked-blue-vy-lo 24576.0
+                                   :knocked-blue-vy-hi 81920.0
+                                   :shadow-size (meters 1)
+                                   :shadow-max-y (meters 1)
+                                   :shadow-min-y (meters -1)
+                                   :shadow-locus-dist (meters 150)
+                                   :gem-joint -1
+                                   :gem-offset (new 'static 'sphere :r 163840.0)
+                                   )
+        )
+
+;; failed to figure out what this is:
+(set! (-> *fort-turret-enemy-info* fact-defaults) *fact-info-enemy-defaults*)
+
+;; definition for method 55 of type fort-turret
+(defmethod enemy-method-55 fort-turret ((obj fort-turret))
+  (let ((t9-0 (method-of-type enemy enemy-method-55)))
+    (t9-0 obj)
+    )
+  (let ((s5-0 (-> obj root-override2)))
+    (update-transforms s5-0)
+    (pull-riders! s5-0)
+    (do-push-aways s5-0)
+    )
+  (when (not (and (-> obj next-state) (= (-> obj next-state name) 'die)))
+    (let ((a0-7 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 12))))
+      (fort-turret-draw-laser a0-7 (-> obj target-bullseye))
+      )
+    (case (-> obj beam-intersect)
+      (('target)
+       (fort-turret-draw-laser-spot (-> obj target-bullseye) #f #t)
+       )
+      (('wall)
+       (fort-turret-draw-laser-spot (-> obj target-bullseye) #f #f)
+       )
+      )
+    )
+  (none)
+  )
+
+;; definition for method 139 of type fort-turret
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch quaternion vs none.
+(defmethod fort-turret-method-139 fort-turret ((obj fort-turret))
+  (let ((a0-2 (handle->process (-> obj focus handle))))
+    (if a0-2
+        (set! (-> obj aim-pos quad) (-> (get-trans (the-as process-focusable a0-2) 3) quad))
+        )
+    )
+  (let ((s4-0 (new 'stack-no-clear 'vector))
+        (s5-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 4)))
+        )
+    (let ((s3-0 (new 'stack-no-clear 'vector)))
+      (vector-! s4-0 (-> obj aim-pos) (-> obj root-override2 trans))
+      (vector-flatten! s4-0 s4-0 (-> obj init-mat vector 1))
+      (vector-normalize! s4-0 1.0)
+      (set! (-> obj desired-twist) (asin (vector-dot (the-as vector (-> obj init-mat)) s4-0)))
+      (set! (-> obj desired-twist) (fmin 9102.223 (fmax -9102.223 (-> obj desired-twist))))
+      (cond
+        ((< 0.0 (vector-dot (-> obj init-mat vector 2) s4-0))
+         )
+        ((< (-> obj desired-twist) 0.0)
+         (set! (-> obj desired-twist) -9102.223)
+         )
+        (else
+          (set! (-> obj desired-twist) 9102.223)
+          )
+        )
+      (set! (-> obj desired-tilt) 0.0)
+      (when (< (fabs (-> obj desired-twist)) 9102.223)
+        (vector-normalize-copy! s3-0 (-> obj node-list data 3 bone transform vector 1) 1.0)
+        (vector-! s4-0 (-> obj aim-pos) s5-2)
+        (set! (-> obj desired-tilt)
+              (- (atan 8192.0 (vector-normalize-ret-len! s4-0 1.0)) (asin (vector-dot s3-0 s4-0)))
+              )
+        (set! (-> obj desired-tilt) (fmin 8192.0 (fmax -8192.0 (-> obj desired-tilt))))
+        )
+      )
+    (vector-normalize-copy!
+      (-> obj aim-pos)
+      (-> obj node-list data 4 bone transform vector 2)
+      (vector-vector-distance s5-2 (-> obj aim-pos))
+      )
+    )
+  (vector+!
+    (-> obj aim-pos)
+    (-> obj aim-pos)
+    (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 7))
+    )
+  (fort-turret-method-140 obj 0.3 364.0889)
+  (none)
+  )
+
+;; definition for method 140 of type fort-turret
+(defmethod fort-turret-method-140 fort-turret ((obj fort-turret) (arg0 float) (arg1 float))
+  (rider-trans)
+  (let ((s3-0 (new 'stack-no-clear 'matrix)))
+    (+! (-> obj gun-twist) (fmax (- arg1) (fmin arg1 (* arg0 (- (-> obj desired-twist) (-> obj gun-twist))))))
+    (matrix-rotate-y! s3-0 (-> obj gun-twist))
+    (matrix*! s3-0 s3-0 (-> obj init-mat))
+    (matrix->quaternion (-> obj root-override2 quat) s3-0)
+    )
+  (+! (-> obj gun-tilt) (fmax (- arg1) (fmin arg1 (* arg0 (- (-> obj desired-tilt) (-> obj gun-tilt))))))
+  (quaternion-axis-angle! (-> obj gun-tilt-jm quat) 1.0 0.0 0.0 (-> obj gun-tilt))
+  )
+
+;; definition for method 141 of type fort-turret
+;; INFO: Used lq/sq
+(defmethod fort-turret-method-141 fort-turret ((obj fort-turret))
+  (with-pp
+    (let* ((s5-0 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 12)))
+           (v1-3
+             (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> obj node-list data 12 bone transform vector 2) 1.0)
+             )
+           (s4-1 (vector-float*! (new 'stack-no-clear 'vector) v1-3 163840.0))
+           )
+      (let ((s3-0 (new 'stack-no-clear 'collide-query)))
+        (set! (-> s3-0 start-pos quad) (-> s5-0 quad))
+        (set! (-> s3-0 move-dist quad) (-> s4-1 quad))
+        (let ((v1-6 s3-0))
+          (set! (-> v1-6 radius) 409.6)
+          (set! (-> v1-6 collide-with)
+                (collide-spec backgnd jak crate obstacle hit-by-player-list hit-by-others-list player-list pusher)
+                )
+          (set! (-> v1-6 ignore-process0) obj)
+          (set! (-> v1-6 ignore-process1) #f)
+          (set! (-> v1-6 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
+          (set! (-> v1-6 action-mask) (collide-action solid))
+          )
+        (let ((f30-0 (fill-and-probe-using-line-sphere *collide-cache* s3-0)))
+          (cond
+            ((>= f30-0 0.0)
+             (set! (-> obj beam-intersect) (the-as basic 'wall))
+             (when (-> s3-0 best-other-tri collide-ptr)
+               (let* ((s3-1 (-> s3-0 best-other-tri collide-ptr))
+                      (a0-14 (if (type? s3-1 collide-shape-prim)
+                                 (the-as collide-shape-prim s3-1)
+                                 )
+                             )
+                      )
+                 (when a0-14
+                   (when (= (-> a0-14 cshape process type) target)
+                     (set! (-> obj target-timeout) (the-as uint (-> pp clock frame-counter)))
+                     (set! (-> obj beam-intersect) (the-as basic 'target))
+                     )
+                   )
+                 )
+               )
+             (vector-float*! s4-1 s4-1 f30-0)
+             (let ((s3-3 (vector+! (new 'stack-no-clear 'vector) s5-0 s4-1))
+                   (a0-21 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 10)))
+                   (v1-23 (-> obj gun-shadow-jm twist-max))
+                   )
+               (set! (-> v1-23 z)
+                     (+ 2.0 (* 0.00024414062 (vector-length (vector-! (new 'stack-no-clear 'vector) s3-3 a0-21))))
+                     )
+               (if (= (-> obj beam-intersect) 'wall)
+                   (set! (-> v1-23 z) (+ -5.0 (-> v1-23 z)))
+                   )
+               )
+             )
+            (else
+              (set! (-> obj beam-intersect) (the-as basic 'nothing))
+              )
+            )
+          )
+        )
+      (vector+! (-> obj target-bullseye) s5-0 s4-1)
+      )
+    )
+  )
+
+;; definition for method 142 of type fort-turret
+;; INFO: Used lq/sq
+(defmethod fort-turret-method-142 fort-turret ((obj fort-turret) (arg0 symbol) (arg1 int))
+  (let ((v1-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data arg1)))
+        (s4-0 (new 'stack-no-clear 'projectile-init-by-other-params))
+        )
+    (let* ((s2-1 (vector-! (new 'stack-no-clear 'vector) (-> obj aim-pos) v1-2))
+           (f30-0 (/ 2013265900.0 (vector-length s2-1)))
+           (s3-0 (new 'stack-no-clear 'vector))
+           )
+      (set! (-> s4-0 ent) (-> obj entity))
+      (set! (-> s4-0 charge) 1.0)
+      (set! (-> s4-0 options) (projectile-options))
+      (set! (-> s4-0 pos quad) (-> v1-2 quad))
+      (set! (-> s4-0 notify-handle) (process->handle obj))
+      (set! (-> s4-0 owner-handle) (the-as handle #f))
+      (set! (-> s4-0 ignore-handle) (process->handle obj))
+      (let* ((v1-10 *game-info*)
+             (a0-18 (+ (-> v1-10 attack-id) 1))
+             )
+        (set! (-> v1-10 attack-id) a0-18)
+        (set! (-> s4-0 attack-id) a0-18)
+        )
+      (set! (-> s4-0 timeout) (new 'static 'handle :process #x4b0 :u64 #x4b0))
+      (vector-normalize-copy! (-> s4-0 vel) s2-1 491520.0)
+      (let ((f30-1 (fmin 16384.0 f30-0)))
+        (set-vector! s3-0 (-> s2-1 z) (-> s2-1 y) (- (-> s2-1 x)) 1.0)
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        (vector+! (-> s4-0 vel) (-> s4-0 vel) s3-0)
+        (vector-cross! s3-0 s3-0 (-> s4-0 vel))
+        (vector-normalize! s3-0 (rand-vu-float-range (- f30-1) f30-1))
+        )
+      (vector+! (-> s4-0 vel) (-> s4-0 vel) s3-0)
+      )
+    (spawn-projectile guard-shot s4-0 obj *default-dead-pool*)
+    )
+  (sound-play "turret-shot")
+  (if arg0
+      (sound-play "gtur-shot-fire")
+      )
+  (let ((v0-11 #t))
+    (set! (-> obj flash-state) (the-as basic v0-11))
+    v0-11
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate attack (fort-turret)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior fort-turret) enemy-event-handler)
+  :exit (behavior ()
+    (set! (-> self flash-state) #f)
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory))
+        (go-virtual victory)
+        )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+      (if (>= 2 (the-as int (-> self focus aware)))
+          (go-stare self)
+          )
+      )
+    (set! (-> self root-override2 penetrated-by) (enemy-method-59 self))
+    (fort-turret-method-141 self)
+    (if (or (>= (- (-> self clock frame-counter) (the-as int (-> self target-timeout))) (seconds 0.5))
+            (< (- (-> self clock frame-counter) (-> self last-hit-time)) (seconds 2))
+            )
+        (go-virtual hostile)
+        )
+    (fort-turret-method-139 self)
+    (none)
+    )
+  :code (behavior ()
+    (sound-play "turret-up")
+    (ja-no-eval :group! fort-turret-rise-ja
+                :num! (seek! (the float (+ (-> (the-as art-joint-anim fort-turret-rise-ja) frames num-frames) -1)))
+                :frame-num 0.0
+                )
+    (until (ja-done? 0)
+      (suspend)
+      (ja :num! (seek!))
+      )
+    (let ((gp-1 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.5))
+        (suspend)
+        )
+      )
+    (until #f
+      (let ((gp-2 7))
+        (sound-play "gturret")
+        (dotimes (s5-2 3)
+          (cond
+            ((not (-> self can-shoot))
+             )
+            (else
+              (fort-turret-method-142 self #t gp-2)
+              )
+            )
+          (ja-no-eval :group! fort-turret-shoot-ja
+                      :num! (seek! (the float (+ (-> (the-as art-joint-anim fort-turret-shoot-ja) frames num-frames) -1)))
+                      :frame-num 0.0
+                      )
+          (until (ja-done? 0)
+            (suspend)
+            (ja :num! (seek!))
+            )
+          (let ((s4-1 (-> self clock frame-counter)))
+            (until (>= (- (-> self clock frame-counter) s4-1) (seconds 0.33))
+              (suspend)
+              )
+            )
+          (if (= gp-2 7)
+              (set! gp-2 8)
+              (set! gp-2 9)
+              )
+          )
+        )
+      (set! (-> self flash-state) #f)
+      (let ((gp-3 (-> self clock frame-counter)))
+        (until (>= (- (-> self clock frame-counter) gp-3) (seconds 1.5))
+          (suspend)
+          )
+        )
+      )
+    #f
+    (none)
+    )
+  :post (behavior ()
+    (when (-> self flash-state)
+      (set-fordumpa-turret-flash! (the-as int (-> self flash-index)))
+      (set-forrescb-turret-flash! (the-as int (-> self flash-index)))
+      )
+    (enemy-simple-post)
+    (none)
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate sweep (fort-turret)
+  :virtual #t
+  :event (the-as (function process int symbol event-message-block object :behavior fort-turret) enemy-event-handler)
+  :enter (behavior ()
+    (set! (-> self state-time) (-> self clock frame-counter))
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory))
+        (go-virtual victory)
+        )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+      (if (>= 2 (the-as int (-> self focus aware)))
+          (go-stare self)
+          )
+      )
+    (set! (-> self root-override2 penetrated-by) (enemy-method-59 self))
+    (set! (-> self desired-twist) (* 8192.0 (cos (get-scaled-val! (-> self sync) 32768.0 0))))
+    (fort-turret-method-140 self 0.1 91.022224)
+    (fort-turret-method-141 self)
+    (if (and (< (- (-> self clock frame-counter) (the-as int (-> self target-timeout))) (seconds 0.5))
+             (>= (- (-> self clock frame-counter) (-> self last-hit-time)) (seconds 2))
+             )
+        (go-virtual attack)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (sleep-code)
+    (none)
+    )
+  :post (the-as (function none :behavior fort-turret) enemy-simple-post)
+  )
+
+;; failed to figure out what this is:
+(defstate hostile (fort-turret)
+  :virtual #t
+  :enter (behavior ()
+    (let ((t9-0 (-> (method-of-type enemy hostile) enter)))
+      (if t9-0
+          (t9-0)
+          )
+      )
+    (set! (-> self desired-tilt) 0.0)
+    (set! (-> self desired-twist) 0.0)
+    (ja-channel-push! 1 (seconds 0.5))
+    (ja :group! fort-turret-idle-ja)
+    (none)
+    )
+  :trans (behavior ()
+    (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory))
+        (go-virtual victory)
+        )
+    (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
+      (if (>= 2 (the-as int (-> self focus aware)))
+          (go-stare self)
+          )
+      )
+    (set! (-> self root-override2 penetrated-by) (enemy-method-59 self))
+    (fort-turret-method-141 self)
+    (if (and (< (- (-> self clock frame-counter) (the-as int (-> self target-timeout))) (seconds 0.5))
+             (>= (- (-> self clock frame-counter) (-> self last-hit-time)) (seconds 2))
+             )
+        (go-virtual attack)
+        )
+    (set! (-> self desired-twist) (* 8192.0 (cos (get-scaled-val! (-> self sync) 32768.0 0))))
+    (fort-turret-method-140 self 0.1 91.022224)
+    (if (and (< (fabs (-> self gun-twist)) 364.0889) (< (fabs (-> self gun-tilt)) 364.0889))
+        (go-virtual sweep)
+        )
+    (none)
+    )
+  :code (behavior ()
+    (sleep-code)
+    (none)
+    )
+  )
+
+;; definition for method 74 of type fort-turret
+(defmethod enemy-method-74 fort-turret ((obj fort-turret) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
+  (with-pp
+    (if (and (= arg2 'notify) (< 1 (the-as int arg1)) (= (-> arg3 param 0) 'attack) (= (-> arg3 param 1) *target*))
+        (set! (-> obj last-hit-time) (-> pp clock frame-counter))
+        )
+    (case arg2
+      (('start)
+       (let ((v0-0 (the-as object #t)))
+         (set! (-> obj can-shoot) (the-as symbol v0-0))
+         v0-0
+         )
+       )
+      (('stop)
+       (set! (-> obj can-shoot) #f)
+       #f
+       )
+      (('attack)
+       (cond
+         ((= (-> arg0 type) target)
+          #f
+          )
+         ((-> obj invincible)
+          #f
+          )
+         (else
+           ((method-of-type enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+           )
+         )
+       )
+      (else
+        ((method-of-type enemy enemy-method-74) obj arg0 arg1 arg2 arg3)
+        )
+      )
+    )
+  )
+
+;; failed to figure out what this is:
+(defstate die (fort-turret)
+  :virtual #t
+  :enter (behavior ()
+    (enemy-method-132 self)
+    (let ((v1-3 (-> self root-override2 root-prim)))
+      (set! (-> v1-3 prim-core collide-as) (collide-spec))
+      (set! (-> v1-3 prim-core collide-with) (collide-spec))
+      )
+    0
+    (set! (-> self hit-points) 0)
+    0
+    (none)
+    )
+  :code (behavior ()
+    (let ((gp-0 (new 'stack 'joint-exploder-tuning (the-as uint 0))))
+      (process-spawn
+        joint-exploder
+        (art-group-get-by-name *level* "skel-fort-turret-explode" (the-as (pointer uint32) #f))
+        9
+        gp-0
+        *fort-turret-exploder-params*
+        :to self
+        )
+      )
+    (activate! *camera-smush-control* 409.6 18 210 1.0 0.995 (-> self clock))
+    (sound-play "turret-explode")
+    (suspend)
+    (ja-channel-set! 0)
+    (let ((gp-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 4)))
+          (s5-2 (-> self clock frame-counter))
+          )
+      (until (>= (- (-> self clock frame-counter) s5-2) (seconds 2))
+        (spawn (-> self part) gp-2)
+        (suspend)
+        )
+      )
+    (let ((gp-3 (-> self clock frame-counter)))
+      (until (>= (- (-> self clock frame-counter) gp-3) (seconds 1))
+        (suspend)
+        )
+      )
+    (send-event self 'death-end)
+    (while (-> self child)
+      (suspend)
+      )
+    (cleanup-for-death self)
+    (none)
+    )
+  :post (behavior ()
+    (enemy-method-55 self)
+    (none)
+    )
+  )
+
+;; definition for method 60 of type fort-turret
+;; INFO: this function exists in multiple non-identical object files
+(defmethod coin-flip? fort-turret ((obj fort-turret))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; definition for method 59 of type fort-turret
+;; WARN: Return type mismatch int vs penetrate.
+(defmethod enemy-method-59 fort-turret ((obj fort-turret))
+  (the-as penetrate 0)
+  )
+
+;; definition for method 114 of type fort-turret
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-114 fort-turret ((obj fort-turret))
+  "@abstract"
+  (stack-size-set! (-> obj main-thread) 512)
+  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
+    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
+    (set! (-> s5-0 reaction) cshape-reaction-default)
+    (set! (-> s5-0 no-reaction)
+          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
+          )
+    (set! (-> s5-0 penetrated-by) (penetrate))
+    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 3) 0)))
+      (set! (-> s5-0 total-prims) (the-as uint 4))
+      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy pusher))
+      (set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> s4-0 prim-core action) (collide-action solid rideable))
+      (set! (-> s4-0 transform-index) 4)
+      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 36864.0)
+      (set! (-> s5-0 root-prim) s4-0)
+      )
+    (pusher-init s5-0)
+    (let ((v1-17 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
+      (set! (-> v1-17 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-17 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-17 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-17 transform-index) 6)
+      (set-vector! (-> v1-17 local-sphere) 0.0 0.0 5120.0 14336.0)
+      )
+    (let ((v1-19 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 1) (the-as uint 0))))
+      (set! (-> v1-19 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-19 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-19 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-19 transform-index) 5)
+      (set-vector! (-> v1-19 local-sphere) 0.0 6144.0 0.0 12288.0)
+      )
+    (let ((v1-21 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 2) (the-as uint 0))))
+      (set! (-> v1-21 prim-core collide-as) (collide-spec enemy))
+      (set! (-> v1-21 prim-core collide-with) (collide-spec jak player-list))
+      (set! (-> v1-21 prim-core action) (collide-action solid rideable))
+      (set! (-> v1-21 transform-index) 3)
+      (set-vector! (-> v1-21 local-sphere) 0.0 24576.0 0.0 24576.0)
+      )
+    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
+    (let ((v1-24 (-> s5-0 root-prim)))
+      (set! (-> s5-0 backup-collide-as) (-> v1-24 prim-core collide-as))
+      (set! (-> s5-0 backup-collide-with) (-> v1-24 prim-core collide-with))
+      )
+    (set! (-> obj root-override2) s5-0)
+    )
+  0
+  (none)
+  )
+
+;; definition for method 60 of type fort-turret
+;; INFO: this function exists in multiple non-identical object files
+(defmethod coin-flip? fort-turret ((obj fort-turret))
+  "@returns The result of a 50/50 RNG roll"
+  #f
+  )
+
+;; definition for method 7 of type fort-turret
+;; WARN: Return type mismatch enemy vs fort-turret.
+(defmethod relocate fort-turret ((obj fort-turret) (arg0 int))
+  (if (nonzero? (-> obj gun-tilt-jm))
+      (&+! (-> obj gun-tilt-jm) arg0)
+      )
+  (if (nonzero? (-> obj gun-shadow-jm))
+      (&+! (-> obj gun-shadow-jm) arg0)
+      )
+  (the-as fort-turret ((method-of-type enemy relocate) obj arg0))
+  )
+
+;; definition for method 115 of type fort-turret
+;; WARN: Return type mismatch int vs none.
+(defmethod enemy-method-115 fort-turret ((obj fort-turret))
+  "@abstract"
+  (initialize-skeleton
+    obj
+    (the-as skeleton-group (art-group-get-by-name *level* "skel-fort-turret" (the-as (pointer uint32) #f)))
+    (the-as pair 0)
+    )
+  (enemy-method-113 obj *fort-turret-enemy-info*)
+  (set! (-> obj invincible) #f)
+  (if (logtest? (the-as int (res-lump-value (-> obj entity) 'enemy-options uint128 :time -1000000000.0)) 1)
+      (set! (-> obj invincible) #t)
+      )
+  (logclear! (-> obj mask) (process-mask actor-pause))
+  (logclear! (-> obj enemy-flags) (enemy-flag notice))
+  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 685) obj))
+  (set! (-> obj gun-tilt-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 4))
+  (set! (-> obj gun-shadow-jm) (the-as joint-mod (new 'process 'joint-mod-set-local obj 10 #f #f #t)))
+  (set! (-> obj gun-shadow-jm twist-min-y) (the-as float #t))
+  (set! (-> obj los-clear) #f)
+  (set! (-> obj gun-twist) 0.0)
+  (set! (-> obj gun-tilt) 0.0)
+  (set! (-> obj desired-twist) 0.0)
+  (set! (-> obj desired-tilt) 0.0)
+  (set! (-> obj flash-state) #f)
+  (set! (-> obj can-shoot) #t)
+  (set! (-> obj last-hit-time) 0)
+  (set! (-> obj target-timeout) (the-as uint 0))
+  (let ((a1-7 (new 'stack-no-clear 'sync-info-params)))
+    (let ((v1-21 0))
+      (if #t
+          (set! v1-21 (logior v1-21 1))
+          )
+      (set! (-> a1-7 sync-type) (the-as basic 'sync-linear))
+      (set! (-> a1-7 sync-flags) (the-as sync-flags v1-21))
+      )
+    (set! (-> a1-7 entity) (-> obj entity))
+    (set! (-> a1-7 period) (the-as uint 3000))
+    (set! (-> a1-7 percent) 0.0)
+    (initialize! (-> obj sync) a1-7)
+    )
+  (set! (-> obj flash-index) (res-lump-value (-> obj entity) 'extra-id uint :time -1000000000.0))
+  (quaternion->matrix (-> obj init-mat) (-> obj root-override2 quat))
+  (set-vector! (-> obj gun-shadow-jm twist-max) 2.0 1.0 10.0 1.0)
+  (let ((v1-32 (new 'static 'shadow-control :settings (new 'static 'shadow-settings
+                                                        :flags (shadow-flags shdf02 shdf03 shdf04 shdf07)
+                                                        :shadow-dir (new 'static 'vector :y -1.0 :w -983040.0)
+                                                        :bot-plane (new 'static 'plane :y -1.0 :w 32358.4)
+                                                        :top-plane (new 'static 'plane :y -1.0 :w 49152.0)
+                                                        :fade-dist 409600.0
+                                                        )
+                                            )
+               )
+        )
+    (-> v1-32 settings)
+    (set! (-> v1-32 settings shadow-type) 1)
+    (set! (-> obj draw shadow-ctrl) v1-32)
+    )
+  0
+  (none)
+  )
diff --git a/test/decompiler/reference/jak2/levels/hideout/hideout-obs_REF.gc b/test/decompiler/reference/jak2/levels/hideout/hideout-obs_REF.gc
index 9a7cadb554..74a746307c 100644
--- a/test/decompiler/reference/jak2/levels/hideout/hideout-obs_REF.gc
+++ b/test/decompiler/reference/jak2/levels/hideout/hideout-obs_REF.gc
@@ -143,7 +143,7 @@
       (lambda :behavior hide-light
         ()
         (let ((v0-0 (-> self node-list data)))
-          (set! (-> v0-0 0 param0) (the-as (function cspace matrix none) cspace<-parent-joint!))
+          (set! (-> v0-0 0 param0) (the-as (function cspace transformq none) cspace<-parent-joint!))
           (set! (-> v0-0 0 param1) (the-as basic (-> self parent)))
           (set! (-> v0-0 0 param2) (the-as basic 12))
           v0-0
diff --git a/test/offline/config/jak2/config.jsonc b/test/offline/config/jak2/config.jsonc
index 192ad8878a..79b2fd1bf6 100644
--- a/test/offline/config/jak2/config.jsonc
+++ b/test/offline/config/jak2/config.jsonc
@@ -212,6 +212,8 @@
     "(method 16 level)", "unpack-comp-lzo", // asm mods
     "update-time-of-day",
 
+    "draw-2d-hud", // unused / dma casts needed
+
     "close-sky-buffer", // asm
     "(method 29 level)", "(method 9 level)", "level-update-after-load", "(method 25 level)", "(method 9 level)",
     "(method 12 level)", "(method 10 level)",
@@ -264,9 +266,11 @@
     "(method 43 nav-mesh)",
     "(method 34 nav-mesh)",
     "(method 18 nav-control)",
+    "(method 3 rhino)",
+    "(method 202 crimson-guard-level)", // vector-dot
     "(method 10 idle-control)", // re-assigns `self`
-    
-    "(method 3 rhino)"
+    "(method 60 fort-turret)", // they defined the same method twice in the same file, identical impl, just returns #f
+    "(method 23 dig-tether)" // working around annoying decomp array output
   ],
 
   "skip_compile_states": {